Snap for 9207990 from 68f96553bbed161d27f9888f8648c192070bc3a9 to tm-qpr2-release
Change-Id: Ia5d7201a3e2e958cf08adbf1205eaf6f5bc7efb8
diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..6777e0d
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,13 @@
+BasedOnStyle: Google
+IndentWidth: 4
+ColumnLimit: 100
+IncludeCategories:
+ - Regex: '^(<(gtest|gmock))'
+ Priority: -1
+FixNamespaceComments: true
+PointerAlignment: Left
+DerivePointerAlignment: false
+AllowShortBlocksOnASingleLine: Empty
+
+# Ensure proper formatting of macros such as GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES
+StatementMacros: ["f"]
diff --git a/Android.mk b/Android.mk
index 8e3be61..29c7978 100644
--- a/Android.mk
+++ b/Android.mk
@@ -52,6 +52,7 @@
# The host-side Android framework implementation
HOST_EMUGL_PATH := $(GOLDFISH_OPENGL_PATH)/../../../external/qemu/android/android-emugl
EMUGL_COMMON_INCLUDES += $(HOST_EMUGL_PATH)/guest
+GFXSTREAM_PROTOCOLS_PATH := $(HOST_EMUGL_PATH)/../../../gfxstream-protocols
EMUGL_COMMON_CFLAGS += \
-DPLATFORM_SDK_VERSION=29 \
@@ -127,6 +128,7 @@
include $(GOLDFISH_OPENGL_PATH)/shared/qemupipe/Android.mk
include $(GOLDFISH_OPENGL_PATH)/shared/gralloc_cb/Android.mk
include $(GOLDFISH_OPENGL_PATH)/shared/GoldfishAddressSpace/Android.mk
+include $(GOLDFISH_OPENGL_PATH)/platform/Android.mk
ifeq (true,$(GFXSTREAM)) # android-emu
include $(GOLDFISH_OPENGL_PATH)/android-emu/Android.mk
diff --git a/BUILD.gn b/BUILD.gn
index 16dcc56..88145db 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -6,6 +6,11 @@
"android-emu/android/base/AndroidSubAllocator.cpp",
"android-emu/android/base/AndroidSubAllocator.h",
"android-emu/android/base/BumpPool.h",
+ "android-emu/android/base/AndroidHealthMonitor.cpp",
+ "android-emu/android/base/AndroidHealthMonitor.h",
+ "android-emu/android/base/AndroidHealthMonitorConsumer.h",
+ "android-emu/android/base/AndroidHealthMonitorConsumerBasic.cpp",
+ "android-emu/android/base/AndroidHealthMonitorConsumerBasic.h",
"android-emu/android/base/Pool.cpp",
"android-emu/android/base/Pool.h",
"android-emu/android/base/Tracing.cpp",
@@ -28,6 +33,7 @@
"android-emu/android/base/synchronization/AndroidLock.h",
"android-emu/android/base/synchronization/AndroidMessageChannel.cpp",
"android-emu/android/base/synchronization/AndroidMessageChannel.h",
+ "android-emu/android/base/testing/TestClock.h",
"android-emu/android/base/threads/AndroidFunctorThread.cpp",
"android-emu/android/base/threads/AndroidFunctorThread.h",
"android-emu/android/base/threads/AndroidThread.h",
@@ -36,6 +42,10 @@
"android-emu/android/base/threads/AndroidThread_pthread.cpp",
"android-emu/android/base/threads/AndroidWorkPool.cpp",
"android-emu/android/base/threads/AndroidWorkPool.h",
+ "platform/include/VirtGpu.h",
+ "platform/stub/VirtGpuBlob.cpp",
+ "platform/stub/VirtGpuBlobMapping.cpp",
+ "platform/stub/VirtGpuDevice.cpp",
"shared/GoldfishAddressSpace/goldfish_address_space.cpp",
"shared/GoldfishAddressSpace/include/goldfish_address_space.h",
"shared/OpenglCodecCommon/ChecksumCalculator.cpp",
@@ -93,6 +103,8 @@
"system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h",
"system/vulkan_enc/goldfish_vk_transform_guest.cpp",
"system/vulkan_enc/goldfish_vk_transform_guest.h",
+ "system/vulkan_enc/vulkan_gfxstream.h",
+ "system/vulkan_enc/vulkan_gfxstream_structure_type.h",
]
include_dirs = [
@@ -113,6 +125,7 @@
"LOG_TAG=\"goldfish_vulkan\"",
"GFXSTREAM",
"GOLDFISH_NO_GL",
+ "VK_GFXSTREAM_STRUCTURE_TYPE_EXT",
"VK_USE_PLATFORM_FUCHSIA",
"PLATFORM_SDK_VERSION=1",
"PAGE_SIZE=4096",
@@ -161,25 +174,31 @@
include_dirs += [
"fuchsia/include",
+ "platform/include",
"//third_party/Vulkan-Headers/include",
]
deps = [
- "//sdk/fidl/fuchsia.hardware.goldfish:fuchsia.hardware.goldfish_llcpp",
- "//sdk/fidl/fuchsia.logger:fuchsia.logger_llcpp",
- "//sdk/fidl/fuchsia.sysmem:fuchsia.sysmem_llcpp",
- "//sdk/lib/fdio",
+ "//sdk/fidl/fuchsia.hardware.goldfish:fuchsia.hardware.goldfish_cpp_wire",
+ "//sdk/fidl/fuchsia.logger:fuchsia.logger_cpp_wire",
+ "//sdk/fidl/fuchsia.sysmem:fuchsia.sysmem_cpp_wire",
"//src/zircon/lib/zircon",
- "//zircon/public/lib/async-cpp",
- "//zircon/public/lib/zx",
- "//zircon/system/ulib/async-default",
+ "//zircon/system/ulib/async:async-cpp",
"//zircon/system/ulib/async-loop:async-loop-cpp",
"//zircon/system/ulib/syslog:syslog-static",
"//zircon/system/ulib/trace:trace-with-static-engine",
"//zircon/system/ulib/trace-provider:trace-provider-with-static-engine",
+ "//zircon/system/ulib/zx",
"//zircon/system/ulib/zxio",
]
+ # Vulkan ICDs on Fuchsia are only allowed to depend on (parts of) libc
+ # and libzircon, and no other shared libraries.
+ assert_no_deps = [
+ "//sdk/lib/fdio",
+ "//zircon/system/ulib/async-default",
+ ]
+
defines += [
"QEMU_PIPE_PATH=\"/loader-gpu-devices/class/goldfish-pipe/000\"",
"GOLDFISH_ADDRESS_SPACE_DEVICE_NAME=\"/loader-gpu-devices/class/goldfish-address-space/000\"",
diff --git a/CMakeLists.txt b/CMakeLists.txt
index d671a50..ff70213 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2,10 +2,11 @@
# instead run make from .../device/generic/goldfish-opengl
# which will re-generate this file.
set(GOLDFISH_DEVICE_ROOT ${CMAKE_CURRENT_SOURCE_DIR})
-android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/./Android.mk" "1b46812779386f6eba221003097f66f4ce3b80515761e8f8694dbe9cfe14cd01")
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/./Android.mk" "8c3ec83d5a5db514b82ea1e43fac4d4d1074590611e8859b52687ef3ba3c045d")
add_subdirectory(shared/qemupipe)
add_subdirectory(shared/gralloc_cb)
add_subdirectory(shared/GoldfishAddressSpace)
+add_subdirectory(platform)
add_subdirectory(android-emu)
add_subdirectory(shared/OpenglCodecCommon)
add_subdirectory(system/GLESv1_enc)
diff --git a/OWNERS b/OWNERS
index c5e9dac..e97ac8d 100644
--- a/OWNERS
+++ b/OWNERS
@@ -8,6 +8,7 @@
natsu@google.com
reveman@google.com
rkir@google.com
+tutankhamen@google.com
yahan@google.com
# COMPONENT: Graphics
diff --git a/android-emu/Android.bp b/android-emu/Android.bp
index b83cab9..6276863 100644
--- a/android-emu/Android.bp
+++ b/android-emu/Android.bp
@@ -18,12 +18,15 @@
"android/base/files/StreamSerializing.cpp",
"android/base/Pool.cpp",
"android/base/StringFormat.cpp",
+ "android/base/Process.cpp",
"android/base/AndroidSubAllocator.cpp",
"android/base/synchronization/AndroidMessageChannel.cpp",
"android/base/threads/AndroidFunctorThread.cpp",
"android/base/threads/AndroidThreadStore.cpp",
"android/base/threads/AndroidThread_pthread.cpp",
"android/base/threads/AndroidWorkPool.cpp",
+ "android/base/AndroidHealthMonitor.cpp",
+ "android/base/AndroidHealthMonitorConsumerBasic.cpp",
"android/base/Tracing.cpp",
"android/utils/debug.c",
],
diff --git a/android-emu/Android.mk b/android-emu/Android.mk
index 88a296c..2ec7f1d 100644
--- a/android-emu/Android.mk
+++ b/android-emu/Android.mk
@@ -18,12 +18,15 @@
android/base/files/StreamSerializing.cpp \
android/base/Pool.cpp \
android/base/StringFormat.cpp \
+ android/base/Process.cpp \
android/base/AndroidSubAllocator.cpp \
android/base/synchronization/AndroidMessageChannel.cpp \
android/base/threads/AndroidFunctorThread.cpp \
android/base/threads/AndroidThreadStore.cpp \
android/base/threads/AndroidThread_pthread.cpp \
android/base/threads/AndroidWorkPool.cpp \
+ android/base/AndroidHealthMonitor.cpp \
+ android/base/AndroidHealthMonitorConsumerBasic.cpp \
android/base/Tracing.cpp \
android/utils/debug.c \
diff --git a/android-emu/CMakeLists.txt b/android-emu/CMakeLists.txt
index 7d42043..75c3664 100644
--- a/android-emu/CMakeLists.txt
+++ b/android-emu/CMakeLists.txt
@@ -1,9 +1,9 @@
# This is an autogenerated file! Do not edit!
# instead run make from .../device/generic/goldfish-opengl
# which will re-generate this file.
-android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/android-emu/Android.mk" "e1609bbe85546522a8f71488322e5c9919d4e81107cf10a1413e5ed0d86211e2")
-set(androidemu_src android/base/AlignedBuf.cpp android/base/files/MemStream.cpp android/base/files/Stream.cpp android/base/files/StreamSerializing.cpp android/base/Pool.cpp android/base/StringFormat.cpp android/base/AndroidSubAllocator.cpp android/base/synchronization/AndroidMessageChannel.cpp android/base/threads/AndroidFunctorThread.cpp android/base/threads/AndroidThreadStore.cpp android/base/threads/AndroidThread_pthread.cpp android/base/threads/AndroidWorkPool.cpp android/base/Tracing.cpp android/utils/debug.c)
-android_add_library(TARGET androidemu SHARED LICENSE Apache-2.0 SRC android/base/AlignedBuf.cpp android/base/files/MemStream.cpp android/base/files/Stream.cpp android/base/files/StreamSerializing.cpp android/base/Pool.cpp android/base/StringFormat.cpp android/base/AndroidSubAllocator.cpp android/base/synchronization/AndroidMessageChannel.cpp android/base/threads/AndroidFunctorThread.cpp android/base/threads/AndroidThreadStore.cpp android/base/threads/AndroidThread_pthread.cpp android/base/threads/AndroidWorkPool.cpp android/base/Tracing.cpp android/utils/debug.c)
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/android-emu/Android.mk" "cb03eba8dae73ce330e2e8fc782b4db1e4ba1eeb0318642c85f0d60b18e1bb94")
+set(androidemu_src android/base/AlignedBuf.cpp android/base/files/MemStream.cpp android/base/files/Stream.cpp android/base/files/StreamSerializing.cpp android/base/Pool.cpp android/base/StringFormat.cpp android/base/Process.cpp android/base/AndroidSubAllocator.cpp android/base/synchronization/AndroidMessageChannel.cpp android/base/threads/AndroidFunctorThread.cpp android/base/threads/AndroidThreadStore.cpp android/base/threads/AndroidThread_pthread.cpp android/base/threads/AndroidWorkPool.cpp android/base/AndroidHealthMonitor.cpp android/base/AndroidHealthMonitorConsumerBasic.cpp android/base/Tracing.cpp android/utils/debug.c)
+android_add_library(TARGET androidemu SHARED LICENSE Apache-2.0 SRC android/base/AlignedBuf.cpp android/base/files/MemStream.cpp android/base/files/Stream.cpp android/base/files/StreamSerializing.cpp android/base/Pool.cpp android/base/StringFormat.cpp android/base/Process.cpp android/base/AndroidSubAllocator.cpp android/base/synchronization/AndroidMessageChannel.cpp android/base/threads/AndroidFunctorThread.cpp android/base/threads/AndroidThreadStore.cpp android/base/threads/AndroidThread_pthread.cpp android/base/threads/AndroidWorkPool.cpp android/base/AndroidHealthMonitor.cpp android/base/AndroidHealthMonitorConsumerBasic.cpp android/base/Tracing.cpp android/utils/debug.c)
target_include_directories(androidemu PRIVATE ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
target_compile_definitions(androidemu PRIVATE "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGFXSTREAM" "-DLOG_TAG=\"androidemu\"")
target_compile_options(androidemu PRIVATE "-fvisibility=default" "-Wno-unused-parameter" "-Wno-missing-field-initializers" "-fstrict-aliasing")
@@ -11,7 +11,7 @@
# This is an autogenerated file! Do not edit!
# instead run make from .../device/generic/goldfish-opengl
# which will re-generate this file.
-android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/android-emu/Android.mk" "e1609bbe85546522a8f71488322e5c9919d4e81107cf10a1413e5ed0d86211e2")
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/android-emu/Android.mk" "cb03eba8dae73ce330e2e8fc782b4db1e4ba1eeb0318642c85f0d60b18e1bb94")
set(ringbuffer_src android/base/ring_buffer.c)
android_add_library(TARGET ringbuffer LICENSE Apache-2.0 SRC android/base/ring_buffer.c)
target_include_directories(ringbuffer PRIVATE ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
diff --git a/android-emu/android/base/AndroidHealthMonitor.cpp b/android-emu/android/base/AndroidHealthMonitor.cpp
new file mode 100644
index 0000000..9934f0a
--- /dev/null
+++ b/android-emu/android/base/AndroidHealthMonitor.cpp
@@ -0,0 +1,271 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * 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 "android/base/AndroidHealthMonitor.h"
+
+#include <map>
+#include <sys/time.h>
+
+namespace android {
+namespace base {
+namespace guest {
+
+using android::base::guest::AutoLock;
+using std::chrono::duration_cast;
+
+template <class... Ts>
+struct MonitoredEventVisitor : Ts... {
+ using Ts::operator()...;
+};
+template <class... Ts>
+MonitoredEventVisitor(Ts...) -> MonitoredEventVisitor<Ts...>;
+
+template <class Clock>
+HealthMonitor<Clock>::HealthMonitor(HealthMonitorConsumer& consumer, uint64_t heartbeatInterval)
+ : mInterval(Duration(std::chrono::milliseconds(heartbeatInterval))), mConsumer(consumer) {
+ start();
+}
+
+template <class Clock>
+HealthMonitor<Clock>::~HealthMonitor() {
+ auto event = std::make_unique<MonitoredEvent>(typename MonitoredEventType::EndMonitoring{});
+ {
+ AutoLock lock(mLock);
+ mEventQueue.push(std::move(event));
+ }
+ poll();
+ wait();
+}
+
+template <class Clock>
+typename HealthMonitor<Clock>::Id HealthMonitor<Clock>::startMonitoringTask(
+ std::unique_ptr<EventHangMetadata> metadata,
+ std::optional<std::function<std::unique_ptr<HangAnnotations>()>> onHangAnnotationsCallback,
+ uint64_t timeout, std::optional<Id> parentId) {
+ auto intervalMs = duration_cast<std::chrono::milliseconds>(mInterval).count();
+ if (timeout < intervalMs) {
+ ALOGW("Timeout value %llu is too low (heartbeat is every %llu). Increasing to %llu",
+ (unsigned long long)timeout, (unsigned long long) intervalMs,
+ (unsigned long long)intervalMs * 2);
+ timeout = intervalMs * 2;
+ }
+
+ AutoLock lock(mLock);
+ auto id = mNextId++;
+ auto event = std::make_unique<MonitoredEvent>(typename MonitoredEventType::Start{
+ .id = id,
+ .metadata = std::move(metadata),
+ .timeOccurred = Clock::now(),
+ .onHangAnnotationsCallback = std::move(onHangAnnotationsCallback),
+ .timeoutThreshold = Duration(std::chrono::milliseconds(timeout)),
+ .parentId = parentId});
+ mEventQueue.push(std::move(event));
+ return id;
+}
+
+template <class Clock>
+void HealthMonitor<Clock>::touchMonitoredTask(Id id) {
+ auto event = std::make_unique<MonitoredEvent>(
+ typename MonitoredEventType::Touch{.id = id, .timeOccurred = Clock::now()});
+ AutoLock lock(mLock);
+ mEventQueue.push(std::move(event));
+}
+
+template <class Clock>
+void HealthMonitor<Clock>::stopMonitoringTask(Id id) {
+ auto event = std::make_unique<MonitoredEvent>(
+ typename MonitoredEventType::Stop{.id = id, .timeOccurred = Clock::now()});
+ AutoLock lock(mLock);
+ mEventQueue.push(std::move(event));
+}
+
+template <class Clock>
+std::future<void> HealthMonitor<Clock>::poll() {
+ auto event = std::make_unique<MonitoredEvent>(typename MonitoredEventType::Poll{});
+ std::future<void> ret =
+ std::get<typename MonitoredEventType::Poll>(*event).complete.get_future();
+
+ AutoLock lock(mLock);
+ mEventQueue.push(std::move(event));
+ mCv.signalAndUnlock(&lock);
+ return ret;
+}
+
+// Thread's main loop
+template <class Clock>
+intptr_t HealthMonitor<Clock>::main() {
+ bool keepMonitoring = true;
+ std::queue<std::unique_ptr<MonitoredEvent>> events;
+
+ while (keepMonitoring) {
+ std::vector<std::promise<void>> pollPromises;
+ std::unordered_set<Id> tasksToRemove;
+ int newHungTasks = mHungTasks;
+ {
+ AutoLock lock(mLock);
+ struct timeval currentTime;
+ gettimeofday(¤tTime, 0);
+ if (mEventQueue.empty()) {
+ mCv.timedWait(
+ &mLock,
+ currentTime.tv_sec * 1000000LL + currentTime.tv_usec +
+ std::chrono::duration_cast<std::chrono::microseconds>(mInterval).count());
+ }
+ mEventQueue.swap(events);
+ }
+
+ Timestamp now = Clock::now();
+ while (!events.empty()) {
+ auto event(std::move(events.front()));
+ events.pop();
+
+ std::visit(MonitoredEventVisitor{
+ [](std::monostate& event) {
+ ALOGE("MonitoredEvent type not found");
+ abort();
+ },
+ [this, &events](typename MonitoredEventType::Start& event) {
+ auto it = mMonitoredTasks.find(event.id);
+ if (it != mMonitoredTasks.end()) {
+ ALOGE("Registered multiple start events for task %llu",
+ (unsigned long long)event.id);
+ return;
+ }
+ if (event.parentId && mMonitoredTasks.find(event.parentId.value()) ==
+ mMonitoredTasks.end()) {
+ ALOGW("Requested parent task %llu does not exist.",
+ (unsigned long long)event.parentId.value());
+ event.parentId = std::nullopt;
+ }
+ it = mMonitoredTasks
+ .emplace(event.id,
+ std::move(MonitoredTask{
+ .id = event.id,
+ .timeoutTimestamp = event.timeOccurred +
+ event.timeoutThreshold,
+ .timeoutThreshold = event.timeoutThreshold,
+ .hungTimestamp = std::nullopt,
+ .metadata = std::move(event.metadata),
+ .onHangAnnotationsCallback =
+ std::move(event.onHangAnnotationsCallback),
+ .parentId = event.parentId}))
+ .first;
+ updateTaskParent(events, it->second, event.timeOccurred);
+ },
+ [this, &events](typename MonitoredEventType::Touch& event) {
+ auto it = mMonitoredTasks.find(event.id);
+ if (it == mMonitoredTasks.end()) {
+ ALOGE("HealthMonitor has no task in progress for id %llu",
+ (unsigned long long)event.id);
+ return;
+ }
+
+ auto& task = it->second;
+ task.timeoutTimestamp = event.timeOccurred + task.timeoutThreshold;
+ updateTaskParent(events, task, event.timeOccurred);
+ },
+ [this, &tasksToRemove,
+ &events](typename MonitoredEventType::Stop& event) {
+ auto it = mMonitoredTasks.find(event.id);
+ if (it == mMonitoredTasks.end()) {
+ ALOGE("HealthMonitor has no task in progress for id %llu",
+ (unsigned long long)event.id);
+ return;
+ }
+
+ auto& task = it->second;
+ task.timeoutTimestamp = event.timeOccurred + task.timeoutThreshold;
+ updateTaskParent(events, task, event.timeOccurred);
+
+ // Mark it for deletion, but retain it until the end of
+ // the health check concurrent tasks hung
+ tasksToRemove.insert(event.id);
+ },
+ [&keepMonitoring](typename MonitoredEventType::EndMonitoring& event) {
+ keepMonitoring = false;
+ },
+ [&pollPromises](typename MonitoredEventType::Poll& event) {
+ pollPromises.push_back(std::move(event.complete));
+ }},
+ *event);
+ }
+
+ // Sort by what times out first. Identical timestamps are possible
+ std::multimap<Timestamp, uint64_t> sortedTasks;
+ for (auto& [_, task] : mMonitoredTasks) {
+ sortedTasks.insert(std::pair<Timestamp, uint64_t>(task.timeoutTimestamp, task.id));
+ }
+
+ for (auto& [_, task_id] : sortedTasks) {
+ auto& task = mMonitoredTasks[task_id];
+ if (task.timeoutTimestamp < now) {
+ // Newly hung task
+ if (!task.hungTimestamp.has_value()) {
+ // Copy over additional annotations captured at hangTime
+ if (task.onHangAnnotationsCallback) {
+ auto newAnnotations = (*task.onHangAnnotationsCallback)();
+ task.metadata->mergeAnnotations(std::move(newAnnotations));
+ }
+ mConsumer.consumeHangEvent(task.id, task.metadata.get(), newHungTasks);
+ task.hungTimestamp = task.timeoutTimestamp;
+ newHungTasks++;
+ }
+ } else {
+ // Task resumes
+ if (task.hungTimestamp.has_value()) {
+ auto hangTime = duration_cast<std::chrono::milliseconds>(
+ task.timeoutTimestamp -
+ (task.hungTimestamp.value() + task.timeoutThreshold))
+ .count();
+ mConsumer.consumeUnHangEvent(task.id, task.metadata.get(), hangTime);
+ task.hungTimestamp = std::nullopt;
+ newHungTasks--;
+ }
+ }
+ if (tasksToRemove.find(task_id) != tasksToRemove.end()) {
+ mMonitoredTasks.erase(task_id);
+ }
+ }
+
+ if (mHungTasks != newHungTasks) {
+ ALOGE("HealthMonitor: Number of unresponsive tasks %s: %d -> %d",
+ mHungTasks < newHungTasks ? "increased" : "decreaased", mHungTasks, newHungTasks);
+ mHungTasks = newHungTasks;
+ }
+
+ for (auto& complete : pollPromises) {
+ complete.set_value();
+ }
+ }
+
+ return 0;
+}
+
+template <class Clock>
+void HealthMonitor<Clock>::updateTaskParent(std::queue<std::unique_ptr<MonitoredEvent>>& events,
+ const MonitoredTask& task, Timestamp eventTime) {
+ std::optional<Id> parentId = task.parentId;
+ if (parentId) {
+ auto event = std::make_unique<MonitoredEvent>(typename MonitoredEventType::Touch{
+ .id = parentId.value(), .timeOccurred = eventTime + Duration(kTimeEpsilon)});
+ events.push(std::move(event));
+ }
+}
+
+template class HealthMonitor<steady_clock>;
+
+} // namespace guest
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/AndroidHealthMonitor.h b/android-emu/android/base/AndroidHealthMonitor.h
new file mode 100644
index 0000000..9520b94
--- /dev/null
+++ b/android-emu/android/base/AndroidHealthMonitor.h
@@ -0,0 +1,311 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * 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.
+ */
+#pragma once
+
+#include <chrono>
+#include <functional>
+#include <future>
+#include <optional>
+#include <queue>
+#include <stack>
+#include <string>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <variant>
+
+#include "android/base/AndroidHealthMonitorConsumer.h"
+#include "android/base/synchronization/AndroidConditionVariable.h"
+#include "android/base/synchronization/AndroidLock.h"
+#include "android/base/threads/AndroidThread.h"
+
+#include <log/log.h>
+
+using android::base::guest::EventHangMetadata;
+
+#define WATCHDOG_BUILDER(healthMonitor, msg) \
+ ::android::base::guest::HealthWatchdogBuilder<std::decay_t<decltype(healthMonitor)>>( \
+ healthMonitor, __FILE__, __func__, msg, __LINE__)
+
+namespace android {
+namespace base {
+namespace guest {
+
+using android::base::guest::ConditionVariable;
+using android::base::guest::Lock;
+using std::chrono::duration;
+using std::chrono::steady_clock;
+using std::chrono::time_point;
+using HangAnnotations = EventHangMetadata::HangAnnotations;
+
+static uint64_t kDefaultIntervalMs = 1'000;
+static uint64_t kDefaultTimeoutMs = 5'000;
+static std::chrono::nanoseconds kTimeEpsilon(1);
+
+// HealthMonitor provides the ability to register arbitrary start/touch/stop events associated
+// with client defined tasks. At some pre-defined interval, it will periodically consume
+// all logged events to assess whether the system is hanging on any task. Via the
+// HealthMonitorConsumer, it will log hang and unhang events when it detects tasks hanging/resuming.
+// Design doc: http://go/gfxstream-health-monitor
+template <class Clock = steady_clock>
+class HealthMonitor : public android::base::guest::Thread {
+ public:
+ // Alias for task id.
+ using Id = uint64_t;
+
+ // Constructor
+ // `heatbeatIntervalMs` is the interval, in milleseconds, that the thread will sleep for
+ // in between health checks.
+ HealthMonitor(HealthMonitorConsumer& consumer, uint64_t heartbeatInterval = kDefaultIntervalMs);
+
+ // Destructor
+ // Enqueues an event to end monitoring and waits on thread to process remaining queued events.
+ ~HealthMonitor();
+
+ // Start monitoring a task. Returns an id that is used for touch and stop operations.
+ // `metadata` is a struct containing info on the task watchdog to be passed through to the
+ // metrics logger.
+ // `onHangAnnotationsCallback` is an optional containing a callable that will return key-value
+ // string pairs to be recorded at the time a hang is detected, which is useful for debugging.
+ // `timeout` is the duration in milliseconds a task is allowed to run before it's
+ // considered "hung". Because `timeout` must be larger than the monitor's heartbeat
+ // interval, as shorter timeout periods would not be detected, this method will set actual
+ // timeout to the lesser of `timeout` and twice the heartbeat interval.
+ // `parentId` can be the Id of another task. Events in this monitored task will update
+ // the parent task recursively.
+ Id startMonitoringTask(std::unique_ptr<EventHangMetadata> metadata,
+ std::optional<std::function<std::unique_ptr<HangAnnotations>()>>
+ onHangAnnotationsCallback = std::nullopt,
+ uint64_t timeout = kDefaultTimeoutMs,
+ std::optional<Id> parentId = std::nullopt);
+
+ // Touch a monitored task. Resets the timeout countdown for that task.
+ void touchMonitoredTask(Id id);
+
+ // Stop monitoring a task.
+ void stopMonitoringTask(Id id);
+
+ private:
+ using Duration = typename Clock::duration; // duration<double>;
+ using Timestamp = time_point<Clock, Duration>;
+
+ // Allow test class access to private functions
+ friend class HealthMonitorTest;
+
+ struct MonitoredEventType {
+ struct Start {
+ Id id;
+ std::unique_ptr<EventHangMetadata> metadata;
+ Timestamp timeOccurred;
+ std::optional<std::function<std::unique_ptr<HangAnnotations>()>>
+ onHangAnnotationsCallback;
+ Duration timeoutThreshold;
+ std::optional<Id> parentId;
+ };
+ struct Touch {
+ Id id;
+ Timestamp timeOccurred;
+ };
+ struct Stop {
+ Id id;
+ Timestamp timeOccurred;
+ };
+ struct EndMonitoring {};
+ struct Poll {
+ std::promise<void> complete;
+ };
+ };
+
+ using MonitoredEvent =
+ std::variant<std::monostate, typename MonitoredEventType::Start,
+ typename MonitoredEventType::Touch, typename MonitoredEventType::Stop,
+ typename MonitoredEventType::EndMonitoring, typename MonitoredEventType::Poll>;
+
+ struct MonitoredTask {
+ Id id;
+ Timestamp timeoutTimestamp;
+ Duration timeoutThreshold;
+ std::optional<Timestamp> hungTimestamp;
+ std::unique_ptr<EventHangMetadata> metadata;
+ std::optional<std::function<std::unique_ptr<HangAnnotations>()>> onHangAnnotationsCallback;
+ std::optional<Id> parentId;
+ };
+
+ // Thread's main loop
+ intptr_t main() override;
+
+ // Update the parent task
+ void updateTaskParent(std::queue<std::unique_ptr<MonitoredEvent>>& events,
+ const MonitoredTask& task, Timestamp eventTime);
+
+ // Explicitly wake the monitor thread. Returns a future that can be used to wait until the
+ // poll event has been processed.
+ std::future<void> poll();
+
+ // Immutable. Multi-thread access is safe.
+ const Duration mInterval;
+
+ // Members accessed only on the worker thread. Not protected by mutex.
+ int mHungTasks = 0;
+ HealthMonitorConsumer& mConsumer;
+ std::unordered_map<Id, MonitoredTask> mMonitoredTasks;
+
+ // Lock and cv control access to queue and id counter
+ ConditionVariable mCv;
+ Lock mLock;
+ Id mNextId = 0;
+ std::queue<std::unique_ptr<MonitoredEvent>> mEventQueue;
+};
+
+// This class provides an RAII mechanism for monitoring a task.
+// HealthMonitorT should have the exact same interface as HealthMonitor. Note that HealthWatchdog
+// can be used in performance critical path, so we use a template to dispatch a call here to
+// overcome the performance cost of virtual function dispatch.
+template <class HealthMonitorT = HealthMonitor<>>
+class HealthWatchdog {
+ public:
+ HealthWatchdog(HealthMonitorT& healthMonitor, std::unique_ptr<EventHangMetadata> metadata,
+ std::optional<std::function<std::unique_ptr<HangAnnotations>()>>
+ onHangAnnotationsCallback = std::nullopt,
+ uint64_t timeout = kDefaultTimeoutMs)
+ : mHealthMonitor(healthMonitor), mThreadId(getCurrentThreadId()) {
+ auto& threadTasks = getMonitoredThreadTasks();
+ auto& stack = threadTasks[&mHealthMonitor];
+ typename HealthMonitorT::Id id = mHealthMonitor.startMonitoringTask(
+ std::move(metadata), std::move(onHangAnnotationsCallback), timeout,
+ stack.empty() ? std::nullopt : std::make_optional(stack.top()));
+ mId = id;
+ stack.push(id);
+ }
+
+ ~HealthWatchdog() {
+ if (!mId.has_value()) {
+ return;
+ }
+ mHealthMonitor.stopMonitoringTask(*mId);
+ checkedStackPop();
+ }
+
+ void touch() {
+ if (!mId.has_value()) {
+ return;
+ }
+ mHealthMonitor.touchMonitoredTask(*mId);
+ }
+
+ // Return the underlying Id, and don't issue a stop on destruction.
+ std::optional<typename HealthMonitorT::Id> release() {
+ if (mId.has_value()) {
+ checkedStackPop();
+ }
+ return std::exchange(mId, std::nullopt);
+ }
+
+ private:
+ using ThreadTasks =
+ std::unordered_map<HealthMonitorT*, std::stack<typename HealthMonitorT::Id>>;
+ std::optional<typename HealthMonitorT::Id> mId;
+ HealthMonitorT& mHealthMonitor;
+ const unsigned long mThreadId;
+
+ // Thread local stack of task Ids enables better reentrant behavior.
+ // Multiple health monitors are not expected or advised, but as an injected dependency,
+ // it is possible.
+ ThreadTasks& getMonitoredThreadTasks() {
+ static thread_local ThreadTasks threadTasks;
+ return threadTasks;
+ }
+
+ // Pop the stack for the current thread, but with validation. Must be called with a non-empty
+ // WatchDog.
+ void checkedStackPop() {
+ typename HealthMonitorT::Id id = *mId;
+ auto& threadTasks = getMonitoredThreadTasks();
+ auto& stack = threadTasks[&mHealthMonitor];
+ if (getCurrentThreadId() != mThreadId) {
+ ALOGE("HealthWatchdog destructor thread does not match origin. Destructor must be "
+ "called on the same thread.");
+ abort();
+ }
+ if (stack.empty()) {
+ ALOGE("HealthWatchdog thread local stack is empty!");
+ abort();
+ }
+ if (stack.top() != id) {
+ ALOGE("HealthWatchdog id %llu does not match top of stack: %llu",
+ (unsigned long long)id, (unsigned long long)stack.top());
+ abort();
+ }
+ stack.pop();
+ }
+};
+
+// HealthMonitorT should have the exact same interface as HealthMonitor. This template parameter is
+// used for injecting a different type for testing.
+template <class HealthMonitorT>
+class HealthWatchdogBuilder {
+ public:
+ HealthWatchdogBuilder(HealthMonitorT& healthMonitor, const char* fileName,
+ const char* functionName, const char* message, uint32_t line)
+ : mHealthMonitor(healthMonitor),
+ mMetadata(std::make_unique<EventHangMetadata>(
+ fileName, functionName, message, line, EventHangMetadata::HangType::kOther, nullptr)),
+ mTimeoutMs(kDefaultTimeoutMs),
+ mOnHangCallback(std::nullopt) {}
+
+ DISALLOW_COPY_ASSIGN_AND_MOVE(HealthWatchdogBuilder);
+
+ HealthWatchdogBuilder& setHangType(EventHangMetadata::HangType hangType) {
+ mMetadata->hangType = hangType;
+ return *this;
+ }
+ HealthWatchdogBuilder& setTimeoutMs(uint32_t timeoutMs) {
+ mTimeoutMs = timeoutMs;
+ return *this;
+ }
+ // F should be a callable that returns a std::unique_ptr<EventHangMetadata::HangAnnotations>. We
+ // use template instead of std::function here to avoid extra copy.
+ template <class F>
+ HealthWatchdogBuilder& setOnHangCallback(F&& callback) {
+ mOnHangCallback =
+ std::function<std::unique_ptr<HangAnnotations>()>(std::forward<F>(callback));
+ return *this;
+ }
+
+ HealthWatchdogBuilder& setAnnotations(std::unique_ptr<HangAnnotations> annotations) {
+ mMetadata->data = std::move(annotations);
+ return *this;
+ }
+
+ std::unique_ptr<HealthWatchdog<HealthMonitorT>> build() {
+ // We are allocating on the heap, so there is a performance hit. However we also allocate
+ // EventHangMetadata on the heap, so this should be Ok. If we see performance issues with
+ // these allocations, for HealthWatchdog, we can always use placement new + noop deleter to
+ // avoid heap allocation for HealthWatchdog.
+ return std::make_unique<HealthWatchdog<HealthMonitorT>>(
+ mHealthMonitor, std::move(mMetadata), std::move(mOnHangCallback), mTimeoutMs);
+ }
+
+ private:
+ HealthMonitorT& mHealthMonitor;
+ std::unique_ptr<EventHangMetadata> mMetadata;
+ uint32_t mTimeoutMs;
+ std::optional<std::function<std::unique_ptr<HangAnnotations>()>> mOnHangCallback;
+};
+
+} // namespace guest
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/AndroidHealthMonitorConsumer.h b/android-emu/android/base/AndroidHealthMonitorConsumer.h
new file mode 100644
index 0000000..7144e8b
--- /dev/null
+++ b/android-emu/android/base/AndroidHealthMonitorConsumer.h
@@ -0,0 +1,83 @@
+// Copyright (C) 2022 The Android Open Source Project
+// Copyright (C) 2022 Google 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.
+#pragma once
+
+#include <inttypes.h>
+
+#include <memory>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <variant>
+
+#include "android/base/threads/AndroidThread.h"
+
+// Interface for consuming events from HealthMonitor
+
+namespace android {
+namespace base {
+namespace guest {
+
+// Struct for hanging events
+struct EventHangMetadata {
+ const char* file;
+ const char* function;
+ const char* msg;
+ const int line;
+ const unsigned long threadId;
+ // Field for adding custom key value annotations
+ using HangAnnotations = std::unordered_map<std::string, std::string>;
+ // Field for adding custom key value annotations
+ std::unique_ptr<HangAnnotations> data;
+
+ // TODO: willho@ replace this enum with a generic string field embedded in the
+ // proto and replace the individual event codes with a general hang event
+ // Requires a new callback to be passed from the vm to gfxstream_backend_init
+ enum class HangType { kRenderThread, kSyncThread, kOther };
+ HangType hangType;
+
+ EventHangMetadata(const char* file, const char* function, const char* msg, int line,
+ HangType hangType, std::unique_ptr<HangAnnotations> data)
+ : file(file),
+ function(function),
+ msg(msg),
+ line(line),
+ threadId(getCurrentThreadId()),
+ data(std::move(data)),
+ hangType(hangType) {}
+
+ EventHangMetadata()
+ : EventHangMetadata(nullptr, nullptr, nullptr, 0, HangType::kRenderThread, nullptr) {}
+
+ void mergeAnnotations(std::unique_ptr<HangAnnotations> annotations) {
+ if (!data) {
+ data = std::make_unique<HangAnnotations>();
+ }
+ data->merge(*annotations);
+ }
+};
+
+class HealthMonitorConsumer {
+public:
+ virtual void consumeHangEvent(uint64_t taskId, const EventHangMetadata* metadata,
+ int64_t otherHungTasks) = 0;
+ virtual void consumeUnHangEvent(uint64_t taskId, const EventHangMetadata* metadata,
+ int64_t hungMs) = 0;
+ virtual ~HealthMonitorConsumer() {}
+};
+
+} // namespace guest
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/AndroidHealthMonitorConsumerBasic.cpp b/android-emu/android/base/AndroidHealthMonitorConsumerBasic.cpp
new file mode 100644
index 0000000..76f4ef8
--- /dev/null
+++ b/android-emu/android/base/AndroidHealthMonitorConsumerBasic.cpp
@@ -0,0 +1,59 @@
+// Copyright (C) 2022 Google 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 "android/base/AndroidHealthMonitorConsumerBasic.h"
+
+#include <log/log.h>
+
+#include "android/base/Process.h"
+
+namespace android {
+namespace base {
+namespace guest {
+
+void logEventHangMetadata(const EventHangMetadata* metadata) {
+ ALOGE("Metadata:");
+ ALOGE("\t file: %s", metadata->file);
+ ALOGE("\t function: %s", metadata->function);
+ ALOGE("\t line: %d", metadata->line);
+ ALOGE("\t msg: %s", metadata->msg);
+ ALOGE("\t thread: %lld (0x%08llx)", (long long)metadata->threadId,
+ (long long)metadata->threadId);
+ ALOGE("\t process name: %s", getProcessName().c_str());
+ if (metadata->data) {
+ ALOGE("\t Additional information:");
+ for (auto& [key, value] : *metadata->data) {
+ ALOGE("\t \t %s: %s", key.c_str(), value.c_str());
+ }
+ }
+}
+
+// HealthMonitorConsumerBasic
+void HealthMonitorConsumerBasic::consumeHangEvent(uint64_t taskId,
+ const EventHangMetadata* metadata,
+ int64_t otherHungTasks) {
+ ALOGE("Logging hang event. Number of tasks already hung: %lld", (long long)otherHungTasks);
+ logEventHangMetadata(metadata);
+}
+
+void HealthMonitorConsumerBasic::consumeUnHangEvent(uint64_t taskId,
+ const EventHangMetadata* metadata,
+ int64_t hungMs) {
+ ALOGE("Logging unhang event. Hang time: %lld ms", (long long)hungMs);
+ logEventHangMetadata(metadata);
+}
+
+} // namespace guest
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/AndroidHealthMonitorConsumerBasic.h b/android-emu/android/base/AndroidHealthMonitorConsumerBasic.h
new file mode 100644
index 0000000..9f3dc03
--- /dev/null
+++ b/android-emu/android/base/AndroidHealthMonitorConsumerBasic.h
@@ -0,0 +1,32 @@
+// Copyright (C) 2022 The Android Open Source Project
+// Copyright (C) 2022 Google 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.
+#pragma once
+
+#include "AndroidHealthMonitorConsumer.h"
+
+namespace android {
+namespace base {
+namespace guest {
+class HealthMonitorConsumerBasic: public HealthMonitorConsumer {
+public:
+ void consumeHangEvent(uint64_t taskId, const EventHangMetadata* metadata,
+ int64_t otherHungTasks) override;
+ void consumeUnHangEvent(uint64_t taskId, const EventHangMetadata* metadata,
+ int64_t hungMs) override;
+
+};
+} // namespace guest
+} // namespace base
+} // namespace android
diff --git a/android-emu/android/base/Process.cpp b/android-emu/android/base/Process.cpp
new file mode 100644
index 0000000..31552ea
--- /dev/null
+++ b/android-emu/android/base/Process.cpp
@@ -0,0 +1,46 @@
+
+// Copyright (C) 2022 Google 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 "android/base/Process.h"
+
+#if defined(__linux__)
+#include <fstream>
+#endif
+#include <string>
+
+namespace android {
+namespace base {
+namespace guest {
+
+std::string getProcessName() {
+ // Support for "getprogname" function in bionic was introduced in L (API level 21)
+ std::string processName;
+#if defined(__ANDROID__) && __ANDROID_API__ >= 21
+ processName = std::string(getprogname());
+#elif defined(__linux__)
+ {
+ std::ifstream stream("/proc/self/cmdline");
+ if (stream.is_open()) {
+ processName = std::string(std::istreambuf_iterator<char>(stream),
+ std::istreambuf_iterator<char>());
+ }
+ }
+#endif
+ return processName;
+}
+
+} // namespace guest
+} // namespace base
+} // namespace android
\ No newline at end of file
diff --git a/android-emu/android/base/Process.h b/android-emu/android/base/Process.h
new file mode 100644
index 0000000..003058e
--- /dev/null
+++ b/android-emu/android/base/Process.h
@@ -0,0 +1,28 @@
+
+// Copyright (C) 2022 The Android Open Source Project
+//
+// 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.
+
+#pragma once
+
+#include <string>
+
+namespace android {
+namespace base {
+namespace guest {
+
+std::string getProcessName();
+
+} // namespace guest
+} // namespace base
+} // namespace android
\ No newline at end of file
diff --git a/android-emu/android/base/StringFormat.h b/android-emu/android/base/StringFormat.h
index d0fd3df..9b68c24 100644
--- a/android-emu/android/base/StringFormat.h
+++ b/android-emu/android/base/StringFormat.h
@@ -14,8 +14,6 @@
#pragma once
-#include "android/base/StringView.h"
-
#include <string>
#include <type_traits>
#include <utility>
diff --git a/android-emu/android/base/StringView.h b/android-emu/android/base/StringView.h
deleted file mode 100644
index a6d9a61..0000000
--- a/android-emu/android/base/StringView.h
+++ /dev/null
@@ -1,298 +0,0 @@
-// Copyright 2014 The Android Open Source Project
-//
-// 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.
-
-#pragma once
-
-#include "android/base/Optional.h"
-#include "android/base/TypeTraits.h"
-
-#include <algorithm>
-#include <cstring>
-#include <string>
-
-namespace android {
-namespace base {
-
-// A StringView is a simple (address, size) pair that points to an
-// existing read-only string. It's a convenience class used to prevent
-// the creation of std::string() objects un-necessarily.
-//
-// Consider the two following functions:
-//
-// size_t count1(const std::string& str) {
-// size_t count = 0;
-// for (size_t n = 0; n < str.size(); ++n) {
-// if (str[n] == '1') {
-// count++;
-// }
-// }
-// return count;
-// }
-//
-// size_t count2(const StringView& str) {
-// size_t count = 0;
-// for (size_t n = 0; n < str.size(); ++n) {
-// if (str[n] == '2') {
-// count++;
-// }
-// }
-// return count;
-// }
-//
-// Then consider the following calls:
-//
-// size_t n1 = count1("There is 1 one in this string!");
-// size_t n2 = count2("I can count 2 too");
-//
-// In the first case, the compiler will silently create a temporary
-// std::string object, copy the input string into it (allocating memory in
-// the heap), call count1() and destroy the std::string upon its return.
-//
-// In the second case, the compiler will create a temporary StringView,
-// initialize it trivially before calling count2(), this results in
-// much less generated code, as well as better performance.
-//
-// Generally speaking, always use a reference or pointer to StringView
-// instead of a std::string if your function or method doesn't need to modify
-// its input.
-//
-class StringView {
-public:
- constexpr StringView() : mString(""), mSize(0U) {}
-
- constexpr StringView(const StringView& other) :
- mString(other.data()), mSize(other.size()) {}
-
- // IMPORTANT: all StringView constructors are intentionally not explict
- // it is needed to allow seamless creation of StringView from all types
- // of strings around - as it's intended to be a generic string wrapper
-
- // A constexpr constructor from a constant buffer, initializing |mSize|
- // as well. This allows one to declare a static const StringView instance
- // and initialize it at compile time, with no runtime overhead:
- //
- // static constexpr StringView message = "blah";
- //
- template <size_t size>
- constexpr StringView(const char (&buf)[size]) :
- mString(buf), mSize(size - 1) {}
-
- // Ctor for non-const arrays, AKA buffers. These usually contain some
- // string formatted at runtime, so call strlen() instead of using the
- // buffer size.
- template <size_t size>
- constexpr StringView(char (&buf)[size]) :
- mString(buf), mSize(strlen(buf)) {}
-
- // Constructor from a const char pointer. It has to be templated to make
- // sure the array-based one is chosen for an array - otherwise non-templated
- // overload always wins
- // Note: the parameter type is a const reference to a const pointer. This
- // is to make this overload a poorer choice for the case of an array. For
- // the 'const char[]' argument both 'reference to an array' and 'pointer'
- // overloads are tied, so compiler can't choose without help
- // Note2: for all constructors and set() calls, |end| must be
- // dereferencable. It is notrequired to be '\0', but there has to be some
- // data there. One may not construct a StringView passing past-the-end
- // iterator as |end|! StringView will try to dereference it.
- template <class Char, class = enable_if<std::is_same<Char, char>>>
- constexpr StringView(const Char* const & string) :
- mString(string ? string : ""), mSize(string ? strlen(string) : 0) {}
-
- StringView(const std::string& str) :
- mString(str.c_str()), mSize(str.size()) {}
-
- constexpr StringView(const char* str, size_t len)
- : mString(str ? str : ""), mSize(len) {}
-
- constexpr StringView(const char* begin, const char* end)
- : mString(begin ? begin : ""), mSize(begin ? end - begin : 0) {}
-
- constexpr StringView(std::nullptr_t) :
- mString(""), mSize(0) {}
-
- std::string str() const { return std::string(mString, mString + mSize); }
- constexpr const char* data() const { return mString; }
- constexpr size_t size() const { return mSize; }
-
- typedef const char* iterator;
- typedef const char* const_iterator;
-
- constexpr const_iterator begin() const { return mString; }
- constexpr const_iterator end() const { return mString + mSize; }
-
- constexpr bool empty() const { return !size(); }
- constexpr bool isNullTerminated() const { return *end() == '\0'; }
-
- void clear() {
- mSize = 0;
- mString = "";
- }
-
- constexpr char operator[](size_t index) const {
- return mString[index];
- }
-
- void set(const char* data, size_t len) {
- mString = data ? data : "";
- mSize = len;
- }
-
- void set(const char* str) {
- mString = str ? str : "";
- mSize = ::strlen(mString);
- }
-
- void set(const StringView& other) {
- mString = other.mString;
- mSize = other.mSize;
- }
-
- // Compare with another StringView.
- int compare(const StringView& other) const;
-
- StringView& operator=(const StringView& other) {
- set(other);
- return *this;
- }
-
- // find() first occurrence of |other| with an initial offset.
- // Returns absolute offset (does not include |off|).
- size_t find(StringView other, size_t off = 0) {
- // Trivial case
- if (!other.mSize) return 0;
-
- size_t safeOff = std::min(off, mSize);
-
- const char* searchStart = mString + safeOff;
- const char* searchEnd = searchStart + mSize - safeOff;
-
- const char* res =
- std::search(searchStart, searchEnd,
- other.mString, other.mString + other.mSize);
- if (res == searchEnd) return std::string::npos;
- return (size_t)((uintptr_t)res - (uintptr_t)mString);
- }
-
- // getSubstr(); returns this string starting at the first place |other|
- // occurs, otherwise a blank string.
- StringView getSubstr(StringView other, size_t off = 0) {
- size_t loc = find(other, off);
- if (loc == std::string::npos) return StringView("");
- return { mString + loc, end() };
- }
-
- // Returns substring starting at |begin| and running for |len|,
- // or the rest of the string if |len| is std::string::npos.
- StringView substr(size_t begin, size_t len = std::string::npos) {
- if (len == std::string::npos) {
- len = mSize - begin;
- }
- size_t safeOff = std::min(begin, mSize);
- size_t safeLen = std::min(len, mSize - safeOff);
- return { mString + safeOff, safeLen };
- }
-
- // Returns substring starting at |begin| ending at |end|,
- // or the rest of the string if |end is std::string::npos.
- StringView substrAbs(size_t begin, size_t end = std::string::npos) {
- if (end == std::string::npos) {
- end = begin + mSize;
- }
- return substr(begin, end - begin);
- }
-
- // Convert to std::string when needed.
- operator std::string() const { return std::string(mString, mSize); }
-
-private:
- const char* mString;
- size_t mSize;
-};
-
-// Comparison operators. Defined as functions to allow automatic type
-// conversions with C strings and std::string objects.
-
-bool operator==(const StringView& x, const StringView& y);
-
-inline bool operator!=(const StringView& x, const StringView& y) {
- return !(x == y);
-}
-
-inline bool operator<(const StringView& x, const StringView& y) {
- return x.compare(y) < 0;
-}
-
-inline bool operator>=(const StringView& x, const StringView& y) {
- return !(x < y);
-}
-
-inline bool operator >(const StringView& x, const StringView& y) {
- return x.compare(y) > 0;
-}
-
-inline bool operator<=(const StringView& x, const StringView& y) {
- return !(x > y);
-}
-
-// Helper to get a null-terminated const char* from a string view.
-// Only allocates if the StringView is not null terminated.
-//
-// Usage:
-//
-// StringView myString = ...;
-// printf("Contents: %s\n", c_str(myString));
-//
-// c_str(...) constructs a temporary object that may allocate memory if the
-// StringView is not null termianted. The lifetime of the temporary object will
-// be until the next sequence point (typically the next semicolon). If the
-// value needs to exist for longer than that, cache the instance.
-//
-// StringView myString = ...;
-// auto myNullTerminatedString = c_str(myString);
-// functionAcceptingConstCharPointer(myNullTerminatedString);
-//
-class CStrWrapper {
-public:
- CStrWrapper(StringView stringView) : mStringView(stringView) {}
-
- // Returns a null-terminated char*, potentially creating a copy to add a
- // null terminator.
- const char* get() {
- if (mStringView.isNullTerminated()) {
- return mStringView.data();
- } else {
- // Create the std::string copy on-demand.
- if (!mStringCopy) {
- mStringCopy.emplace(mStringView.str());
- }
-
- return mStringCopy->c_str();
- }
- }
-
- // Enable casting to const char*
- operator const char*() { return get(); }
-
-private:
- const StringView mStringView;
- Optional<std::string> mStringCopy;
-};
-
-inline CStrWrapper c_str(StringView stringView) {
- return CStrWrapper(stringView);
-}
-
-} // namespace base
-} // namespace android
diff --git a/android-emu/android/base/files/MemStream.cpp b/android-emu/android/base/files/MemStream.cpp
index f2b0055..8561694 100644
--- a/android-emu/android/base/files/MemStream.cpp
+++ b/android-emu/android/base/files/MemStream.cpp
@@ -18,6 +18,7 @@
#include <algorithm>
#include <utility>
+#include <cstring>
namespace android {
namespace base {
diff --git a/android-emu/android/base/files/Stream.cpp b/android-emu/android/base/files/Stream.cpp
index 85730d0..6de638a 100644
--- a/android-emu/android/base/files/Stream.cpp
+++ b/android-emu/android/base/files/Stream.cpp
@@ -103,17 +103,23 @@
return u.f;
}
-void Stream::putString(StringView str) {
- this->putBe32(str.size());
- this->write(str.data(), str.size());
+void Stream::putString(const char* str) {
+ if (str) {
+ putString(str, strlen(str));
+ } else {
+ putString("", 0);
+ }
}
-void Stream::putString(const char* str) {
- putString(StringView(str));
+void Stream::putString(const std::string& str) {
+ putString(str.data(), str.size());
}
void Stream::putString(const char* str, size_t len) {
- putString(StringView(str, len));
+ if (str) {
+ this->putBe32(len);
+ this->write(str, len);
+ }
}
std::string Stream::getString() {
diff --git a/android-emu/android/base/files/Stream.h b/android-emu/android/base/files/Stream.h
index fa175f3..a934bb9 100644
--- a/android-emu/android/base/files/Stream.h
+++ b/android-emu/android/base/files/Stream.h
@@ -14,8 +14,6 @@
#pragma once
-#include "android/base/StringView.h"
-
#include <string>
#include <inttypes.h>
@@ -76,11 +74,9 @@
// Read a single 32-bit float value from the stream.
float getFloat();
- // Write a string |str| into the stream. Ignore errors.
- void putString(StringView str);
-
// Write a 0-terminated C string |str| into the stream. Ignore error.
void putString(const char* str);
+ void putString(const std::string& str);
// Write a string |str| of |strlen| bytes into the stream.
// Ignore errors.
diff --git a/android-emu/android/base/meson.build b/android-emu/android/base/meson.build
index 882b28e..3d2e732 100644
--- a/android-emu/android/base/meson.build
+++ b/android-emu/android/base/meson.build
@@ -6,6 +6,9 @@
'AndroidSubAllocator.cpp',
'AndroidSubAllocator.h',
'Pool.cpp',
+ 'Process.cpp'
+ 'AndroidHealthMonitor.cpp',
+ 'AndroidHealthMonitorConsumerBasic.cpp',
'Tracing.cpp',
'ring_buffer.c',
'files/MemStream.cpp',
diff --git a/android-emu/android/base/threads/AndroidThread_pthread.cpp b/android-emu/android/base/threads/AndroidThread_pthread.cpp
index d106887..8a0ecf0 100644
--- a/android-emu/android/base/threads/AndroidThread_pthread.cpp
+++ b/android-emu/android/base/threads/AndroidThread_pthread.cpp
@@ -24,6 +24,14 @@
#ifndef _MSC_VER
#include <unistd.h>
#endif
+#ifdef __linux__
+#include <sys/syscall.h>
+#include <sys/types.h>
+#endif
+
+#ifdef __Fuchsia__
+#include <zircon/process.h>
+#endif
namespace android {
namespace base {
@@ -179,12 +187,28 @@
}
unsigned long getCurrentThreadId() {
- pthread_t tid = pthread_self();
+#ifdef __ANDROID__
+ // bionic has an efficient implementation for gettid.
+ pid_t tid = gettid();
+#elif defined(__linux__)
+ // Linux doesn't always include an implementation of gettid, so we use syscall.
+ thread_local pid_t tid = -1;
+ if (tid == -1) {
+ tid = syscall(__NR_gettid);
+ }
+#elif defined(__Fuchsia__)
+ zx_handle_t tid = zx_thread_self();
+#else
+ pthread_t thread = pthread_self();
// POSIX doesn't require pthread_t to be a numeric type.
// Instead, just pick up the first sizeof(long) bytes as the "id".
- static_assert(sizeof(tid) >= sizeof(long),
+ static_assert(sizeof(thread) >= sizeof(long),
"Expected pthread_t to be at least sizeof(long) wide");
- return *reinterpret_cast<unsigned long*>(&tid);
+ unsigned long tid = *reinterpret_cast<unsigned long*>(&tid);
+#endif
+ static_assert(sizeof(tid) <= sizeof(long),
+ "Expected thread handle to be at most sizeof(long) wide");
+ return static_cast<unsigned long>(tid);
}
} // namespace guest
diff --git a/fuchsia/include/android/hardware_buffer.h b/fuchsia/include/android/hardware_buffer.h
index 1a6c57e..3d31f52 100644
--- a/fuchsia/include/android/hardware_buffer.h
+++ b/fuchsia/include/android/hardware_buffer.h
@@ -358,7 +358,7 @@
*
* Available since API level 26.
*/
-void AHardwareBuffer_release(AHardwareBuffer* buffer) { }
+void AHardwareBuffer_release(AHardwareBuffer* buffer);
/**
* Return a description of the AHardwareBuffer in the passed
diff --git a/fuchsia/include/cutils/threads.h b/fuchsia/include/cutils/threads.h
deleted file mode 100644
index fc332dd..0000000
--- a/fuchsia/include/cutils/threads.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef __CUTILS_THREADS_H__
-#define __CUTILS_THREADS_H__
-
-#include <pthread.h>
-
-extern "C" {
-
-pid_t gettid();
-
-}
-
-#endif
diff --git a/fuchsia/port.cc b/fuchsia/port.cc
index fdbf583..7c0a338 100644
--- a/fuchsia/port.cc
+++ b/fuchsia/port.cc
@@ -20,7 +20,6 @@
#include "cutils/log.h"
#include "cutils/properties.h"
-#include "cutils/threads.h"
extern "C" {
@@ -100,17 +99,5 @@
abort();
}
-int sync_wait(int fd, int timeout) {
- return -1;
-}
-
-pid_t gettid() {
- static thread_local pid_t id = 0;
- if (!id) {
- static std::atomic<pid_t> next_thread_id{1};
- id = next_thread_id++;
- }
- return id;
-}
-
+int sync_wait(int fd, int timeout) { return -1; }
}
diff --git a/meson.build b/meson.build
index 19cc4ac..c084518 100644
--- a/meson.build
+++ b/meson.build
@@ -3,7 +3,8 @@
project('gfxstream', 'cpp', 'c',
version : '0.0.1',
- license : 'MIT OR Apache-2.0')
+ license : 'MIT OR Apache-2.0',
+ default_options : ['cpp_std=gnu++17'])
cc = meson.get_compiler('cpp')
prog_python = import('python').find_installation('python3')
@@ -36,6 +37,8 @@
cpp_args += '-DPAGE_SIZE=4096'
# This should just be called NO_TRACE eventually
cpp_args += '-DFUCHSIA_NO_TRACE'
+# Include the gfxstream private VkStructureType definitions
+cpp_args += '-DVK_GFXSTREAM_STRUCTURE_TYPE_EXT'
#===============#
# Dependencies #
@@ -58,6 +61,7 @@
#================#
subdir('fuchsia')
+subdir('platform')
subdir('android-emu/android/base')
subdir('shared')
subdir('system')
diff --git a/platform/Android.bp b/platform/Android.bp
new file mode 100644
index 0000000..3e2dd31
--- /dev/null
+++ b/platform/Android.bp
@@ -0,0 +1,35 @@
+package {
+ // See: http://go/android-license-faq
+ // A large-scale-change added 'default_applicable_licenses' to import
+ // all of the 'license_kinds' from "device_generic_goldfish-opengl_license"
+ // to get the below license kinds:
+ // SPDX-license-identifier-Apache-2.0
+ // SPDX-license-identifier-GPL-2.0
+ default_applicable_licenses: ["device_generic_goldfish-opengl_license"],
+}
+
+cc_library_static {
+ name: "libplatform",
+ vendor: true,
+ srcs: [
+ "linux/VirtGpuBlob.cpp",
+ "linux/VirtGpuBlobMapping.cpp",
+ "linux/VirtGpuDevice.cpp"
+ ],
+ shared_libs: [
+ "libcutils",
+ "libutils",
+ "libdrm",
+ "liblog",
+ ],
+ export_include_dirs: [
+ "include"
+ ],
+ cflags: [
+ "-DLOG_TAG=\"platform\"",
+ "-Wno-missing-field-initializers",
+ "-fvisibility=default",
+ "-fstrict-aliasing",
+ ],
+ include_dirs: ["device/generic/goldfish-opengl/platform/include"],
+}
diff --git a/platform/Android.mk b/platform/Android.mk
new file mode 100644
index 0000000..bbfd4d4
--- /dev/null
+++ b/platform/Android.mk
@@ -0,0 +1,15 @@
+ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+
+LOCAL_PATH := $(call my-dir)
+
+$(call emugl-begin-static-library,libplatform$(GOLDFISH_OPENGL_LIB_SUFFIX))
+
+sources := stub/VirtGpuBlob.cpp \
+ stub/VirtGpuBlobMapping.cpp \
+ stub/VirtGpuDevice.cpp \
+
+LOCAL_SRC_FILES := $(sources)
+$(call emugl-export,C_INCLUDES,$(LOCAL_PATH)/include)
+$(call emugl-end-module)
+
+endif
diff --git a/platform/CMakeLists.txt b/platform/CMakeLists.txt
new file mode 100644
index 0000000..20a9e1c
--- /dev/null
+++ b/platform/CMakeLists.txt
@@ -0,0 +1,10 @@
+# This is an autogenerated file! Do not edit!
+# instead run make from .../device/generic/goldfish-opengl
+# which will re-generate this file.
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/platform/Android.mk" "b2e96eaf4c7c9823b6d1846beb672c82f82465e1122b699cc91192837f93782b")
+set(platform_host_src stub/VirtGpuBlob.cpp stub/VirtGpuBlobMapping.cpp stub/VirtGpuDevice.cpp)
+android_add_library(TARGET platform_host LICENSE Apache-2.0 SRC stub/VirtGpuBlob.cpp stub/VirtGpuBlobMapping.cpp stub/VirtGpuDevice.cpp)
+target_include_directories(platform_host PRIVATE ${GOLDFISH_DEVICE_ROOT}/platform/include ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_compile_definitions(platform_host PRIVATE "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGFXSTREAM")
+target_compile_options(platform_host PRIVATE "-fvisibility=default" "-Wno-unused-parameter")
+target_link_libraries(platform_host PRIVATE log android-emu-shared)
\ No newline at end of file
diff --git a/platform/include/VirtGpu.h b/platform/include/VirtGpu.h
new file mode 100644
index 0000000..60de99f
--- /dev/null
+++ b/platform/include/VirtGpu.h
@@ -0,0 +1,175 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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 VIRTGPU_DEVICE_H
+#define VIRTGPU_DEVICE_H
+
+#include <cstdint>
+#include <memory>
+
+enum VirtGpuParamId {
+ kParam3D,
+ kParamCapsetFix,
+ kParamResourceBlob,
+ kParamHostVisible,
+ kParamCrossDevice,
+ kParamContextInit,
+ kParamSupportedCapsetIds,
+ kParamMax
+};
+
+enum VirtGpuExecBufferFlags : uint32_t {
+ kFenceIn = 0x0001,
+ kFenceOut = 0x0002,
+ kRingIdx = 0x0004,
+};
+
+enum VirtGpuCapset {
+ kCapsetNone = 0,
+ kCapsetVirgl = 1,
+ kCapsetVirgl2 = 2,
+ kCapsetGfxStream = 3,
+ kCapsetVenus = 4,
+ kCapsetCrossDomain = 5,
+};
+
+// Try to keep aligned with vulkan-cereal / rutabaga.
+enum VirtGpuHandleType {
+ kMemHandleOpaqueFd = 0x0001,
+ kMemHandleDmabuf = 0x0002,
+ kMemHandleOpaqueWin32 = 0x0003,
+ kMemHandleShm = 0x0004,
+ kMemHandleZircon = 0x0008,
+ kFenceHandleOpaqueFd = 0x0010,
+ kFenceHandleSyncFd = 0x0020,
+ kFenceHandleOpaqueWin32 = 0x0040,
+ kFenceHandleZircon = 0x0080,
+};
+
+enum VirtGpuBlobFlags : uint32_t {
+ kBlobFlagMappable = 0x0001,
+ kBlobFlagShareable = 0x0002,
+ kBlobFlagCrossDevice = 0x0004
+};
+
+enum VirtGpuBlobMem {
+ kBlobMemGuest = 0x0001,
+ kBlobMemHost3d = 0x0002,
+ kBlobMemHost3dGuest = 0x0003,
+};
+
+struct VirtGpuExternalHandle {
+ int64_t osHandle;
+ enum VirtGpuHandleType type;
+};
+
+struct VirtGpuExecBuffer {
+ void* command;
+ uint32_t command_size;
+ enum VirtGpuExecBufferFlags flags;
+ struct VirtGpuExternalHandle handle;
+};
+
+struct VirtGpuParam {
+ uint64_t param;
+ const char* name;
+ uint64_t value;
+};
+
+struct VirtGpuCreateBlob {
+ uint64_t size;
+ enum VirtGpuBlobFlags flags;
+ enum VirtGpuBlobMem blobMem;
+ uint64_t blobId;
+};
+
+class VirtGpuBlobMapping;
+class VirtGpuBlob;
+using VirtGpuBlobPtr = std::shared_ptr<VirtGpuBlob>;
+using VirtGpuBlobMappingPtr = std::shared_ptr<VirtGpuBlobMapping>;
+
+class VirtGpuBlob : public std::enable_shared_from_this<VirtGpuBlob> {
+ public:
+ VirtGpuBlob(int64_t deviceHandle, uint32_t blobHandle, uint32_t resourceHandle, uint64_t size);
+ ~VirtGpuBlob();
+
+ uint32_t getResourceHandle(void);
+ uint32_t getBlobHandle(void);
+ int wait(void);
+
+ VirtGpuBlobMappingPtr createMapping(void);
+ int exportBlob(struct VirtGpuExternalHandle& handle);
+
+ private:
+ // Not owned. Really should use a ScopedFD for this, but doesn't matter since we have a
+ // singleton deviceimplemenentation anyways.
+ int64_t mDeviceHandle;
+
+ uint32_t mBlobHandle;
+ uint32_t mResourceHandle;
+ uint64_t mSize;
+};
+
+class VirtGpuBlobMapping {
+ public:
+ VirtGpuBlobMapping(VirtGpuBlobPtr blob, uint8_t* ptr, uint64_t size);
+ ~VirtGpuBlobMapping(void);
+
+ uint8_t* asRawPtr(void);
+
+ private:
+ VirtGpuBlobPtr mBlob;
+ uint8_t* mPtr;
+ uint64_t mSize;
+};
+
+class VirtGpuDevice {
+ public:
+ static VirtGpuDevice& getInstance(enum VirtGpuCapset capset = kCapsetNone);
+ int64_t getDeviceHandle(void);
+
+ uint64_t getParam(enum VirtGpuParamId param);
+
+ VirtGpuBlobPtr createBlob(struct VirtGpuCreateBlob& blobCreate);
+ VirtGpuBlobPtr createPipeBlob(uint32_t size);
+ VirtGpuBlobPtr importBlob(struct VirtGpuExternalHandle& handle);
+
+ int execBuffer(struct VirtGpuExecBuffer& execbuffer, VirtGpuBlobPtr blob);
+
+ private:
+ VirtGpuDevice(enum VirtGpuCapset capset);
+ ~VirtGpuDevice();
+ VirtGpuDevice(VirtGpuDevice const&);
+ void operator=(VirtGpuDevice const&);
+
+ static VirtGpuDevice mInstance;
+ int64_t mDeviceHandle;
+ struct VirtGpuParam mParams[kParamMax];
+};
+
+// HACK: We can use android::base::EnumFlags, but we'll have to do more guest
+// refactorings to figure out our end goal. We can either depend more on base or
+// try to transition to something else (b:202552093) [atleast for guests].
+constexpr enum VirtGpuBlobFlags operator |(const enum VirtGpuBlobFlags self,
+ const enum VirtGpuBlobFlags other) {
+ return (enum VirtGpuBlobFlags)(uint32_t(self) | uint32_t(other));
+}
+
+constexpr enum VirtGpuExecBufferFlags operator |(const enum VirtGpuExecBufferFlags self,
+ const enum VirtGpuExecBufferFlags other) {
+ return (enum VirtGpuExecBufferFlags)(uint32_t(self) | uint32_t(other));
+}
+
+#endif
diff --git a/platform/include/virtgpu_drm.h b/platform/include/virtgpu_drm.h
new file mode 100644
index 0000000..a13e20c
--- /dev/null
+++ b/platform/include/virtgpu_drm.h
@@ -0,0 +1,246 @@
+/*
+ * Copyright 2013 Red Hat
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef VIRTGPU_DRM_H
+#define VIRTGPU_DRM_H
+
+#include "drm.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* Please note that modifications to all structs defined here are
+ * subject to backwards-compatibility constraints.
+ *
+ * Do not use pointers, use __u64 instead for 32 bit / 64 bit user/kernel
+ * compatibility Keep fields aligned to their size
+ */
+
+#define DRM_VIRTGPU_MAP 0x01
+#define DRM_VIRTGPU_EXECBUFFER 0x02
+#define DRM_VIRTGPU_GETPARAM 0x03
+#define DRM_VIRTGPU_RESOURCE_CREATE 0x04
+#define DRM_VIRTGPU_RESOURCE_INFO 0x05
+#define DRM_VIRTGPU_TRANSFER_FROM_HOST 0x06
+#define DRM_VIRTGPU_TRANSFER_TO_HOST 0x07
+#define DRM_VIRTGPU_WAIT 0x08
+#define DRM_VIRTGPU_GET_CAPS 0x09
+#define DRM_VIRTGPU_RESOURCE_CREATE_BLOB 0x0a
+#define DRM_VIRTGPU_CONTEXT_INIT 0x0b
+
+#define VIRTGPU_EXECBUF_FENCE_FD_IN 0x01
+#define VIRTGPU_EXECBUF_FENCE_FD_OUT 0x02
+#define VIRTGPU_EXECBUF_RING_IDX 0x04
+#define VIRTGPU_EXECBUF_FLAGS (\
+ VIRTGPU_EXECBUF_FENCE_FD_IN |\
+ VIRTGPU_EXECBUF_FENCE_FD_OUT |\
+ VIRTGPU_EXECBUF_RING_IDX |\
+ 0)
+
+struct drm_virtgpu_map {
+ __u64 offset; /* use for mmap system call */
+ __u32 handle;
+ __u32 pad;
+};
+
+struct drm_virtgpu_execbuffer {
+ __u32 flags;
+ __u32 size;
+ __u64 command; /* void* */
+ __u64 bo_handles;
+ __u32 num_bo_handles;
+ __s32 fence_fd; /* in/out fence fd (see VIRTGPU_EXECBUF_FENCE_FD_IN/OUT) */
+ __u32 ring_idx; /* command ring index (see VIRTGPU_EXECBUF_RING_IDX) */
+ __u32 pad;
+};
+
+#define VIRTGPU_PARAM_3D_FEATURES 1 /* do we have 3D features in the hw */
+#define VIRTGPU_PARAM_CAPSET_QUERY_FIX 2 /* do we have the capset fix */
+#define VIRTGPU_PARAM_RESOURCE_BLOB 3 /* DRM_VIRTGPU_RESOURCE_CREATE_BLOB */
+#define VIRTGPU_PARAM_HOST_VISIBLE 4 /* Host blob resources are mappable */
+#define VIRTGPU_PARAM_CROSS_DEVICE 5 /* Cross virtio-device resource sharing */
+#define VIRTGPU_PARAM_CONTEXT_INIT 6 /* DRM_VIRTGPU_CONTEXT_INIT */
+#define VIRTGPU_PARAM_SUPPORTED_CAPSET_IDs 7 /* Bitmask of supported capability set ids */
+
+struct drm_virtgpu_getparam {
+ __u64 param;
+ __u64 value;
+};
+
+/* NO_BO flags? NO resource flag? */
+/* resource flag for y_0_top */
+struct drm_virtgpu_resource_create {
+ __u32 target;
+ __u32 format;
+ __u32 bind;
+ __u32 width;
+ __u32 height;
+ __u32 depth;
+ __u32 array_size;
+ __u32 last_level;
+ __u32 nr_samples;
+ __u32 flags;
+ __u32 bo_handle; /* if this is set - recreate a new resource attached to this bo ? */
+ __u32 res_handle; /* returned by kernel */
+ __u32 size; /* validate transfer in the host */
+ __u32 stride; /* validate transfer in the host */
+};
+
+struct drm_virtgpu_resource_info {
+ __u32 bo_handle;
+ __u32 res_handle;
+ __u32 size;
+ __u32 blob_mem;
+};
+
+struct drm_virtgpu_3d_box {
+ __u32 x;
+ __u32 y;
+ __u32 z;
+ __u32 w;
+ __u32 h;
+ __u32 d;
+};
+
+struct drm_virtgpu_3d_transfer_to_host {
+ __u32 bo_handle;
+ struct drm_virtgpu_3d_box box;
+ __u32 level;
+ __u32 offset;
+ __u32 stride;
+ __u32 layer_stride;
+};
+
+struct drm_virtgpu_3d_transfer_from_host {
+ __u32 bo_handle;
+ struct drm_virtgpu_3d_box box;
+ __u32 level;
+ __u32 offset;
+ __u32 stride;
+ __u32 layer_stride;
+};
+
+#define VIRTGPU_WAIT_NOWAIT 1 /* like it */
+struct drm_virtgpu_3d_wait {
+ __u32 handle; /* 0 is an invalid handle */
+ __u32 flags;
+};
+
+struct drm_virtgpu_get_caps {
+ __u32 cap_set_id;
+ __u32 cap_set_ver;
+ __u64 addr;
+ __u32 size;
+ __u32 pad;
+};
+
+struct drm_virtgpu_resource_create_blob {
+#define VIRTGPU_BLOB_MEM_GUEST 0x0001
+#define VIRTGPU_BLOB_MEM_HOST3D 0x0002
+#define VIRTGPU_BLOB_MEM_HOST3D_GUEST 0x0003
+
+#define VIRTGPU_BLOB_FLAG_USE_MAPPABLE 0x0001
+#define VIRTGPU_BLOB_FLAG_USE_SHAREABLE 0x0002
+#define VIRTGPU_BLOB_FLAG_USE_CROSS_DEVICE 0x0004
+ /* zero is invalid blob_mem */
+ __u32 blob_mem;
+ __u32 blob_flags;
+ __u32 bo_handle;
+ __u32 res_handle;
+ __u64 size;
+
+ /*
+ * for 3D contexts with VIRTGPU_BLOB_MEM_HOST3D_GUEST and
+ * VIRTGPU_BLOB_MEM_HOST3D otherwise, must be zero.
+ */
+ __u32 pad;
+ __u32 cmd_size;
+ __u64 cmd;
+ __u64 blob_id;
+};
+
+#define VIRTGPU_CONTEXT_PARAM_CAPSET_ID 0x0001
+#define VIRTGPU_CONTEXT_PARAM_NUM_RINGS 0x0002
+#define VIRTGPU_CONTEXT_PARAM_POLL_RINGS_MASK 0x0003
+struct drm_virtgpu_context_set_param {
+ __u64 param;
+ __u64 value;
+};
+
+struct drm_virtgpu_context_init {
+ __u32 num_params;
+ __u32 pad;
+
+ /* pointer to drm_virtgpu_context_set_param array */
+ __u64 ctx_set_params;
+};
+
+#define DRM_IOCTL_VIRTGPU_MAP \
+ DRM_IOWR(DRM_COMMAND_BASE + DRM_VIRTGPU_MAP, struct drm_virtgpu_map)
+
+#define DRM_IOCTL_VIRTGPU_EXECBUFFER \
+ DRM_IOWR(DRM_COMMAND_BASE + DRM_VIRTGPU_EXECBUFFER,\
+ struct drm_virtgpu_execbuffer)
+
+#define DRM_IOCTL_VIRTGPU_GETPARAM \
+ DRM_IOWR(DRM_COMMAND_BASE + DRM_VIRTGPU_GETPARAM,\
+ struct drm_virtgpu_getparam)
+
+#define DRM_IOCTL_VIRTGPU_RESOURCE_CREATE \
+ DRM_IOWR(DRM_COMMAND_BASE + DRM_VIRTGPU_RESOURCE_CREATE, \
+ struct drm_virtgpu_resource_create)
+
+#define DRM_IOCTL_VIRTGPU_RESOURCE_INFO \
+ DRM_IOWR(DRM_COMMAND_BASE + DRM_VIRTGPU_RESOURCE_INFO, \
+ struct drm_virtgpu_resource_info)
+
+#define DRM_IOCTL_VIRTGPU_TRANSFER_FROM_HOST \
+ DRM_IOWR(DRM_COMMAND_BASE + DRM_VIRTGPU_TRANSFER_FROM_HOST, \
+ struct drm_virtgpu_3d_transfer_from_host)
+
+#define DRM_IOCTL_VIRTGPU_TRANSFER_TO_HOST \
+ DRM_IOWR(DRM_COMMAND_BASE + DRM_VIRTGPU_TRANSFER_TO_HOST, \
+ struct drm_virtgpu_3d_transfer_to_host)
+
+#define DRM_IOCTL_VIRTGPU_WAIT \
+ DRM_IOWR(DRM_COMMAND_BASE + DRM_VIRTGPU_WAIT, \
+ struct drm_virtgpu_3d_wait)
+
+#define DRM_IOCTL_VIRTGPU_GET_CAPS \
+ DRM_IOWR(DRM_COMMAND_BASE + DRM_VIRTGPU_GET_CAPS, \
+ struct drm_virtgpu_get_caps)
+
+#define DRM_IOCTL_VIRTGPU_RESOURCE_CREATE_BLOB \
+ DRM_IOWR(DRM_COMMAND_BASE + DRM_VIRTGPU_RESOURCE_CREATE_BLOB, \
+ struct drm_virtgpu_resource_create_blob)
+
+#define DRM_IOCTL_VIRTGPU_CONTEXT_INIT \
+ DRM_IOWR(DRM_COMMAND_BASE + DRM_VIRTGPU_CONTEXT_INIT, \
+ struct drm_virtgpu_context_init)
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif
diff --git a/platform/include/virtgpu_gfxstream_protocol.h b/platform/include/virtgpu_gfxstream_protocol.h
new file mode 100644
index 0000000..6bf26a2
--- /dev/null
+++ b/platform/include/virtgpu_gfxstream_protocol.h
@@ -0,0 +1,68 @@
+// Copyright 2022 The Android Open Source Project
+//
+// 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 VIRTGPU_GFXSTREAM_PROTOCOL_H
+#define VIRTGPU_GFXSTREAM_PROTOCOL_H
+
+#include <stdint.h>
+
+// Address Space Graphics contexts
+#define GFXSTREAM_CONTEXT_CREATE 0x1001
+#define GFXSTREAM_CONTEXT_PING 0x1002
+#define GFXSTREAM_CONTEXT_PING_WITH_RESPONSE 0x1003
+
+// Native Sync FD
+#define GFXSTREAM_CREATE_EXPORT_SYNC 0x9000
+#define GFXSTREAM_CREATE_IMPORT_SYNC 0x9001
+
+// Vulkan Sync
+#define GFXSTREAM_CREATE_EXPORT_SYNC_VK 0xa000
+#define GFXSTREAM_CREATE_IMPORT_SYNC_VK 0xa001
+#define GFXSTREAM_CREATE_QSRI_EXPORT_VK 0xa002
+
+struct gfxstreamHeader {
+ uint32_t opCode;
+};
+
+struct gfxstreamContextCreate {
+ struct gfxstreamHeader hdr;
+ uint32_t resourceId;
+};
+
+struct gfxstreamContextPing {
+ struct gfxstreamHeader hdr;
+ uint32_t resourceId;
+};
+
+struct gfxstreamCreateExportSync {
+ struct gfxstreamHeader hdr;
+ uint32_t syncHandleLo;
+ uint32_t syncHandleHi;
+};
+
+struct gfxstreamCreateExportSyncVK {
+ struct gfxstreamHeader hdr;
+ uint32_t deviceHandleLo;
+ uint32_t deviceHandleHi;
+ uint32_t fenceHandleLo;
+ uint32_t fenceHandleHi;
+};
+
+struct gfxstreamCreateQSRIExportVK {
+ struct gfxstreamHeader hdr;
+ uint32_t imageHandleLo;
+ uint32_t imageHandleHi;
+};
+
+#endif
diff --git a/platform/linux/VirtGpuBlob.cpp b/platform/linux/VirtGpuBlob.cpp
new file mode 100644
index 0000000..63d508e
--- /dev/null
+++ b/platform/linux/VirtGpuBlob.cpp
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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 <fcntl.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <xf86drm.h>
+#include <cerrno>
+#include <cstring>
+
+#include <cutils/log.h>
+
+#include "VirtGpu.h"
+#include "virtgpu_drm.h"
+
+VirtGpuBlob::VirtGpuBlob(int64_t deviceHandle, uint32_t blobHandle, uint32_t resourceHandle,
+ uint64_t size)
+ : mDeviceHandle(deviceHandle),
+ mBlobHandle(blobHandle),
+ mResourceHandle(resourceHandle),
+ mSize(size) {}
+
+VirtGpuBlob::~VirtGpuBlob(void) {
+ struct drm_gem_close gem_close {
+ .handle = mBlobHandle, .pad = 0,
+ };
+
+ int ret = drmIoctl(mDeviceHandle, DRM_IOCTL_GEM_CLOSE, &gem_close);
+ if (ret) {
+ ALOGE("DRM_IOCTL_GEM_CLOSE failed with : [%s, blobHandle %u, resourceHandle: %u]",
+ strerror(errno), mBlobHandle, mResourceHandle);
+ }
+}
+
+uint32_t VirtGpuBlob::getBlobHandle(void) {
+ return mBlobHandle;
+}
+
+uint32_t VirtGpuBlob::getResourceHandle(void) {
+ return mResourceHandle;
+}
+
+VirtGpuBlobMappingPtr VirtGpuBlob::createMapping(void) {
+ int ret;
+ struct drm_virtgpu_map map {
+ .handle = mBlobHandle, .pad = 0,
+ };
+
+ ret = drmIoctl(mDeviceHandle, DRM_IOCTL_VIRTGPU_MAP, &map);
+ if (ret) {
+ ALOGE("DRM_IOCTL_VIRTGPU_MAP failed with %s", strerror(errno));
+ return nullptr;
+ }
+
+ uint8_t* ptr = static_cast<uint8_t*>(
+ mmap64(nullptr, mSize, PROT_WRITE | PROT_READ, MAP_SHARED, mDeviceHandle, map.offset));
+
+ if (ptr == MAP_FAILED) {
+ ALOGE("mmap64 failed with (%s)", strerror(errno));
+ return nullptr;
+ }
+
+ return std::make_shared<VirtGpuBlobMapping>(shared_from_this(), ptr, mSize);
+}
+
+int VirtGpuBlob::exportBlob(struct VirtGpuExternalHandle& handle) {
+ int ret, fd;
+
+ ret = drmPrimeHandleToFD(mDeviceHandle, mBlobHandle, DRM_CLOEXEC | DRM_RDWR, &fd);
+ if (ret) {
+ ALOGE("drmPrimeHandleToFD failed with %s", strerror(errno));
+ return ret;
+ }
+
+ handle.osHandle = static_cast<int64_t>(fd);
+ handle.type = kMemHandleDmabuf;
+ return 0;
+}
+
+int VirtGpuBlob::wait() {
+ int ret;
+ struct drm_virtgpu_3d_wait wait_3d = {0};
+
+ int retry = 0;
+ do {
+ if (retry > 0 && (retry % 10 == 0)) {
+ ALOGE("DRM_IOCTL_VIRTGPU_WAIT failed with EBUSY for %d times.", retry);
+ }
+ wait_3d.handle = mBlobHandle;
+ ret = drmIoctl(mDeviceHandle, DRM_IOCTL_VIRTGPU_WAIT, &wait_3d);
+ ++retry;
+ } while (ret < 0 && errno == EBUSY);
+
+ if (ret < 0) {
+ ALOGE("DRM_IOCTL_VIRTGPU_WAIT failed with %s", strerror(errno));
+ return ret;
+ }
+
+ return 0;
+}
diff --git a/platform/linux/VirtGpuBlobMapping.cpp b/platform/linux/VirtGpuBlobMapping.cpp
new file mode 100644
index 0000000..e8251b8
--- /dev/null
+++ b/platform/linux/VirtGpuBlobMapping.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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 <sys/mman.h>
+
+#include "VirtGpu.h"
+
+VirtGpuBlobMapping::VirtGpuBlobMapping(VirtGpuBlobPtr blob, uint8_t* ptr, uint64_t size)
+ : mBlob(blob), mPtr(ptr), mSize(size) {}
+
+VirtGpuBlobMapping::~VirtGpuBlobMapping(void) {
+ munmap(mPtr, mSize);
+}
+
+uint8_t* VirtGpuBlobMapping::asRawPtr(void) {
+ return mPtr;
+}
+
diff --git a/platform/linux/VirtGpuDevice.cpp b/platform/linux/VirtGpuDevice.cpp
new file mode 100644
index 0000000..77f2509
--- /dev/null
+++ b/platform/linux/VirtGpuDevice.cpp
@@ -0,0 +1,201 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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 <fcntl.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <xf86drm.h>
+#include <cerrno>
+#include <cstring>
+
+#include <cutils/log.h>
+
+#include "VirtGpu.h"
+#include "virtgpu_drm.h"
+
+#define PARAM(x) \
+ (struct VirtGpuParam) { x, #x, 0 }
+
+// See virgl_hw.h and p_defines.h
+#define VIRGL_FORMAT_R8_UNORM 64
+#define VIRGL_BIND_CUSTOM (1 << 17)
+#define PIPE_BUFFER 0
+
+VirtGpuDevice& VirtGpuDevice::getInstance(enum VirtGpuCapset capset) {
+ static VirtGpuDevice mInstance(capset);
+ return mInstance;
+}
+
+VirtGpuDevice::VirtGpuDevice(enum VirtGpuCapset capset) {
+ struct VirtGpuParam params[] = {
+ PARAM(VIRTGPU_PARAM_3D_FEATURES), PARAM(VIRTGPU_PARAM_CAPSET_QUERY_FIX),
+ PARAM(VIRTGPU_PARAM_RESOURCE_BLOB), PARAM(VIRTGPU_PARAM_HOST_VISIBLE),
+ PARAM(VIRTGPU_PARAM_CROSS_DEVICE), PARAM(VIRTGPU_PARAM_CONTEXT_INIT),
+ PARAM(VIRTGPU_PARAM_SUPPORTED_CAPSET_IDs),
+ };
+
+ mDeviceHandle = static_cast<int64_t>(drmOpenRender(128));
+ if (mDeviceHandle < 0) {
+ ALOGE("Failed to open rendernode: %s", strerror(errno));
+ return;
+ }
+
+ for (uint32_t i = 0; i < kParamMax; i++) {
+ struct drm_virtgpu_getparam get_param = {0};
+ get_param.param = params[i].param;
+ get_param.value = (uint64_t)(uintptr_t)¶ms[i].value;
+
+ int ret = drmIoctl(mDeviceHandle, DRM_IOCTL_VIRTGPU_GETPARAM, &get_param);
+ if (ret) {
+ ALOGE("virtgpu backend not enabling %s", params[i].name);
+ }
+
+ mParams[i] = params[i];
+ }
+
+ if (capset != kCapsetNone) {
+ int ret;
+ struct drm_virtgpu_context_init init = {0};
+ struct drm_virtgpu_context_set_param ctx_set_params[2] = {{0}};
+
+ ctx_set_params[0].param = VIRTGPU_CONTEXT_PARAM_NUM_RINGS;
+ ctx_set_params[0].value = 1;
+ init.num_params = 1;
+
+ ctx_set_params[1].param = VIRTGPU_CONTEXT_PARAM_CAPSET_ID;
+ ctx_set_params[1].value = static_cast<uint32_t>(capset);
+ init.num_params++;
+
+ init.ctx_set_params = (unsigned long long)&ctx_set_params[0];
+ ret = drmIoctl(mDeviceHandle, DRM_IOCTL_VIRTGPU_CONTEXT_INIT, &init);
+ if (ret) {
+ ALOGE("DRM_IOCTL_VIRTGPU_CONTEXT_INIT failed with %s, continuing without context...",
+ strerror(errno));
+ }
+ }
+}
+
+uint64_t VirtGpuDevice::getParam(enum VirtGpuParamId param) {
+ if (param >= kParamMax) {
+ ALOGE("Invalid parameter");
+ return false;
+ }
+
+ return mParams[param].value;
+}
+
+int64_t VirtGpuDevice::getDeviceHandle(void) {
+ return mDeviceHandle;
+}
+
+VirtGpuBlobPtr VirtGpuDevice::createPipeBlob(uint32_t size) {
+ drm_virtgpu_resource_create create = {
+ .target = PIPE_BUFFER,
+ .format = VIRGL_FORMAT_R8_UNORM,
+ .bind = VIRGL_BIND_CUSTOM,
+ .width = size,
+ .height = 1U,
+ .depth = 1U,
+ .array_size = 0U,
+ .size = size,
+ .stride = size,
+ };
+
+ int ret = drmIoctl(mDeviceHandle, DRM_IOCTL_VIRTGPU_RESOURCE_CREATE, &create);
+ if (ret) {
+ ALOGE("DRM_IOCTL_VIRTGPU_RESOURCE_CREATE failed with %s", strerror(errno));
+ return nullptr;
+ }
+
+ return std::make_shared<VirtGpuBlob>(mDeviceHandle, create.bo_handle, create.res_handle,
+ static_cast<uint64_t>(size));
+}
+
+VirtGpuBlobPtr VirtGpuDevice::createBlob(struct VirtGpuCreateBlob& blobCreate) {
+ int ret;
+ struct drm_virtgpu_resource_create_blob create = {0};
+
+ create.size = blobCreate.size;
+ create.blob_mem = blobCreate.blobMem;
+ create.blob_flags = blobCreate.flags;
+ create.blob_id = blobCreate.blobId;
+
+ ret = drmIoctl(mDeviceHandle, DRM_IOCTL_VIRTGPU_RESOURCE_CREATE_BLOB, &create);
+ if (ret < 0) {
+ ALOGE("DRM_VIRTGPU_RESOURCE_CREATE_BLOB failed with %s", strerror(errno));
+ return nullptr;
+ }
+
+ return std::make_shared<VirtGpuBlob>(mDeviceHandle, create.bo_handle, create.res_handle,
+ blobCreate.size);
+}
+
+VirtGpuBlobPtr VirtGpuDevice::importBlob(struct VirtGpuExternalHandle& handle) {
+ struct drm_virtgpu_resource_info info = {0};
+ uint32_t blobHandle;
+ int ret;
+
+ ret = drmPrimeFDToHandle(mDeviceHandle, handle.osHandle, &blobHandle);
+ close(handle.osHandle);
+ if (ret) {
+ ALOGE("DRM_IOCTL_PRIME_FD_TO_HANDLE failed: %s", strerror(errno));
+ return nullptr;
+ }
+
+ info.bo_handle = blobHandle;
+ ret = drmIoctl(mDeviceHandle, DRM_IOCTL_VIRTGPU_RESOURCE_INFO, &info);
+ if (ret) {
+ ALOGE("DRM_IOCTL_VIRTGPU_RESOURCE_INFO failed: %s", strerror(errno));
+ return nullptr;
+ }
+
+ return std::make_shared<VirtGpuBlob>(mDeviceHandle, blobHandle, info.res_handle,
+ static_cast<uint64_t>(info.size));
+}
+
+int VirtGpuDevice::execBuffer(struct VirtGpuExecBuffer& execbuffer, VirtGpuBlobPtr blob) {
+ int ret;
+ struct drm_virtgpu_execbuffer exec = {0};
+ uint32_t blobHandle;
+
+ exec.flags = execbuffer.flags;
+ exec.size = execbuffer.command_size;
+ exec.command = (uint64_t)(uintptr_t)(execbuffer.command);
+ exec.fence_fd = -1;
+
+ if (blob) {
+ blobHandle = blob->getBlobHandle();
+ exec.bo_handles = (uint64_t)(uintptr_t)(&blobHandle);
+ exec.num_bo_handles = 1;
+ }
+
+ ret = drmIoctl(mDeviceHandle, DRM_IOCTL_VIRTGPU_EXECBUFFER, &exec);
+ if (ret) {
+ ALOGE("DRM_IOCTL_VIRTGPU_EXECBUFFER failed: %s", strerror(errno));
+ return ret;
+ }
+
+ if (execbuffer.flags & kFenceOut) {
+ execbuffer.handle.osHandle = exec.fence_fd;
+ execbuffer.handle.type = kFenceHandleSyncFd;
+ }
+
+ return 0;
+}
+
+VirtGpuDevice::~VirtGpuDevice() {
+ close(mDeviceHandle);
+}
diff --git a/platform/linux/meson.build b/platform/linux/meson.build
new file mode 100644
index 0000000..07bae4e
--- /dev/null
+++ b/platform/linux/meson.build
@@ -0,0 +1,16 @@
+# Copyright 2022 Android Open Source Project
+# SPDX-License-Identifier: MIT
+
+files_lib_platform = files(
+ 'VirtGpuDevice.cpp',
+ 'VirtGpuBlobMapping.cpp',
+ 'VirtGpuBlob.cpp',
+)
+
+lib_platform = static_library(
+ 'platform',
+ files_lib_platform,
+ cpp_args: cpp_args,
+ include_directories: [inc_platform, inc_android_compat],
+ dependencies: drm_dep,
+)
diff --git a/platform/meson.build b/platform/meson.build
new file mode 100644
index 0000000..db13d00
--- /dev/null
+++ b/platform/meson.build
@@ -0,0 +1,5 @@
+# Copyright 2022 Android Open Source Project
+# SPDX-License-Identifier: MIT
+
+inc_platform = include_directories('include')
+subdir('linux')
diff --git a/platform/stub/VirtGpuBlob.cpp b/platform/stub/VirtGpuBlob.cpp
new file mode 100644
index 0000000..d07fa18
--- /dev/null
+++ b/platform/stub/VirtGpuBlob.cpp
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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 "VirtGpu.h"
+
+VirtGpuBlob::VirtGpuBlob(int64_t deviceHandle, uint32_t blobHandle, uint32_t resourceHandle,
+ uint64_t size)
+ : mDeviceHandle(deviceHandle),
+ mBlobHandle(blobHandle),
+ mResourceHandle(resourceHandle),
+ mSize(size) {}
+
+VirtGpuBlob::~VirtGpuBlob(void) {
+ // Unimplemented stub
+}
+
+uint32_t VirtGpuBlob::getBlobHandle(void) {
+ return 0;
+}
+
+uint32_t VirtGpuBlob::getResourceHandle(void) {
+ return 0;
+}
+
+VirtGpuBlobMappingPtr VirtGpuBlob::createMapping(void) {
+ return nullptr;
+}
+
+int VirtGpuBlob::wait() {
+ return -1;
+}
diff --git a/platform/stub/VirtGpuBlobMapping.cpp b/platform/stub/VirtGpuBlobMapping.cpp
new file mode 100644
index 0000000..b14b658
--- /dev/null
+++ b/platform/stub/VirtGpuBlobMapping.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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 "VirtGpu.h"
+
+VirtGpuBlobMapping::VirtGpuBlobMapping(VirtGpuBlobPtr blob, uint8_t* ptr, uint64_t size)
+ : mBlob(blob), mPtr(ptr), mSize(size) {}
+
+VirtGpuBlobMapping::~VirtGpuBlobMapping(void) {
+ // Unimplemented for now
+ (void) mPtr;
+ (void) mSize;
+ (void) mBlob;
+}
+
+uint8_t* VirtGpuBlobMapping::asRawPtr(void) {
+ return nullptr;
+}
diff --git a/platform/stub/VirtGpuDevice.cpp b/platform/stub/VirtGpuDevice.cpp
new file mode 100644
index 0000000..84c1d18
--- /dev/null
+++ b/platform/stub/VirtGpuDevice.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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 "VirtGpu.h"
+
+VirtGpuDevice& VirtGpuDevice::getInstance(enum VirtGpuCapset capset) {
+ static VirtGpuDevice mInstance(capset);
+ return mInstance;
+}
+
+VirtGpuDevice::VirtGpuDevice(enum VirtGpuCapset capset) {
+ // Unimplemented stub
+}
+
+uint64_t VirtGpuDevice::getParam(enum VirtGpuParamId param) {
+ return 0;
+}
+
+int64_t VirtGpuDevice::getDeviceHandle(void) {
+ return mDeviceHandle;
+}
+
+VirtGpuBlobPtr VirtGpuDevice::createPipeBlob(uint32_t size) {
+ return nullptr;
+}
+
+VirtGpuBlobPtr VirtGpuDevice::createBlob(struct VirtGpuCreateBlob& blobCreate) {
+ return nullptr;
+}
+
+VirtGpuBlobPtr VirtGpuDevice::importBlob(struct VirtGpuExternalHandle& handle) {
+ return nullptr;
+}
+
+int VirtGpuDevice::execBuffer(struct VirtGpuExecBuffer& execbuffer, VirtGpuBlobPtr blob) {
+ return -1;
+}
+
+VirtGpuDevice::~VirtGpuDevice() {
+ // Unimplemented stub
+}
diff --git a/shared/GoldfishAddressSpace/Android.bp b/shared/GoldfishAddressSpace/Android.bp
index 26cc468..4b477a1 100644
--- a/shared/GoldfishAddressSpace/Android.bp
+++ b/shared/GoldfishAddressSpace/Android.bp
@@ -17,6 +17,9 @@
"liblog",
"libdrm",
],
+ static_libs: [
+ "libplatform",
+ ],
export_include_dirs: [
"include",
],
diff --git a/shared/GoldfishAddressSpace/include/goldfish_address_space.h b/shared/GoldfishAddressSpace/include/goldfish_address_space.h
index d0381b8..63587aa 100644
--- a/shared/GoldfishAddressSpace/include/goldfish_address_space.h
+++ b/shared/GoldfishAddressSpace/include/goldfish_address_space.h
@@ -143,7 +143,7 @@
uint64_t offset;
uint64_t size;
uint64_t metadata;
- uint32_t version;
+ uint32_t resourceId;
uint32_t wait_fd;
uint32_t wait_flags;
uint32_t direction;
@@ -170,43 +170,6 @@
bool goldfish_address_space_set_subdevice_type(address_space_handle_t, GoldfishAddressSpaceSubdeviceType type, address_space_handle_t*);
bool goldfish_address_space_ping(address_space_handle_t, struct address_space_ping*);
-// virtio-gpu version
-
-struct address_space_virtgpu_hostmem_info {
- uint32_t id;
- uint32_t bo;
- void* ptr;
-};
-
-struct address_space_virtgpu_info {
- int fd;
- uint32_t resp_bo;
- uint32_t resp_resid;
- void* resp_mapped_ptr;
-};
-
-address_space_handle_t virtgpu_address_space_open();
-void virtgpu_address_space_close(address_space_handle_t);
-
-// Ping with no response
-bool virtgpu_address_space_ping(address_space_handle_t, struct address_space_ping*);
-
-bool virtgpu_address_space_create_context_with_subdevice(
- address_space_handle_t,
- uint32_t subdevice_type,
- struct address_space_virtgpu_info* info_out);
-
-bool virtgpu_address_space_allocate_hostmem(
- address_space_handle_t fd,
- size_t size,
- uint64_t hostmem_id,
- struct address_space_virtgpu_hostmem_info* hostmem_info_out);
-
-// Ping with response
-bool virtgpu_address_space_ping_with_response(
- struct address_space_virtgpu_info* info,
- struct address_space_ping* ping);
-
// typedef/struct to abstract over goldfish vs virtio-gpu implementations
typedef address_space_handle_t (*address_space_open_t)(void);
typedef void (*address_space_close_t)(address_space_handle_t);
@@ -231,22 +194,6 @@
typedef bool (*address_space_ping_t)(
address_space_handle_t, struct address_space_ping*);
-// Specific to virtio-gpu
-typedef bool (*address_space_create_context_with_subdevice_t)(
- address_space_handle_t,
- uint32_t subdevice_type,
- struct address_space_virtgpu_info* info_out);
-
-typedef bool (*address_space_allocate_hostmem_t)(
- address_space_handle_t fd,
- size_t size,
- uint64_t hostmem_id,
- struct address_space_virtgpu_hostmem_info* hostmem_info_out);
-
-typedef bool (*address_space_ping_with_response_t)(
- struct address_space_virtgpu_info* info,
- struct address_space_ping* ping);
-
struct address_space_ops {
address_space_open_t open;
address_space_close_t close;
@@ -256,9 +203,6 @@
address_space_unmap_t unmap;
address_space_set_subdevice_type_t set_subdevice_type;
address_space_ping_t ping;
- address_space_create_context_with_subdevice_t create_context_with_subdevice;
- address_space_allocate_hostmem_t allocate_hostmem;
- address_space_ping_with_response_t ping_with_response;
};
#endif // #ifndef ANDROID_INCLUDE_HARDWARE_GOLDFISH_ADDRESS_SPACE_H
diff --git a/shared/GoldfishAddressSpace/include/goldfish_address_space_android.impl b/shared/GoldfishAddressSpace/include/goldfish_address_space_android.impl
index e390ba8..af46444 100644
--- a/shared/GoldfishAddressSpace/include/goldfish_address_space_android.impl
+++ b/shared/GoldfishAddressSpace/include/goldfish_address_space_android.impl
@@ -26,14 +26,9 @@
#include <memory>
#include <cstring>
-#ifdef VIRTIO_GPU
-#include <xf86drm.h>
-#endif
-
+#include "goldfish_address_space.h"
#include <log/log.h>
-#include "goldfish_address_space.h"
-#include "virtgpu_drm.h"
// See virgl_hw.h and p_defines.h
#define VIRGL_FORMAT_R8_UNORM 64
@@ -90,7 +85,7 @@
{
struct address_space_ping request;
::memset(&request, 0, sizeof(request));
- request.version = sizeof(request);
+ request.resourceId = sizeof(request);
request.metadata = type;
long ret = ioctl_ping(fd, &request);
@@ -374,7 +369,7 @@
if (m_useSharedSlots) {
// shared memory slots are supported
::memset(&request, 0, sizeof(request));
- request.version = sizeof(request);
+ request.resourceId = sizeof(request);
request.size = size;
request.metadata = HOST_MEMORY_ALLOCATOR_COMMAND_ALLOCATE_ID;
@@ -395,7 +390,7 @@
}
::memset(&request, 0, sizeof(request));
- request.version = sizeof(request);
+ request.resourceId = sizeof(request);
request.offset = block->offset();
request.size = block->size();
request.metadata = HOST_MEMORY_ALLOCATOR_COMMAND_ALLOCATE_ID;
@@ -428,7 +423,7 @@
if (block->guestPtr()) {
struct address_space_ping request;
::memset(&request, 0, sizeof(request));
- request.version = sizeof(request);
+ request.resourceId = sizeof(request);
request.offset = block->offset();
request.metadata = HOST_MEMORY_ALLOCATOR_COMMAND_UNALLOCATE_ID;
@@ -546,256 +541,3 @@
return true;
}
-
-#define CAPSET_GFXSTREAM 3
-
-
-address_space_handle_t virtgpu_address_space_open() {
- return -EINVAL;
-}
-
-void virtgpu_address_space_close(address_space_handle_t fd) {
- close(fd);
-}
-
-// kVirtioGpuAddressSpaceContextCreateWithSubdevice | subdeviceType
-const uint32_t kVirtioGpuAddressSpaceContextCreateWithSubdevice = 0x1001;
-
-// kVirtioGpuAddressSpacePing | offset_lo | offset_hi | size_lo | size_hi | metadata_lo | metadata_hi | version | wait_fd | wait_flags | direction
-// no output
-const uint32_t kVirtioGpuAddressSpacePing = 0x1002;
-
-// kVirtioGpuAddressSpacePingWithResponse | resp_resid | offset_lo | offset_hi | metadata_lo | metadata_hi | version | wait_fd | wait_flags | direction
-// out: same as input then | out: error
-const uint32_t kVirtioGpuAddressSpacePingWithResponse = 0x1003;
-
-// Ping with no response
-bool virtgpu_address_space_ping(address_space_handle_t fd, struct address_space_ping* info) {
-
- uint32_t words[] = {
- kVirtioGpuAddressSpacePing,
- (uint32_t)(info->offset), (uint32_t)(info->offset >> 32),
- (uint32_t)(info->size), (uint32_t)(info->size >> 32),
- (uint32_t)(info->metadata), (uint32_t)(info->metadata >> 32),
- (uint32_t)(info->version), (uint32_t)(info->wait_fd),
- (uint32_t)(info->wait_flags), (uint32_t)(info->direction),
- };
-
- drm_virtgpu_execbuffer execbuffer = {
- .flags = 0,
- .size = sizeof(words),
- .command = (uint64_t)(uintptr_t)(words),
- .bo_handles = 0,
- .num_bo_handles = 0,
- .fence_fd = -1,
- };
-
- int queue_work_err = drmIoctl(fd, DRM_IOCTL_VIRTGPU_EXECBUFFER, &execbuffer);
-
- if (queue_work_err) {
- ALOGE("%s: failed with %d executing command buffer (%s)\n", __func__,
- queue_work_err, strerror(errno));
- return false;
- }
-
- return true;
-}
-
-bool virtgpu_address_space_create_context_with_subdevice(
- address_space_handle_t fd,
- uint32_t subdevice_type,
- struct address_space_virtgpu_info* info_out) {
-
- // response page
- drm_virtgpu_resource_create create = {
- .target = PIPE_BUFFER,
- .format = VIRGL_FORMAT_R8_UNORM,
- .bind = VIRGL_BIND_CUSTOM,
- .width = 4096,
- .height = 1U,
- .depth = 1U,
- .array_size = 0U,
- .size = 4096,
- .stride = 4096,
- };
-
- int ret = drmIoctl(fd, DRM_IOCTL_VIRTGPU_RESOURCE_CREATE, &create);
- if (ret) {
- ALOGE("%s: failed with %d allocating command buffer (%s)\n",
- __func__, ret, strerror(errno));
- return false;
- }
-
- drm_virtgpu_map map;
- memset(&map, 0, sizeof(map));
- map.handle = create.bo_handle;
-
- ret = drmIoctl(fd, DRM_IOCTL_VIRTGPU_MAP, &map);
- if (ret) {
- ALOGE("%s: failed with %d mapping command response buffer (%s)\n",
- __func__, ret, strerror(errno));
- return false;
- }
-
- void* ptr = static_cast<unsigned char*>(
- mmap64(nullptr, 4096, PROT_WRITE, MAP_SHARED, fd, map.offset));
-
- if (ptr == MAP_FAILED) {
- ALOGE("%s: failed with %d mmap'ing command response buffer (%s)\n",
- __func__, errno, strerror(errno));
- return false;
- }
-
- info_out->fd = fd;
- info_out->resp_bo = create.bo_handle;
- info_out->resp_resid = create.res_handle;
- info_out->resp_mapped_ptr = ptr;
-
- ALOGD("%s: resp bo: %u resid %u mapped %p\n", __func__,
- create.bo_handle, create.res_handle, ptr);
-
- // Context creation command
- uint32_t words[] = {
- kVirtioGpuAddressSpaceContextCreateWithSubdevice,
- subdevice_type,
- };
-
- drm_virtgpu_execbuffer execbuffer = {
- .flags = 0,
- .size = sizeof(words),
- .command = (uint64_t)(uintptr_t)(words),
- .bo_handles = 0,
- .num_bo_handles = 0,
- .fence_fd = -1,
- };
-
- int queue_work_err = drmIoctl(fd, DRM_IOCTL_VIRTGPU_EXECBUFFER, &execbuffer);
-
- if (queue_work_err) {
- ALOGE("%s: failed with %d executing command buffer (%s)\n", __func__,
- queue_work_err, strerror(errno));
- return false;
- }
-
- return true;
-}
-
-bool virtgpu_address_space_allocate_hostmem(
- address_space_handle_t fd,
- size_t size,
- uint64_t hostmem_id,
- struct address_space_virtgpu_hostmem_info* hostmem_info_out) {
-
- struct drm_virtgpu_resource_create_blob drm_rc_blob = {};
- drm_rc_blob.blob_mem = VIRTGPU_BLOB_MEM_HOST3D;
- drm_rc_blob.blob_flags = VIRTGPU_BLOB_FLAG_USE_MAPPABLE;
- drm_rc_blob.blob_id = hostmem_id;
- drm_rc_blob.size = size;
-
- int res = drmIoctl(
- fd, DRM_IOCTL_VIRTGPU_RESOURCE_CREATE_BLOB, &drm_rc_blob);
-
- if (res) {
- ALOGE("%s: Failed to resource create v2: sterror: %s errno: %d\n", __func__,
- strerror(errno), errno);
- abort();
- }
-
- drm_virtgpu_map map;
- memset(&map, 0, sizeof(map));
- map.handle = drm_rc_blob.bo_handle;
-
- res = drmIoctl(fd, DRM_IOCTL_VIRTGPU_MAP, &map);
- if (res) {
- ALOGE("%s: Failed to virtgpu map: sterror: %s errno: %d\n", __func__,
- strerror(errno), errno);
- abort();
- }
-
- void* directMappedAddr = mmap64(0, size, PROT_WRITE, MAP_SHARED, fd, map.offset);
-
- if (directMappedAddr == MAP_FAILED) {
- ALOGE("%s: mmap of virtio gpu resource failed\n", __func__);
- abort();
- }
-
- hostmem_info_out->id = hostmem_id;
- hostmem_info_out->bo = drm_rc_blob.bo_handle;
- hostmem_info_out->ptr = directMappedAddr;
- return true;
-}
-
-uint64_t buildu64(uint32_t lo, uint32_t hi) {
- uint64_t res = (uint64_t)lo;
- uint64_t hi64 = (uint64_t)hi;
- return res | (hi64 << 32);
-}
-
-/* Used to retry DRM_IOCTL_VIRTGPU_WAIT, which can also return EBUSY. */
-#define TEMP_FAILURE_RETRY_BUSY(tag, exp) ({ \
- __typeof__(exp) _rc; \
- do { \
- uint32_t busy_times = 0; \
- _rc = (exp); \
- if (errno == EBUSY) { \
- ++busy_times; \
- usleep(10000); \
- ALOGE("%s:%s busy! waited %u times on EBUSY\n", __func__, tag, busy_times); \
- } \
- } while (_rc != 0 && (errno == EINTR || errno == EBUSY)); \
- _rc; })
-
-// Ping with response
-bool virtgpu_address_space_ping_with_response(
- struct address_space_virtgpu_info* info,
- struct address_space_ping* ping) {
-
- uint32_t words[] = {
- kVirtioGpuAddressSpacePingWithResponse,
- info->resp_resid,
- (uint32_t)(ping->offset), (uint32_t)(ping->offset >> 32),
- (uint32_t)(ping->size), (uint32_t)(ping->size >> 32),
- (uint32_t)(ping->metadata), (uint32_t)(ping->metadata >> 32),
- (uint32_t)(ping->version), (uint32_t)(ping->wait_fd),
- (uint32_t)(ping->wait_flags), (uint32_t)(ping->direction),
- };
-
- drm_virtgpu_execbuffer execbuffer = {
- .flags = 0,
- .size = sizeof(words),
- .command = (uint64_t)(uintptr_t)(words),
- .bo_handles = (uint64_t)(uintptr_t)(&info->resp_bo),
- .num_bo_handles = 1,
- .fence_fd = -1,
- };
-
- int queue_work_err = drmIoctl(info->fd, DRM_IOCTL_VIRTGPU_EXECBUFFER, &execbuffer);
-
- if (queue_work_err) {
- ALOGE("%s: failed with %d executing command buffer (%s)\n", __func__,
- queue_work_err, strerror(errno));
- return false;
- }
-
- struct drm_virtgpu_3d_wait waitcmd;
- memset(&waitcmd, 0, sizeof(waitcmd));
- waitcmd.handle = info->resp_bo;
-
- int ret = TEMP_FAILURE_RETRY_BUSY("DRM_IOCTL_VIRTGPU_WAIT", drmIoctl(info->fd, DRM_IOCTL_VIRTGPU_WAIT, &waitcmd));
- if (ret) {
- ALOGE("%s: DRM_IOCTL_VIRTGPU_WAIT failed with %d (%s)\n", __func__, errno, strerror(errno));
- return false;
- }
-
- uint32_t* respWords = (uint32_t*)info->resp_mapped_ptr;
-
- ping->offset = buildu64(respWords[0], respWords[1]);
- ping->size = buildu64(respWords[2], respWords[3]);
- ping->metadata = buildu64(respWords[4], respWords[5]);
- ping->version = respWords[6];
- ping->wait_fd = respWords[7];
- ping->wait_flags = respWords[8];
- ping->direction = respWords[9];
-
- return true;
-}
diff --git a/shared/GoldfishAddressSpace/include/goldfish_address_space_fuchsia.impl b/shared/GoldfishAddressSpace/include/goldfish_address_space_fuchsia.impl
index ca0dac8..3568c76 100644
--- a/shared/GoldfishAddressSpace/include/goldfish_address_space_fuchsia.impl
+++ b/shared/GoldfishAddressSpace/include/goldfish_address_space_fuchsia.impl
@@ -33,7 +33,7 @@
#include <unordered_map>
#define GET_STATUS_SAFE(result, member) \
- ((result).ok() ? ((result).Unwrap()->member) : ZX_OK)
+ ((result).ok() ? ((result)->member) : ZX_OK)
using android::base::guest::AutoLock;
using android::base::guest::Lock;
@@ -131,12 +131,12 @@
const fidl::WireSyncClient<AddressSpaceChildDriver>& driver = provider->m_child_driver;
auto result = driver->AllocateBlock(size);
- if (!result.ok() || result.Unwrap()->res != ZX_OK) {
+ if (!result.ok() || result->res != ZX_OK) {
ALOGE("%s: allocate block failed: %d:%d", __func__, result.status(), GET_STATUS_SAFE(result, res));
return false;
}
- m_phys_addr = result.Unwrap()->paddr;
- m_vmo = result.Unwrap()->vmo.release();
+ m_phys_addr = result->paddr;
+ m_vmo = result->vmo.release();
m_size = size;
m_offset = 0;
@@ -225,13 +225,13 @@
abort();
// int32_t res = ZX_OK;
// auto result = m_driver->UnclaimShared(m_offset);
- // if (!result.ok() || result.Unwrap()->res != ZX_OK) {
+ // if (!result.ok() || result->res != ZX_OK) {
// ALOGE("%s: unclaim shared block failed: %d:%d", __func__,
// result.status(), GET_STATUS_SAFE(result, res));
// }
} else {
auto result = (*m_driver)->DeallocateBlock(m_phys_addr);
- if (!result.ok() || result.Unwrap()->res != ZX_OK) {
+ if (!result.ok() || result->res != ZX_OK) {
ALOGE("%s: deallocate block failed: %d:%d", __func__,
result.status(), GET_STATUS_SAFE(result, res));
}
@@ -359,12 +359,12 @@
zx::vmo vmo;
auto result = deviceSync->AllocateBlock(size);
- if (!result.ok() || result.Unwrap()->res != ZX_OK) {
+ if (!result.ok() || result->res != ZX_OK) {
ALOGE("%s: allocate block failed: %d:%d", __func__, result.status(), GET_STATUS_SAFE(result, res));
return false;
}
- *phys_addr = result.Unwrap()->paddr;
- vmo = std::move(result.Unwrap()->vmo);
+ *phys_addr = result->paddr;
+ vmo = std::move(result->vmo);
*offset = 0;
@@ -388,7 +388,7 @@
fidl::WireSyncClient<AddressSpaceChildDriver>*>(handle);
auto result = deviceSync->DeallocateBlock(info.phys_addr);
- if (!result.ok() || result.Unwrap()->res != ZX_OK) {
+ if (!result.ok() || result->res != ZX_OK) {
ALOGE("%s: deallocate block failed: %d:%d", __func__, result.status(), GET_STATUS_SAFE(result, res));
return false;
}
@@ -405,11 +405,11 @@
zx::vmo vmo;
auto result = deviceSync->ClaimSharedBlock(offset, size);
- if (!result.ok() || result.Unwrap()->res != ZX_OK) {
+ if (!result.ok() || result->res != ZX_OK) {
ALOGE("%s: claim shared failed: %d:%d", __func__, result.status(), GET_STATUS_SAFE(result, res));
return false;
}
- vmo = std::move(result.Unwrap()->vmo);
+ vmo = std::move(result->vmo);
VmoStore::Info info = {
vmo.release(),
@@ -427,7 +427,7 @@
fidl::WireSyncClient<AddressSpaceChildDriver>*>(handle);
auto result = deviceSync->UnclaimSharedBlock(offset);
- if (!result.ok() || result.Unwrap()->res != ZX_OK) {
+ if (!result.ok() || result->res != ZX_OK) {
ALOGE("%s: unclaim shared failed: %d:%d", __func__, result.status(), GET_STATUS_SAFE(result, res));
return false;
}
@@ -474,10 +474,10 @@
AddressSpaceChildDriverPingMessage res;
auto result = deviceSync->Ping(fuchsiaPing);
- if (!result.ok() || result.Unwrap()->res != ZX_OK) {
+ if (!result.ok() || result->res != ZX_OK) {
return false;
}
- res = std::move(result.Unwrap()->ping);
+ res = std::move(result->ping);
*ping = *(struct address_space_ping*)(&res);
return true;
diff --git a/shared/GoldfishAddressSpace/meson.build b/shared/GoldfishAddressSpace/meson.build
index 50fef3a..0326524 100644
--- a/shared/GoldfishAddressSpace/meson.build
+++ b/shared/GoldfishAddressSpace/meson.build
@@ -13,6 +13,7 @@
cpp_args: cpp_args,
include_directories: [inc_android_compat,
inc_goldfish_address_space,
- inc_system],
+ inc_system, inc_platform],
+ link_with: [lib_platform],
dependencies: drm_dep
)
diff --git a/shared/OpenglCodecCommon/GLClientState.cpp b/shared/OpenglCodecCommon/GLClientState.cpp
index a6dbbd6..7a1fad4 100644
--- a/shared/OpenglCodecCommon/GLClientState.cpp
+++ b/shared/OpenglCodecCommon/GLClientState.cpp
@@ -97,6 +97,7 @@
m_dispatchIndirectBuffer = 0;
m_drawIndirectBuffer = 0;
m_shaderStorageBuffer = 0;
+ m_textureBuffer = 0;
m_transformFeedbackActive = false;
m_transformFeedbackUnpaused = false;
@@ -774,6 +775,8 @@
m_drawIndirectBuffer = 0;
if (m_shaderStorageBuffer == id)
m_shaderStorageBuffer = 0;
+ if (m_textureBuffer == id)
+ m_textureBuffer = 0;
sClearIndexedBufferBinding(id, m_indexedTransformFeedbackBuffers);
sClearIndexedBufferBinding(id, m_indexedUniformBuffers);
@@ -824,6 +827,9 @@
case GL_SHADER_STORAGE_BUFFER:
m_shaderStorageBuffer = id;
break;
+ case GL_TEXTURE_BUFFER_OES:
+ m_textureBuffer = id;
+ break;
default:
err = -1;
}
@@ -883,7 +889,7 @@
}
bool GLClientState::isNonIndexedBindNoOp(GLenum target, GLuint buffer) {
- if (buffer != !getLastEncodedBufferBind(target)) return false;
+ if (buffer != getLastEncodedBufferBind(target)) return false;
int idOrError = getBuffer(target);
if (idOrError < 0) {
@@ -1009,6 +1015,9 @@
case GL_SHADER_STORAGE_BUFFER:
ret = m_shaderStorageBuffer;
break;
+ case GL_TEXTURE_BUFFER_OES:
+ ret = m_textureBuffer;
+ break;
default:
ret = -1;
}
@@ -1477,6 +1486,9 @@
case GL_TEXTURE_2D_MULTISAMPLE:
m_tex.activeUnit->texture[TEXTURE_2D_MULTISAMPLE] = texture;
break;
+ case GL_TEXTURE_BUFFER_OES:
+ m_tex.activeUnit->texture[TEXTURE_BUFFER] = texture;
+ break;
}
if (firstUse) {
@@ -1760,6 +1772,8 @@
return m_tex.activeUnit->texture[TEXTURE_3D];
case GL_TEXTURE_2D_MULTISAMPLE:
return m_tex.activeUnit->texture[TEXTURE_2D_MULTISAMPLE];
+ case GL_TEXTURE_BUFFER_OES:
+ return m_tex.activeUnit->texture[TEXTURE_BUFFER];
default:
return 0;
}
@@ -2354,10 +2368,10 @@
void GLClientState::validateUniform(bool isFloat, bool isUnsigned, GLint columns, GLint rows, GLint location, GLsizei count, GLenum* err) {
UNIFORM_VALIDATION_ERR_COND(!m_currentProgram && !m_currentShaderProgram, GL_INVALID_OPERATION);
- if (-1 == location) return; \
- auto info = currentUniformValidationInfo.get_const(location); \
- UNIFORM_VALIDATION_ERR_COND(!info || !info->valid, GL_INVALID_OPERATION); \
- UNIFORM_VALIDATION_ERR_COND(columns != info->columns || rows != info->rows, GL_INVALID_OPERATION); \
+ if (-1 == location) return;
+ auto info = currentUniformValidationInfo.get_const(location);
+ UNIFORM_VALIDATION_ERR_COND(!info || !info->valid, GL_INVALID_OPERATION);
+ UNIFORM_VALIDATION_ERR_COND(columns != info->columns || rows != info->rows, GL_INVALID_OPERATION);
UNIFORM_VALIDATION_ERR_COND(count > 1 && !info->isArray, GL_INVALID_OPERATION);
if (isFloat) {
UNIFORM_VALIDATION_ERR_COND(UNIFORM_VALIDATION_TYPE_VIOLATION_FOR_FLOATS, GL_INVALID_OPERATION);
diff --git a/shared/OpenglCodecCommon/GLClientState.h b/shared/OpenglCodecCommon/GLClientState.h
index 308b737..21fbd31 100644
--- a/shared/OpenglCodecCommon/GLClientState.h
+++ b/shared/OpenglCodecCommon/GLClientState.h
@@ -640,6 +640,7 @@
GLuint m_dispatchIndirectBuffer;
GLuint m_drawIndirectBuffer;
GLuint m_shaderStorageBuffer;
+ GLuint m_textureBuffer;
bool m_transformFeedbackActive;
bool m_transformFeedbackUnpaused;
@@ -670,6 +671,7 @@
TEXTURE_2D_ARRAY = 3,
TEXTURE_3D = 4,
TEXTURE_2D_MULTISAMPLE = 5,
+ TEXTURE_BUFFER = 6,
TEXTURE_TARGET_COUNT
};
struct TextureUnit {
diff --git a/shared/OpenglCodecCommon/glUtils.cpp b/shared/OpenglCodecCommon/glUtils.cpp
index a6b0b7c..fb96686 100644
--- a/shared/OpenglCodecCommon/glUtils.cpp
+++ b/shared/OpenglCodecCommon/glUtils.cpp
@@ -30,16 +30,19 @@
case GL_SAMPLER_2D_ARRAY_SHADOW:
case GL_SAMPLER_2D_MULTISAMPLE:
case GL_SAMPLER_CUBE_SHADOW:
+ case GL_SAMPLER_BUFFER_OES:
case GL_INT_SAMPLER_2D:
case GL_INT_SAMPLER_3D:
case GL_INT_SAMPLER_CUBE:
case GL_INT_SAMPLER_2D_ARRAY:
case GL_INT_SAMPLER_2D_MULTISAMPLE:
+ case GL_INT_SAMPLER_BUFFER_OES:
case GL_UNSIGNED_INT_SAMPLER_2D:
case GL_UNSIGNED_INT_SAMPLER_3D:
case GL_UNSIGNED_INT_SAMPLER_CUBE:
case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
+ case GL_UNSIGNED_INT_SAMPLER_BUFFER_OES:
return true;
default:
return false;
@@ -60,11 +63,13 @@
case GL_INT_IMAGE_3D:
case GL_INT_IMAGE_CUBE:
case GL_INT_IMAGE_2D_ARRAY:
+ case GL_INT_IMAGE_BUFFER_OES:
case GL_UNSIGNED_INT_IMAGE_2D:
case GL_UNSIGNED_INT_IMAGE_3D:
case GL_UNSIGNED_INT_IMAGE_CUBE:
case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:
case GL_UNSIGNED_INT_ATOMIC_COUNTER:
+ case GL_UNSIGNED_INT_IMAGE_BUFFER_OES:
return true;
default:
return false;
@@ -82,6 +87,7 @@
case GL_UNSIGNED_INT_IMAGE_CUBE:
case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:
case GL_UNSIGNED_INT_ATOMIC_COUNTER:
+ case GL_UNSIGNED_INT_IMAGE_BUFFER_OES:
return true;
default:
return false;
@@ -167,27 +173,33 @@
case GL_SAMPLER_2D_ARRAY_SHADOW:
case GL_SAMPLER_2D_MULTISAMPLE:
case GL_SAMPLER_CUBE_SHADOW:
+ case GL_SAMPLER_BUFFER_OES:
case GL_INT_SAMPLER_2D:
case GL_INT_SAMPLER_3D:
case GL_INT_SAMPLER_CUBE:
case GL_INT_SAMPLER_2D_ARRAY:
case GL_INT_SAMPLER_2D_MULTISAMPLE:
+ case GL_INT_SAMPLER_BUFFER_OES:
case GL_UNSIGNED_INT_SAMPLER_2D:
case GL_UNSIGNED_INT_SAMPLER_3D:
case GL_UNSIGNED_INT_SAMPLER_CUBE:
case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
+ case GL_UNSIGNED_INT_SAMPLER_BUFFER_OES:
case GL_IMAGE_CUBE:
case GL_IMAGE_2D_ARRAY:
+ case GL_IMAGE_BUFFER_OES:
case GL_INT_IMAGE_2D:
case GL_INT_IMAGE_3D:
case GL_INT_IMAGE_CUBE:
case GL_INT_IMAGE_2D_ARRAY:
+ case GL_INT_IMAGE_BUFFER_OES:
case GL_UNSIGNED_INT_IMAGE_2D:
case GL_UNSIGNED_INT_IMAGE_3D:
case GL_UNSIGNED_INT_IMAGE_CUBE:
case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:
case GL_UNSIGNED_INT_ATOMIC_COUNTER:
+ case GL_UNSIGNED_INT_IMAGE_BUFFER_OES:
default:
return 1;
}
@@ -261,27 +273,33 @@
case GL_SAMPLER_2D_ARRAY_SHADOW:
case GL_SAMPLER_2D_MULTISAMPLE:
case GL_SAMPLER_CUBE_SHADOW:
+ case GL_SAMPLER_BUFFER_OES:
case GL_INT_SAMPLER_2D:
case GL_INT_SAMPLER_3D:
case GL_INT_SAMPLER_CUBE:
case GL_INT_SAMPLER_2D_ARRAY:
case GL_INT_SAMPLER_2D_MULTISAMPLE:
+ case GL_INT_SAMPLER_BUFFER_OES:
case GL_UNSIGNED_INT_SAMPLER_2D:
case GL_UNSIGNED_INT_SAMPLER_3D:
case GL_UNSIGNED_INT_SAMPLER_CUBE:
case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
+ case GL_UNSIGNED_INT_SAMPLER_BUFFER_OES:
case GL_IMAGE_CUBE:
case GL_IMAGE_2D_ARRAY:
+ case GL_IMAGE_BUFFER_OES:
case GL_INT_IMAGE_2D:
case GL_INT_IMAGE_3D:
case GL_INT_IMAGE_CUBE:
case GL_INT_IMAGE_2D_ARRAY:
+ case GL_INT_IMAGE_BUFFER_OES:
case GL_UNSIGNED_INT_IMAGE_2D:
case GL_UNSIGNED_INT_IMAGE_3D:
case GL_UNSIGNED_INT_IMAGE_CUBE:
case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:
case GL_UNSIGNED_INT_ATOMIC_COUNTER:
+ case GL_UNSIGNED_INT_IMAGE_BUFFER_OES:
default:
return 1;
}
@@ -355,27 +373,33 @@
case GL_SAMPLER_2D_ARRAY_SHADOW:
case GL_SAMPLER_2D_MULTISAMPLE:
case GL_SAMPLER_CUBE_SHADOW:
+ case GL_SAMPLER_BUFFER_OES:
case GL_INT_SAMPLER_2D:
case GL_INT_SAMPLER_3D:
case GL_INT_SAMPLER_CUBE:
case GL_INT_SAMPLER_2D_ARRAY:
case GL_INT_SAMPLER_2D_MULTISAMPLE:
+ case GL_INT_SAMPLER_BUFFER_OES:
case GL_UNSIGNED_INT_SAMPLER_2D:
case GL_UNSIGNED_INT_SAMPLER_3D:
case GL_UNSIGNED_INT_SAMPLER_CUBE:
case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
+ case GL_UNSIGNED_INT_SAMPLER_BUFFER_OES:
case GL_IMAGE_CUBE:
case GL_IMAGE_2D_ARRAY:
+ case GL_IMAGE_BUFFER_OES:
case GL_INT_IMAGE_2D:
case GL_INT_IMAGE_3D:
case GL_INT_IMAGE_CUBE:
case GL_INT_IMAGE_2D_ARRAY:
+ case GL_INT_IMAGE_BUFFER_OES:
case GL_UNSIGNED_INT_IMAGE_2D:
case GL_UNSIGNED_INT_IMAGE_3D:
case GL_UNSIGNED_INT_IMAGE_CUBE:
case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:
case GL_UNSIGNED_INT_ATOMIC_COUNTER:
+ case GL_UNSIGNED_INT_IMAGE_BUFFER_OES:
default:
return 1;
}
@@ -484,27 +508,33 @@
case GL_SAMPLER_2D_ARRAY_SHADOW:
case GL_SAMPLER_2D_MULTISAMPLE:
case GL_SAMPLER_CUBE_SHADOW:
+ case GL_SAMPLER_BUFFER_OES:
case GL_INT_SAMPLER_2D:
case GL_INT_SAMPLER_3D:
case GL_INT_SAMPLER_CUBE:
case GL_INT_SAMPLER_2D_ARRAY:
case GL_INT_SAMPLER_2D_MULTISAMPLE:
+ case GL_INT_SAMPLER_BUFFER_OES:
case GL_UNSIGNED_INT_SAMPLER_2D:
case GL_UNSIGNED_INT_SAMPLER_3D:
case GL_UNSIGNED_INT_SAMPLER_CUBE:
case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
+ case GL_UNSIGNED_INT_SAMPLER_BUFFER_OES:
case GL_IMAGE_CUBE:
case GL_IMAGE_2D_ARRAY:
+ case GL_IMAGE_BUFFER_OES:
case GL_INT_IMAGE_2D:
case GL_INT_IMAGE_3D:
case GL_INT_IMAGE_CUBE:
case GL_INT_IMAGE_2D_ARRAY:
+ case GL_INT_IMAGE_BUFFER_OES:
case GL_UNSIGNED_INT_IMAGE_2D:
case GL_UNSIGNED_INT_IMAGE_3D:
case GL_UNSIGNED_INT_IMAGE_CUBE:
case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:
case GL_UNSIGNED_INT_ATOMIC_COUNTER:
+ case GL_UNSIGNED_INT_IMAGE_BUFFER_OES:
retval = 4;
break;
case GL_UNSIGNED_SHORT_4_4_4_4:
diff --git a/shared/gralloc_cb/include/gralloc_cb_bp.h b/shared/gralloc_cb/include/gralloc_cb_bp.h
index 259ed85..e78b8fa 100644
--- a/shared/gralloc_cb/include/gralloc_cb_bp.h
+++ b/shared/gralloc_cb/include/gralloc_cb_bp.h
@@ -20,6 +20,8 @@
#include <cutils/native_handle.h>
#include <qemu_pipe_types_bp.h>
+#include <cinttypes>
+
const uint32_t CB_HANDLE_MAGIC_MASK = 0xFFFFFFF0;
const uint32_t CB_HANDLE_MAGIC_BASE = 0xABFABFA0;
diff --git a/system/GLESv1/CMakeLists.txt b/system/GLESv1/CMakeLists.txt
index 052dec8..24f2ce7 100644
--- a/system/GLESv1/CMakeLists.txt
+++ b/system/GLESv1/CMakeLists.txt
@@ -4,7 +4,7 @@
android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/GLESv1/Android.mk" "e095cb082e3791719749cfc80b90560afd7348eb0d7895449d2509aa129bea75")
set(GLESv1_CM_emulation_src gl.cpp)
android_add_library(TARGET GLESv1_CM_emulation SHARED LICENSE Apache-2.0 SRC gl.cpp)
-target_include_directories(GLESv1_CM_emulation PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon/bionic-include ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/bionic/libc/platform ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/shared/gralloc_cb/include ${GOLDFISH_DEVICE_ROOT}/shared/GoldfishAddressSpace/include ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include-types ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_include_directories(GLESv1_CM_emulation PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon/bionic-include ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/bionic/libc/platform ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/shared/gralloc_cb/include ${GOLDFISH_DEVICE_ROOT}/shared/GoldfishAddressSpace/include ${GOLDFISH_DEVICE_ROOT}/platform/include ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include-types ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
target_compile_definitions(GLESv1_CM_emulation PRIVATE "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGFXSTREAM" "-DLOG_TAG=\"GLES_emulation\"")
target_compile_options(GLESv1_CM_emulation PRIVATE "-fvisibility=default" "-Wno-unused-parameter")
-target_link_libraries(GLESv1_CM_emulation PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host cutils utils androidemu PRIVATE gralloc_cb_host GoldfishAddressSpace_host qemupipe_host)
\ No newline at end of file
+target_link_libraries(GLESv1_CM_emulation PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host cutils utils androidemu PRIVATE gralloc_cb_host GoldfishAddressSpace_host platform_host qemupipe_host)
\ No newline at end of file
diff --git a/system/GLESv2/CMakeLists.txt b/system/GLESv2/CMakeLists.txt
index 1f04583..7fa0e18 100644
--- a/system/GLESv2/CMakeLists.txt
+++ b/system/GLESv2/CMakeLists.txt
@@ -4,7 +4,7 @@
android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/GLESv2/Android.mk" "d8f9dda69ec57ad8b7a65f02c3335b16a4724f612dec1d1a2cd793c28c0a10f9")
set(GLESv2_emulation_src gl2.cpp)
android_add_library(TARGET GLESv2_emulation SHARED LICENSE Apache-2.0 SRC gl2.cpp)
-target_include_directories(GLESv2_emulation PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon/bionic-include ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/bionic/libc/platform ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/shared/gralloc_cb/include ${GOLDFISH_DEVICE_ROOT}/shared/GoldfishAddressSpace/include ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include-types ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_include_directories(GLESv2_emulation PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon/bionic-include ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/bionic/libc/platform ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/shared/gralloc_cb/include ${GOLDFISH_DEVICE_ROOT}/shared/GoldfishAddressSpace/include ${GOLDFISH_DEVICE_ROOT}/platform/include ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include-types ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
target_compile_definitions(GLESv2_emulation PRIVATE "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGFXSTREAM" "-DLOG_TAG=\"GLESv2_emulation\"")
target_compile_options(GLESv2_emulation PRIVATE "-fvisibility=default" "-Wno-unused-parameter")
-target_link_libraries(GLESv2_emulation PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host cutils utils androidemu PRIVATE gralloc_cb_host GoldfishAddressSpace_host qemupipe_host)
\ No newline at end of file
+target_link_libraries(GLESv2_emulation PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host cutils utils androidemu PRIVATE gralloc_cb_host GoldfishAddressSpace_host platform_host qemupipe_host)
\ No newline at end of file
diff --git a/system/GLESv2_enc/GL2Encoder.cpp b/system/GLESv2_enc/GL2Encoder.cpp
index 65048cf..162a4be 100755
--- a/system/GLESv2_enc/GL2Encoder.cpp
+++ b/system/GLESv2_enc/GL2Encoder.cpp
@@ -100,6 +100,8 @@
m_max_shaderStorageBufferBindings = 0;
m_max_vertexAttribBindings = 0;
+ m_textureBufferOffsetAlign = 0;
+
m_compressedTextureFormats = NULL;
m_ssbo_offset_align = 0;
@@ -194,6 +196,19 @@
OVERRIDE(glTexImage2D);
OVERRIDE(glTexSubImage2D);
OVERRIDE(glCopyTexImage2D);
+ OVERRIDE(glTexBufferOES);
+ OVERRIDE(glTexBufferRangeOES);
+ OVERRIDE(glTexBufferEXT);
+ OVERRIDE(glTexBufferRangeEXT);
+
+ OVERRIDE(glEnableiEXT);
+ OVERRIDE(glDisableiEXT);
+ OVERRIDE(glBlendEquationiEXT);
+ OVERRIDE(glBlendEquationSeparateiEXT);
+ OVERRIDE(glBlendFunciEXT);
+ OVERRIDE(glBlendFuncSeparateiEXT);
+ OVERRIDE(glColorMaskiEXT);
+ OVERRIDE(glIsEnablediEXT);
OVERRIDE(glGenRenderbuffers);
OVERRIDE(glDeleteRenderbuffers);
@@ -826,7 +841,6 @@
if (!state) return;
*ptr = state->getBoundTexture(GL_TEXTURE_EXTERNAL_OES);
break;
-
case GL_MAX_VERTEX_ATTRIBS:
*ptr = CODEC_MAX_VERTEX_ATTRIBUTES;
break;
@@ -921,6 +935,15 @@
ctx->m_max_uniformBufferBindings = *ptr;
}
break;
+ case GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_OES:
+ SET_ERROR_IF(!ctx->es32Plus() && !ctx->getExtensions().textureBufferAny(), GL_INVALID_ENUM);
+ if(ctx->m_textureBufferOffsetAlign != 0) {
+ *ptr = ctx->m_textureBufferOffsetAlign;
+ } else {
+ ctx->safe_glGetIntegerv(param, ptr);
+ ctx->m_textureBufferOffsetAlign = *ptr;
+ }
+ break;
case GL_MAX_COLOR_ATTACHMENTS:
SET_ERROR_IF(ctx->majorVersion() < 3 &&
!ctx->hasExtension("GL_EXT_draw_buffers"), GL_INVALID_ENUM);
@@ -2592,6 +2615,167 @@
}
}
+bool GL2Encoder::validateTexBuffer(void* self, GLenum target, GLenum internalFormat, GLuint buffer) {
+ GL2Encoder* ctx = (GL2Encoder*)self;
+ RET_AND_SET_ERROR_IF((target != GL_TEXTURE_BUFFER_OES), GL_INVALID_ENUM, false);
+ RET_AND_SET_ERROR_IF(!GLESv2Validation::textureBufferFormat(ctx, internalFormat), GL_INVALID_ENUM, false);
+ RET_AND_SET_ERROR_IF(buffer != 0 && !ctx->getBufferDataById(buffer), GL_INVALID_OPERATION, false);
+ return true;
+}
+
+bool GL2Encoder::validateTexBufferRange(void* self, GLenum target, GLenum internalFormat, GLuint buffer, GLintptr offset, GLsizeiptr size)
+{
+ GL2Encoder* ctx = (GL2Encoder*)self;
+ RET_AND_SET_ERROR_IF((target != GL_TEXTURE_BUFFER_OES), GL_INVALID_ENUM, false);
+ RET_AND_SET_ERROR_IF(!GLESv2Validation::textureBufferFormat(ctx, internalFormat), GL_INVALID_ENUM, false);
+ if (buffer != 0) {
+ BufferData* buf = ctx->getBufferDataById(buffer);
+ RET_AND_SET_ERROR_IF(((!buf) || (buf->m_size < offset+size) || (offset < 0) || (size<0)), GL_INVALID_VALUE, false);
+ }
+ GLint tex_buffer_offset_align = 1;
+ ctx->s_glGetIntegerv(ctx, GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_OES, &tex_buffer_offset_align);
+ RET_AND_SET_ERROR_IF((offset % tex_buffer_offset_align) != 0, GL_INVALID_VALUE, false);
+ return true;
+}
+
+void GL2Encoder::s_glTexBufferOES(void* self,
+ GLenum target, GLenum internalFormat, GLuint buffer)
+{
+ GL2Encoder* ctx = (GL2Encoder*)self;
+ SET_ERROR_IF(!ctx->getExtensions().textureBufferOES, GL_INVALID_OPERATION);
+ if(!validateTexBuffer(ctx, target, internalFormat, buffer)) return;
+ GLClientState* state = ctx->m_state;
+ state->setBoundTextureInternalFormat(target, internalFormat);
+ ctx->m_glTexBufferOES_enc(ctx, target, internalFormat, buffer);
+}
+
+
+void GL2Encoder::s_glTexBufferRangeOES(void* self,
+ GLenum target, GLenum internalFormat, GLuint buffer, GLintptr offset, GLsizeiptr size) {
+ GL2Encoder* ctx = (GL2Encoder*)self;
+ SET_ERROR_IF(!ctx->getExtensions().textureBufferOES, GL_INVALID_OPERATION);
+ if(!validateTexBufferRange(ctx, target, internalFormat, buffer, offset, size)) return;
+ GLClientState* state = ctx->m_state;
+ state->setBoundTextureInternalFormat(target, internalFormat);
+ ctx->m_glTexBufferRangeOES_enc(ctx, target, internalFormat, buffer, offset, size);
+}
+
+void GL2Encoder::s_glTexBufferEXT(void* self,
+ GLenum target, GLenum internalFormat, GLuint buffer)
+{
+ GL2Encoder* ctx = (GL2Encoder*)self;
+ SET_ERROR_IF(!ctx->getExtensions().textureBufferEXT, GL_INVALID_OPERATION);
+ if(!validateTexBuffer(ctx, target, internalFormat, buffer)) return;
+ GLClientState* state = ctx->m_state;
+ state->setBoundTextureInternalFormat(target, internalFormat);
+ ctx->m_glTexBufferEXT_enc(ctx, target, internalFormat, buffer);
+}
+
+
+void GL2Encoder::s_glTexBufferRangeEXT(void* self,
+ GLenum target, GLenum internalFormat, GLuint buffer, GLintptr offset, GLsizeiptr size) {
+ GL2Encoder* ctx = (GL2Encoder*)self;
+ SET_ERROR_IF(!ctx->getExtensions().textureBufferEXT, GL_INVALID_OPERATION);
+ if(!validateTexBufferRange(ctx, target, internalFormat, buffer, offset, size)) return;
+ GLClientState* state = ctx->m_state;
+ state->setBoundTextureInternalFormat(target, internalFormat);
+ ctx->m_glTexBufferRangeEXT_enc(ctx, target, internalFormat, buffer, offset, size);
+}
+
+bool GL2Encoder::validateAllowedEnablei(void* self, GLenum cap, GLuint index) {
+ GL2Encoder* ctx = (GL2Encoder*)self;
+ switch(cap)
+ {
+ case GL_BLEND:
+ RET_AND_SET_ERROR_IF(index >= ctx->m_state->getMaxDrawBuffers(), GL_INVALID_VALUE, false);
+ break;
+ default:
+ RET_AND_SET_ERROR_IF(false, GL_INVALID_ENUM, false);
+ }
+ return true;
+}
+
+void GL2Encoder::s_glEnableiEXT(void * self, GLenum cap, GLuint index)
+{
+ GL2Encoder* ctx = (GL2Encoder*)self;
+ SET_ERROR_IF(!ctx->getExtensions().drawBuffersIndexedEXT, GL_INVALID_OPERATION);
+ if(!validateAllowedEnablei(ctx, cap, index)) return;
+ ctx->m_glEnableiEXT_enc(ctx, cap, index);
+}
+
+void GL2Encoder::s_glDisableiEXT(void* self, GLenum cap, GLuint index)
+{
+ GL2Encoder* ctx = (GL2Encoder*)self;
+ SET_ERROR_IF(!ctx->getExtensions().drawBuffersIndexedEXT, GL_INVALID_OPERATION);
+ if(!validateAllowedEnablei(ctx, cap, index)) return;
+ ctx->m_glDisableiEXT_enc(ctx, cap, index);
+}
+
+void GL2Encoder::s_glBlendEquationiEXT(void* self, GLuint buf, GLenum mode)
+{
+ GL2Encoder* ctx = (GL2Encoder*)self;
+ SET_ERROR_IF(!ctx->getExtensions().drawBuffersIndexedEXT, GL_INVALID_OPERATION);
+ SET_ERROR_IF(buf >= ctx->m_state->getMaxDrawBuffers(), GL_INVALID_VALUE);
+ SET_ERROR_IF(
+ !GLESv2Validation::allowedBlendEquation(mode),
+ GL_INVALID_ENUM);
+ ctx->m_glBlendEquationiEXT_enc(ctx, buf, mode);
+}
+
+void GL2Encoder::s_glBlendEquationSeparateiEXT(void* self, GLuint buf, GLenum modeRGB, GLenum modeAlpha)
+{
+ GL2Encoder* ctx = (GL2Encoder*)self;
+ SET_ERROR_IF(!ctx->getExtensions().drawBuffersIndexedEXT, GL_INVALID_OPERATION);
+ SET_ERROR_IF(buf >= ctx->m_state->getMaxDrawBuffers(), GL_INVALID_VALUE);
+ SET_ERROR_IF(
+ !GLESv2Validation::allowedBlendEquation(modeRGB) ||
+ !GLESv2Validation::allowedBlendEquation(modeAlpha),
+ GL_INVALID_ENUM);
+ ctx->m_glBlendEquationSeparateiEXT_enc(ctx, buf, modeRGB, modeAlpha);
+}
+
+void GL2Encoder::s_glBlendFunciEXT(void* self, GLuint buf, GLenum sfactor, GLenum dfactor)
+{
+ GL2Encoder* ctx = (GL2Encoder*)self;
+ SET_ERROR_IF(!ctx->getExtensions().drawBuffersIndexedEXT, GL_INVALID_OPERATION);
+ SET_ERROR_IF(buf >= ctx->m_state->getMaxDrawBuffers(), GL_INVALID_VALUE);
+ SET_ERROR_IF(
+ !GLESv2Validation::allowedBlendFunc(sfactor) ||
+ !GLESv2Validation::allowedBlendFunc(dfactor),
+ GL_INVALID_ENUM);
+ ctx->m_glBlendFunciEXT_enc(ctx, buf, sfactor, dfactor);
+}
+
+void GL2Encoder::s_glBlendFuncSeparateiEXT(void* self, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
+{
+ GL2Encoder* ctx = (GL2Encoder*)self;
+ SET_ERROR_IF(!ctx->getExtensions().drawBuffersIndexedEXT, GL_INVALID_OPERATION);
+ SET_ERROR_IF(buf >= ctx->m_state->getMaxDrawBuffers(), GL_INVALID_VALUE);
+ SET_ERROR_IF(
+ !GLESv2Validation::allowedBlendFunc(srcRGB) ||
+ !GLESv2Validation::allowedBlendFunc(dstRGB) ||
+ !GLESv2Validation::allowedBlendFunc(srcAlpha) ||
+ !GLESv2Validation::allowedBlendFunc(dstAlpha),
+ GL_INVALID_ENUM);
+ ctx->m_glBlendFuncSeparateiEXT_enc(ctx, buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
+}
+
+void GL2Encoder::s_glColorMaskiEXT(void* self, GLuint buf, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+{
+ GL2Encoder* ctx = (GL2Encoder*)self;
+ SET_ERROR_IF(!ctx->getExtensions().drawBuffersIndexedEXT, GL_INVALID_OPERATION);
+ SET_ERROR_IF(buf >= ctx->m_state->getMaxDrawBuffers(), GL_INVALID_VALUE);
+ ctx->m_glColorMaskiEXT_enc(ctx, buf, red, green, blue, alpha);
+}
+
+GLboolean GL2Encoder::s_glIsEnablediEXT(void* self, GLenum cap, GLuint index)
+{
+ GL2Encoder* ctx = (GL2Encoder*)self;
+ RET_AND_SET_ERROR_IF(!ctx->getExtensions().drawBuffersIndexedEXT, GL_INVALID_OPERATION, GL_FALSE);
+ if(!validateAllowedEnablei(ctx, cap, index)) return GL_FALSE;
+ return ctx->m_glIsEnablediEXT_enc(ctx, cap, index);
+}
+
static int ilog2(uint32_t x) {
int p = 0;
while ((1 << p) < x)
@@ -6608,7 +6792,7 @@
GLboolean GL2Encoder::s_glIsEnabled(void *self , GLenum cap) {
GL2Encoder* ctx = (GL2Encoder*)self;
- RET_AND_SET_ERROR_IF(!GLESv2Validation::allowedEnable(ctx->majorVersion(), ctx->minorVersion(), cap), GL_INVALID_ENUM, 0);
+ RET_AND_SET_ERROR_IF(!GLESv2Validation::allowedEnable(ctx->majorVersion(), ctx->minorVersion(), cap), GL_INVALID_ENUM, 0);
return ctx->m_glIsEnabled_enc(ctx, cap);
}
diff --git a/system/GLESv2_enc/GL2Encoder.h b/system/GLESv2_enc/GL2Encoder.h
index 90978be..29fe37f 100644
--- a/system/GLESv2_enc/GL2Encoder.h
+++ b/system/GLESv2_enc/GL2Encoder.h
@@ -16,8 +16,6 @@
#ifndef _GL2_ENCODER_H_
#define _GL2_ENCODER_H_
-#include <vector>
-
#include "gl2_enc.h"
#include "GLClientState.h"
#include "GLSharedGroup.h"
@@ -25,10 +23,29 @@
#include <string>
#include <vector>
+struct Extensions
+{
+ Extensions() = default;
+ Extensions(const Extensions &other) = default;
+
+ Extensions &operator=(const Extensions &other) = default;
+
+ bool textureBufferAny() const { return textureBufferEXT || textureBufferOES; }
+ // GL_EXT_texture_buffer
+ bool textureBufferEXT = false;
+
+ // GL_OES_texture_buffer
+ bool textureBufferOES = false;
+
+ // GL_EXT_draw_buffers_indexed
+ bool drawBuffersIndexedEXT = false;
+};
+
class GL2Encoder : public gl2_encoder_context_t {
public:
GL2Encoder(IOStream *stream, ChecksumCalculator* protocol);
virtual ~GL2Encoder();
+ const Extensions& getExtensions() const { return m_extensions; }
void setDrawCallFlushInterval(uint32_t interval) {
m_drawCallFlushInterval = interval;
}
@@ -71,6 +88,7 @@
m_state->setSamplerInfo(m_shared->getSamplerInfo());
}
}
+ bool es32Plus() const { return m_currMajorVersion > 3 || (m_currMajorVersion == 3 && m_currMinorVersion >= 2); }
int majorVersion() const { return m_currMajorVersion; }
int minorVersion() const { return m_currMinorVersion; }
void setExtensions(const char* exts,
@@ -78,6 +96,10 @@
m_currExtensions = std::string(exts);
m_currExtensionsArray = extArray;
m_state->setExtensions(m_currExtensions);
+
+ m_extensions.textureBufferEXT = hasExtension("GL_EXT_texture_buffer");
+ m_extensions.textureBufferOES = hasExtension("GL_OES_texture_buffer");
+ m_extensions.drawBuffersIndexedEXT = hasExtension("GL_EXT_draw_buffers_indexed");
}
bool hasExtension(const char* ext) const {
return m_currExtensions.find(ext) != std::string::npos;
@@ -115,6 +137,8 @@
std::string m_currExtensions;
std::vector<std::string> m_currExtensionsArray;
+ Extensions m_extensions;
+
bool m_hasAsyncUnmapBuffer;
bool m_hasSyncBufferData;
bool m_initialized;
@@ -145,6 +169,7 @@
GLint m_max_atomicCounterBufferBindings;
GLint m_max_shaderStorageBufferBindings;
GLint m_max_vertexAttribBindings;
+ GLint m_textureBufferOffsetAlign;
GLuint m_ssbo_offset_align;
GLuint m_ubo_offset_align;
@@ -370,6 +395,20 @@
glTexImage2D_client_proc_t m_glTexImage2D_enc;
glTexSubImage2D_client_proc_t m_glTexSubImage2D_enc;
glCopyTexImage2D_client_proc_t m_glCopyTexImage2D_enc;
+ glTexBufferOES_client_proc_t m_glTexBufferOES_enc;
+ glTexBufferRangeOES_client_proc_t m_glTexBufferRangeOES_enc;
+ glTexBufferEXT_client_proc_t m_glTexBufferEXT_enc;
+ glTexBufferRangeEXT_client_proc_t m_glTexBufferRangeEXT_enc;
+
+ glEnableiEXT_client_proc_t m_glEnableiEXT_enc;
+ glDisableiEXT_client_proc_t m_glDisableiEXT_enc;
+ glBlendEquationiEXT_client_proc_t m_glBlendEquationiEXT_enc;
+ glBlendEquationSeparateiEXT_client_proc_t m_glBlendEquationSeparateiEXT_enc;
+ glBlendFunciEXT_client_proc_t m_glBlendFunciEXT_enc;
+ glBlendFuncSeparateiEXT_client_proc_t m_glBlendFuncSeparateiEXT_enc;
+ glColorMaskiEXT_client_proc_t m_glColorMaskiEXT_enc;
+ glIsEnablediEXT_client_proc_t m_glIsEnablediEXT_enc;
+
static void s_glActiveTexture(void* self, GLenum texture);
static void s_glBindTexture(void* self, GLenum target, GLuint texture);
@@ -389,6 +428,26 @@
static void s_glCopyTexImage2D(void* self, GLenum target, GLint level, GLenum internalformat,
GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+ static bool validateTexBuffer(void* self, GLenum target, GLenum internalFormat, GLuint buffer);
+ static bool validateTexBufferRange(void* self, GLenum target, GLenum internalFormat, GLuint buffer, GLintptr offset, GLsizeiptr size);
+
+ static void s_glTexBufferOES(void* self, GLenum target, GLenum internalFormat, GLuint buffer);
+ static void s_glTexBufferRangeOES(void* self, GLenum target, GLenum internalFormat, GLuint buffer, GLintptr offset, GLsizeiptr size);
+
+ static void s_glTexBufferEXT(void* self, GLenum target, GLenum internalFormat, GLuint buffer);
+ static void s_glTexBufferRangeEXT(void* self, GLenum target, GLenum internalFormat, GLuint buffer, GLintptr offset, GLsizeiptr size);
+
+
+ static bool validateAllowedEnablei(void* self, GLenum cap, GLuint index);
+ static void s_glEnableiEXT(void* self, GLenum cap, GLuint index);
+ static void s_glDisableiEXT(void* self, GLenum cap, GLuint index);
+ static void s_glBlendEquationiEXT(void* self, GLuint buf, GLenum mode);
+ static void s_glBlendEquationSeparateiEXT(void* self, GLuint buf, GLenum modeRGB, GLenum modeAlpha);
+ static void s_glBlendFunciEXT(void* self, GLuint buf, GLenum sfactor, GLenum dfactor);
+ static void s_glBlendFuncSeparateiEXT(void* self, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+ static void s_glColorMaskiEXT(void* self, GLuint buf, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+ static GLboolean s_glIsEnablediEXT(void* self, GLenum cap, GLuint index);
+
glGenRenderbuffers_client_proc_t m_glGenRenderbuffers_enc;
static void s_glGenRenderbuffers(void* self, GLsizei n, GLuint* renderbuffers);
glDeleteRenderbuffers_client_proc_t m_glDeleteRenderbuffers_enc;
diff --git a/system/GLESv2_enc/GLESv2Validation.cpp b/system/GLESv2_enc/GLESv2Validation.cpp
index d8eac8d..14a0e07 100644
--- a/system/GLESv2_enc/GLESv2Validation.cpp
+++ b/system/GLESv2_enc/GLESv2Validation.cpp
@@ -130,6 +130,38 @@
f(GL_COMPRESSED_RED_GREEN_RGTC2_EXT) \
f(GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT)
+#define LIST_VALID_TEX_BUFFER_FORMATS(f) \
+ f(GL_R8) \
+ f(GL_R16F) \
+ f(GL_R32F) \
+ f(GL_R8I) \
+ f(GL_R16I) \
+ f(GL_R32I) \
+ f(GL_R8UI) \
+ f(GL_R16UI) \
+ f(GL_R32UI) \
+ f(GL_RG8) \
+ f(GL_RG16F) \
+ f(GL_RG32F) \
+ f(GL_RG8I) \
+ f(GL_RG16I) \
+ f(GL_RG32I) \
+ f(GL_RG8UI) \
+ f(GL_RG16UI) \
+ f(GL_RG32UI) \
+ f(GL_RGB32F) \
+ f(GL_RGB32I) \
+ f(GL_RGB32UI) \
+ f(GL_RGBA8) \
+ f(GL_RGBA16F) \
+ f(GL_RGBA32F) \
+ f(GL_RGBA8I) \
+ f(GL_RGBA16I) \
+ f(GL_RGBA32I) \
+ f(GL_RGBA8UI) \
+ f(GL_RGBA16UI) \
+ f(GL_RGBA32UI)
+
#define LIST_INTEGER_TEX_FORMATS(f) \
f(GL_RED_INTEGER) \
@@ -316,8 +348,10 @@
case GL_ATOMIC_COUNTER_BUFFER: // Atomic counter storage
case GL_DISPATCH_INDIRECT_BUFFER: // Indirect compute dispatch commands
case GL_DRAW_INDIRECT_BUFFER: // Indirect command arguments
- case GL_SHADER_STORAGE_BUFFER: // Read-write storage for shaders
+ case GL_SHADER_STORAGE_BUFFER: // Read-write storage for shader
return glesMajorVersion >= 3 && glesMinorVersion >= 1;
+ case GL_TEXTURE_BUFFER_OES:
+ return ctx->es32Plus() || ctx->getExtensions().textureBufferAny();
default:
return false;
}
@@ -638,8 +672,9 @@
case GL_TEXTURE_3D:
return glesMajorVersion >= 3;
case GL_TEXTURE_2D_MULTISAMPLE:
- return glesMajorVersion >= 3 &&
- glesMinorVersion >= 1;
+ return glesMajorVersion >= 3 && glesMinorVersion >= 1;
+ case GL_TEXTURE_BUFFER_OES:
+ return ctx->es32Plus() || ctx->getExtensions().textureBufferAny();
default:
break;
}
@@ -1165,6 +1200,7 @@
}
return false;
}
+
bool pixelInternalFormat(GLenum internalformat) {
#define VALID_INTERNAL_FORMAT(format) \
case format: \
@@ -1180,6 +1216,18 @@
return false;
}
+
+bool textureBufferFormat(GL2Encoder* ctx, GLenum internalFormat) {
+ switch(internalFormat) {
+ LIST_VALID_TEX_BUFFER_FORMATS(VALID_INTERNAL_FORMAT)
+ default:
+ break;
+ }
+
+ ALOGW("error internal format: 0x%x is invalid\n", internalFormat);
+ return false;
+}
+
bool pixelSizedFormat(GL2Encoder* ctx, GLenum internalformat, GLenum format, GLenum type) {
int glesMajorVersion = ctx->majorVersion();
if (internalformat == format) {
@@ -1407,8 +1455,9 @@
return majorVersion >= 3;
case GL_SAMPLE_MASK:
return majorVersion >= 3 && minorVersion >= 1;
- default:
- return false;
+ default:
+ ALOGW("error cap: 0x%x is invalid\n", cap);
+ return false;
}
}
diff --git a/system/GLESv2_enc/GLESv2Validation.h b/system/GLESv2_enc/GLESv2Validation.h
index 4ac5787..8e072c3 100644
--- a/system/GLESv2_enc/GLESv2Validation.h
+++ b/system/GLESv2_enc/GLESv2Validation.h
@@ -73,6 +73,8 @@
bool pixelType(GL2Encoder* ctx, GLenum type);
bool pixelFormat(GL2Encoder* ctx, GLenum format);
+bool textureBufferFormat(GL2Encoder* ctx, GLenum internalFormat);
+
bool pixelInternalFormat(GLenum internalformat);
bool pixelSizedFormat(GL2Encoder* ctx, GLenum internalformat, GLenum format, GLenum type);
void getCompatibleFormatTypeForInternalFormat(GLenum internalformat, GLenum* format_out, GLenum* type_out);
diff --git a/system/GLESv2_enc/gl2_client_context.cpp b/system/GLESv2_enc/gl2_client_context.cpp
index 49b52a7..2c10f7d 100644
--- a/system/GLESv2_enc/gl2_client_context.cpp
+++ b/system/GLESv2_enc/gl2_client_context.cpp
@@ -437,6 +437,18 @@
glUnmapBufferAsyncAEMU = (glUnmapBufferAsyncAEMU_client_proc_t) getProc("glUnmapBufferAsyncAEMU", userData);
glFlushMappedBufferRangeAEMU2 = (glFlushMappedBufferRangeAEMU2_client_proc_t) getProc("glFlushMappedBufferRangeAEMU2", userData);
glBufferDataSyncAEMU = (glBufferDataSyncAEMU_client_proc_t) getProc("glBufferDataSyncAEMU", userData);
+ glTexBufferOES = (glTexBufferOES_client_proc_t) getProc("glTexBufferOES", userData);
+ glTexBufferRangeOES = (glTexBufferRangeOES_client_proc_t) getProc("glTexBufferRangeOES", userData);
+ glTexBufferEXT = (glTexBufferEXT_client_proc_t) getProc("glTexBufferEXT", userData);
+ glTexBufferRangeEXT = (glTexBufferRangeEXT_client_proc_t) getProc("glTexBufferRangeEXT", userData);
+ glEnableiEXT = (glEnableiEXT_client_proc_t) getProc("glEnableiEXT", userData);
+ glDisableiEXT = (glDisableiEXT_client_proc_t) getProc("glDisableiEXT", userData);
+ glBlendEquationiEXT = (glBlendEquationiEXT_client_proc_t) getProc("glBlendEquationiEXT", userData);
+ glBlendEquationSeparateiEXT = (glBlendEquationSeparateiEXT_client_proc_t) getProc("glBlendEquationSeparateiEXT", userData);
+ glBlendFunciEXT = (glBlendFunciEXT_client_proc_t) getProc("glBlendFunciEXT", userData);
+ glBlendFuncSeparateiEXT = (glBlendFuncSeparateiEXT_client_proc_t) getProc("glBlendFuncSeparateiEXT", userData);
+ glColorMaskiEXT = (glColorMaskiEXT_client_proc_t) getProc("glColorMaskiEXT", userData);
+ glIsEnablediEXT = (glIsEnablediEXT_client_proc_t) getProc("glIsEnablediEXT", userData);
return 0;
}
diff --git a/system/GLESv2_enc/gl2_client_context.h b/system/GLESv2_enc/gl2_client_context.h
index b3d5f70..a4911d1 100644
--- a/system/GLESv2_enc/gl2_client_context.h
+++ b/system/GLESv2_enc/gl2_client_context.h
@@ -437,6 +437,18 @@
glUnmapBufferAsyncAEMU_client_proc_t glUnmapBufferAsyncAEMU;
glFlushMappedBufferRangeAEMU2_client_proc_t glFlushMappedBufferRangeAEMU2;
glBufferDataSyncAEMU_client_proc_t glBufferDataSyncAEMU;
+ glTexBufferOES_client_proc_t glTexBufferOES;
+ glTexBufferRangeOES_client_proc_t glTexBufferRangeOES;
+ glTexBufferEXT_client_proc_t glTexBufferEXT;
+ glTexBufferRangeEXT_client_proc_t glTexBufferRangeEXT;
+ glEnableiEXT_client_proc_t glEnableiEXT;
+ glDisableiEXT_client_proc_t glDisableiEXT;
+ glBlendEquationiEXT_client_proc_t glBlendEquationiEXT;
+ glBlendEquationSeparateiEXT_client_proc_t glBlendEquationSeparateiEXT;
+ glBlendFunciEXT_client_proc_t glBlendFunciEXT;
+ glBlendFuncSeparateiEXT_client_proc_t glBlendFuncSeparateiEXT;
+ glColorMaskiEXT_client_proc_t glColorMaskiEXT;
+ glIsEnablediEXT_client_proc_t glIsEnablediEXT;
virtual ~gl2_client_context_t() {}
typedef gl2_client_context_t *CONTEXT_ACCESSOR_TYPE(void);
diff --git a/system/GLESv2_enc/gl2_client_proc.h b/system/GLESv2_enc/gl2_client_proc.h
index 268cb99..18a24ae 100644
--- a/system/GLESv2_enc/gl2_client_proc.h
+++ b/system/GLESv2_enc/gl2_client_proc.h
@@ -439,6 +439,18 @@
typedef void (gl2_APIENTRY *glUnmapBufferAsyncAEMU_client_proc_t) (void * ctx, GLenum, GLintptr, GLsizeiptr, GLbitfield, void*, GLboolean*);
typedef void (gl2_APIENTRY *glFlushMappedBufferRangeAEMU2_client_proc_t) (void * ctx, GLenum, GLintptr, GLsizeiptr, GLbitfield, void*);
typedef GLboolean (gl2_APIENTRY *glBufferDataSyncAEMU_client_proc_t) (void * ctx, GLenum, GLsizeiptr, const GLvoid*, GLenum);
+typedef void (gl2_APIENTRY *glTexBufferOES_client_proc_t) (void * ctx, GLenum, GLenum, GLuint);
+typedef void (gl2_APIENTRY *glTexBufferRangeOES_client_proc_t) (void * ctx, GLenum, GLenum, GLuint, GLintptr, GLsizeiptr);
+typedef void (gl2_APIENTRY *glTexBufferEXT_client_proc_t) (void * ctx, GLenum, GLenum, GLuint);
+typedef void (gl2_APIENTRY *glTexBufferRangeEXT_client_proc_t) (void * ctx, GLenum, GLenum, GLuint, GLintptr, GLsizeiptr);
+typedef void (gl2_APIENTRY *glEnableiEXT_client_proc_t) (void * ctx, GLenum, GLuint);
+typedef void (gl2_APIENTRY *glDisableiEXT_client_proc_t) (void * ctx, GLenum, GLuint);
+typedef void (gl2_APIENTRY *glBlendEquationiEXT_client_proc_t) (void * ctx, GLuint, GLenum);
+typedef void (gl2_APIENTRY *glBlendEquationSeparateiEXT_client_proc_t) (void * ctx, GLuint, GLenum, GLenum);
+typedef void (gl2_APIENTRY *glBlendFunciEXT_client_proc_t) (void * ctx, GLuint, GLenum, GLenum);
+typedef void (gl2_APIENTRY *glBlendFuncSeparateiEXT_client_proc_t) (void * ctx, GLuint, GLenum, GLenum, GLenum, GLenum);
+typedef void (gl2_APIENTRY *glColorMaskiEXT_client_proc_t) (void * ctx, GLuint, GLboolean, GLboolean, GLboolean, GLboolean);
+typedef GLboolean (gl2_APIENTRY *glIsEnablediEXT_client_proc_t) (void * ctx, GLenum, GLuint);
#endif
diff --git a/system/GLESv2_enc/gl2_enc.cpp b/system/GLESv2_enc/gl2_enc.cpp
index 98fe387..6be6864 100644
--- a/system/GLESv2_enc/gl2_enc.cpp
+++ b/system/GLESv2_enc/gl2_enc.cpp
@@ -7712,6 +7712,7 @@
if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+ stream->flush();
}
@@ -12322,6 +12323,373 @@
return retval;
}
+void glTexBufferOES_enc(void *self , GLenum target, GLenum internalFormat, GLuint buffer)
+{
+ ENCODER_DEBUG_LOG("glTexBufferOES(target:0x%08x, internalFormat:0x%08x, buffer:%u)", target, internalFormat, buffer);
+ AEMU_SCOPED_TRACE("glTexBufferOES encode");
+
+ gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_glTexBufferOES;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &target, 4); ptr += 4;
+ memcpy(ptr, &internalFormat, 4); ptr += 4;
+ memcpy(ptr, &buffer, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+void glTexBufferRangeOES_enc(void *self , GLenum target, GLenum internalFormat, GLuint buffer, GLintptr offset, GLsizeiptr size)
+{
+ ENCODER_DEBUG_LOG("glTexBufferRangeOES(target:0x%08x, internalFormat:0x%08x, buffer:%u, offset:0x%08lx, size:0x%08lx)", target, internalFormat, buffer, offset, size);
+ AEMU_SCOPED_TRACE("glTexBufferRangeOES encode");
+
+ gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_glTexBufferRangeOES;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &target, 4); ptr += 4;
+ memcpy(ptr, &internalFormat, 4); ptr += 4;
+ memcpy(ptr, &buffer, 4); ptr += 4;
+ memcpy(ptr, &offset, 4); ptr += 4;
+ memcpy(ptr, &size, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+void glTexBufferEXT_enc(void *self , GLenum target, GLenum internalFormat, GLuint buffer)
+{
+ ENCODER_DEBUG_LOG("glTexBufferEXT(target:0x%08x, internalFormat:0x%08x, buffer:%u)", target, internalFormat, buffer);
+ AEMU_SCOPED_TRACE("glTexBufferEXT encode");
+
+ gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_glTexBufferEXT;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &target, 4); ptr += 4;
+ memcpy(ptr, &internalFormat, 4); ptr += 4;
+ memcpy(ptr, &buffer, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+void glTexBufferRangeEXT_enc(void *self , GLenum target, GLenum internalFormat, GLuint buffer, GLintptr offset, GLsizeiptr size)
+{
+ ENCODER_DEBUG_LOG("glTexBufferRangeEXT(target:0x%08x, internalFormat:0x%08x, buffer:%u, offset:0x%08lx, size:0x%08lx)", target, internalFormat, buffer, offset, size);
+ AEMU_SCOPED_TRACE("glTexBufferRangeEXT encode");
+
+ gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_glTexBufferRangeEXT;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &target, 4); ptr += 4;
+ memcpy(ptr, &internalFormat, 4); ptr += 4;
+ memcpy(ptr, &buffer, 4); ptr += 4;
+ memcpy(ptr, &offset, 4); ptr += 4;
+ memcpy(ptr, &size, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+void glEnableiEXT_enc(void *self , GLenum cap, GLuint index)
+{
+ ENCODER_DEBUG_LOG("glEnableiEXT(cap:0x%08x, index:%u)", cap, index);
+ AEMU_SCOPED_TRACE("glEnableiEXT encode");
+
+ gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4 + 4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_glEnableiEXT;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &cap, 4); ptr += 4;
+ memcpy(ptr, &index, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+void glDisableiEXT_enc(void *self , GLenum cap, GLuint index)
+{
+ ENCODER_DEBUG_LOG("glDisableiEXT(cap:0x%08x, index:%u)", cap, index);
+ AEMU_SCOPED_TRACE("glDisableiEXT encode");
+
+ gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4 + 4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_glDisableiEXT;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &cap, 4); ptr += 4;
+ memcpy(ptr, &index, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+void glBlendEquationiEXT_enc(void *self , GLuint index, GLenum mode)
+{
+ ENCODER_DEBUG_LOG("glBlendEquationiEXT(index:%u, mode:0x%08x)", index, mode);
+ AEMU_SCOPED_TRACE("glBlendEquationiEXT encode");
+
+ gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4 + 4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_glBlendEquationiEXT;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &index, 4); ptr += 4;
+ memcpy(ptr, &mode, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+void glBlendEquationSeparateiEXT_enc(void *self , GLuint index, GLenum modeRGB, GLenum modeAlpha)
+{
+ ENCODER_DEBUG_LOG("glBlendEquationSeparateiEXT(index:%u, modeRGB:0x%08x, modeAlpha:0x%08x)", index, modeRGB, modeAlpha);
+ AEMU_SCOPED_TRACE("glBlendEquationSeparateiEXT encode");
+
+ gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_glBlendEquationSeparateiEXT;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &index, 4); ptr += 4;
+ memcpy(ptr, &modeRGB, 4); ptr += 4;
+ memcpy(ptr, &modeAlpha, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+void glBlendFunciEXT_enc(void *self , GLuint index, GLenum sfactor, GLenum dfactor)
+{
+ ENCODER_DEBUG_LOG("glBlendFunciEXT(index:%u, sfactor:0x%08x, dfactor:0x%08x)", index, sfactor, dfactor);
+ AEMU_SCOPED_TRACE("glBlendFunciEXT encode");
+
+ gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_glBlendFunciEXT;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &index, 4); ptr += 4;
+ memcpy(ptr, &sfactor, 4); ptr += 4;
+ memcpy(ptr, &dfactor, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+void glBlendFuncSeparateiEXT_enc(void *self , GLuint index, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
+{
+ ENCODER_DEBUG_LOG("glBlendFuncSeparateiEXT(index:%u, srcRGB:0x%08x, dstRGB:0x%08x, srcAlpha:0x%08x, dstAlpha:0x%08x)", index, srcRGB, dstRGB, srcAlpha, dstAlpha);
+ AEMU_SCOPED_TRACE("glBlendFuncSeparateiEXT encode");
+
+ gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4 + 4 + 4 + 4 + 4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_glBlendFuncSeparateiEXT;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &index, 4); ptr += 4;
+ memcpy(ptr, &srcRGB, 4); ptr += 4;
+ memcpy(ptr, &dstRGB, 4); ptr += 4;
+ memcpy(ptr, &srcAlpha, 4); ptr += 4;
+ memcpy(ptr, &dstAlpha, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+void glColorMaskiEXT_enc(void *self , GLuint index, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+{
+ ENCODER_DEBUG_LOG("glColorMaskiEXT(index:%u, red:%d, green:%d, blue:%d, alpha:%d)", index, red, green, blue, alpha);
+ AEMU_SCOPED_TRACE("glColorMaskiEXT encode");
+
+ gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4 + 1 + 1 + 1 + 1;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_glColorMaskiEXT;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &index, 4); ptr += 4;
+ memcpy(ptr, &red, 1); ptr += 1;
+ memcpy(ptr, &green, 1); ptr += 1;
+ memcpy(ptr, &blue, 1); ptr += 1;
+ memcpy(ptr, &alpha, 1); ptr += 1;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+GLboolean glIsEnablediEXT_enc(void *self , GLenum cap, GLuint index)
+{
+ ENCODER_DEBUG_LOG("glIsEnablediEXT(cap:0x%08x, index:%u)", cap, index);
+ AEMU_SCOPED_TRACE("glIsEnablediEXT encode");
+
+ gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4 + 4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_glIsEnablediEXT;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &cap, 4); ptr += 4;
+ memcpy(ptr, &index, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+
+ GLboolean retval;
+ stream->readback(&retval, 1);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 1);
+ if (useChecksum) {
+ unsigned char *checksumBufPtr = NULL;
+ unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
+ if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
+ stream->readback(checksumBufPtr, checksumSize);
+ if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
+ ALOGE("glIsEnablediEXT: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
} // namespace
gl2_encoder_context_t::gl2_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator)
@@ -12756,5 +13124,17 @@
this->glUnmapBufferAsyncAEMU = &glUnmapBufferAsyncAEMU_enc;
this->glFlushMappedBufferRangeAEMU2 = &glFlushMappedBufferRangeAEMU2_enc;
this->glBufferDataSyncAEMU = &glBufferDataSyncAEMU_enc;
+ this->glTexBufferOES = &glTexBufferOES_enc;
+ this->glTexBufferRangeOES = &glTexBufferRangeOES_enc;
+ this->glTexBufferEXT = &glTexBufferEXT_enc;
+ this->glTexBufferRangeEXT = &glTexBufferRangeEXT_enc;
+ this->glEnableiEXT = &glEnableiEXT_enc;
+ this->glDisableiEXT = &glDisableiEXT_enc;
+ this->glBlendEquationiEXT = &glBlendEquationiEXT_enc;
+ this->glBlendEquationSeparateiEXT = &glBlendEquationSeparateiEXT_enc;
+ this->glBlendFunciEXT = &glBlendFunciEXT_enc;
+ this->glBlendFuncSeparateiEXT = &glBlendFuncSeparateiEXT_enc;
+ this->glColorMaskiEXT = &glColorMaskiEXT_enc;
+ this->glIsEnablediEXT = &glIsEnablediEXT_enc;
}
diff --git a/system/GLESv2_enc/gl2_entry.cpp b/system/GLESv2_enc/gl2_entry.cpp
index 5ea44c2..a187ad0 100644
--- a/system/GLESv2_enc/gl2_entry.cpp
+++ b/system/GLESv2_enc/gl2_entry.cpp
@@ -432,6 +432,18 @@
void glUnmapBufferAsyncAEMU(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void* guest_buffer, GLboolean* out_res);
void glFlushMappedBufferRangeAEMU2(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void* guest_buffer);
GLboolean glBufferDataSyncAEMU(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage);
+ void glTexBufferOES(GLenum target, GLenum internalFormat, GLuint buffer);
+ void glTexBufferRangeOES(GLenum target, GLenum internalFormat, GLuint buffer, GLintptr offset, GLsizeiptr size);
+ void glTexBufferEXT(GLenum target, GLenum internalFormat, GLuint buffer);
+ void glTexBufferRangeEXT(GLenum target, GLenum internalFormat, GLuint buffer, GLintptr offset, GLsizeiptr size);
+ void glEnableiEXT(GLenum cap, GLuint index);
+ void glDisableiEXT(GLenum cap, GLuint index);
+ void glBlendEquationiEXT(GLuint index, GLenum mode);
+ void glBlendEquationSeparateiEXT(GLuint index, GLenum modeRGB, GLenum modeAlpha);
+ void glBlendFunciEXT(GLuint index, GLenum sfactor, GLenum dfactor);
+ void glBlendFuncSeparateiEXT(GLuint index, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+ void glColorMaskiEXT(GLuint index, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+ GLboolean glIsEnablediEXT(GLenum cap, GLuint index);
};
#ifndef GET_CONTEXT
@@ -3039,3 +3051,75 @@
return ctx->glBufferDataSyncAEMU(ctx, target, size, data, usage);
}
+void glTexBufferOES(GLenum target, GLenum internalFormat, GLuint buffer)
+{
+ GET_CONTEXT;
+ ctx->glTexBufferOES(ctx, target, internalFormat, buffer);
+}
+
+void glTexBufferRangeOES(GLenum target, GLenum internalFormat, GLuint buffer, GLintptr offset, GLsizeiptr size)
+{
+ GET_CONTEXT;
+ ctx->glTexBufferRangeOES(ctx, target, internalFormat, buffer, offset, size);
+}
+
+void glTexBufferEXT(GLenum target, GLenum internalFormat, GLuint buffer)
+{
+ GET_CONTEXT;
+ ctx->glTexBufferEXT(ctx, target, internalFormat, buffer);
+}
+
+void glTexBufferRangeEXT(GLenum target, GLenum internalFormat, GLuint buffer, GLintptr offset, GLsizeiptr size)
+{
+ GET_CONTEXT;
+ ctx->glTexBufferRangeEXT(ctx, target, internalFormat, buffer, offset, size);
+}
+
+void glEnableiEXT(GLenum cap, GLuint index)
+{
+ GET_CONTEXT;
+ ctx->glEnableiEXT(ctx, cap, index);
+}
+
+void glDisableiEXT(GLenum cap, GLuint index)
+{
+ GET_CONTEXT;
+ ctx->glDisableiEXT(ctx, cap, index);
+}
+
+void glBlendEquationiEXT(GLuint index, GLenum mode)
+{
+ GET_CONTEXT;
+ ctx->glBlendEquationiEXT(ctx, index, mode);
+}
+
+void glBlendEquationSeparateiEXT(GLuint index, GLenum modeRGB, GLenum modeAlpha)
+{
+ GET_CONTEXT;
+ ctx->glBlendEquationSeparateiEXT(ctx, index, modeRGB, modeAlpha);
+}
+
+void glBlendFunciEXT(GLuint index, GLenum sfactor, GLenum dfactor)
+{
+ GET_CONTEXT;
+ ctx->glBlendFunciEXT(ctx, index, sfactor, dfactor);
+}
+
+void glBlendFuncSeparateiEXT(GLuint index, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
+{
+ GET_CONTEXT;
+ ctx->glBlendFuncSeparateiEXT(ctx, index, srcRGB, dstRGB, srcAlpha, dstAlpha);
+}
+
+void glColorMaskiEXT(GLuint index, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+{
+ GET_CONTEXT;
+ ctx->glColorMaskiEXT(ctx, index, red, green, blue, alpha);
+}
+
+GLboolean glIsEnablediEXT(GLenum cap, GLuint index)
+{
+ GET_CONTEXT;
+ return ctx->glIsEnablediEXT(ctx, cap, index);
+}
+
diff --git a/system/GLESv2_enc/gl2_ftable.h b/system/GLESv2_enc/gl2_ftable.h
index ff3de2e..3a3e8f5 100644
--- a/system/GLESv2_enc/gl2_ftable.h
+++ b/system/GLESv2_enc/gl2_ftable.h
@@ -387,6 +387,18 @@
{"glGetnUniformivEXT", (void*)glGetnUniformivEXT},
{"glDrawArraysNullAEMU", (void*)glDrawArraysNullAEMU},
{"glDrawElementsNullAEMU", (void*)glDrawElementsNullAEMU},
+ {"glTexBufferOES", (void*)glTexBufferOES},
+ {"glTexBufferRangeOES", (void*)glTexBufferRangeOES},
+ {"glTexBufferEXT", (void*)glTexBufferEXT},
+ {"glTexBufferRangeEXT", (void*)glTexBufferRangeEXT},
+ {"glEnableiEXT", (void*)glEnableiEXT},
+ {"glDisableiEXT", (void*)glDisableiEXT},
+ {"glBlendEquationiEXT", (void*)glBlendEquationiEXT},
+ {"glBlendEquationSeparateiEXT", (void*)glBlendEquationSeparateiEXT},
+ {"glBlendFunciEXT", (void*)glBlendFunciEXT},
+ {"glBlendFuncSeparateiEXT", (void*)glBlendFuncSeparateiEXT},
+ {"glColorMaskiEXT", (void*)glColorMaskiEXT},
+ {"glIsEnablediEXT", (void*)glIsEnablediEXT},
};
static const int gl2_num_funcs = sizeof(gl2_funcs_by_name) / sizeof(struct _gl2_funcs_by_name);
diff --git a/system/GLESv2_enc/gl2_opcodes.h b/system/GLESv2_enc/gl2_opcodes.h
index 25ab3e7..ae21891 100644
--- a/system/GLESv2_enc/gl2_opcodes.h
+++ b/system/GLESv2_enc/gl2_opcodes.h
@@ -430,7 +430,19 @@
#define OP_glUnmapBufferAsyncAEMU 2472
#define OP_glFlushMappedBufferRangeAEMU2 2473
#define OP_glBufferDataSyncAEMU 2474
-#define OP_last 2475
+#define OP_glTexBufferOES 2475
+#define OP_glTexBufferRangeOES 2476
+#define OP_glTexBufferEXT 2477
+#define OP_glTexBufferRangeEXT 2478
+#define OP_glEnableiEXT 2479
+#define OP_glDisableiEXT 2480
+#define OP_glBlendEquationiEXT 2481
+#define OP_glBlendEquationSeparateiEXT 2482
+#define OP_glBlendFunciEXT 2483
+#define OP_glBlendFuncSeparateiEXT 2484
+#define OP_glColorMaskiEXT 2485
+#define OP_glIsEnablediEXT 2486
+#define OP_last 2487
#endif
diff --git a/system/OpenglSystemCommon/AddressSpaceStream.cpp b/system/OpenglSystemCommon/AddressSpaceStream.cpp
index 8e12550..48f5227 100644
--- a/system/OpenglSystemCommon/AddressSpaceStream.cpp
+++ b/system/OpenglSystemCommon/AddressSpaceStream.cpp
@@ -15,7 +15,9 @@
*/
#include "AddressSpaceStream.h"
+#include "VirtGpu.h"
#include "android/base/Tracing.h"
+#include "virtgpu_gfxstream_protocol.h"
#if PLATFORM_SDK_VERSION < 26
#include <cutils/log.h>
@@ -26,15 +28,14 @@
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
-#include <unistd.h>
#include <string.h>
-
-#include <sys/mman.h>
+#include <unistd.h>
static const size_t kReadSize = 512 * 1024;
static const size_t kWriteOffset = kReadSize;
-AddressSpaceStream* createAddressSpaceStream(size_t ignored_bufSize) {
+AddressSpaceStream* createAddressSpaceStream(size_t ignored_bufSize,
+ HealthMonitor<>& healthMonitor) {
// Ignore incoming ignored_bufSize
(void)ignored_bufSize;
@@ -142,111 +143,88 @@
AddressSpaceStream* res =
new AddressSpaceStream(
child_device_handle, version, context,
- ringOffset, bufferOffset, false /* not virtio */, ops);
+ ringOffset, bufferOffset, ops, healthMonitor);
return res;
}
-#if defined(VIRTIO_GPU) && !defined(HOST_BUILD)
-AddressSpaceStream* createVirtioGpuAddressSpaceStream(const struct StreamCreate &streamCreate) {
- auto handle = reinterpret_cast<address_space_handle_t>(streamCreate.streamHandle);
- struct address_space_virtgpu_info virtgpu_info;
+address_space_handle_t virtgpu_address_space_open() {
+ return (address_space_handle_t)(-EINVAL);
+}
- ALOGD("%s: create subdevice and get resp\n", __func__);
- if (!virtgpu_address_space_create_context_with_subdevice(
- handle, GoldfishAddressSpaceSubdeviceType::VirtioGpuGraphics,
- &virtgpu_info)) {
- ALOGE("AddressSpaceStream::create failed (create subdevice)\n");
- if (virtgpu_info.resp_mapped_ptr) {
- munmap(virtgpu_info.resp_mapped_ptr, 4096);
- }
- virtgpu_address_space_close(handle);
+void virtgpu_address_space_close(address_space_handle_t fd) {
+ // Handle opened by VirtioGpuDevice wrapper
+}
+
+bool virtgpu_address_space_ping(address_space_handle_t fd, struct address_space_ping* info) {
+ int ret;
+ struct VirtGpuExecBuffer exec = {};
+ VirtGpuDevice& instance = VirtGpuDevice::getInstance();
+ struct gfxstreamContextPing ping = {};
+
+ ping.hdr.opCode = GFXSTREAM_CONTEXT_PING;
+ ping.resourceId = info->resourceId;
+
+ exec.command = static_cast<void*>(&ping);
+ exec.command_size = sizeof(ping);
+
+ ret = instance.execBuffer(exec, nullptr);
+ if (ret)
+ return false;
+
+ return true;
+}
+
+AddressSpaceStream* createVirtioGpuAddressSpaceStream(HealthMonitor<>& healthMonitor) {
+ VirtGpuBlobPtr pipe, blob;
+ VirtGpuBlobMappingPtr pipeMapping, blobMapping;
+ struct VirtGpuExecBuffer exec = {};
+ struct VirtGpuCreateBlob blobCreate = {};
+ struct gfxstreamContextCreate contextCreate = {};
+
+ char* blobAddr, *bufferPtr;
+ int ret;
+
+ // HACK: constants that are currently used.
+ // Ideal solution would use virtio-gpu capabilities to report both ringSize and bufferSize
+ uint32_t ringSize = 12288;
+ uint32_t bufferSize = 1048576;
+
+ VirtGpuDevice& instance = VirtGpuDevice::getInstance();
+
+ blobCreate.blobId = 0;
+ blobCreate.blobMem = kBlobMemHost3d;
+ blobCreate.flags = kBlobFlagMappable;
+ blobCreate.size = ringSize + bufferSize;
+ blob = instance.createBlob(blobCreate);
+ if (!blob)
return nullptr;
- }
- ALOGD("%s: create subdevice and get resp (done)\n", __func__);
- struct address_space_ping request;
- uint32_t ringSize = 0;
- uint32_t bufferSize = 0;
+ // Context creation command
+ contextCreate.hdr.opCode = GFXSTREAM_CONTEXT_CREATE;
+ contextCreate.resourceId = blob->getResourceHandle();
- request.metadata = ASG_GET_RING;
- if (!virtgpu_address_space_ping_with_response(
- &virtgpu_info, &request)) {
- ALOGE("AddressSpaceStream::create failed (get ring version)\n");
- if (virtgpu_info.resp_mapped_ptr) {
- munmap(virtgpu_info.resp_mapped_ptr, 4096);
- }
- virtgpu_address_space_close(handle);
+ exec.command = static_cast<void*>(&contextCreate);
+ exec.command_size = sizeof(contextCreate);
+
+ ret = instance.execBuffer(exec, blob);
+ if (ret)
return nullptr;
- }
- ringSize = request.size;
- request.metadata = ASG_GET_BUFFER;
- if (!virtgpu_address_space_ping_with_response(
- &virtgpu_info, &request)) {
- ALOGE("AddressSpaceStream::create failed (get ring version)\n");
- if (virtgpu_info.resp_mapped_ptr) {
- munmap(virtgpu_info.resp_mapped_ptr, 4096);
- }
- virtgpu_address_space_close(handle);
+ // Wait occurs on global timeline -- should we use context specific one?
+ ret = blob->wait();
+ if (ret)
return nullptr;
- }
- bufferSize = request.size;
- request.metadata = ASG_SET_VERSION;
- request.size = 1; // version 1
-
- if (!virtgpu_address_space_ping_with_response(
- &virtgpu_info, &request)) {
- ALOGE("AddressSpaceStream::create failed (set version)\n");
- if (virtgpu_info.resp_mapped_ptr) {
- munmap(virtgpu_info.resp_mapped_ptr, 4096);
- }
- virtgpu_address_space_close(handle);
+ blobMapping = blob->createMapping();
+ if (!blobMapping)
return nullptr;
- }
- ALOGD("%s: ping returned. context ring and buffer sizes %u %u\n", __func__,
- ringSize, bufferSize);
+ blobAddr = reinterpret_cast<char*>(blobMapping->asRawPtr());
- uint64_t hostmem_id = request.metadata;
- uint32_t version = request.size;
- size_t hostmem_alloc_size =
- (size_t)(ringSize + bufferSize);
-
- ALOGD("%s: hostmem size: %zu\n", __func__, hostmem_alloc_size);
-
- struct address_space_virtgpu_hostmem_info hostmem_info;
- if (!virtgpu_address_space_allocate_hostmem(
- handle,
- hostmem_alloc_size,
- hostmem_id,
- &hostmem_info)) {
- ALOGE("AddressSpaceStream::create failed (alloc hostmem)\n");
- if (virtgpu_info.resp_mapped_ptr) {
- munmap(virtgpu_info.resp_mapped_ptr, 4096);
- }
- virtgpu_address_space_close(handle);
- return nullptr;
- }
-
- request.metadata = ASG_GET_CONFIG;
- if (!virtgpu_address_space_ping_with_response(
- &virtgpu_info, &request)) {
- ALOGE("AddressSpaceStream::create failed (get config)\n");
- if (virtgpu_info.resp_mapped_ptr) {
- munmap(virtgpu_info.resp_mapped_ptr, 4096);
- }
- virtgpu_address_space_close(handle);
- return nullptr;
- }
-
- char* ringPtr = (char*)hostmem_info.ptr;
- char* bufferPtr = ((char*)hostmem_info.ptr) + sizeof(struct asg_ring_storage);
-
+ bufferPtr = blobAddr + sizeof(struct asg_ring_storage);
struct asg_context context =
- asg_context_create(
- (char*)ringPtr, (char*)bufferPtr, bufferSize);
+ asg_context_create(blobAddr, bufferPtr, bufferSize);
context.ring_config->transfer_mode = 1;
context.ring_config->host_consumed_pos = 0;
@@ -256,23 +234,15 @@
.open = virtgpu_address_space_open,
.close = virtgpu_address_space_close,
.ping = virtgpu_address_space_ping,
- .allocate_hostmem = virtgpu_address_space_allocate_hostmem,
- .ping_with_response = virtgpu_address_space_ping_with_response,
};
- if (virtgpu_info.resp_mapped_ptr) {
- munmap(virtgpu_info.resp_mapped_ptr, 4096);
- }
-
AddressSpaceStream* res =
- new AddressSpaceStream(
- handle, version, context,
- 0, 0, true /* is virtio */, ops);
+ new AddressSpaceStream((address_space_handle_t)(-1), 1, context, 0, 0, ops, healthMonitor);
+ res->setMapping(blobMapping);
+ res->setResourceId(contextCreate.resourceId);
return res;
}
-#endif // VIRTIO_GPU && !HOST_BUILD
-
AddressSpaceStream::AddressSpaceStream(
address_space_handle_t handle,
@@ -280,10 +250,9 @@
struct asg_context context,
uint64_t ringOffset,
uint64_t writeBufferOffset,
- bool virtioMode,
- struct address_space_ops ops) :
+ struct address_space_ops ops,
+ HealthMonitor<>& healthMonitor) :
IOStream(context.ring_config->flush_interval),
- m_virtioMode(virtioMode),
m_ops(ops),
m_tmpBuf(0),
m_tmpBufSize(0),
@@ -306,9 +275,11 @@
m_written(0),
m_backoffIters(0),
m_backoffFactor(1),
- m_ringStorageSize(sizeof(struct asg_ring_storage) + m_writeBufferSize) {
+ m_ringStorageSize(sizeof(struct asg_ring_storage) + m_writeBufferSize),
+ m_healthMonitor(healthMonitor) {
// We'll use this in the future, but at the moment,
// it's a potential compile Werror.
+ (void)m_ringStorageSize;
(void)m_version;
}
@@ -316,16 +287,14 @@
flush();
ensureType3Finished();
ensureType1Finished();
- if (m_virtioMode) {
- if (m_context.to_host) {
- munmap(m_context.to_host, m_ringStorageSize);
- }
- } else {
+
+ if (!m_mapping) {
m_ops.unmap(m_context.to_host, sizeof(struct asg_ring_storage));
m_ops.unmap(m_context.buffer, m_writeBufferSize);
m_ops.unclaim_shared(m_handle, m_ringOffset);
m_ops.unclaim_shared(m_handle, m_writeBufferOffset);
}
+
m_ops.close(m_handle);
if (m_readBuf) free(m_readBuf);
if (m_tmpBuf) free(m_tmpBuf);
@@ -337,6 +306,7 @@
}
void *AddressSpaceStream::allocBuffer(size_t minSize) {
+ auto watchdog = WATCHDOG_BUILDER(m_healthMonitor, "ASG watchdog").build();
AEMU_SCOPED_TRACE("allocBuffer");
ensureType3Finished();
@@ -484,6 +454,7 @@
int AddressSpaceStream::writeFully(const void *buf, size_t size)
{
+ auto watchdog = WATCHDOG_BUILDER(m_healthMonitor, "ASG watchdog").build();
AEMU_SCOPED_TRACE("writeFully");
ensureType3Finished();
ensureType1Finished();
@@ -549,6 +520,7 @@
int AddressSpaceStream::writeFullyAsync(const void *buf, size_t size)
{
+ auto watchdog = WATCHDOG_BUILDER(m_healthMonitor, "ASG watchdog").build();
AEMU_SCOPED_TRACE("writeFullyAsync");
ensureType3Finished();
ensureType1Finished();
@@ -672,9 +644,11 @@
}
void AddressSpaceStream::notifyAvailable() {
+ auto watchdog = WATCHDOG_BUILDER(m_healthMonitor, "ASG watchdog").build();
AEMU_SCOPED_TRACE("PING");
struct address_space_ping request;
request.metadata = ASG_NOTIFY_AVAILABLE;
+ request.resourceId = m_resourceId;
m_ops.ping(m_handle, &request);
++m_notifs;
}
@@ -713,6 +687,7 @@
}
void AddressSpaceStream::ensureType1Finished() {
+ auto watchdog = WATCHDOG_BUILDER(m_healthMonitor, "ASG watchdog").build();
AEMU_SCOPED_TRACE("ensureType1Finished");
uint32_t currAvailRead =
@@ -729,6 +704,7 @@
}
void AddressSpaceStream::ensureType3Finished() {
+ auto watchdog = WATCHDOG_BUILDER(m_healthMonitor, "ASG watchdog").build();
AEMU_SCOPED_TRACE("ensureType3Finished");
uint32_t availReadLarge =
ring_buffer_available_read(
@@ -753,6 +729,7 @@
int AddressSpaceStream::type1Write(uint32_t bufferOffset, size_t size) {
+ auto watchdog = WATCHDOG_BUILDER(m_healthMonitor, "ASG watchdog").build();
AEMU_SCOPED_TRACE("type1Write");
ensureType3Finished();
diff --git a/system/OpenglSystemCommon/AddressSpaceStream.h b/system/OpenglSystemCommon/AddressSpaceStream.h
index 68ad80d..da15dbc 100644
--- a/system/OpenglSystemCommon/AddressSpaceStream.h
+++ b/system/OpenglSystemCommon/AddressSpaceStream.h
@@ -17,21 +17,17 @@
#define __ADDRESS_SPACE_STREAM_H
#include "IOStream.h"
-
+#include "VirtGpu.h"
#include "address_space_graphics_types.h"
+#include "android/base/AndroidHealthMonitor.h"
#include "goldfish_address_space.h"
+using android::base::guest::HealthMonitor;
+
class AddressSpaceStream;
-AddressSpaceStream* createAddressSpaceStream(size_t bufSize);
-
-#if defined(VIRTIO_GPU) && !defined(HOST_BUILD)
-struct StreamCreate {
- int streamHandle;
-};
-
-AddressSpaceStream* createVirtioGpuAddressSpaceStream(const struct StreamCreate &streamCreate);
-#endif
+AddressSpaceStream* createAddressSpaceStream(size_t bufSize, HealthMonitor<>& healthMonitor);
+AddressSpaceStream* createVirtioGpuAddressSpaceStream(HealthMonitor<>& healthMonitor);
class AddressSpaceStream : public IOStream {
public:
@@ -41,8 +37,8 @@
struct asg_context context,
uint64_t ringOffset,
uint64_t writeBufferOffset,
- bool virtioMode,
- struct address_space_ops ops);
+ struct address_space_ops ops,
+ HealthMonitor<>& healthMonitor);
~AddressSpaceStream();
virtual size_t idealAllocSize(size_t len);
@@ -54,13 +50,12 @@
virtual int writeFullyAsync(const void *buf, size_t len);
virtual const unsigned char *commitBufferAndReadFully(size_t size, void *buf, size_t len);
- int getRendernodeFd() const {
-#if defined(__Fuchsia__)
- return -1;
-#else
- if (!m_virtioMode) return -1;
- return m_handle;
-#endif
+ void setMapping(VirtGpuBlobMappingPtr mapping) {
+ m_mapping = mapping;
+ }
+
+ void setResourceId(uint32_t id) {
+ m_resourceId = id;
}
private:
@@ -77,7 +72,7 @@
void backoff();
void resetBackoff();
- bool m_virtioMode;
+ VirtGpuBlobMappingPtr m_mapping = nullptr;
struct address_space_ops m_ops;
unsigned char* m_tmpBuf;
@@ -109,6 +104,9 @@
uint64_t m_backoffFactor;
size_t m_ringStorageSize;
+ uint32_t m_resourceId = 0;
+
+ HealthMonitor<>& m_healthMonitor;
};
#endif
diff --git a/system/OpenglSystemCommon/Android.mk b/system/OpenglSystemCommon/Android.mk
index f9cd67a..f586915 100644
--- a/system/OpenglSystemCommon/Android.mk
+++ b/system/OpenglSystemCommon/Android.mk
@@ -3,10 +3,12 @@
$(call emugl-begin-shared-library,libOpenglSystemCommon)
$(call emugl-import,libGLESv1_enc libGLESv2_enc lib_renderControl_enc)
ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+$(call emugl-import,libplatform$(GOLDFISH_OPENGL_LIB_SUFFIX))
$(call emugl-import,libGoldfishAddressSpace$(GOLDFISH_OPENGL_LIB_SUFFIX))
$(call emugl-import,libqemupipe$(GOLDFISH_OPENGL_LIB_SUFFIX))
$(call emugl-import,libgralloc_cb$(GOLDFISH_OPENGL_LIB_SUFFIX))
else
+$(call emugl-export,STATIC_LIBRARIES,libplatform)
$(call emugl-export,STATIC_LIBRARIES,libGoldfishAddressSpace libringbuffer)
$(call emugl-export,STATIC_LIBRARIES,libqemupipe.ranchu)
$(call emugl-export,HEADER_LIBRARIES,libgralloc_cb.ranchu)
@@ -34,11 +36,10 @@
ifeq (true,$(GFXSTREAM))
-LOCAL_HEADER_LIBRARIES += vulkan_headers
+LOCAL_HEADER_LIBRARIES += gfxstream_vulkan_headers
LOCAL_CFLAGS += -DVIRTIO_GPU
LOCAL_SRC_FILES += \
- VirtioGpuStream.cpp \
VirtioGpuPipeStream.cpp \
LOCAL_C_INCLUDES += external/libdrm external/minigbm/cros_gralloc
diff --git a/system/OpenglSystemCommon/CMakeLists.txt b/system/OpenglSystemCommon/CMakeLists.txt
index a9f1d18..04d2893 100644
--- a/system/OpenglSystemCommon/CMakeLists.txt
+++ b/system/OpenglSystemCommon/CMakeLists.txt
@@ -1,10 +1,10 @@
# This is an autogenerated file! Do not edit!
# instead run make from .../device/generic/goldfish-opengl
# which will re-generate this file.
-android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon/Android.mk" "401986affa6f80625f00675980f448fa434d724df34034781651daffaa8e6b70")
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon/Android.mk" "5086200ad090dcbd2e94e4d253914680c8f0b5feea92776c0f64cbdd7fe4e4fa")
set(OpenglSystemCommon_src FormatConversions.cpp HostConnection.cpp QemuPipeStream.cpp ProcessPipe.cpp ThreadInfo.cpp AddressSpaceStream.cpp)
android_add_library(TARGET OpenglSystemCommon SHARED LICENSE Apache-2.0 SRC FormatConversions.cpp HostConnection.cpp QemuPipeStream.cpp ProcessPipe.cpp ThreadInfo.cpp AddressSpaceStream.cpp)
-target_include_directories(OpenglSystemCommon PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/platform ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon/bionic-include ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/shared/gralloc_cb/include ${GOLDFISH_DEVICE_ROOT}/shared/GoldfishAddressSpace/include ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include-types ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_include_directories(OpenglSystemCommon PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/platform ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon/bionic-include ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/shared/gralloc_cb/include ${GOLDFISH_DEVICE_ROOT}/shared/GoldfishAddressSpace/include ${GOLDFISH_DEVICE_ROOT}/platform/include ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include-types ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
target_compile_definitions(OpenglSystemCommon PRIVATE "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGFXSTREAM")
target_compile_options(OpenglSystemCommon PRIVATE "-fvisibility=default" "-Wno-unused-parameter" "-Wno-unused-variable" "-fno-emulated-tls")
-target_link_libraries(OpenglSystemCommon PRIVATE android-emu-shared vulkan_enc gui log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host cutils utils androidemu PRIVATE gralloc_cb_host GoldfishAddressSpace_host qemupipe_host)
\ No newline at end of file
+target_link_libraries(OpenglSystemCommon PRIVATE android-emu-shared vulkan_enc gui log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host cutils utils androidemu PRIVATE gralloc_cb_host GoldfishAddressSpace_host platform_host qemupipe_host)
\ No newline at end of file
diff --git a/system/OpenglSystemCommon/EmulatorFeatureInfo.h b/system/OpenglSystemCommon/EmulatorFeatureInfo.h
index 8a243c2..67799eb 100644
--- a/system/OpenglSystemCommon/EmulatorFeatureInfo.h
+++ b/system/OpenglSystemCommon/EmulatorFeatureInfo.h
@@ -204,10 +204,9 @@
enum HostConnectionType {
HOST_CONNECTION_TCP = 0,
HOST_CONNECTION_QEMU_PIPE = 1,
- HOST_CONNECTION_VIRTIO_GPU = 2,
- HOST_CONNECTION_ADDRESS_SPACE = 3,
- HOST_CONNECTION_VIRTIO_GPU_PIPE = 4,
- HOST_CONNECTION_VIRTIO_GPU_ADDRESS_SPACE = 5,
+ HOST_CONNECTION_ADDRESS_SPACE = 2,
+ HOST_CONNECTION_VIRTIO_GPU_PIPE = 3,
+ HOST_CONNECTION_VIRTIO_GPU_ADDRESS_SPACE = 4,
};
enum GrallocType {
diff --git a/system/OpenglSystemCommon/HostConnection.cpp b/system/OpenglSystemCommon/HostConnection.cpp
index 9d41be4..0430447 100644
--- a/system/OpenglSystemCommon/HostConnection.cpp
+++ b/system/OpenglSystemCommon/HostConnection.cpp
@@ -15,11 +15,27 @@
*/
#include "HostConnection.h"
+#include "android/base/threads/AndroidThread.h"
+#include "android/base/AndroidHealthMonitor.h"
+#include "android/base/AndroidHealthMonitorConsumerBasic.h"
#include "cutils/properties.h"
+#include "renderControl_types.h"
#ifdef HOST_BUILD
#include "android/base/Tracing.h"
#endif
+#include "android/base/Process.h"
+
+#define DEBUG_HOSTCONNECTION 0
+
+#if DEBUG_HOSTCONNECTION
+#define DPRINT(fmt,...) ALOGD("%s: " fmt, __FUNCTION__, ##__VA_ARGS__);
+#else
+#define DPRINT(...)
+#endif
+
+using android::base::guest::HealthMonitor;
+using android::base::guest::HealthMonitorConsumerBasic;
#ifdef GOLDFISH_NO_GL
struct gl_client_context_t {
@@ -53,19 +69,19 @@
#else
namespace goldfish_vk {
struct VkEncoder {
- VkEncoder(IOStream*) { }
+ VkEncoder(IOStream* stream, HealthMonitor<>* healthMonitor = nullptr) { }
void decRef() { }
int placeholder;
};
} // namespace goldfish_vk
class QemuPipeStream;
typedef QemuPipeStream AddressSpaceStream;
-AddressSpaceStream* createAddressSpaceStream(size_t bufSize) {
+AddressSpaceStream* createAddressSpaceStream(size_t bufSize, HealthMonitor<>& healthMonitor) {
ALOGE("%s: FATAL: Trying to create ASG stream in unsupported build\n", __func__);
abort();
}
-AddressSpaceStream* createVirtioGpuAddressSpaceStream(size_t bufSize) {
- ALOGE("%s: FATAL: Trying to create virtgpu ASG stream in unsupported build\n", __func__);
+AddressSpaceStream* createVirtioGpuAddressSpaceStream(HealthMonitor<>& healthMonitor) {
+ ALOGE("%s: FATAL: Trying to create VirtioGpu ASG stream in unsupported build\n", __func__);
abort();
}
#endif
@@ -79,9 +95,11 @@
#include <gralloc_cb_bp.h>
#include <unistd.h>
+using android::base::guest::getCurrentThreadId;
+
#ifdef VIRTIO_GPU
-#include "VirtioGpuStream.h"
+#include "VirtGpu.h"
#include "VirtioGpuPipeStream.h"
#include "virtgpu_drm.h"
@@ -90,6 +108,11 @@
#endif
+#if defined(__linux__) || defined(__ANDROID__)
+#include <fstream>
+#include <string>
+#endif
+
#undef LOG_TAG
#define LOG_TAG "HostConnection"
#if PLATFORM_SDK_VERSION < 26
@@ -101,6 +124,15 @@
#define STREAM_BUFFER_SIZE (4*1024*1024)
#define STREAM_PORT_NUM 22468
+HealthMonitor<>& getGlobalHealthMonitor() {
+ // Initialize HealthMonitor
+ // Rather than inject as a construct arg, we keep it as a static variable in the .cpp
+ // to avoid setting up dependencies in other repos (external/qemu)
+ static HealthMonitorConsumerBasic sHealthMonitorConsumerBasic;
+ static HealthMonitor sHealthMonitor(sHealthMonitorConsumerBasic);
+ return sHealthMonitor;
+}
+
static HostConnectionType getConnectionTypeFromProperty() {
#ifdef __Fuchsia__
return HOST_CONNECTION_ADDRESS_SPACE;
@@ -121,7 +153,6 @@
if (!strcmp("tcp", transportValue)) return HOST_CONNECTION_TCP;
if (!strcmp("pipe", transportValue)) return HOST_CONNECTION_QEMU_PIPE;
- if (!strcmp("virtio-gpu", transportValue)) return HOST_CONNECTION_VIRTIO_GPU;
if (!strcmp("asg", transportValue)) return HOST_CONNECTION_ADDRESS_SPACE;
if (!strcmp("virtio-gpu-pipe", transportValue)) return HOST_CONNECTION_VIRTIO_GPU_PIPE;
if (!strcmp("virtio-gpu-asg", transportValue)) return HOST_CONNECTION_VIRTIO_GPU_ADDRESS_SPACE;
@@ -201,7 +232,7 @@
uint32_t bpp = 0;
switch (glformat) {
case kGlRGB:
- ALOGD("Note: egl wanted GL_RGB, still using RGBA");
+ DPRINT("Note: egl wanted GL_RGB, still using RGBA");
virtgpu_format = kVirglFormatRGBA;
bpp = 4;
break;
@@ -210,7 +241,7 @@
bpp = 4;
break;
default:
- ALOGD("Note: egl wanted 0x%x, still using RGBA", glformat);
+ DPRINT("Note: egl wanted 0x%x, still using RGBA", glformat);
virtgpu_format = kVirglFormatRGBA;
bpp = 4;
break;
@@ -255,6 +286,10 @@
return ((cros_gralloc_handle *)handle)->droid_format;
}
+ virtual uint32_t getFormatDrmFourcc(native_handle_t const* handle) override {
+ return ((cros_gralloc_handle *)handle)->format;
+ }
+
virtual size_t getAllocatedSize(native_handle_t const* handle) {
struct drm_virtgpu_resource_info info;
if (!getResInfo(handle, &info)) {
@@ -382,7 +417,7 @@
{
return ::processPipeInit(stream_handle, connType, rcEnc);
}
-
+
};
static GoldfishGralloc m_goldfishGralloc;
@@ -391,7 +426,7 @@
HostConnection::HostConnection() :
exitUncleanly(false),
m_checksumHelper(),
- m_glExtensions(),
+ m_hostExtensions(),
m_grallocOnly(true),
m_noHostError(true),
m_rendernodeFd(-1) {
@@ -421,41 +456,6 @@
}
}
-#if defined(VIRTIO_GPU) && !defined(HOST_BUILD)
-int virtgpuOpen(uint32_t capset_id) {
- int fd = drmOpenRender(128);
- if (fd < 0) {
- ALOGE("Failed to open rendernode: %s", strerror(errno));
- return fd;
- }
-
- if (capset_id) {
- int ret;
- struct drm_virtgpu_context_init init = {0};
- struct drm_virtgpu_context_set_param ctx_set_params[2] = {{0}};
-
- ctx_set_params[0].param = VIRTGPU_CONTEXT_PARAM_NUM_RINGS;
- ctx_set_params[0].value = 1;
- init.num_params = 1;
-
- // TODO(b/218538495): A KI in the 5.4 kernel will sometimes result in capsets not
- // being properly queried.
-#if defined(__linux__) && !defined(__ANDROID__)
- ctx_set_params[1].param = VIRTGPU_CONTEXT_PARAM_CAPSET_ID;
- ctx_set_params[1].value = capset_id;
- init.num_params++;
-#endif
-
- init.ctx_set_params = (unsigned long long)&ctx_set_params[0];
- ret = drmIoctl(fd, DRM_IOCTL_VIRTGPU_CONTEXT_INIT, &init);
- if (ret) {
- ALOGE("DRM_IOCTL_VIRTGPU_CONTEXT_INIT failed with %s, continuing without context...", strerror(errno));
- }
- }
-
- return fd;
-}
-#endif
// static
std::unique_ptr<HostConnection> HostConnection::connect(uint32_t capset_id) {
@@ -463,9 +463,10 @@
// Use "new" to access a non-public constructor.
auto con = std::unique_ptr<HostConnection>(new HostConnection);
+
switch (connType) {
case HOST_CONNECTION_ADDRESS_SPACE: {
- auto stream = createAddressSpaceStream(STREAM_BUFFER_SIZE);
+ auto stream = createAddressSpaceStream(STREAM_BUFFER_SIZE, getGlobalHealthMonitor());
if (!stream) {
ALOGE("Failed to create AddressSpaceStream for host connection\n");
return nullptr;
@@ -519,27 +520,6 @@
#endif
}
#if defined(VIRTIO_GPU) && !defined(HOST_BUILD)
- case HOST_CONNECTION_VIRTIO_GPU: {
- auto stream = new VirtioGpuStream(STREAM_BUFFER_SIZE);
- if (!stream) {
- ALOGE("Failed to create VirtioGpu for host connection\n");
- return nullptr;
- }
- if (stream->connect() < 0) {
- ALOGE("Failed to connect to host (VirtioGpu)\n");
- return nullptr;
- }
- con->m_connectionType = HOST_CONNECTION_VIRTIO_GPU;
- con->m_grallocType = GRALLOC_TYPE_MINIGBM;
- auto rendernodeFd = stream->getRendernodeFd();
- con->m_processPipe = stream->getProcessPipe();
- con->m_stream = stream;
- con->m_rendernodeFd = rendernodeFd;
- MinigbmGralloc* m = new MinigbmGralloc;
- m->setFd(rendernodeFd);
- con->m_grallocHelper = m;
- break;
- }
case HOST_CONNECTION_VIRTIO_GPU_PIPE: {
auto stream = new VirtioGpuPipeStream(STREAM_BUFFER_SIZE);
if (!stream) {
@@ -573,30 +553,24 @@
break;
}
case HOST_CONNECTION_VIRTIO_GPU_ADDRESS_SPACE: {
- struct StreamCreate streamCreate = {0};
- streamCreate.streamHandle = virtgpuOpen(capset_id);
- if (streamCreate.streamHandle < 0) {
- ALOGE("Failed to open virtgpu for ASG host connection\n");
- return nullptr;
- }
-
- auto stream = createVirtioGpuAddressSpaceStream(streamCreate);
+ VirtGpuDevice& instance = VirtGpuDevice::getInstance((enum VirtGpuCapset)capset_id);
+ auto deviceHandle = instance.getDeviceHandle();
+ auto stream = createVirtioGpuAddressSpaceStream(getGlobalHealthMonitor());
if (!stream) {
ALOGE("Failed to create virtgpu AddressSpaceStream\n");
return nullptr;
}
con->m_connectionType = HOST_CONNECTION_VIRTIO_GPU_ADDRESS_SPACE;
con->m_grallocType = getGrallocTypeFromProperty();
- auto rendernodeFd = stream->getRendernodeFd();
con->m_stream = stream;
- con->m_rendernodeFd = rendernodeFd;
+ con->m_rendernodeFd = deviceHandle;
switch (con->m_grallocType) {
case GRALLOC_TYPE_RANCHU:
con->m_grallocHelper = &m_goldfishGralloc;
break;
case GRALLOC_TYPE_MINIGBM: {
MinigbmGralloc* m = new MinigbmGralloc;
- m->setFd(rendernodeFd);
+ m->setFd(deviceHandle);
con->m_grallocHelper = m;
break;
}
@@ -618,10 +592,22 @@
*pClientFlags = 0;
con->m_stream->commitBuffer(sizeof(unsigned int));
- ALOGD("HostConnection::get() New Host Connection established %p, tid %d\n",
- con.get(), getCurrentThreadId());
+ DPRINT("HostConnection::get() New Host Connection established %p, tid %lu\n", con.get(),
+ getCurrentThreadId());
- // ALOGD("Address space echo latency check done\n");
+#if defined(__linux__) || defined(__ANDROID__)
+ auto rcEnc = con->rcEncoder();
+ if (rcEnc != nullptr) {
+ auto processName = android::base::guest::getProcessName();
+ if (!processName.empty()) {
+ rcEnc->rcSetProcessMetadata(
+ rcEnc, const_cast<char*>("process_name"),
+ const_cast<RenderControlByte*>(processName.c_str()),
+ strlen(processName.c_str())+ 1);
+ }
+ }
+#endif
+
return con;
}
@@ -667,7 +653,7 @@
// static
std::unique_ptr<HostConnection> HostConnection::createUnique(uint32_t capset_id) {
- ALOGD("%s: call\n", __func__);
+ DPRINT("%s: call\n", __func__);
return connect(capset_id);
}
@@ -675,8 +661,7 @@
{
if (!m_glEnc) {
m_glEnc = std::make_unique<GLEncoder>(m_stream, checksumHelper());
- DBG("HostConnection::glEncoder new encoder %p, tid %d",
- m_glEnc, getCurrentThreadId());
+ DBG("HostConnection::glEncoder new encoder %p, tid %lu", m_glEnc, getCurrentThreadId());
m_glEnc->setContextAccessor(s_getGLContext);
}
return m_glEnc.get();
@@ -687,8 +672,7 @@
if (!m_gl2Enc) {
m_gl2Enc =
std::make_unique<GL2Encoder>(m_stream, checksumHelper());
- DBG("HostConnection::gl2Encoder new encoder %p, tid %d",
- m_gl2Enc, getCurrentThreadId());
+ DBG("HostConnection::gl2Encoder new encoder %p, tid %lu", m_gl2Enc, getCurrentThreadId());
m_gl2Enc->setContextAccessor(s_getGL2Context);
m_gl2Enc->setNoHostError(m_noHostError);
m_gl2Enc->setDrawCallFlushInterval(
@@ -703,7 +687,7 @@
{
rcEncoder();
if (!m_vkEnc) {
- m_vkEnc = new VkEncoder(m_stream);
+ m_vkEnc = new VkEncoder(m_stream, &getGlobalHealthMonitor());
}
return m_vkEnc;
}
@@ -770,42 +754,42 @@
return NULL;
}
-const std::string& HostConnection::queryGLExtensions(ExtendedRCEncoderContext *rcEnc) {
- if (!m_glExtensions.empty()) {
- return m_glExtensions;
+const std::string& HostConnection::queryHostExtensions(ExtendedRCEncoderContext *rcEnc) {
+ if (!m_hostExtensions.empty()) {
+ return m_hostExtensions;
}
// Extensions strings are usually quite long, preallocate enough here.
- std::string extensions_buffer(1023, '\0');
+ std::string extensionsBuffer(1023, '\0');
- // rcGetGLString() returns required size including the 0-terminator, so
+ // Returns the required size including the 0-terminator, so
// account it when passing/using the sizes.
- int extensionSize = rcEnc->rcGetGLString(rcEnc, GL_EXTENSIONS,
- &extensions_buffer[0],
- extensions_buffer.size() + 1);
+ int extensionSize = rcEnc->rcGetHostExtensionsString(rcEnc,
+ extensionsBuffer.size() + 1,
+ &extensionsBuffer[0]);
if (extensionSize < 0) {
- extensions_buffer.resize(-extensionSize);
- extensionSize = rcEnc->rcGetGLString(rcEnc, GL_EXTENSIONS,
- &extensions_buffer[0],
- -extensionSize + 1);
+ extensionsBuffer.resize(-extensionSize);
+ extensionSize = rcEnc->rcGetHostExtensionsString(rcEnc,
+ -extensionSize + 1,
+ &extensionsBuffer[0]);
}
if (extensionSize > 0) {
- extensions_buffer.resize(extensionSize - 1);
- m_glExtensions.swap(extensions_buffer);
+ extensionsBuffer.resize(extensionSize - 1);
+ m_hostExtensions.swap(extensionsBuffer);
}
- return m_glExtensions;
+ return m_hostExtensions;
}
void HostConnection::queryAndSetHostCompositionImpl(ExtendedRCEncoderContext *rcEnc) {
- const std::string& glExtensions = queryGLExtensions(rcEnc);
- ALOGD("HostComposition ext %s", glExtensions.c_str());
+ const std::string& hostExtensions = queryHostExtensions(rcEnc);
+ DPRINT("HostComposition ext %s", hostExtensions.c_str());
// make sure V2 is checked first before V1, as host may declare supporting both
- if (glExtensions.find(kHostCompositionV2) != std::string::npos) {
+ if (hostExtensions.find(kHostCompositionV2) != std::string::npos) {
rcEnc->setHostComposition(HOST_COMPOSITION_V2);
}
- else if (glExtensions.find(kHostCompositionV1) != std::string::npos) {
+ else if (hostExtensions.find(kHostCompositionV1) != std::string::npos) {
rcEnc->setHostComposition(HOST_COMPOSITION_V1);
}
else {
@@ -814,11 +798,11 @@
}
void HostConnection::setChecksumHelper(ExtendedRCEncoderContext *rcEnc) {
- const std::string& glExtensions = queryGLExtensions(rcEnc);
+ const std::string& hostExtensions = queryHostExtensions(rcEnc);
// check the host supported version
uint32_t checksumVersion = 0;
const char* checksumPrefix = ChecksumCalculator::getMaxVersionStrPrefix();
- const char* glProtocolStr = strstr(glExtensions.c_str(), checksumPrefix);
+ const char* glProtocolStr = strstr(hostExtensions.c_str(), checksumPrefix);
if (glProtocolStr) {
uint32_t maxVersion = ChecksumCalculator::getMaxVersion();
sscanf(glProtocolStr+strlen(checksumPrefix), "%d", &checksumVersion);
@@ -833,12 +817,12 @@
}
void HostConnection::queryAndSetSyncImpl(ExtendedRCEncoderContext *rcEnc) {
- const std::string& glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kRCNativeSyncV4) != std::string::npos) {
+ const std::string& hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kRCNativeSyncV4) != std::string::npos) {
rcEnc->setSyncImpl(SYNC_IMPL_NATIVE_SYNC_V4);
- } else if (glExtensions.find(kRCNativeSyncV3) != std::string::npos) {
+ } else if (hostExtensions.find(kRCNativeSyncV3) != std::string::npos) {
rcEnc->setSyncImpl(SYNC_IMPL_NATIVE_SYNC_V3);
- } else if (glExtensions.find(kRCNativeSyncV2) != std::string::npos) {
+ } else if (hostExtensions.find(kRCNativeSyncV2) != std::string::npos) {
rcEnc->setSyncImpl(SYNC_IMPL_NATIVE_SYNC_V2);
} else {
rcEnc->setSyncImpl(SYNC_IMPL_NONE);
@@ -846,8 +830,8 @@
}
void HostConnection::queryAndSetDmaImpl(ExtendedRCEncoderContext *rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kDmaExtStr_v1) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kDmaExtStr_v1) != std::string::npos) {
rcEnc->setDmaImpl(DMA_IMPL_v1);
} else {
rcEnc->setDmaImpl(DMA_IMPL_NONE);
@@ -855,179 +839,179 @@
}
void HostConnection::queryAndSetGLESMaxVersion(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kGLESMaxVersion_2) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kGLESMaxVersion_2) != std::string::npos) {
rcEnc->setGLESMaxVersion(GLES_MAX_VERSION_2);
- } else if (glExtensions.find(kGLESMaxVersion_3_0) != std::string::npos) {
+ } else if (hostExtensions.find(kGLESMaxVersion_3_0) != std::string::npos) {
rcEnc->setGLESMaxVersion(GLES_MAX_VERSION_3_0);
- } else if (glExtensions.find(kGLESMaxVersion_3_1) != std::string::npos) {
+ } else if (hostExtensions.find(kGLESMaxVersion_3_1) != std::string::npos) {
rcEnc->setGLESMaxVersion(GLES_MAX_VERSION_3_1);
- } else if (glExtensions.find(kGLESMaxVersion_3_2) != std::string::npos) {
+ } else if (hostExtensions.find(kGLESMaxVersion_3_2) != std::string::npos) {
rcEnc->setGLESMaxVersion(GLES_MAX_VERSION_3_2);
} else {
ALOGW("Unrecognized GLES max version string in extensions: %s",
- glExtensions.c_str());
+ hostExtensions.c_str());
rcEnc->setGLESMaxVersion(GLES_MAX_VERSION_2);
}
}
void HostConnection::queryAndSetNoErrorState(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kGLESUseHostError) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kGLESUseHostError) != std::string::npos) {
m_noHostError = false;
}
}
void HostConnection::queryAndSetDirectMemSupport(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kGLDirectMem) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kGLDirectMem) != std::string::npos) {
rcEnc->featureInfo()->hasDirectMem = true;
}
}
void HostConnection::queryAndSetVulkanSupport(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kVulkan) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kVulkan) != std::string::npos) {
rcEnc->featureInfo()->hasVulkan = true;
}
}
void HostConnection::queryAndSetDeferredVulkanCommandsSupport(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kDeferredVulkanCommands) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kDeferredVulkanCommands) != std::string::npos) {
rcEnc->featureInfo()->hasDeferredVulkanCommands = true;
}
}
void HostConnection::queryAndSetVulkanNullOptionalStringsSupport(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kVulkanNullOptionalStrings) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kVulkanNullOptionalStrings) != std::string::npos) {
rcEnc->featureInfo()->hasVulkanNullOptionalStrings = true;
}
}
void HostConnection::queryAndSetVulkanCreateResourcesWithRequirementsSupport(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kVulkanCreateResourcesWithRequirements) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kVulkanCreateResourcesWithRequirements) != std::string::npos) {
rcEnc->featureInfo()->hasVulkanCreateResourcesWithRequirements = true;
}
}
void HostConnection::queryAndSetVulkanIgnoredHandles(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kVulkanIgnoredHandles) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kVulkanIgnoredHandles) != std::string::npos) {
rcEnc->featureInfo()->hasVulkanIgnoredHandles = true;
}
}
void HostConnection::queryAndSetYUVCache(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kYUVCache) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kYUVCache) != std::string::npos) {
rcEnc->featureInfo()->hasYUVCache = true;
}
}
void HostConnection::queryAndSetAsyncUnmapBuffer(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kAsyncUnmapBuffer) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kAsyncUnmapBuffer) != std::string::npos) {
rcEnc->featureInfo()->hasAsyncUnmapBuffer = true;
}
}
void HostConnection::queryAndSetVirtioGpuNext(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kVirtioGpuNext) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kVirtioGpuNext) != std::string::npos) {
rcEnc->featureInfo()->hasVirtioGpuNext = true;
}
}
void HostConnection::queryHasSharedSlotsHostMemoryAllocator(ExtendedRCEncoderContext *rcEnc) {
- const std::string& glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kHasSharedSlotsHostMemoryAllocator) != std::string::npos) {
+ const std::string& hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kHasSharedSlotsHostMemoryAllocator) != std::string::npos) {
rcEnc->featureInfo()->hasSharedSlotsHostMemoryAllocator = true;
}
}
void HostConnection::queryAndSetVulkanFreeMemorySync(ExtendedRCEncoderContext *rcEnc) {
- const std::string& glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kVulkanFreeMemorySync) != std::string::npos) {
+ const std::string& hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kVulkanFreeMemorySync) != std::string::npos) {
rcEnc->featureInfo()->hasVulkanFreeMemorySync = true;
}
}
void HostConnection::queryAndSetVirtioGpuNativeSync(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kVirtioGpuNativeSync) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kVirtioGpuNativeSync) != std::string::npos) {
rcEnc->featureInfo()->hasVirtioGpuNativeSync = true;
}
}
void HostConnection::queryAndSetVulkanShaderFloat16Int8Support(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kVulkanShaderFloat16Int8) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kVulkanShaderFloat16Int8) != std::string::npos) {
rcEnc->featureInfo()->hasVulkanShaderFloat16Int8 = true;
}
}
void HostConnection::queryAndSetVulkanAsyncQueueSubmitSupport(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kVulkanAsyncQueueSubmit) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kVulkanAsyncQueueSubmit) != std::string::npos) {
rcEnc->featureInfo()->hasVulkanAsyncQueueSubmit = true;
}
}
void HostConnection::queryAndSetHostSideTracingSupport(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kHostSideTracing) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kHostSideTracing) != std::string::npos) {
rcEnc->featureInfo()->hasHostSideTracing = true;
}
}
void HostConnection::queryAndSetAsyncFrameCommands(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kAsyncFrameCommands) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kAsyncFrameCommands) != std::string::npos) {
rcEnc->featureInfo()->hasAsyncFrameCommands = true;
}
}
void HostConnection::queryAndSetVulkanQueueSubmitWithCommandsSupport(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kVulkanQueueSubmitWithCommands) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kVulkanQueueSubmitWithCommands) != std::string::npos) {
rcEnc->featureInfo()->hasVulkanQueueSubmitWithCommands = true;
}
}
void HostConnection::queryAndSetVulkanBatchedDescriptorSetUpdateSupport(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kVulkanBatchedDescriptorSetUpdate) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kVulkanBatchedDescriptorSetUpdate) != std::string::npos) {
rcEnc->featureInfo()->hasVulkanBatchedDescriptorSetUpdate = true;
}
}
void HostConnection::queryAndSetSyncBufferData(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kSyncBufferData) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kSyncBufferData) != std::string::npos) {
rcEnc->featureInfo()->hasSyncBufferData = true;
}
}
void HostConnection::queryAndSetVulkanAsyncQsri(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kVulkanAsyncQsri) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kVulkanAsyncQsri) != std::string::npos) {
rcEnc->featureInfo()->hasVulkanAsyncQsri = true;
}
}
void HostConnection::queryAndSetReadColorBufferDma(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kReadColorBufferDma) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kReadColorBufferDma) != std::string::npos) {
rcEnc->featureInfo()->hasReadColorBufferDma = true;
}
}
void HostConnection::queryAndSetHWCMultiConfigs(ExtendedRCEncoderContext* rcEnc) {
- std::string glExtensions = queryGLExtensions(rcEnc);
- if (glExtensions.find(kHWCMultiConfigs) != std::string::npos) {
+ std::string hostExtensions = queryHostExtensions(rcEnc);
+ if (hostExtensions.find(kHWCMultiConfigs) != std::string::npos) {
rcEnc->featureInfo()->hasHWCMultiConfigs = true;
}
}
diff --git a/system/OpenglSystemCommon/HostConnection.h b/system/OpenglSystemCommon/HostConnection.h
index d954c02..760b7f7 100644
--- a/system/OpenglSystemCommon/HostConnection.h
+++ b/system/OpenglSystemCommon/HostConnection.h
@@ -35,6 +35,7 @@
#endif
#include <memory>
+#include <optional>
#include <cstring>
class GLEncoder;
@@ -142,6 +143,10 @@
ExtendedRCEncoderContext* rcEnc, int width, int height, uint32_t glformat) = 0;
virtual uint32_t getHostHandle(native_handle_t const* handle) = 0;
virtual int getFormat(native_handle_t const* handle) = 0;
+ virtual uint32_t getFormatDrmFourcc(native_handle_t const* /*handle*/) {
+ // Equal to DRM_FORMAT_INVALID -- see <drm_fourcc.h>
+ return 0;
+ }
virtual size_t getAllocatedSize(native_handle_t const* handle) = 0;
virtual ~Gralloc() {}
};
@@ -222,7 +227,7 @@
static gl_client_context_t *s_getGLContext();
static gl2_client_context_t *s_getGL2Context();
- const std::string& queryGLExtensions(ExtendedRCEncoderContext *rcEnc);
+ const std::string& queryHostExtensions(ExtendedRCEncoderContext *rcEnc);
// setProtocol initilizes GL communication protocol for checksums
// should be called when m_rcEnc is created
void setChecksumHelper(ExtendedRCEncoderContext *rcEnc);
@@ -272,7 +277,7 @@
ChecksumCalculator m_checksumHelper;
Gralloc* m_grallocHelper = nullptr;
ProcessPipe* m_processPipe = nullptr;
- std::string m_glExtensions;
+ std::string m_hostExtensions;
bool m_grallocOnly;
bool m_noHostError;
#ifdef GFXSTREAM
diff --git a/system/OpenglSystemCommon/ProcessPipe.cpp b/system/OpenglSystemCommon/ProcessPipe.cpp
index e444f73..c02bd5f 100644
--- a/system/OpenglSystemCommon/ProcessPipe.cpp
+++ b/system/OpenglSystemCommon/ProcessPipe.cpp
@@ -35,7 +35,7 @@
#include "services/service_connector.h"
#define GET_STATUS_SAFE(result, member) \
- ((result).ok() ? ((result).Unwrap()->member) : ZX_OK)
+ ((result).ok() ? ((result)->member) : ZX_OK)
static QEMU_PIPE_HANDLE sProcDevice = 0;
#else // __Fuchsia__
@@ -101,12 +101,12 @@
zx::vmo vmo;
{
auto result = pipe->GetBuffer();
- if (!result.ok() || result.Unwrap()->res != ZX_OK) {
+ if (!result.ok() || result->res != ZX_OK) {
ALOGE("%s: failed to get buffer: %d:%d", __FUNCTION__,
result.status(), GET_STATUS_SAFE(result, res));
return;
}
- vmo = std::move(result.Unwrap()->vmo);
+ vmo = std::move(result->vmo);
}
size_t len = strlen("pipe:GLProcessPipe");
@@ -118,7 +118,7 @@
{
auto result = pipe->Write(len + 1, 0);
- if (!result.ok() || result.Unwrap()->res != ZX_OK) {
+ if (!result.ok() || result->res != ZX_OK) {
ALOGD("%s: connecting to pipe service failed: %d:%d", __FUNCTION__,
result.status(), GET_STATUS_SAFE(result, res));
return;
@@ -135,7 +135,7 @@
{
auto result = pipe->DoCall(sizeof(confirmInt), 0, sizeof(sProcUID), 0);
- if (!result.ok() || result.Unwrap()->res != ZX_OK) {
+ if (!result.ok() || result->res != ZX_OK) {
ALOGD("%s: failed to get per-process ID: %d:%d", __FUNCTION__,
result.status(), GET_STATUS_SAFE(result, res));
return;
@@ -189,7 +189,6 @@
case HOST_CONNECTION_QEMU_PIPE:
case HOST_CONNECTION_ADDRESS_SPACE:
case HOST_CONNECTION_TCP:
- case HOST_CONNECTION_VIRTIO_GPU:
sQemuPipeInit();
break;
case HOST_CONNECTION_VIRTIO_GPU_PIPE:
@@ -231,7 +230,6 @@
case HOST_CONNECTION_QEMU_PIPE:
case HOST_CONNECTION_ADDRESS_SPACE:
case HOST_CONNECTION_TCP:
- case HOST_CONNECTION_VIRTIO_GPU:
isPipe = true;
break;
case HOST_CONNECTION_VIRTIO_GPU_PIPE:
diff --git a/system/OpenglSystemCommon/QemuPipeStreamFuchsia.cpp b/system/OpenglSystemCommon/QemuPipeStreamFuchsia.cpp
index 7a3ab82..20f1d97 100644
--- a/system/OpenglSystemCommon/QemuPipeStreamFuchsia.cpp
+++ b/system/OpenglSystemCommon/QemuPipeStreamFuchsia.cpp
@@ -29,7 +29,7 @@
#include "services/service_connector.h"
#define GET_STATUS_SAFE(result, member) \
- ((result).ok() ? ((result).Unwrap()->member) : ZX_OK)
+ ((result).ok() ? ((result)->member) : ZX_OK)
constexpr size_t kReadSize = 512 * 1024;
constexpr size_t kWriteOffset = kReadSize;
@@ -131,7 +131,7 @@
{
auto result = m_pipe->Write(len + 1, 0);
- if (!result.ok() || result.Unwrap()->res != ZX_OK) {
+ if (!result.ok() || result->res != ZX_OK) {
ALOGD("%s: connecting to pipe service failed: %d:%d", __FUNCTION__,
result.status(), GET_STATUS_SAFE(result, res));
return -1;
@@ -166,7 +166,7 @@
{
auto result = m_pipe->SetBufferSize(allocSize);
- if (!result.ok() || result.Unwrap()->res != ZX_OK) {
+ if (!result.ok() || result->res != ZX_OK) {
ALOGE("%s: failed to get buffer: %d:%d", __FUNCTION__,
result.status(), GET_STATUS_SAFE(result, res));
return nullptr;
@@ -176,12 +176,12 @@
zx::vmo vmo;
{
auto result = m_pipe->GetBuffer();
- if (!result.ok() || result.Unwrap()->res != ZX_OK) {
+ if (!result.ok() || result->res != ZX_OK) {
ALOGE("%s: failed to get buffer: %d:%d", __FUNCTION__,
result.status(), GET_STATUS_SAFE(result, res));
return nullptr;
}
- vmo = std::move(result.Unwrap()->vmo);
+ vmo = std::move(result->vmo);
}
zx_vaddr_t mapped_addr;
@@ -204,7 +204,7 @@
if (size == 0) return 0;
auto result = m_pipe->DoCall(size, kWriteOffset, 0, 0);
- if (!result.ok() || result.Unwrap()->res != ZX_OK) {
+ if (!result.ok() || result->res != ZX_OK) {
ALOGD("%s: Pipe call failed: %d:%d", __FUNCTION__, result.status(),
GET_STATUS_SAFE(result, res));
return -1;
@@ -269,8 +269,8 @@
}
// Updated buffered read size.
- if (result.Unwrap()->actual) {
- m_read = m_readLeft = result.Unwrap()->actual;
+ if (result->actual) {
+ m_read = m_readLeft = result->actual;
}
// Consume buffered read and read more if neccessary.
@@ -292,13 +292,13 @@
return nullptr;
}
- if (result.Unwrap()->actual) {
- m_read = m_readLeft = result.Unwrap()->actual;
+ if (result->actual) {
+ m_read = m_readLeft = result->actual;
continue;
}
- if (result.Unwrap()->res != ZX_ERR_SHOULD_WAIT) {
+ if (result->res != ZX_ERR_SHOULD_WAIT) {
ALOGD("%s: Error reading from pipe: %d", __FUNCTION__,
- result.Unwrap()->res);
+ result->res);
return nullptr;
}
diff --git a/system/OpenglSystemCommon/ThreadInfo.cpp b/system/OpenglSystemCommon/ThreadInfo.cpp
index 5f7372f..ee022e2 100644
--- a/system/OpenglSystemCommon/ThreadInfo.cpp
+++ b/system/OpenglSystemCommon/ThreadInfo.cpp
@@ -16,12 +16,6 @@
#include "ThreadInfo.h"
-#ifdef HOST_BUILD
-#include "android/base/threads/AndroidThread.h"
-#else
-#include "cutils/threads.h"
-#endif
-
#include <pthread.h>
#if defined(HOST_BUILD) || defined(GFXSTREAM)
@@ -37,14 +31,6 @@
return goldfish_get_egl_tls();
}
-int32_t getCurrentThreadId() {
-#ifdef HOST_BUILD
- return (int32_t)android::base::guest::getCurrentThreadId();
-#else
- return (int32_t)gettid();
-#endif
-}
-
void setTlsDestructor(tlsDtorCallback func) {
getEGLThreadInfo()->dtor = func;
}
@@ -117,8 +103,4 @@
#endif
}
-int32_t getCurrentThreadId() {
- return (int32_t)gettid();
-}
-
#endif // !GFXSTREAM
diff --git a/system/OpenglSystemCommon/ThreadInfo.h b/system/OpenglSystemCommon/ThreadInfo.h
index 7f49273..c8bf291 100644
--- a/system/OpenglSystemCommon/ThreadInfo.h
+++ b/system/OpenglSystemCommon/ThreadInfo.h
@@ -41,6 +41,4 @@
EGLThreadInfo* getEGLThreadInfo();
-int32_t getCurrentThreadId();
-
#endif // of _THREAD_INFO_H
diff --git a/system/OpenglSystemCommon/ThreadInfo_host.cpp b/system/OpenglSystemCommon/ThreadInfo_host.cpp
deleted file mode 100644
index 0379933..0000000
--- a/system/OpenglSystemCommon/ThreadInfo_host.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright 2018 The Android Open Source Project
-//
-// 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 "ThreadInfo.h"
-
-#include "android/base/memory/LazyInstance.h"
-#include "android/base/threads/Thread.h"
-#include "android/base/threads/ThreadStore.h"
-
-using android::base::LazyInstance;
-using android::base::ThreadStoreBase;
-
-static bool sDefaultTlsDestructorCallback(__attribute__((__unused__)) void* ptr) {
- return true;
-}
-static bool (*sTlsDestructorCallback)(void*) = sDefaultTlsDestructorCallback;
-
-void setTlsDestructor(tlsDtorCallback func) {
- sTlsDestructorCallback = func;
-}
-
-static void doTlsDestruct(void* obj) {
- sTlsDestructorCallback(obj);
-}
-
-class ThreadInfoStore : public ThreadStoreBase {
-public:
- ThreadInfoStore() : ThreadStoreBase(NULL) { }
- ~ThreadInfoStore();
-};
-
-static LazyInstance<ThreadInfoStore> sTls = LAZY_INSTANCE_INIT;
-
-ThreadInfoStore::~ThreadInfoStore() {
- doTlsDestruct(sTls->get());
-}
-
-EGLThreadInfo *goldfish_get_egl_tls()
-{
- EGLThreadInfo* ti = (EGLThreadInfo*)sTls->get();
-
- if (ti) return ti;
-
- ti = new EGLThreadInfo();
- sTls->set(ti);
-
- return ti;
-}
-
-EGLThreadInfo* getEGLThreadInfo() {
- return goldfish_get_egl_tls();
-}
-
-int32_t getCurrentThreadId() {
- return (int32_t)android::base::getCurrentThreadId();
-}
diff --git a/system/OpenglSystemCommon/TraceProviderFuchsia.cpp b/system/OpenglSystemCommon/TraceProviderFuchsia.cpp
index fc38c0b..2e67162 100644
--- a/system/OpenglSystemCommon/TraceProviderFuchsia.cpp
+++ b/system/OpenglSystemCommon/TraceProviderFuchsia.cpp
@@ -18,9 +18,7 @@
#include <log/log.h>
-#include <lib/async-loop/default.h>
#include <lib/async/cpp/task.h>
-#include <lib/fdio/directory.h>
#include <lib/zx/channel.h>
#include "services/service_connector.h"
diff --git a/system/OpenglSystemCommon/VirtioGpuStream.cpp b/system/OpenglSystemCommon/VirtioGpuStream.cpp
deleted file mode 100644
index 21a76e9..0000000
--- a/system/OpenglSystemCommon/VirtioGpuStream.cpp
+++ /dev/null
@@ -1,422 +0,0 @@
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * 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 "VirtioGpuStream.h"
-#include "virtgpu_drm.h"
-
-#include <xf86drm.h>
-
-#include <sys/types.h>
-#include <sys/mman.h>
-
-#include <errno.h>
-#include <unistd.h>
-
-#ifndef PAGE_SIZE
-#define PAGE_SIZE 0x1000
-#endif
-
-// In a virtual machine, there should only be one GPU
-#define RENDERNODE_MINOR 128
-
-// Maximum size of readback / response buffer in bytes
-#define MAX_CMDRESPBUF_SIZE (10*PAGE_SIZE)
-
-// Attributes use to allocate our response buffer
-// Similar to virgl's fence objects
-#define PIPE_BUFFER 0
-#define VIRGL_FORMAT_R8_UNORM 64
-#define VIRGL_BIND_CUSTOM (1 << 17)
-
-// Conservative; see virgl_winsys.h
-#define VIRGL_MAX_CMDBUF_DWORDS (16*1024)
-#define VIRGL_MAX_CMDBUF_SIZE (4*VIRGL_MAX_CMDBUF_DWORDS)
-
-struct VirtioGpuCmd {
- uint32_t op;
- uint32_t cmdSize;
- unsigned char buf[0];
-} __attribute__((packed));
-
-union process_pipe_info {
- uint64_t proto;
- struct {
- int pid;
- int tid;
- } id;
-};
-
-bool VirtioGpuProcessPipe::processPipeInit(int stream_handle, HostConnectionType, renderControl_encoder_context_t *rcEnc)
-{
- union process_pipe_info info;
-
- info.id.pid = getpid();
- info.id.tid = gettid();
- rcEnc->rcSetPuid(rcEnc, info.proto);
- return true;
-}
-
-VirtioGpuStream::VirtioGpuStream(size_t bufSize) :
- IOStream(0U),
- m_fd(-1),
- m_bufSize(bufSize),
- m_buf(nullptr),
- m_cmdResp_rh(0U),
- m_cmdResp_bo(0U),
- m_cmdResp(nullptr),
- m_cmdRespPos(0U),
- m_cmdPos(0U),
- m_flushPos(0U),
- m_allocSize(0U),
- m_allocFlushSize(0U)
-{
-}
-
-VirtioGpuStream::~VirtioGpuStream()
-{
- if (m_cmdResp) {
- munmap(m_cmdResp, MAX_CMDRESPBUF_SIZE);
- }
-
- if (m_cmdResp_bo > 0U) {
- drm_gem_close gem_close = {
- .handle = m_cmdResp_bo,
- };
- drmIoctl(m_fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
- }
-
- if (m_fd >= 0) {
- close(m_fd);
- }
-
- free(m_buf);
-}
-
-int VirtioGpuStream::connect()
-{
- if (m_fd < 0) {
- m_fd = drmOpenRender(RENDERNODE_MINOR);
- if (m_fd < 0) {
- ERR("%s: failed with fd %d (%s)", __func__, m_fd, strerror(errno));
- return -1;
- }
- }
-
- if (!m_cmdResp_bo) {
- drm_virtgpu_resource_create create = {
- .target = PIPE_BUFFER,
- .format = VIRGL_FORMAT_R8_UNORM,
- .bind = VIRGL_BIND_CUSTOM,
- .width = MAX_CMDRESPBUF_SIZE,
- .height = 1U,
- .depth = 1U,
- .array_size = 0U,
- .size = MAX_CMDRESPBUF_SIZE,
- .stride = MAX_CMDRESPBUF_SIZE,
- };
- int ret = drmIoctl(m_fd, DRM_IOCTL_VIRTGPU_RESOURCE_CREATE, &create);
- if (ret) {
- ERR("%s: failed with %d allocating command response buffer (%s)",
- __func__, ret, strerror(errno));
- return -1;
- }
- m_cmdResp_bo = create.bo_handle;
- if (!m_cmdResp_bo) {
- ERR("%s: no handle when allocating command response buffer",
- __func__);
- return -1;
- }
- m_cmdResp_rh = create.res_handle;
- if (create.size != MAX_CMDRESPBUF_SIZE) {
- ERR("%s: command response buffer wrongly sized, create.size=%zu "
- "!= %zu", __func__,
- static_cast<size_t>(create.size),
- static_cast<size_t>(MAX_CMDRESPBUF_SIZE));
- abort();
- }
- }
-
- if (!m_cmdResp) {
- drm_virtgpu_map map;
- memset(&map, 0, sizeof(map));
- map.handle = m_cmdResp_bo;
-
- int ret = drmIoctl(m_fd, DRM_IOCTL_VIRTGPU_MAP, &map);
- if (ret) {
- ERR("%s: failed with %d mapping command response buffer (%s)",
- __func__, ret, strerror(errno));
- return -1;
- }
- m_cmdResp = static_cast<VirtioGpuCmd *>(mmap64(nullptr,
- MAX_CMDRESPBUF_SIZE,
- PROT_READ, MAP_SHARED,
- m_fd, map.offset));
- if (m_cmdResp == MAP_FAILED) {
- ERR("%s: failed with %d mmap'ing command response buffer (%s)",
- __func__, ret, strerror(errno));
- return -1;
- }
- }
-
- return 0;
-}
-
-int VirtioGpuStream::flush()
-{
- int ret = commitBuffer(m_allocSize - m_allocFlushSize);
- if (ret)
- return ret;
- m_allocFlushSize = m_allocSize;
- return 0;
-}
-
-void *VirtioGpuStream::allocBuffer(size_t minSize)
-{
- if (m_buf) {
- // Try to model the alloc() calls being made by the user. They should be
- // obeying the protocol and using alloc() for anything they don't write
- // with writeFully(), so we can know if this alloc() is for part of a
- // command, or not. If it is not for part of a command, we are starting
- // a new command, and should increment m_cmdPos.
- VirtioGpuCmd *cmd = reinterpret_cast<VirtioGpuCmd *>(&m_buf[m_cmdPos]);
- if (m_allocSize + minSize > cmd->cmdSize) {
- m_allocFlushSize = 0U;
- m_allocSize = 0U;
- // This might also be a convenient point to flush commands
- if (m_cmdPos + cmd->cmdSize + minSize > m_bufSize) {
- if (commitAll() < 0) {
- ERR("%s: command flush failed", __func__);
- m_flushPos = 0U;
- m_bufSize = 0U;
- m_cmdPos = 0U;
- free(m_buf);
- m_buf = nullptr;
- return nullptr;
- }
- } else {
- m_cmdPos += cmd->cmdSize;
- m_flushPos = m_cmdPos;
- }
- }
- }
-
- // Update m_allocSize here, before minSize is tampered with below
- m_allocSize += minSize;
-
- // Make sure anything we already have written to the buffer is retained
- minSize += m_flushPos;
-
- size_t allocSize = (m_bufSize < minSize ? minSize : m_bufSize);
- if (!m_buf) {
- m_buf = static_cast<unsigned char *>(malloc(allocSize));
- } else if (m_bufSize < allocSize) {
- unsigned char *p = static_cast<unsigned char *>(realloc(m_buf, allocSize));
- if (!p) {
- free(m_buf);
- }
- m_buf = p;
- }
- if (!m_buf) {
- ERR("%s: alloc (%zu) failed\n", __func__, allocSize);
- m_allocFlushSize = 0U;
- m_allocSize = 0U;
- m_flushPos = 0U;
- m_bufSize = 0U;
- m_cmdPos = 0U;
- } else {
- m_bufSize = allocSize;
- }
- if (m_flushPos == 0 && m_cmdPos == 0) {
- // During initialization, HostConnection will send an empty command
- // packet to check the connection is good, but it doesn't obey the usual
- // line protocol. This is a 4 byte write to [0], which is our 'op' field,
- // and we don't have an op=0 so it's OK. We fake up a valid length, and
- // overload this workaround by putting the res_handle for the readback
- // buffer in the command payload, patched in just before we submit.
- VirtioGpuCmd *cmd = reinterpret_cast<VirtioGpuCmd *>(&m_buf[m_cmdPos]);
- cmd->op = 0U;
- cmd->cmdSize = sizeof(*cmd) + sizeof(__u32);
- }
- return m_buf + m_cmdPos;
-}
-
-// For us, writeFully() means to write a command without any header, directly
-// into the buffer stream. We can use the packet frame written directly to the
-// stream to verify this write is within bounds, then update the counter.
-
-int VirtioGpuStream::writeFully(const void *buf, size_t len)
-{
- if (!valid())
- return -1;
-
- if (!buf) {
- if (len > 0) {
- // If len is non-zero, buf must not be NULL. Otherwise the pipe would
- // be in a corrupted state, which is lethal for the emulator.
- ERR("%s: failed, buf=NULL, len %zu, lethal error, exiting",
- __func__, len);
- abort();
- }
- return 0;
- }
-
- VirtioGpuCmd *cmd = reinterpret_cast<VirtioGpuCmd *>(&m_buf[m_cmdPos]);
-
- if (m_flushPos < sizeof(*cmd)) {
- ERR("%s: writeFully len %zu would overwrite command header, "
- "cmd_pos=%zu, flush_pos=%zu, lethal error, exiting", __func__,
- len, m_cmdPos, m_flushPos);
- abort();
- }
-
- if (m_flushPos + len > cmd->cmdSize) {
- ERR("%s: writeFully len %zu would overflow the command bounds, "
- "cmd_pos=%zu, flush_pos=%zu, cmdsize=%" PRIu32 ", lethal error, exiting",
- __func__, len, m_cmdPos, m_flushPos, cmd->cmdSize);
- abort();
- }
-
- if (len > VIRGL_MAX_CMDBUF_SIZE) {
- ERR("%s: Large command (%zu bytes) exceeds virgl limits",
- __func__, len);
- /* Fall through */
- }
-
- memcpy(&m_buf[m_flushPos], buf, len);
- commitBuffer(len);
- m_allocSize += len;
- return 0;
-}
-
-const unsigned char *VirtioGpuStream::readFully(void *buf, size_t len)
-{
- if (!valid())
- return nullptr;
-
- if (!buf) {
- if (len > 0) {
- // If len is non-zero, buf must not be NULL. Otherwise the pipe would
- // be in a corrupted state, which is lethal for the emulator.
- ERR("%s: failed, buf=NULL, len %zu, lethal error, exiting.",
- __func__, len);
- abort();
- }
- return nullptr;
- }
-
- // Read is too big for current architecture
- if (len > MAX_CMDRESPBUF_SIZE - sizeof(*m_cmdResp)) {
- ERR("%s: failed, read too large, len %zu, lethal error, exiting.",
- __func__, len);
- abort();
- }
-
- // Commit all outstanding write commands (if any)
- if (commitAll() < 0) {
- ERR("%s: command flush failed", __func__);
- return nullptr;
- }
-
- if (len > 0U && m_cmdRespPos == 0U) {
- // When we are about to read for the first time, wait for the virtqueue
- // to drain to this command, otherwise the data could be stale
- drm_virtgpu_3d_wait wait = {
- .handle = m_cmdResp_bo,
- };
- int ret = drmIoctl(m_fd, DRM_IOCTL_VIRTGPU_WAIT, &wait);
- if (ret) {
- ERR("%s: failed with %d waiting for response buffer (%s)",
- __func__, ret, strerror(errno));
- // Fall through, hope for the best
- }
- }
-
- // Most likely a protocol implementation error
- if (m_cmdResp->cmdSize - sizeof(*m_cmdResp) < m_cmdRespPos + len) {
- ERR("%s: failed, op %" PRIu32 ", len %zu, cmdSize %" PRIu32 ", pos %zu, lethal "
- "error, exiting.", __func__, m_cmdResp->op, len,
- m_cmdResp->cmdSize, m_cmdRespPos);
- abort();
- }
-
- memcpy(buf, &m_cmdResp->buf[m_cmdRespPos], len);
-
- if (m_cmdRespPos + len == m_cmdResp->cmdSize - sizeof(*m_cmdResp)) {
- m_cmdRespPos = 0U;
- } else {
- m_cmdRespPos += len;
- }
-
- return reinterpret_cast<const unsigned char *>(buf);
-}
-
-int VirtioGpuStream::commitBuffer(size_t size)
-{
- if (m_flushPos + size > m_bufSize) {
- ERR("%s: illegal commit size %zu, flushPos %zu, bufSize %zu",
- __func__, size, m_flushPos, m_bufSize);
- return -1;
- }
- m_flushPos += size;
- return 0;
-}
-
-int VirtioGpuStream::commitAll()
-{
- size_t pos = 0U, numFlushed = 0U;
- while (pos < m_flushPos) {
- VirtioGpuCmd *cmd = reinterpret_cast<VirtioGpuCmd *>(&m_buf[pos]);
-
- // Should never happen
- if (pos + cmd->cmdSize > m_bufSize) {
- ERR("%s: failed, pos %zu, cmdSize %" PRIu32 ", bufSize %zu, lethal "
- "error, exiting.", __func__, pos, cmd->cmdSize, m_bufSize);
- abort();
- }
-
- // Saw dummy command; patch it with res handle
- if (cmd->op == 0) {
- *(uint32_t *)cmd->buf = m_cmdResp_rh;
- }
-
- // Flush a single command
- drm_virtgpu_execbuffer execbuffer = {
- .size = cmd->cmdSize,
- .command = reinterpret_cast<__u64>(cmd),
- .bo_handles = reinterpret_cast<__u64>(&m_cmdResp_bo),
- .num_bo_handles = 1U,
- };
- int ret = drmIoctl(m_fd, DRM_IOCTL_VIRTGPU_EXECBUFFER, &execbuffer);
- if (ret) {
- ERR("%s: failed with %d executing command buffer (%s)", __func__,
- ret, strerror(errno));
- return -1;
- }
-
- pos += cmd->cmdSize;
- numFlushed++;
- }
-
- if (pos > m_flushPos) {
- ERR("%s: aliasing, flushPos %zu, pos %zu, probably ok", __func__,
- m_flushPos, pos);
- /* Fall through */
- }
-
- m_flushPos = 0U;
- m_cmdPos = 0U;
- return 0;
-}
diff --git a/system/OpenglSystemCommon/VirtioGpuStream.h b/system/OpenglSystemCommon/VirtioGpuStream.h
deleted file mode 100644
index 4f2c2dc..0000000
--- a/system/OpenglSystemCommon/VirtioGpuStream.h
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
- * Copyright (C) 2018 The Android Open Source Project
- *
- * 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.
- */
-
-#pragma once
-
-#include "HostConnection.h"
-#include "IOStream.h"
-
-#include <stdlib.h>
-
-/* This file implements an IOStream that uses VIRTGPU_EXECBUFFER ioctls on a
- * virtio-gpu DRM rendernode device to communicate with the host.
- */
-
-struct VirtioGpuCmd;
-
-class VirtioGpuProcessPipe : public ProcessPipe
-{
-public:
- virtual bool processPipeInit(int stream_handle, HostConnectionType connType, renderControl_encoder_context_t *rcEnc);
-};
-
-class VirtioGpuStream : public IOStream
-{
-public:
- explicit VirtioGpuStream(size_t bufSize);
- ~VirtioGpuStream();
-
- int connect();
- ProcessPipe *getProcessPipe() { return &m_processPipe; }
-
- // override IOStream so we can see non-rounded allocation sizes
- virtual unsigned char *alloc(size_t len)
- {
- return static_cast<unsigned char *>(allocBuffer(len));
- }
-
- // override IOStream so we can model the caller's writes
- virtual int flush();
-
- virtual void *allocBuffer(size_t minSize);
- virtual int writeFully(const void *buf, size_t len);
- virtual const unsigned char *readFully(void *buf, size_t len);
- virtual int commitBuffer(size_t size);
- virtual const unsigned char* commitBufferAndReadFully(size_t size, void *buf, size_t len)
- {
- return commitBuffer(size) ? nullptr : readFully(buf, len);
- }
- virtual const unsigned char *read(void *buf, size_t *inout_len) final
- {
- return readFully(buf, *inout_len);
- }
-
- bool valid()
- {
- return m_fd >= 0 && m_cmdResp_bo > 0 && m_cmdResp;
- }
-
- int getRendernodeFd() { return m_fd; }
-
-private:
- // rendernode fd
- int m_fd;
-
- // command memory buffer
- size_t m_bufSize;
- unsigned char *m_buf;
-
- // response buffer res handle
- uint32_t m_cmdResp_rh;
-
- // response buffer ttm buffer object
- uint32_t m_cmdResp_bo;
-
- // user mapping of response buffer object
- VirtioGpuCmd *m_cmdResp;
-
- // byte offset to read cursor for last response
- size_t m_cmdRespPos;
-
- // byte offset to command being assembled
- size_t m_cmdPos;
-
- // byte offset to flush cursor
- size_t m_flushPos;
-
- // byte counter of allocs since last command boundary
- size_t m_allocSize;
-
- // bytes of an alloc flushed through flush() API
- size_t m_allocFlushSize;
-
- // Fake process pipe implementation
- VirtioGpuProcessPipe m_processPipe;
-
- // commits all commands, resets buffer offsets
- int commitAll();
-};
diff --git a/system/OpenglSystemCommon/meson.build b/system/OpenglSystemCommon/meson.build
index 90f0193..2b834d9 100644
--- a/system/OpenglSystemCommon/meson.build
+++ b/system/OpenglSystemCommon/meson.build
@@ -7,7 +7,6 @@
'ProcessPipe.cpp',
'QemuPipeStream.cpp',
'ThreadInfo.cpp',
- 'VirtioGpuStream.cpp',
'VirtioGpuPipeStream.cpp',
)
@@ -19,8 +18,8 @@
inc_render_enc, inc_android_compat,
inc_qemu_pipe, inc_qemu_pipe_types, inc_gralloc,
inc_vulkan_enc, inc_goldfish_address_space,
- inc_system],
+ inc_system, inc_platform],
link_with: [lib_codec_common, lib_goldfish_address_space, lib_qemu_pipe,
- lib_render_control_enc],
+ lib_render_control_enc, lib_platform],
dependencies: drm_dep
)
diff --git a/system/codecs/c2/decoders/base/Android.bp b/system/codecs/c2/decoders/base/Android.bp
index 58e26a3..348334b 100644
--- a/system/codecs/c2/decoders/base/Android.bp
+++ b/system/codecs/c2/decoders/base/Android.bp
@@ -41,6 +41,7 @@
],
static_libs: [
+ "libplatform",
"libGoldfishAddressSpace",
],
diff --git a/system/codecs/c2/service/Android.bp b/system/codecs/c2/service/Android.bp
index 0765602..8333a31 100644
--- a/system/codecs/c2/service/Android.bp
+++ b/system/codecs/c2/service/Android.bp
@@ -22,6 +22,7 @@
],
init_rc: ["android.hardware.media.c2@1.0-service-goldfish.rc"],
+ vintf_fragments: ["android.hardware.media.c2@1.0-service-goldfish.xml"],
shared_libs: [
"libgoldfish_codec2_store",
diff --git a/system/codecs/c2/service/android.hardware.media.c2@1.0-service-goldfish.xml b/system/codecs/c2/service/android.hardware.media.c2@1.0-service-goldfish.xml
new file mode 100644
index 0000000..3bc347c
--- /dev/null
+++ b/system/codecs/c2/service/android.hardware.media.c2@1.0-service-goldfish.xml
@@ -0,0 +1,11 @@
+<manifest version="1.0" type="device">
+ <hal format="hidl">
+ <name>android.hardware.media.c2</name>
+ <transport>hwbinder</transport>
+ <version>1.0</version>
+ <interface>
+ <name>IComponentStore</name>
+ <instance>default</instance>
+ </interface>
+ </hal>
+</manifest>
diff --git a/system/codecs/omx/common/Android.mk b/system/codecs/omx/common/Android.mk
index 1ebdff9..6b1674c 100644
--- a/system/codecs/omx/common/Android.mk
+++ b/system/codecs/omx/common/Android.mk
@@ -32,6 +32,7 @@
ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
$(call emugl-import,libGoldfishAddressSpace$(GOLDFISH_OPENGL_LIB_SUFFIX))
else
+$(call emugl-export,STATIC_LIBRARIES,libplatform)
$(call emugl-export,STATIC_LIBRARIES,libGoldfishAddressSpace)
ifeq (true,$(GFXSTREAM))
diff --git a/system/egl/CMakeLists.txt b/system/egl/CMakeLists.txt
index 3ce2e3a..d081b26 100644
--- a/system/egl/CMakeLists.txt
+++ b/system/egl/CMakeLists.txt
@@ -4,7 +4,7 @@
android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/egl/Android.mk" "d7a50905a3d2624cf594158d9c370bf29bc6115d967bdfa919e9ffa42a87d0bb")
set(EGL_emulation_src eglDisplay.cpp egl.cpp ClientAPIExts.cpp)
android_add_library(TARGET EGL_emulation SHARED LICENSE Apache-2.0 SRC eglDisplay.cpp egl.cpp ClientAPIExts.cpp)
-target_include_directories(EGL_emulation PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/profiler ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon/bionic-include ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/bionic/libc/platform ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/shared/gralloc_cb/include ${GOLDFISH_DEVICE_ROOT}/shared/GoldfishAddressSpace/include ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include-types ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_include_directories(EGL_emulation PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/profiler ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon/bionic-include ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/bionic/libc/platform ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/shared/gralloc_cb/include ${GOLDFISH_DEVICE_ROOT}/shared/GoldfishAddressSpace/include ${GOLDFISH_DEVICE_ROOT}/platform/include ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include-types ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
target_compile_definitions(EGL_emulation PRIVATE "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGFXSTREAM" "-DLOG_TAG=\"EGL_emulation\"" "-DEGL_EGLEXT_PROTOTYPES" "-DWITH_GLES2")
target_compile_options(EGL_emulation PRIVATE "-fvisibility=default" "-Wno-unused-parameter" "-Wno-gnu-designator")
-target_link_libraries(EGL_emulation PRIVATE GoldfishProfiler OpenglSystemCommon android-emu-shared vulkan_enc gui log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host cutils utils androidemu PRIVATE gralloc_cb_host GoldfishAddressSpace_host qemupipe_host)
\ No newline at end of file
+target_link_libraries(EGL_emulation PRIVATE GoldfishProfiler OpenglSystemCommon android-emu-shared vulkan_enc gui log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host cutils utils androidemu PRIVATE gralloc_cb_host GoldfishAddressSpace_host platform_host qemupipe_host)
\ No newline at end of file
diff --git a/system/egl/egl.cpp b/system/egl/egl.cpp
index 11553e3..4dd10a4 100644
--- a/system/egl/egl.cpp
+++ b/system/egl/egl.cpp
@@ -20,8 +20,10 @@
#endif
#include <assert.h>
+
#include "HostConnection.h"
#include "ThreadInfo.h"
+#include "android/base/threads/AndroidThread.h"
#include "eglDisplay.h"
#include "eglSync.h"
#include "egl_ftable.h"
@@ -61,6 +63,9 @@
#include <cutils/trace.h>
#include <system/window.h>
+
+using android::base::guest::getCurrentThreadId;
+
#define DEBUG_EGL 0
#if DEBUG_EGL
@@ -101,15 +106,17 @@
#ifdef LOG_EGL_ERRORS
-#define setErrorReturn(error, retVal) \
- { \
- ALOGE("tid %d: %s(%d): error 0x%x (%s)", getCurrentThreadId(), __FUNCTION__, __LINE__, error, eglStrError(error)); \
- return setErrorFunc(error, retVal); \
+#define setErrorReturn(error, retVal) \
+ { \
+ ALOGE("tid %lu: %s(%d): error 0x%x (%s)", getCurrentThreadId(), __FUNCTION__, __LINE__, \
+ error, eglStrError(error)); \
+ return setErrorFunc(error, retVal); \
}
-#define RETURN_ERROR(ret,err) \
- ALOGE("tid %d: %s(%d): error 0x%x (%s)", getCurrentThreadId(), __FUNCTION__, __LINE__, err, eglStrError(err)); \
- getEGLThreadInfo()->eglError = err; \
+#define RETURN_ERROR(ret, err) \
+ ALOGE("tid %lu: %s(%d): error 0x%x (%s)", getCurrentThreadId(), __FUNCTION__, __LINE__, err, \
+ eglStrError(err)); \
+ getEGLThreadInfo()->eglError = err; \
return ret;
#else //!LOG_EGL_ERRORS
@@ -337,6 +344,7 @@
float avgMs = ns2ms(totalAppTime) / numSamples;
float minMs = ns2ms(minAppTime);
float maxMs = ns2ms(maxAppTime);
+ // B* needs the following log.
ALOGD("app_time_stats: avg=%0.2fms min=%0.2fms max=%0.2fms count=%u", avgMs, minMs, maxMs, numSamples);
totalAppTime = 0;
minAppTime = 0;
@@ -1250,7 +1258,7 @@
}
else
{
- ALOGD("%s: bad attrib 0x%x", __FUNCTION__, attribute);
+ DPRINT("%s: bad attrib 0x%x", __FUNCTION__, attribute);
RETURN_ERROR(EGL_FALSE, EGL_BAD_ATTRIBUTE);
}
}
@@ -1628,7 +1636,7 @@
}
return true;
case EGL_TIMESTAMPS_ANDROID:
- ALOGD("%s: set frame timestamps collecting %d\n", __func__, value);
+ DPRINT("%s: set frame timestamps collecting %d\n", __func__, value);
p_surface->setCollectingTimestamps(value);
return true;
default:
@@ -1724,9 +1732,9 @@
wantedMinorVersion = true;
break;
case EGL_CONTEXT_FLAGS_KHR:
- if ((attrib_val | EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR) ||
- (attrib_val | EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR) ||
- (attrib_val | EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR)) {
+ if ((attrib_val & EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR) ||
+ (attrib_val & EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR) ||
+ (attrib_val & EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR)) {
context_flags = attrib_val;
} else {
RETURN_ERROR(EGL_NO_CONTEXT,EGL_BAD_ATTRIBUTE);
@@ -1850,7 +1858,7 @@
}
EGLContext_t * context = new EGLContext_t(dpy, config, shareCtx, majorVersion, minorVersion);
- ALOGD("%s: %p: maj %d min %d rcv %d", __FUNCTION__, context, majorVersion, minorVersion, rcMajorVersion);
+ DPRINT("%s: %p: maj %d min %d rcv %d", __FUNCTION__, context, majorVersion, minorVersion, rcMajorVersion);
if (!context) {
ALOGE("could not alloc egl context!");
setErrorReturn(EGL_BAD_ALLOC, EGL_NO_CONTEXT);
@@ -1959,7 +1967,7 @@
context->getClientState();
if (!hostCon->gl2Encoder()->isInitialized()) {
- ALOGD("%s: %p: ver %d %d (tinfo %p) (first time)",
+ DPRINT("%s: %p: ver %d %d (tinfo %p) (first time)",
__FUNCTION__,
context, context->majorVersion, context->minorVersion, tInfo);
s_display.gles2_iface()->init();
@@ -2049,7 +2057,7 @@
}
else {
if (!hostCon->glEncoder()->isInitialized()) {
- ALOGD("%s: %p: ver %d %d (tinfo %p) (first time)",
+ DPRINT("%s: %p: ver %d %d (tinfo %p) (first time)",
__FUNCTION__,
context, context->majorVersion, context->minorVersion, tInfo);
s_display.gles_iface()->init();
diff --git a/system/egl/eglDisplay.cpp b/system/egl/eglDisplay.cpp
index c3384b9..3950ffd 100644
--- a/system/egl/eglDisplay.cpp
+++ b/system/egl/eglDisplay.cpp
@@ -283,8 +283,8 @@
std::string baseDir =
android::base::System::get()->getProgramDirectory();
std::string path =
- android::base::pj(
- baseDir, "lib64", std::string(basename) + LIBSUFFIX);
+ android::base::pj({
+ baseDir, "lib64", std::string(basename) + LIBSUFFIX});
void *lib = dlopen(path.c_str(), RTLD_NOW);
#else
std::string path(PARTITION);
diff --git a/system/gralloc/CMakeLists.txt b/system/gralloc/CMakeLists.txt
index e65c11c..9f24624 100644
--- a/system/gralloc/CMakeLists.txt
+++ b/system/gralloc/CMakeLists.txt
@@ -4,17 +4,17 @@
android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/gralloc/Android.mk" "4c44a906197808b25fde953a476e026aac725e5286e0f91d5f8a3083f40f49da")
set(gralloc.goldfish_src gralloc_old.cpp)
android_add_library(TARGET gralloc.goldfish SHARED LICENSE Apache-2.0 SRC gralloc_old.cpp)
-target_include_directories(gralloc.goldfish PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon/bionic-include ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/bionic/libc/platform ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/shared/gralloc_cb/include ${GOLDFISH_DEVICE_ROOT}/shared/GoldfishAddressSpace/include ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include-types ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_include_directories(gralloc.goldfish PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon/bionic-include ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/bionic/libc/platform ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/shared/gralloc_cb/include ${GOLDFISH_DEVICE_ROOT}/shared/GoldfishAddressSpace/include ${GOLDFISH_DEVICE_ROOT}/platform/include ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include-types ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
target_compile_definitions(gralloc.goldfish PRIVATE "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGFXSTREAM" "-DLOG_TAG=\"gralloc_goldfish\"")
target_compile_options(gralloc.goldfish PRIVATE "-fvisibility=default" "-Wno-unused-parameter" "-Wno-missing-field-initializers" "-Wno-gnu-designator")
-target_link_libraries(gralloc.goldfish PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui log GLESv2_enc _renderControl_enc GLESv1_enc OpenglCodecCommon_host cutils utils androidemu PRIVATE gralloc_cb_host GoldfishAddressSpace_host qemupipe_host)
+target_link_libraries(gralloc.goldfish PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui log GLESv2_enc _renderControl_enc GLESv1_enc OpenglCodecCommon_host cutils utils androidemu PRIVATE gralloc_cb_host GoldfishAddressSpace_host platform_host qemupipe_host)
# This is an autogenerated file! Do not edit!
# instead run make from .../device/generic/goldfish-opengl
# which will re-generate this file.
android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/gralloc/Android.mk" "4c44a906197808b25fde953a476e026aac725e5286e0f91d5f8a3083f40f49da")
set(gralloc.ranchu_src gralloc_old.cpp)
android_add_library(TARGET gralloc.ranchu SHARED LICENSE Apache-2.0 SRC gralloc_old.cpp)
-target_include_directories(gralloc.ranchu PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon/bionic-include ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/bionic/libc/platform ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/shared/gralloc_cb/include ${GOLDFISH_DEVICE_ROOT}/shared/GoldfishAddressSpace/include ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include-types ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
+target_include_directories(gralloc.ranchu PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon/bionic-include ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/bionic/libc/platform ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/shared/gralloc_cb/include ${GOLDFISH_DEVICE_ROOT}/shared/GoldfishAddressSpace/include ${GOLDFISH_DEVICE_ROOT}/platform/include ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include-types ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
target_compile_definitions(gralloc.ranchu PRIVATE "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGFXSTREAM" "-DLOG_TAG=\"gralloc_ranchu\"")
target_compile_options(gralloc.ranchu PRIVATE "-fvisibility=default" "-Wno-unused-parameter" "-Wno-missing-field-initializers" "-Wno-gnu-designator")
-target_link_libraries(gralloc.ranchu PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui log GLESv2_enc _renderControl_enc GLESv1_enc OpenglCodecCommon_host cutils utils androidemu PRIVATE gralloc_cb_host GoldfishAddressSpace_host qemupipe_host)
\ No newline at end of file
+target_link_libraries(gralloc.ranchu PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui log GLESv2_enc _renderControl_enc GLESv1_enc OpenglCodecCommon_host cutils utils androidemu PRIVATE gralloc_cb_host GoldfishAddressSpace_host platform_host qemupipe_host)
\ No newline at end of file
diff --git a/system/gralloc/gralloc_30.cpp b/system/gralloc/gralloc_30.cpp
index c012908..298842f 100644
--- a/system/gralloc/gralloc_30.cpp
+++ b/system/gralloc/gralloc_30.cpp
@@ -450,7 +450,7 @@
RETURN_ERROR(nullptr);
}
- if ((m->id == GRALLOC_HARDWARE_MODULE_ID) && (m->name == GOLDFISH_GRALLOC_MODULE_NAME)) {
+ if (strcmp(m->id, GRALLOC_HARDWARE_MODULE_ID) == 0 && m->name == GOLDFISH_GRALLOC_MODULE_NAME) {
return reinterpret_cast<private_module_t*>(const_cast<hw_module_t*>(m));
} else {
RETURN_ERROR(nullptr);
diff --git a/system/gralloc/gralloc_old.cpp b/system/gralloc/gralloc_old.cpp
index 2cae482..f1e5f0e 100644
--- a/system/gralloc/gralloc_old.cpp
+++ b/system/gralloc/gralloc_old.cpp
@@ -1,39 +1,39 @@
/*
-* Copyright (C) 2011 The Android Open Source Project
-*
-* 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 <string.h>
-#include <pthread.h>
-#include <limits.h>
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * 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 <cutils/ashmem.h>
-#include <unistd.h>
-#include <errno.h>
#include <dlfcn.h>
-#include <sys/mman.h>
-#include <hardware/gralloc.h>
-
+#include <errno.h>
#include <gralloc_cb_bp.h>
-#include "gralloc_common.h"
+#include <hardware/gralloc.h>
+#include <limits.h>
+#include <pthread.h>
+#include <qemu_pipe_bp.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <unistd.h>
-#include "goldfish_dma.h"
-#include "goldfish_address_space.h"
#include "FormatConversions.h"
#include "HostConnection.h"
#include "ProcessPipe.h"
#include "ThreadInfo.h"
+#include "android/base/threads/AndroidThread.h"
#include "glUtils.h"
-#include <qemu_pipe_bp.h>
+#include "goldfish_address_space.h"
+#include "goldfish_dma.h"
+#include "gralloc_common.h"
#if PLATFORM_SDK_VERSION < 26
#include <cutils/log.h>
@@ -79,6 +79,8 @@
static const bool isHidlGralloc = false;
#endif
+using android::base::guest::getCurrentThreadId;
+
const uint32_t CB_HANDLE_MAGIC_OLD = CB_HANDLE_MAGIC_BASE | 0x1;
struct cb_handle_old_t : public cb_handle_t {
@@ -819,8 +821,8 @@
}
}
- D("gralloc_alloc format=%d, ashmem_size=%d, stride=%d, tid %d\n", format,
- ashmem_size, stride, getCurrentThreadId());
+ D("gralloc_alloc format=%d, ashmem_size=%d, stride=%d, tid %lu\n", format, ashmem_size, stride,
+ getCurrentThreadId());
//
// Allocate space in ashmem if needed
diff --git a/system/hwc2/ClientComposer.cpp b/system/hwc2/ClientComposer.cpp
index 211667b..ee494cd 100644
--- a/system/hwc2/ClientComposer.cpp
+++ b/system/hwc2/ClientComposer.cpp
@@ -71,16 +71,15 @@
DisplayInfo& displayInfo = it->second;
- auto clientTargetNativeBuffer = display->getClientTarget().getBuffer();
- auto clientTargetDrmBuffer =
- std::make_unique<DrmBuffer>(clientTargetNativeBuffer, mDrmPresenter);
- if (!clientTargetDrmBuffer) {
+ auto [drmBufferCreateError, drmBuffer] =
+ mDrmPresenter->create(display->getClientTarget().getBuffer());
+ if (drmBufferCreateError != HWC2::Error::None) {
ALOGE("%s: display:%" PRIu64 " failed to create client target drm buffer",
__FUNCTION__, displayId);
return HWC2::Error::NoResources;
}
+ displayInfo.clientTargetDrmBuffer = std::move(drmBuffer);
- displayInfo.clientTargetDrmBuffer = std::move(clientTargetDrmBuffer);
return HWC2::Error::None;
}
@@ -126,12 +125,16 @@
}
DisplayInfo& displayInfo = displayInfoIt->second;
+ if (!displayInfo.clientTargetDrmBuffer) {
+ ALOGW("%s: display:%" PRIu64 " no client target set, nothing to present.",
+ __FUNCTION__, displayId);
+ return std::make_tuple(HWC2::Error::None, base::unique_fd());
+ }
auto clientTargetFence = display->getClientTarget().getFence();
- auto [error, presentFence] =
- displayInfo.clientTargetDrmBuffer->flushToDisplay(
- static_cast<int>(displayId), clientTargetFence);
+ auto [error, presentFence] = mDrmPresenter->flushToDisplay(
+ displayId, *displayInfo.clientTargetDrmBuffer, clientTargetFence);
if (error != HWC2::Error::None) {
ALOGE("%s: display:%" PRIu64 " failed to flush drm buffer" PRIu64,
__FUNCTION__, displayId);
diff --git a/system/hwc2/ClientComposer.h b/system/hwc2/ClientComposer.h
index 58d4cce..216a67e 100644
--- a/system/hwc2/ClientComposer.h
+++ b/system/hwc2/ClientComposer.h
@@ -17,6 +17,7 @@
#ifndef ANDROID_HWC_CLIENTCOMPOSER_H
#define ANDROID_HWC_CLIENTCOMPOSER_H
+#include <memory>
#include <unordered_map>
#include "Common.h"
@@ -60,7 +61,7 @@
private:
struct DisplayInfo {
- std::unique_ptr<DrmBuffer> clientTargetDrmBuffer;
+ std::shared_ptr<DrmBuffer> clientTargetDrmBuffer;
};
std::unordered_map<int64_t, DisplayInfo> mDisplayInfos;
diff --git a/system/hwc2/Common.cpp b/system/hwc2/Common.cpp
index 021d032..f33fb8d 100644
--- a/system/hwc2/Common.cpp
+++ b/system/hwc2/Common.cpp
@@ -28,8 +28,32 @@
std::string::npos;
}
-bool IsNoOpMode() {
- return android::base::GetProperty("ro.vendor.hwcomposer.mode", "") == "noop";
+bool IsInNoOpCompositionMode() {
+ const std::string mode = ::android::base::GetProperty("ro.vendor.hwcomposer.mode", "");
+ DEBUG_LOG("%s: sysprop ro.vendor.hwcomposer.mode is %s", __FUNCTION__, mode.c_str());
+ return mode == "noop";
+}
+
+bool IsInClientCompositionMode() {
+ const std::string mode = ::android::base::GetProperty("ro.vendor.hwcomposer.mode", "");
+ DEBUG_LOG("%s: sysprop ro.vendor.hwcomposer.mode is %s", __FUNCTION__, mode.c_str());
+ return mode == "client";
+}
+
+bool IsInNoOpDisplayFinderMode() {
+ const std::string mode =
+ ::android::base::GetProperty("ro.vendor.hwcomposer.display_finder_mode", "");
+ DEBUG_LOG("%s: sysprop ro.vendor.hwcomposer.display_finder_mode is %s",
+ __FUNCTION__, mode.c_str());
+ return mode == "noop";
+}
+
+bool IsInDrmDisplayFinderMode() {
+ const std::string mode =
+ ::android::base::GetProperty("ro.vendor.hwcomposer.display_finder_mode", "");
+ DEBUG_LOG("%s: sysprop ro.vendor.hwcomposer.display_finder_mode is %s",
+ __FUNCTION__, mode.c_str());
+ return mode == "drm";
}
bool IsClientCompositionMode() {
diff --git a/system/hwc2/Common.h b/system/hwc2/Common.h
index f13553b..7d364cb 100644
--- a/system/hwc2/Common.h
+++ b/system/hwc2/Common.h
@@ -44,7 +44,11 @@
bool IsCuttlefish();
bool IsCuttlefishFoldable();
-bool IsNoOpMode();
-bool IsClientCompositionMode();
+
+bool IsInNoOpCompositionMode();
+bool IsInClientCompositionMode();
+
+bool IsInNoOpDisplayFinderMode();
+bool IsInDrmDisplayFinderMode();
#endif
diff --git a/system/hwc2/Device.cpp b/system/hwc2/Device.cpp
index f49905d..5f6fb86 100644
--- a/system/hwc2/Device.cpp
+++ b/system/hwc2/Device.cpp
@@ -76,10 +76,10 @@
DEBUG_LOG("%s", __FUNCTION__);
bool isMinigbm = isMinigbmFromProperty();
- if (IsNoOpMode()) {
+ if (IsInNoOpCompositionMode()) {
DEBUG_LOG("%s: using NoOpComposer", __FUNCTION__);
mComposer = std::make_unique<NoOpComposer>();
- } else if (IsClientCompositionMode()) {
+ } else if (IsInClientCompositionMode()) {
DEBUG_LOG("%s: using ClientComposer", __FUNCTION__);
mComposer = std::make_unique<ClientComposer>(mDrmPresenter.get());
} else if (ShouldUseGuestComposer()) {
@@ -90,7 +90,7 @@
mComposer = std::make_unique<HostComposer>(mDrmPresenter.get(), isMinigbm);
}
- if (!IsNoOpMode() && (ShouldUseGuestComposer() || isMinigbm)) {
+ if (!IsInNoOpCompositionMode() && (ShouldUseGuestComposer() || isMinigbm)) {
bool success = mDrmPresenter->init(
[this](bool connected, uint32_t id, uint32_t width, uint32_t height,
uint32_t dpiX, uint32_t dpiY, uint32_t refreshRate) {
@@ -136,7 +136,7 @@
std::vector<DisplayMultiConfigs> displays;
- HWC2::Error error = findDisplays(mDrmPresenter.get(), displays);
+ HWC2::Error error = findDisplays(mDrmPresenter.get(), &displays);
if (error != HWC2::Error::None) {
ALOGE("%s failed to find display configs", __FUNCTION__);
return error;
diff --git a/system/hwc2/DisplayFinder.cpp b/system/hwc2/DisplayFinder.cpp
index 2016c4b..44b1f92 100644
--- a/system/hwc2/DisplayFinder.cpp
+++ b/system/hwc2/DisplayFinder.cpp
@@ -54,7 +54,8 @@
: HertzToPeriodNanos(vsyncPeriodForDisplay);
}
-HWC2::Error findCuttlefishDisplays(std::vector<DisplayMultiConfigs>& displays) {
+HWC2::Error findCuttlefishDisplays(
+ std::vector<DisplayMultiConfigs>* outDisplays) {
DEBUG_LOG("%s", __FUNCTION__);
// TODO: replace with initializing directly from DRM info.
@@ -80,7 +81,7 @@
vsyncPeriodNanos),
},
};
- displays.push_back(display);
+ outDisplays->push_back(display);
++displayId;
}
@@ -88,7 +89,8 @@
}
HWC2::Error findGoldfishPrimaryDisplay(
- DrmPresenter* drmPresenter, std::vector<DisplayMultiConfigs>& displays) {
+ DrmPresenter* drmPresenter,
+ std::vector<DisplayMultiConfigs>* outDisplays) {
DEBUG_LOG("%s", __FUNCTION__);
DEFINE_AND_VALIDATE_HOST_CONNECTION
@@ -126,13 +128,13 @@
}
hostCon->unlock();
- displays.push_back(display);
+ outDisplays->push_back(display);
return HWC2::Error::None;
}
HWC2::Error findGoldfishSecondaryDisplays(
- std::vector<DisplayMultiConfigs>& displays) {
+ std::vector<DisplayMultiConfigs>* outDisplays) {
DEBUG_LOG("%s", __FUNCTION__);
static constexpr const char kExternalDisplayProp[] =
@@ -177,7 +179,7 @@
/*dpiYh=*/propIntParts[3], //
/*vsyncPeriod=*/HertzToPeriodNanos(160) //
));
- displays.push_back(display);
+ outDisplays->push_back(display);
++secondaryDisplayId;
@@ -187,15 +189,16 @@
return HWC2::Error::None;
}
-HWC2::Error findGoldfishDisplays(DrmPresenter* drmPresenter,
- std::vector<DisplayMultiConfigs>& displays) {
- HWC2::Error error = findGoldfishPrimaryDisplay(drmPresenter, displays);
+HWC2::Error findGoldfishDisplays(
+ DrmPresenter* drmPresenter,
+ std::vector<DisplayMultiConfigs>* outDisplays) {
+ HWC2::Error error = findGoldfishPrimaryDisplay(drmPresenter, outDisplays);
if (error != HWC2::Error::None) {
ALOGE("%s failed to find Goldfish primary display", __FUNCTION__);
return error;
}
- error = findGoldfishSecondaryDisplays(displays);
+ error = findGoldfishSecondaryDisplays(outDisplays);
if (error != HWC2::Error::None) {
ALOGE("%s failed to find Goldfish secondary displays", __FUNCTION__);
}
@@ -205,8 +208,8 @@
// This is currently only used for Gem5 bring-up where virtio-gpu and drm
// are not currently available. For now, just return a placeholder display.
-HWC2::Error findNoOpDisplays(std::vector<DisplayMultiConfigs>& displays) {
- displays.push_back(DisplayMultiConfigs{
+HWC2::Error findNoOpDisplays(std::vector<DisplayMultiConfigs>* outDisplays) {
+ outDisplays->push_back(DisplayMultiConfigs{
.displayId = 0,
.activeConfigId = 0,
.configs = {DisplayConfig(0,
@@ -221,17 +224,54 @@
return HWC2::Error::None;
}
+HWC2::Error findDrmDisplays(const DrmPresenter& drm,
+ std::vector<DisplayMultiConfigs>* outDisplays) {
+ outDisplays->clear();
+
+ std::vector<DrmPresenter::DisplayConfig> drmDisplayConfigs;
+
+ HWC2::Error error = drm.getDisplayConfigs(&drmDisplayConfigs);
+ if (error != HWC2::Error::None) {
+ ALOGE("%s failed to find displays from DRM.", __FUNCTION__);
+ return error;
+ }
+
+ for (const DrmPresenter::DisplayConfig drmDisplayConfig : drmDisplayConfigs) {
+ outDisplays->push_back(DisplayMultiConfigs{
+ .displayId = drmDisplayConfig.id,
+ .activeConfigId = drmDisplayConfig.id,
+ .configs = {
+ DisplayConfig(drmDisplayConfig.id,
+ drmDisplayConfig.width,
+ drmDisplayConfig.height,
+ drmDisplayConfig.dpiX,
+ drmDisplayConfig.dpiY,
+ HertzToPeriodNanos(drmDisplayConfig.refreshRateHz)),
+ },
+ });
+ }
+
+ return HWC2::Error::None;
+}
+
} // namespace
HWC2::Error findDisplays(DrmPresenter* drmPresenter,
- std::vector<DisplayMultiConfigs>& displays) {
+ std::vector<DisplayMultiConfigs>* outDisplays) {
HWC2::Error error = HWC2::Error::None;
- if (IsNoOpMode()) {
- error = findNoOpDisplays(displays);
+ if (IsInNoOpDisplayFinderMode()) {
+ error = findNoOpDisplays(outDisplays);
+ } else if (IsInDrmDisplayFinderMode()) {
+ if (drmPresenter == nullptr) {
+ ALOGE("%s asked to find displays from DRM, but DRM not available.",
+ __FUNCTION__);
+ return HWC2::Error::NoResources;
+ }
+ error = findDrmDisplays(*drmPresenter, outDisplays);
} else if (IsCuttlefish()) {
- error = findCuttlefishDisplays(displays);
+ error = findCuttlefishDisplays(outDisplays);
} else {
- error = findGoldfishDisplays(drmPresenter, displays);
+ error = findGoldfishDisplays(drmPresenter, outDisplays);
}
if (error != HWC2::Error::None) {
@@ -239,7 +279,7 @@
return error;
}
- for (auto& display : displays) {
+ for (auto& display : *outDisplays) {
DisplayConfig::addConfigGroups(&display.configs);
}
diff --git a/system/hwc2/DisplayFinder.h b/system/hwc2/DisplayFinder.h
index 5f22172..16844fa 100644
--- a/system/hwc2/DisplayFinder.h
+++ b/system/hwc2/DisplayFinder.h
@@ -17,6 +17,7 @@
#ifndef ANDROID_HWC_DISPLAYFINDER_H
#define ANDROID_HWC_DISPLAYFINDER_H
+#include <optional>
#include <vector>
#include "Common.h"
@@ -33,7 +34,7 @@
};
HWC2::Error findDisplays(DrmPresenter* drmPresenter,
- std::vector<DisplayMultiConfigs>& displays);
+ std::vector<DisplayMultiConfigs>* outDisplays);
} // namespace android
diff --git a/system/hwc2/DrmPresenter.cpp b/system/hwc2/DrmPresenter.cpp
index 40b4c37..a36bd89 100644
--- a/system/hwc2/DrmPresenter.cpp
+++ b/system/hwc2/DrmPresenter.cpp
@@ -26,6 +26,11 @@
namespace android {
+DrmBuffer::DrmBuffer(DrmPresenter& DrmPresenter)
+ : mDrmPresenter(DrmPresenter) {}
+
+DrmBuffer::~DrmBuffer() { mDrmPresenter.destroyDrmFramebuffer(this); }
+
bool DrmPresenter::init(const HotplugCallback& cb) {
DEBUG_LOG("%s", __FUNCTION__);
@@ -59,6 +64,18 @@
ALOGE("%s: Failed to initialize DRM backend", __FUNCTION__);
return false;
}
+
+ constexpr const std::size_t kCachedBuffersPerDisplay = 3;
+ std::size_t numDisplays = 0;
+ for (const DrmConnector& connector : mConnectors) {
+ if (connector.connection == DRM_MODE_CONNECTED) {
+ ++numDisplays;
+ }
+ }
+ const std::size_t bufferCacheSize = kCachedBuffersPerDisplay * numDisplays;
+ DEBUG_LOG("%s: initializing DRM buffer cache to size %zu",
+ __FUNCTION__, bufferCacheSize);
+ mBufferCache = std::make_unique<DrmBufferCache>(bufferCacheSize);
}
mDrmEventListener = sp<DrmEventListener>::make(*this);
@@ -291,43 +308,29 @@
mPlanes.clear();
}
-int DrmPresenter::getDrmFB(hwc_drm_bo_t& bo) {
- int ret = drmPrimeFDToHandle(mFd.get(), bo.prime_fds[0], &bo.gem_handles[0]);
- if (ret) {
- ALOGE("%s: drmPrimeFDToHandle failed: %s (errno %d)", __FUNCTION__,
- strerror(errno), errno);
- return -1;
- }
- ret = drmModeAddFB2(mFd.get(), bo.width, bo.height, bo.format, bo.gem_handles,
- bo.pitches, bo.offsets, &bo.fb_id, 0);
- if (ret) {
- ALOGE("%s: drmModeAddFB2 failed: %s (errno %d)", __FUNCTION__,
- strerror(errno), errno);
- return -1;
- }
- return 0;
-}
+HWC2::Error DrmPresenter::getDisplayConfigs(std::vector<DisplayConfig>* configs) const {
+ AutoReadLock lock(mStateMutex);
-int DrmPresenter::clearDrmFB(hwc_drm_bo_t& bo) {
- int ret = 0;
- if (bo.fb_id) {
- if (drmModeRmFB(mFd.get(), bo.fb_id)) {
- ALOGE("%s: drmModeRmFB failed: %s (errno %d)", __FUNCTION__,
- strerror(errno), errno);
+ configs->clear();
+
+ for (uint32_t i = 0; i < mConnectors.size(); i++) {
+ const auto& connector = mConnectors[i];
+
+ if (connector.connection != DRM_MODE_CONNECTED) {
+ continue;
}
- ret = -1;
+
+ configs->emplace_back(DisplayConfig{
+ .id = i,
+ .width = connector.mMode.hdisplay,
+ .height = connector.mMode.vdisplay,
+ .dpiX = 160, //static_cast<uint32_t>(connector.dpiX),
+ .dpiY = 160, //static_cast<uint32_t>(connector.dpiY),
+ .refreshRateHz = connector.mRefreshRateAsInteger,
+ });
}
- if (bo.gem_handles[0]) {
- struct drm_gem_close gem_close = {};
- gem_close.handle = bo.gem_handles[0];
- if (drmIoctl(mFd.get(), DRM_IOCTL_GEM_CLOSE, &gem_close)) {
- ALOGE("%s: DRM_IOCTL_GEM_CLOSE failed: %s (errno %d)", __FUNCTION__,
- strerror(errno), errno);
- }
- ret = -1;
- }
- ALOGV("%s: drm FB %d", __FUNCTION__, bo.fb_id);
- return ret;
+
+ return HWC2::Error::None;
}
bool DrmPresenter::handleHotplug() {
@@ -378,10 +381,97 @@
return true;
}
+std::tuple<HWC2::Error, std::shared_ptr<DrmBuffer>> DrmPresenter::create(
+ const native_handle_t* handle) {
+ cros_gralloc_handle* crosHandle = (cros_gralloc_handle*)handle;
+ if (crosHandle == nullptr) {
+ ALOGE("%s: invalid cros_gralloc_handle", __FUNCTION__);
+ return std::make_tuple(HWC2::Error::NoResources, nullptr);
+ }
+
+ DrmPrimeBufferHandle primeHandle = 0;
+ int ret = drmPrimeFDToHandle(mFd.get(), crosHandle->fds[0], &primeHandle);
+ if (ret) {
+ ALOGE("%s: drmPrimeFDToHandle failed: %s (errno %d)", __FUNCTION__,
+ strerror(errno), errno);
+ return std::make_tuple(HWC2::Error::NoResources, nullptr);
+ }
+
+ auto drmBufferPtr = mBufferCache->get(primeHandle);
+ if (drmBufferPtr != nullptr) {
+ return std::make_tuple(HWC2::Error::None,
+ std::shared_ptr<DrmBuffer>(*drmBufferPtr));
+ }
+
+ auto buffer = std::shared_ptr<DrmBuffer>(new DrmBuffer(*this));
+ buffer->mWidth = crosHandle->width;
+ buffer->mHeight = crosHandle->height;
+ buffer->mDrmFormat = crosHandle->format;
+ buffer->mPlaneFds[0] = crosHandle->fds[0];
+ buffer->mPlaneHandles[0] = primeHandle;
+ buffer->mPlanePitches[0] = crosHandle->strides[0];
+ buffer->mPlaneOffsets[0] = crosHandle->offsets[0];
+
+ uint32_t framebuffer = 0;
+ ret = drmModeAddFB2(mFd.get(),
+ buffer->mWidth,
+ buffer->mHeight,
+ buffer->mDrmFormat,
+ buffer->mPlaneHandles,
+ buffer->mPlanePitches,
+ buffer->mPlaneOffsets,
+ &framebuffer,
+ 0);
+ if (ret) {
+ ALOGE("%s: drmModeAddFB2 failed: %s (errno %d)", __FUNCTION__,
+ strerror(errno), errno);
+ return std::make_tuple(HWC2::Error::NoResources, nullptr);
+ }
+ DEBUG_LOG("%s: created framebuffer:%" PRIu32, __FUNCTION__, framebuffer);
+ buffer->mDrmFramebuffer = framebuffer;
+
+ mBufferCache->set(primeHandle, std::shared_ptr<DrmBuffer>(buffer));
+
+ return std::make_tuple(HWC2::Error::None,
+ std::shared_ptr<DrmBuffer>(buffer));
+}
+
+HWC2::Error DrmPresenter::destroyDrmFramebuffer(DrmBuffer* buffer) {
+ if (buffer->mDrmFramebuffer) {
+ uint32_t framebuffer = *buffer->mDrmFramebuffer;
+ if (drmModeRmFB(mFd.get(), framebuffer)) {
+ ALOGE("%s: drmModeRmFB failed: %s (errno %d)", __FUNCTION__,
+ strerror(errno), errno);
+ return HWC2::Error::NoResources;
+ }
+ DEBUG_LOG("%s: destroyed framebuffer:%" PRIu32, __FUNCTION__, framebuffer);
+ buffer->mDrmFramebuffer.reset();
+ }
+ if (buffer->mPlaneHandles[0]) {
+ struct drm_gem_close gem_close = {};
+ gem_close.handle = buffer->mPlaneHandles[0];
+ if (drmIoctl(mFd.get(), DRM_IOCTL_GEM_CLOSE, &gem_close)) {
+ ALOGE("%s: DRM_IOCTL_GEM_CLOSE failed: %s (errno %d)", __FUNCTION__,
+ strerror(errno), errno);
+ return HWC2::Error::NoResources;
+ }
+
+ mBufferCache->remove(buffer->mPlaneHandles[0]);
+ }
+
+ return HWC2::Error::None;
+}
+
std::tuple<HWC2::Error, base::unique_fd> DrmPresenter::flushToDisplay(
- int display, hwc_drm_bo_t& bo, base::borrowed_fd inSyncFd) {
+ int display, const DrmBuffer& buffer, base::borrowed_fd inSyncFd) {
ATRACE_CALL();
+ if (!buffer.mDrmFramebuffer) {
+ ALOGE("%s: failed, no framebuffer created.", __FUNCTION__);
+ return std::make_tuple(HWC2::Error::NoResources,
+ ::android::base::unique_fd());
+ }
+
AutoReadLock lock(mStateMutex);
DrmConnector& connector = mConnectors[display];
@@ -435,7 +525,8 @@
DrmPlane& plane = mPlanes[crtc.mPlaneId];
DEBUG_LOG("%s: set plane: plane id %d crtc id %d fbid %d bo w h %d %d\n",
- __FUNCTION__, plane.mId, crtc.mId, bo.fb_id, bo.width, bo.height);
+ __FUNCTION__, plane.mId, crtc.mId, *buffer.mDrmFramebuffer,
+ buffer.mWidth, buffer.mHeight);
ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mCrtcPropertyId,
crtc.mId);
@@ -448,8 +539,8 @@
ALOGE("%s:%d: set IN_FENCE_FD failed %d errno %d\n", __FUNCTION__, __LINE__,
ret, errno);
}
- ret =
- drmModeAtomicAddProperty(pset, plane.mId, plane.mFbPropertyId, bo.fb_id);
+ ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mFbPropertyId,
+ *buffer.mDrmFramebuffer);
if (ret < 0) {
ALOGE("%s:%d: failed %d errno %d\n", __FUNCTION__, __LINE__, ret, errno);
}
@@ -462,12 +553,12 @@
ALOGE("%s:%d: failed %d errno %d\n", __FUNCTION__, __LINE__, ret, errno);
}
ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mCrtcWPropertyId,
- bo.width);
+ buffer.mWidth);
if (ret < 0) {
ALOGE("%s:%d: failed %d errno %d\n", __FUNCTION__, __LINE__, ret, errno);
}
ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mCrtcHPropertyId,
- bo.height);
+ buffer.mHeight);
if (ret < 0) {
ALOGE("%s:%d: failed %d errno %d\n", __FUNCTION__, __LINE__, ret, errno);
}
@@ -480,12 +571,12 @@
ALOGE("%s:%d: failed %d errno %d\n", __FUNCTION__, __LINE__, ret, errno);
}
ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mSrcWPropertyId,
- bo.width << 16);
+ buffer.mWidth << 16);
if (ret < 0) {
ALOGE("%s:%d: failed %d errno %d\n", __FUNCTION__, __LINE__, ret, errno);
}
ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mSrcHPropertyId,
- bo.height << 16);
+ buffer.mHeight << 16);
if (ret < 0) {
ALOGE("%s:%d: failed %d errno %d\n", __FUNCTION__, __LINE__, ret, errno);
}
@@ -530,36 +621,6 @@
return edid;
}
-DrmBuffer::DrmBuffer(const native_handle_t* handle, DrmPresenter* drmPresenter)
- : mDrmPresenter(drmPresenter), mBo({}) {
- if (!convertBoInfo(handle)) {
- mDrmPresenter->getDrmFB(mBo);
- }
-}
-
-DrmBuffer::~DrmBuffer() { mDrmPresenter->clearDrmFB(mBo); }
-
-int DrmBuffer::convertBoInfo(const native_handle_t* handle) {
- cros_gralloc_handle* gr_handle = (cros_gralloc_handle*)handle;
- if (!gr_handle) {
- ALOGE("%s: Null buffer handle", __FUNCTION__);
- return -1;
- }
- mBo.width = gr_handle->width;
- mBo.height = gr_handle->height;
- mBo.hal_format = gr_handle->droid_format;
- mBo.format = gr_handle->format;
- mBo.usage = gr_handle->usage;
- mBo.prime_fds[0] = gr_handle->fds[0];
- mBo.pitches[0] = gr_handle->strides[0];
- return 0;
-}
-
-std::tuple<HWC2::Error, base::unique_fd> DrmBuffer::flushToDisplay(
- int display, base::borrowed_fd inWaitSyncFd) {
- return mDrmPresenter->flushToDisplay(display, mBo, inWaitSyncFd);
-}
-
DrmPresenter::DrmEventListener::DrmEventListener(DrmPresenter& presenter)
: mPresenter(presenter) {}
diff --git a/system/hwc2/DrmPresenter.h b/system/hwc2/DrmPresenter.h
index 24614ac..5ef3724 100644
--- a/system/hwc2/DrmPresenter.h
+++ b/system/hwc2/DrmPresenter.h
@@ -28,8 +28,8 @@
#include <vector>
#include "Common.h"
+#include "LruCache.h"
#include "android/base/synchronization/AndroidLock.h"
-#include "drmhwcgralloc.h"
namespace android {
@@ -39,7 +39,6 @@
// A RAII object that will clear a drm framebuffer upon destruction.
class DrmBuffer {
public:
- DrmBuffer(const native_handle_t* handle, DrmPresenter* drmPresenter);
~DrmBuffer();
DrmBuffer(const DrmBuffer&) = delete;
@@ -48,14 +47,21 @@
DrmBuffer(DrmBuffer&&) = delete;
DrmBuffer& operator=(DrmBuffer&&) = delete;
- std::tuple<HWC2::Error, base::unique_fd> flushToDisplay(
- int display, base::borrowed_fd inWaitSyncFd);
-
private:
- int convertBoInfo(const native_handle_t* handle);
+ friend class DrmPresenter;
+ DrmBuffer(DrmPresenter& drmPresenter);
- DrmPresenter* mDrmPresenter;
- hwc_drm_bo_t mBo;
+ DrmPresenter& mDrmPresenter;
+
+ uint32_t mWidth = 0;
+ uint32_t mHeight = 0;
+ uint32_t mDrmFormat = 0;
+ uint32_t mPlaneFds[4] = {0, 0, 0, 0};
+ uint32_t mPlaneHandles[4] = {0, 0, 0, 0};
+ uint32_t mPlanePitches[4] = {0, 0, 0, 0};
+ uint32_t mPlaneOffsets[4] = {0, 0, 0, 0};
+
+ std::optional<uint32_t> mDrmFramebuffer;
};
class DrmPresenter {
@@ -76,6 +82,17 @@
bool init(const HotplugCallback& cb);
+ struct DisplayConfig {
+ uint32_t id;
+ uint32_t width;
+ uint32_t height;
+ uint32_t dpiX;
+ uint32_t dpiY;
+ uint32_t refreshRateHz;
+ };
+
+ HWC2::Error getDisplayConfigs(std::vector<DisplayConfig>* configs) const;
+
uint32_t refreshRate(uint32_t display) const {
if (display < mConnectors.size()) {
return mConnectors[display].mRefreshRateAsInteger;
@@ -84,16 +101,23 @@
return -1;
}
+ std::tuple<HWC2::Error, std::shared_ptr<DrmBuffer>> create(
+ const native_handle_t* handle);
+
std::tuple<HWC2::Error, base::unique_fd> flushToDisplay(
- int display, hwc_drm_bo_t& fb, base::borrowed_fd inWaitSyncFd);
+ int display, const DrmBuffer& buffer, base::borrowed_fd inWaitSyncFd);
std::optional<std::vector<uint8_t>> getEdid(uint32_t id);
private:
+ using DrmPrimeBufferHandle = uint32_t;
+ using DrmBufferCache = LruCache<DrmPrimeBufferHandle, std::shared_ptr<DrmBuffer>>;
+ std::unique_ptr<DrmBufferCache> mBufferCache;
+
// Grant visibility for getDrmFB and clearDrmFB to DrmBuffer.
+ // Grant visibility to destroyDrmFramebuffer to DrmBuffer.
friend class DrmBuffer;
- int getDrmFB(hwc_drm_bo_t& bo);
- int clearDrmFB(hwc_drm_bo_t& bo);
+ HWC2::Error destroyDrmFramebuffer(DrmBuffer* buffer);
// Grant visibility for handleHotplug to DrmEventListener.
bool handleHotplug();
@@ -107,7 +131,7 @@
HotplugCallback mHotplugCallback;
// Protects access to the below drm structs.
- android::base::guest::ReadWriteLock mStateMutex;
+ mutable android::base::guest::ReadWriteLock mStateMutex;
struct DrmPlane {
uint32_t mId = -1;
diff --git a/system/hwc2/GuestComposer.cpp b/system/hwc2/GuestComposer.cpp
index 9f8dc05..2c91192 100644
--- a/system/hwc2/GuestComposer.cpp
+++ b/system/hwc2/GuestComposer.cpp
@@ -463,12 +463,17 @@
displayInfo.compositionResultBuffer = bufferHandle;
- displayInfo.compositionResultDrmBuffer = std::make_unique<DrmBuffer>(
- displayInfo.compositionResultBuffer, mDrmPresenter);
+ auto [drmBufferCreateError, drmBuffer] = mDrmPresenter->create(bufferHandle);
+ if (drmBufferCreateError != HWC2::Error::None) {
+ ALOGE("%s: display:%" PRIu64 " failed to create client target drm buffer",
+ __FUNCTION__, displayId);
+ return HWC2::Error::NoResources;
+ }
+ displayInfo.compositionResultDrmBuffer = std::move(drmBuffer);
if (displayId == 0) {
- auto [flushError, flushSyncFd] =
- displayInfo.compositionResultDrmBuffer->flushToDisplay(displayId, -1);
+ auto [flushError, flushSyncFd] = mDrmPresenter->flushToDisplay(
+ displayId, *displayInfo.compositionResultDrmBuffer, -1);
if (flushError != HWC2::Error::None) {
ALOGW(
"%s: Initial display flush failed. HWComposer assuming that we are "
@@ -835,9 +840,8 @@
DEBUG_LOG("%s display:%" PRIu64 " flushing drm buffer", __FUNCTION__,
displayId);
- auto [error, outRetireFence] =
- displayInfo.compositionResultDrmBuffer->flushToDisplay(
- static_cast<int>(displayId), -1);
+ auto [error, outRetireFence] = mDrmPresenter->flushToDisplay(
+ displayId, *displayInfo.compositionResultDrmBuffer, -1);
if (error != HWC2::Error::None) {
ALOGE("%s: display:%" PRIu64 " failed to flush drm buffer" PRIu64,
__FUNCTION__, displayId);
diff --git a/system/hwc2/GuestComposer.h b/system/hwc2/GuestComposer.h
index a7a8be7..d9579a0 100644
--- a/system/hwc2/GuestComposer.h
+++ b/system/hwc2/GuestComposer.h
@@ -90,7 +90,7 @@
// Additional per display buffer for the composition result.
buffer_handle_t compositionResultBuffer = nullptr;
- std::unique_ptr<DrmBuffer> compositionResultDrmBuffer;
+ std::shared_ptr<DrmBuffer> compositionResultDrmBuffer;
};
std::unordered_map<hwc2_display_t, GuestComposerDisplayInfo> mDisplayInfos;
diff --git a/system/hwc2/HostComposer.cpp b/system/hwc2/HostComposer.cpp
index 472e782..48b8d51 100644
--- a/system/hwc2/HostComposer.cpp
+++ b/system/hwc2/HostComposer.cpp
@@ -134,8 +134,13 @@
if (!res) {
return nullptr;
}
- res->mDrmBuffer = std::make_unique<DrmBuffer>(res->mFencedBuffer->getBuffer(),
- &drmPresenter);
+
+ auto [error, buffer] = drmPresenter.create(res->mFencedBuffer->getBuffer());
+ if (error != HWC2::Error::None) {
+ return nullptr;
+ }
+ res->mDrmBuffer = std::move(buffer);
+
return res;
}
@@ -441,8 +446,14 @@
if (mIsMinigbm) {
FencedBuffer& clientTargetFencedBuffer = display->getClientTarget();
- displayInfo.clientTargetDrmBuffer.reset(
- new DrmBuffer(clientTargetFencedBuffer.getBuffer(), mDrmPresenter));
+ auto [drmBufferCreateError, drmBuffer] =
+ mDrmPresenter->create(clientTargetFencedBuffer.getBuffer());
+ if (drmBufferCreateError != HWC2::Error::None) {
+ ALOGE("%s: display:%" PRIu64 " failed to create client target drm buffer",
+ __FUNCTION__, displayId);
+ return HWC2::Error::NoResources;
+ }
+ displayInfo.clientTargetDrmBuffer = std::move(drmBuffer);
}
return HWC2::Error::None;
@@ -470,24 +481,18 @@
// layers will fall back to the client composition type.
bool fallBackToClient = (!hostCompositionV1 && !hostCompositionV2) ||
display->hasColorTransform();
- std::unordered_map<hwc2_layer_t, HWC2::Composition> changes;
+ std::unordered_map<Layer*, HWC2::Composition> changes;
if (!fallBackToClient) {
- for (const auto& layer : layers) {
+ for (Layer* layer : layers) {
HWC2::Composition layerCompositionType = layer->getCompositionType();
std::optional<HWC2::Composition> layerFallBackTo = std::nullopt;
switch (layerCompositionType) {
case HWC2::Composition::Client:
case HWC2::Composition::Sideband:
- ALOGI("%s: layer %" PRIu32 " CompositionType %d, fallback to client",
- __FUNCTION__, static_cast<uint32_t>(layer->getId()),
- layerCompositionType);
layerFallBackTo = HWC2::Composition::Client;
break;
case HWC2::Composition::Cursor:
- ALOGI("%s: layer %" PRIu32 " CompositionType %d, fallback to device",
- __FUNCTION__, static_cast<uint32_t>(layer->getId()),
- layerCompositionType);
layerFallBackTo = HWC2::Composition::Device;
break;
case HWC2::Composition::Invalid:
@@ -504,24 +509,28 @@
fallBackToClient = true;
}
if (layerFallBackTo.has_value()) {
- changes[layer->getId()] = layerFallBackTo.value();
+ changes.emplace(layer, layerFallBackTo.value());
}
}
}
if (fallBackToClient) {
changes.clear();
- for (auto& layer : layers) {
+ for (Layer* layer : layers) {
if (layer->getCompositionType() == HWC2::Composition::Invalid) {
continue;
}
if (layer->getCompositionType() != HWC2::Composition::Client) {
- changes[layer->getId()] = HWC2::Composition::Client;
+ changes.emplace(layer, HWC2::Composition::Client);
}
}
}
- *layerCompositionChanges = std::move(changes);
+ layerCompositionChanges->clear();
+ for (auto& [layer, newCompositionType] : changes) {
+ layer->logCompositionFallbackIfChanged(newCompositionType);
+ layerCompositionChanges->emplace(layer->getId(), newCompositionType);
+ }
return HWC2::Error::None;
}
@@ -578,9 +587,8 @@
if (displayClientTarget.getBuffer() != nullptr) {
base::unique_fd fence = displayClientTarget.getFence();
if (mIsMinigbm) {
- auto [_, flushCompleteFence] =
- displayInfo.clientTargetDrmBuffer->flushToDisplay(
- display->getId(), fence);
+ auto [_, flushCompleteFence] = mDrmPresenter->flushToDisplay(
+ display->getId(), *displayInfo.clientTargetDrmBuffer, fence);
outRetireFence = std::move(flushCompleteFence);
} else {
post(hostCon, rcEnc, displayClientTarget.getBuffer());
@@ -725,9 +733,8 @@
}
if (mIsMinigbm) {
- auto [_, fence] =
- compositionResultBuffer.waitAndGetDrmBuffer().flushToDisplay(
- display->getId(), -1);
+ auto [_, fence] = mDrmPresenter->flushToDisplay(
+ display->getId(), compositionResultBuffer.waitAndGetDrmBuffer(), -1);
retire_fd = std::move(fence);
} else {
int fd;
@@ -756,9 +763,8 @@
FencedBuffer& displayClientTarget = display->getClientTarget();
base::unique_fd fence = displayClientTarget.getFence();
if (mIsMinigbm) {
- auto [_, outRetireFence] =
- displayInfo.clientTargetDrmBuffer->flushToDisplay(display->getId(),
- fence);
+ auto [_, outRetireFence] = mDrmPresenter->flushToDisplay(
+ display->getId(), *displayInfo.clientTargetDrmBuffer, fence);
outRetireFence = std::move(fence);
} else {
post(hostCon, rcEnc, displayClientTarget.getBuffer());
diff --git a/system/hwc2/HostComposer.h b/system/hwc2/HostComposer.h
index f17b610..e8a9927 100644
--- a/system/hwc2/HostComposer.h
+++ b/system/hwc2/HostComposer.h
@@ -19,6 +19,7 @@
#include <android-base/unique_fd.h>
+#include <memory>
#include <tuple>
#include <vector>
@@ -68,8 +69,6 @@
void post(HostConnection* hostCon, ExtendedRCEncoderContext* rcEnc,
buffer_handle_t h);
- bool mIsMinigbm = false;
-
int mSyncDeviceFd = -1;
class CompositionResultBuffer {
@@ -92,7 +91,7 @@
std::unique_ptr<FencedBuffer> mFencedBuffer;
// Drm info for the additional composition result buffer.
- std::unique_ptr<DrmBuffer> mDrmBuffer;
+ std::shared_ptr<DrmBuffer> mDrmBuffer;
};
class HostComposerDisplayInfo {
public:
@@ -103,7 +102,7 @@
uint32_t hostDisplayId = 0;
// Drm info for the displays client target buffer.
- std::unique_ptr<DrmBuffer> clientTargetDrmBuffer;
+ std::shared_ptr<DrmBuffer> clientTargetDrmBuffer;
private:
// Additional per display buffer for the composition result.
@@ -113,6 +112,7 @@
std::unordered_map<hwc2_display_t, HostComposerDisplayInfo> mDisplayInfos;
DrmPresenter* mDrmPresenter;
+ bool mIsMinigbm = false;
};
} // namespace android
diff --git a/system/hwc2/Layer.cpp b/system/hwc2/Layer.cpp
index e26de10..7421ec8 100644
--- a/system/hwc2/Layer.cpp
+++ b/system/hwc2/Layer.cpp
@@ -255,4 +255,18 @@
return z;
}
+void Layer::logCompositionFallbackIfChanged(HWC2::Composition to) {
+ HWC2::Composition from = getCompositionType();
+ if (mLastCompositionFallback && mLastCompositionFallback->from == from &&
+ mLastCompositionFallback->to == to) {
+ return;
+ }
+ ALOGI("%s: layer %" PRIu32 " CompositionType fallback from %d to %d", __FUNCTION__,
+ static_cast<uint32_t>(getId()), static_cast<int>(from), static_cast<int>(to));
+ mLastCompositionFallback = {
+ .from = from,
+ .to = to,
+ };
+}
+
} // namespace android
diff --git a/system/hwc2/Layer.h b/system/hwc2/Layer.h
index f576201..f1668e0 100644
--- a/system/hwc2/Layer.h
+++ b/system/hwc2/Layer.h
@@ -17,6 +17,7 @@
#ifndef ANDROID_HWC_LAYER_H
#define ANDROID_HWC_LAYER_H
+#include <optional>
#include <vector>
#include "Common.h"
@@ -78,6 +79,9 @@
HWC2::Error setZ(uint32_t z);
uint32_t getZ() const;
+ // For log use only.
+ void logCompositionFallbackIfChanged(HWC2::Composition to);
+
private:
const hwc2_layer_t mId;
FencedBuffer mBuffer;
@@ -85,6 +89,12 @@
HWC2::BlendMode mBlendMode = HWC2::BlendMode::None;
hwc_color_t mColor = {0, 0, 0, 0};
HWC2::Composition mCompositionType = HWC2::Composition::Invalid;
+ struct CompositionTypeFallback {
+ HWC2::Composition from;
+ HWC2::Composition to;
+ };
+ // For log use only.
+ std::optional<CompositionTypeFallback> mLastCompositionFallback = std::nullopt;
hwc_rect_t mDisplayFrame = {0, 0, -1, -1};
float mPlaneAlpha = 0.0f;
const native_handle_t* mSidebandStream = nullptr;
@@ -96,4 +106,4 @@
} // namespace android
-#endif
\ No newline at end of file
+#endif
diff --git a/system/hwc2/LruCache.h b/system/hwc2/LruCache.h
new file mode 100644
index 0000000..9ffca46
--- /dev/null
+++ b/system/hwc2/LruCache.h
@@ -0,0 +1,83 @@
+// Copyright 2022 The Android Open Source Project
+//
+// 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.
+
+#pragma once
+
+#include <list>
+#include <unordered_map>
+
+template <typename Key, typename Value>
+class LruCache {
+ public:
+ LruCache(std::size_t maxSize) : m_maxSize(maxSize) {
+ m_table.reserve(maxSize);
+ }
+
+ Value* get(const Key& key) {
+ auto tableIt = m_table.find(key);
+ if (tableIt == m_table.end()) {
+ return nullptr;
+ }
+
+ // Move to front.
+ auto elementsIt = tableIt->second;
+ m_elements.splice(elementsIt, m_elements, m_elements.begin());
+ return &elementsIt->value;
+ }
+
+ void set(const Key& key, Value&& value) {
+ auto tableIt = m_table.find(key);
+ if (tableIt == m_table.end()) {
+ if (m_table.size() >= m_maxSize) {
+ auto& kv = m_elements.back();
+ m_table.erase(kv.key);
+ m_elements.pop_back();
+ }
+ } else {
+ auto elementsIt = tableIt->second;
+ m_elements.erase(elementsIt);
+ }
+ m_elements.emplace_front(KeyValue{
+ key,
+ std::forward<Value>(value),
+ });
+ m_table[key] = m_elements.begin();
+ }
+
+ void remove(const Key& key) {
+ auto tableIt = m_table.find(key);
+ if (tableIt == m_table.end()) {
+ return;
+ }
+ auto elementsIt = tableIt->second;
+ m_elements.erase(elementsIt);
+ m_table.erase(tableIt);
+ }
+
+ void clear() {
+ m_elements.clear();
+ m_table.clear();
+ }
+
+ private:
+ struct KeyValue {
+ Key key;
+ Value value;
+ };
+
+ const std::size_t m_maxSize;
+ // Front is the most recently used and back is the least recently used.
+ std::list<KeyValue> m_elements;
+ std::unordered_map<Key, typename std::list<KeyValue>::iterator> m_table;
+};
diff --git a/system/hwc3/Android.mk b/system/hwc3/Android.mk
index 3d30e89..a0d0843 100644
--- a/system/hwc3/Android.mk
+++ b/system/hwc3/Android.mk
@@ -84,7 +84,15 @@
DisplayConfig.cpp \
DisplayFinder.cpp \
Drm.cpp \
- DrmPresenter.cpp \
+ DrmAtomicRequest.cpp \
+ DrmBuffer.cpp \
+ DrmClient.cpp \
+ DrmConnector.cpp \
+ DrmCrtc.cpp \
+ DrmDisplay.cpp \
+ DrmEventListener.cpp \
+ DrmMode.cpp \
+ DrmPlane.cpp \
Gralloc.cpp \
GuestFrameComposer.cpp \
HostFrameComposer.cpp \
diff --git a/system/hwc3/ClientFrameComposer.cpp b/system/hwc3/ClientFrameComposer.cpp
index 284a46f..85ba90f 100644
--- a/system/hwc3/ClientFrameComposer.cpp
+++ b/system/hwc3/ClientFrameComposer.cpp
@@ -37,9 +37,9 @@
HWC3::Error ClientFrameComposer::init() {
DEBUG_LOG("%s", __FUNCTION__);
- HWC3::Error error = mDrmPresenter.init();
+ HWC3::Error error = mDrmClient.init();
if (error != HWC3::Error::None) {
- ALOGE("%s: failed to initialize DrmPresenter", __FUNCTION__);
+ ALOGE("%s: failed to initialize DrmClient", __FUNCTION__);
return error;
}
@@ -48,12 +48,12 @@
HWC3::Error ClientFrameComposer::registerOnHotplugCallback(
const HotplugCallback& cb) {
- return mDrmPresenter.registerOnHotplugCallback(cb);
+ return mDrmClient.registerOnHotplugCallback(cb);
return HWC3::Error::None;
}
HWC3::Error ClientFrameComposer::unregisterOnHotplugCallback() {
- return mDrmPresenter.unregisterOnHotplugCallback();
+ return mDrmClient.unregisterOnHotplugCallback();
}
HWC3::Error ClientFrameComposer::onDisplayCreate(Display* display) {
@@ -96,7 +96,7 @@
DisplayInfo& displayInfo = it->second;
auto [drmBufferCreateError, drmBuffer] =
- mDrmPresenter.create(display->getClientTarget().getBuffer());
+ mDrmClient.create(display->getClientTarget().getBuffer());
if (drmBufferCreateError != HWC3::Error::None) {
ALOGE("%s: display:%" PRIu64 " failed to create client target drm buffer",
__FUNCTION__, displayId);
@@ -154,8 +154,8 @@
::android::base::unique_fd fence = display->getClientTarget().getFence();
- auto [flushError, flushCompleteFence] = mDrmPresenter.flushToDisplay(
- displayId, *displayInfo.clientTargetDrmBuffer, fence);
+ auto [flushError, flushCompleteFence] = mDrmClient.flushToDisplay(
+ displayId, displayInfo.clientTargetDrmBuffer, fence);
if (flushError != HWC3::Error::None) {
ALOGE("%s: display:%" PRIu64 " failed to flush drm buffer" PRIu64,
__FUNCTION__, displayId);
diff --git a/system/hwc3/ClientFrameComposer.h b/system/hwc3/ClientFrameComposer.h
index 28199b3..8798807 100644
--- a/system/hwc3/ClientFrameComposer.h
+++ b/system/hwc3/ClientFrameComposer.h
@@ -19,7 +19,7 @@
#include "Common.h"
#include "Display.h"
-#include "DrmPresenter.h"
+#include "DrmClient.h"
#include "FrameComposer.h"
#include "Gralloc.h"
#include "Layer.h"
@@ -64,8 +64,8 @@
std::unordered_map<int64_t, ::android::base::unique_fd>* outLayerFences)
override;
- const DrmPresenter* getDrmPresenter() const override {
- return &mDrmPresenter;
+ const DrmClient* getDrmPresenter() const override {
+ return &mDrmClient;
}
private:
@@ -75,7 +75,7 @@
std::unordered_map<int64_t, DisplayInfo> mDisplayInfos;
- DrmPresenter mDrmPresenter;
+ DrmClient mDrmClient;
};
} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/ComposerClient.cpp b/system/hwc3/ComposerClient.cpp
index 2098435..f7ba42e 100644
--- a/system/hwc3/ComposerClient.cpp
+++ b/system/hwc3/ComposerClient.cpp
@@ -1284,6 +1284,8 @@
return error;
}
+ display->setPowerMode(PowerMode::ON);
+
DEBUG_LOG("%s: adding display:%" PRIu64, __FUNCTION__, displayId);
mDisplays.emplace(displayId, std::move(display));
@@ -1320,6 +1322,10 @@
return HWC3::Error::BadDisplay;
}
+ Display* display = it->second.get();
+
+ display->setPowerMode(PowerMode::OFF);
+
HWC3::Error error = mComposer->onDisplayDestroy(it->second.get());
if (error != HWC3::Error::None) {
ALOGE("%s: display:%" PRId64 " failed to destroy with frame composer",
diff --git a/system/hwc3/DisplayFinder.cpp b/system/hwc3/DisplayFinder.cpp
index 10bd5fd..1b45d0a 100644
--- a/system/hwc3/DisplayFinder.cpp
+++ b/system/hwc3/DisplayFinder.cpp
@@ -213,11 +213,11 @@
return HWC3::Error::None;
}
-HWC3::Error findDrmDisplays(const DrmPresenter& drm,
+HWC3::Error findDrmDisplays(const DrmClient& drm,
std::vector<DisplayMultiConfigs>* outDisplays) {
outDisplays->clear();
- std::vector<DrmPresenter::DisplayConfig> drmDisplayConfigs;
+ std::vector<DrmClient::DisplayConfig> drmDisplayConfigs;
HWC3::Error error = drm.getDisplayConfigs(&drmDisplayConfigs);
if (error != HWC3::Error::None) {
@@ -225,7 +225,7 @@
return error;
}
- for (const DrmPresenter::DisplayConfig drmDisplayConfig : drmDisplayConfigs) {
+ for (const DrmClient::DisplayConfig drmDisplayConfig : drmDisplayConfigs) {
outDisplays->push_back(DisplayMultiConfigs{
.displayId = drmDisplayConfig.id,
.activeConfigId = static_cast<int32_t>(drmDisplayConfig.id),
@@ -245,7 +245,7 @@
} // namespace
-HWC3::Error findDisplays(const DrmPresenter* drm,
+HWC3::Error findDisplays(const DrmClient* drm,
std::vector<DisplayMultiConfigs>* outDisplays) {
HWC3::Error error = HWC3::Error::None;
if (IsInNoOpCompositionMode()) {
diff --git a/system/hwc3/DisplayFinder.h b/system/hwc3/DisplayFinder.h
index 171d204..963e4c1 100644
--- a/system/hwc3/DisplayFinder.h
+++ b/system/hwc3/DisplayFinder.h
@@ -22,7 +22,7 @@
#include "Common.h"
#include "DisplayConfig.h"
-#include "DrmPresenter.h"
+#include "DrmClient.h"
namespace aidl::android::hardware::graphics::composer3::impl {
@@ -33,7 +33,7 @@
std::vector<DisplayConfig> configs;
};
-HWC3::Error findDisplays(const DrmPresenter* drm,
+HWC3::Error findDisplays(const DrmClient* drm,
std::vector<DisplayMultiConfigs>* outDisplays);
} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/Drm.cpp b/system/hwc3/Drm.cpp
index 6872eb4..d5cf1d7 100644
--- a/system/hwc3/Drm.cpp
+++ b/system/hwc3/Drm.cpp
@@ -23,158 +23,158 @@
namespace aidl::android::hardware::graphics::composer3::impl {
const char* GetDrmFormatString(uint32_t drm_format) {
- switch (drm_format) {
- case DRM_FORMAT_ABGR1555:
- return "DRM_FORMAT_ABGR1555";
- case DRM_FORMAT_ABGR2101010:
- return "DRM_FORMAT_ABGR2101010";
- case DRM_FORMAT_ABGR4444:
- return "DRM_FORMAT_ABGR4444";
- case DRM_FORMAT_ABGR8888:
- return "DRM_FORMAT_ABGR8888";
- case DRM_FORMAT_ARGB1555:
- return "DRM_FORMAT_ARGB1555";
- case DRM_FORMAT_ARGB2101010:
- return "DRM_FORMAT_ARGB2101010";
- case DRM_FORMAT_ARGB4444:
- return "DRM_FORMAT_ARGB4444";
- case DRM_FORMAT_ARGB8888:
- return "DRM_FORMAT_ARGB8888";
- case DRM_FORMAT_AYUV:
- return "DRM_FORMAT_AYUV";
- case DRM_FORMAT_BGR233:
- return "DRM_FORMAT_BGR233";
- case DRM_FORMAT_BGR565:
- return "DRM_FORMAT_BGR565";
- case DRM_FORMAT_BGR888:
- return "DRM_FORMAT_BGR888";
- case DRM_FORMAT_BGRA1010102:
- return "DRM_FORMAT_BGRA1010102";
- case DRM_FORMAT_BGRA4444:
- return "DRM_FORMAT_BGRA4444";
- case DRM_FORMAT_BGRA5551:
- return "DRM_FORMAT_BGRA5551";
- case DRM_FORMAT_BGRA8888:
- return "DRM_FORMAT_BGRA8888";
- case DRM_FORMAT_BGRX1010102:
- return "DRM_FORMAT_BGRX1010102";
- case DRM_FORMAT_BGRX4444:
- return "DRM_FORMAT_BGRX4444";
- case DRM_FORMAT_BGRX5551:
- return "DRM_FORMAT_BGRX5551";
- case DRM_FORMAT_BGRX8888:
- return "DRM_FORMAT_BGRX8888";
- case DRM_FORMAT_C8:
- return "DRM_FORMAT_C8";
- case DRM_FORMAT_GR88:
- return "DRM_FORMAT_GR88";
- case DRM_FORMAT_NV12:
- return "DRM_FORMAT_NV12";
- case DRM_FORMAT_NV21:
- return "DRM_FORMAT_NV21";
- case DRM_FORMAT_R8:
- return "DRM_FORMAT_R8";
- case DRM_FORMAT_RG88:
- return "DRM_FORMAT_RG88";
- case DRM_FORMAT_RGB332:
- return "DRM_FORMAT_RGB332";
- case DRM_FORMAT_RGB565:
- return "DRM_FORMAT_RGB565";
- case DRM_FORMAT_RGB888:
- return "DRM_FORMAT_RGB888";
- case DRM_FORMAT_RGBA1010102:
- return "DRM_FORMAT_RGBA1010102";
- case DRM_FORMAT_RGBA4444:
- return "DRM_FORMAT_RGBA4444";
- case DRM_FORMAT_RGBA5551:
- return "DRM_FORMAT_RGBA5551";
- case DRM_FORMAT_RGBA8888:
- return "DRM_FORMAT_RGBA8888";
- case DRM_FORMAT_RGBX1010102:
- return "DRM_FORMAT_RGBX1010102";
- case DRM_FORMAT_RGBX4444:
- return "DRM_FORMAT_RGBX4444";
- case DRM_FORMAT_RGBX5551:
- return "DRM_FORMAT_RGBX5551";
- case DRM_FORMAT_RGBX8888:
- return "DRM_FORMAT_RGBX8888";
- case DRM_FORMAT_UYVY:
- return "DRM_FORMAT_UYVY";
- case DRM_FORMAT_VYUY:
- return "DRM_FORMAT_VYUY";
- case DRM_FORMAT_XBGR1555:
- return "DRM_FORMAT_XBGR1555";
- case DRM_FORMAT_XBGR2101010:
- return "DRM_FORMAT_XBGR2101010";
- case DRM_FORMAT_XBGR4444:
- return "DRM_FORMAT_XBGR4444";
- case DRM_FORMAT_XBGR8888:
- return "DRM_FORMAT_XBGR8888";
- case DRM_FORMAT_XRGB1555:
- return "DRM_FORMAT_XRGB1555";
- case DRM_FORMAT_XRGB2101010:
- return "DRM_FORMAT_XRGB2101010";
- case DRM_FORMAT_XRGB4444:
- return "DRM_FORMAT_XRGB4444";
- case DRM_FORMAT_XRGB8888:
- return "DRM_FORMAT_XRGB8888";
- case DRM_FORMAT_YUYV:
- return "DRM_FORMAT_YUYV";
- case DRM_FORMAT_YVU420:
- return "DRM_FORMAT_YVU420";
- case DRM_FORMAT_YVYU:
- return "DRM_FORMAT_YVYU";
- }
- return "Unknown";
+ switch (drm_format) {
+ case DRM_FORMAT_ABGR1555:
+ return "DRM_FORMAT_ABGR1555";
+ case DRM_FORMAT_ABGR2101010:
+ return "DRM_FORMAT_ABGR2101010";
+ case DRM_FORMAT_ABGR4444:
+ return "DRM_FORMAT_ABGR4444";
+ case DRM_FORMAT_ABGR8888:
+ return "DRM_FORMAT_ABGR8888";
+ case DRM_FORMAT_ARGB1555:
+ return "DRM_FORMAT_ARGB1555";
+ case DRM_FORMAT_ARGB2101010:
+ return "DRM_FORMAT_ARGB2101010";
+ case DRM_FORMAT_ARGB4444:
+ return "DRM_FORMAT_ARGB4444";
+ case DRM_FORMAT_ARGB8888:
+ return "DRM_FORMAT_ARGB8888";
+ case DRM_FORMAT_AYUV:
+ return "DRM_FORMAT_AYUV";
+ case DRM_FORMAT_BGR233:
+ return "DRM_FORMAT_BGR233";
+ case DRM_FORMAT_BGR565:
+ return "DRM_FORMAT_BGR565";
+ case DRM_FORMAT_BGR888:
+ return "DRM_FORMAT_BGR888";
+ case DRM_FORMAT_BGRA1010102:
+ return "DRM_FORMAT_BGRA1010102";
+ case DRM_FORMAT_BGRA4444:
+ return "DRM_FORMAT_BGRA4444";
+ case DRM_FORMAT_BGRA5551:
+ return "DRM_FORMAT_BGRA5551";
+ case DRM_FORMAT_BGRA8888:
+ return "DRM_FORMAT_BGRA8888";
+ case DRM_FORMAT_BGRX1010102:
+ return "DRM_FORMAT_BGRX1010102";
+ case DRM_FORMAT_BGRX4444:
+ return "DRM_FORMAT_BGRX4444";
+ case DRM_FORMAT_BGRX5551:
+ return "DRM_FORMAT_BGRX5551";
+ case DRM_FORMAT_BGRX8888:
+ return "DRM_FORMAT_BGRX8888";
+ case DRM_FORMAT_C8:
+ return "DRM_FORMAT_C8";
+ case DRM_FORMAT_GR88:
+ return "DRM_FORMAT_GR88";
+ case DRM_FORMAT_NV12:
+ return "DRM_FORMAT_NV12";
+ case DRM_FORMAT_NV21:
+ return "DRM_FORMAT_NV21";
+ case DRM_FORMAT_R8:
+ return "DRM_FORMAT_R8";
+ case DRM_FORMAT_RG88:
+ return "DRM_FORMAT_RG88";
+ case DRM_FORMAT_RGB332:
+ return "DRM_FORMAT_RGB332";
+ case DRM_FORMAT_RGB565:
+ return "DRM_FORMAT_RGB565";
+ case DRM_FORMAT_RGB888:
+ return "DRM_FORMAT_RGB888";
+ case DRM_FORMAT_RGBA1010102:
+ return "DRM_FORMAT_RGBA1010102";
+ case DRM_FORMAT_RGBA4444:
+ return "DRM_FORMAT_RGBA4444";
+ case DRM_FORMAT_RGBA5551:
+ return "DRM_FORMAT_RGBA5551";
+ case DRM_FORMAT_RGBA8888:
+ return "DRM_FORMAT_RGBA8888";
+ case DRM_FORMAT_RGBX1010102:
+ return "DRM_FORMAT_RGBX1010102";
+ case DRM_FORMAT_RGBX4444:
+ return "DRM_FORMAT_RGBX4444";
+ case DRM_FORMAT_RGBX5551:
+ return "DRM_FORMAT_RGBX5551";
+ case DRM_FORMAT_RGBX8888:
+ return "DRM_FORMAT_RGBX8888";
+ case DRM_FORMAT_UYVY:
+ return "DRM_FORMAT_UYVY";
+ case DRM_FORMAT_VYUY:
+ return "DRM_FORMAT_VYUY";
+ case DRM_FORMAT_XBGR1555:
+ return "DRM_FORMAT_XBGR1555";
+ case DRM_FORMAT_XBGR2101010:
+ return "DRM_FORMAT_XBGR2101010";
+ case DRM_FORMAT_XBGR4444:
+ return "DRM_FORMAT_XBGR4444";
+ case DRM_FORMAT_XBGR8888:
+ return "DRM_FORMAT_XBGR8888";
+ case DRM_FORMAT_XRGB1555:
+ return "DRM_FORMAT_XRGB1555";
+ case DRM_FORMAT_XRGB2101010:
+ return "DRM_FORMAT_XRGB2101010";
+ case DRM_FORMAT_XRGB4444:
+ return "DRM_FORMAT_XRGB4444";
+ case DRM_FORMAT_XRGB8888:
+ return "DRM_FORMAT_XRGB8888";
+ case DRM_FORMAT_YUYV:
+ return "DRM_FORMAT_YUYV";
+ case DRM_FORMAT_YVU420:
+ return "DRM_FORMAT_YVU420";
+ case DRM_FORMAT_YVYU:
+ return "DRM_FORMAT_YVYU";
+ }
+ return "Unknown";
}
int GetDrmFormatBytesPerPixel(uint32_t drm_format) {
- switch (drm_format) {
- case DRM_FORMAT_ABGR8888:
- case DRM_FORMAT_ARGB8888:
- case DRM_FORMAT_XBGR8888:
- return 4;
- case DRM_FORMAT_BGR888:
- return 3;
- case DRM_FORMAT_RGB565:
- case DRM_FORMAT_YVU420:
+ switch (drm_format) {
+ case DRM_FORMAT_ABGR8888:
+ case DRM_FORMAT_ARGB8888:
+ case DRM_FORMAT_XBGR8888:
+ return 4;
+ case DRM_FORMAT_BGR888:
+ return 3;
+ case DRM_FORMAT_RGB565:
+ case DRM_FORMAT_YVU420:
#ifdef GRALLOC_MODULE_API_VERSION_0_2
- case DRM_FORMAT_FLEX_YCbCr_420_888:
+ case DRM_FORMAT_FLEX_YCbCr_420_888:
#endif
- return 2;
- case DRM_FORMAT_R8:
- return 1;
- }
- ALOGE("%s: format size unknown %d(%s)", __FUNCTION__, drm_format,
- GetDrmFormatString(drm_format));
- return 8;
+ return 2;
+ case DRM_FORMAT_R8:
+ return 1;
+ }
+ ALOGE("%s: format size unknown %d(%s)", __FUNCTION__, drm_format,
+ GetDrmFormatString(drm_format));
+ return 8;
}
int GetDrmFormatFromHalFormat(int hal_format) {
- switch (hal_format) {
- case HAL_PIXEL_FORMAT_RGBA_FP16:
- return DRM_FORMAT_ABGR16161616F;
- case HAL_PIXEL_FORMAT_RGBA_8888:
- return DRM_FORMAT_ABGR8888;
- case HAL_PIXEL_FORMAT_RGBX_8888:
- return DRM_FORMAT_XBGR8888;
- case HAL_PIXEL_FORMAT_BGRA_8888:
- return DRM_FORMAT_ARGB8888;
- case HAL_PIXEL_FORMAT_RGB_888:
- return DRM_FORMAT_BGR888;
- case HAL_PIXEL_FORMAT_RGB_565:
- return DRM_FORMAT_BGR565;
- case HAL_PIXEL_FORMAT_YV12:
- return DRM_FORMAT_YVU420;
- case HAL_PIXEL_FORMAT_YCbCr_420_888:
- return DRM_FORMAT_YVU420;
- case HAL_PIXEL_FORMAT_BLOB:
- return DRM_FORMAT_R8;
- default:
- break;
- }
- ALOGE("%s unhandled hal format: %d", __FUNCTION__, hal_format);
- return 0;
+ switch (hal_format) {
+ case HAL_PIXEL_FORMAT_RGBA_FP16:
+ return DRM_FORMAT_ABGR16161616F;
+ case HAL_PIXEL_FORMAT_RGBA_8888:
+ return DRM_FORMAT_ABGR8888;
+ case HAL_PIXEL_FORMAT_RGBX_8888:
+ return DRM_FORMAT_XBGR8888;
+ case HAL_PIXEL_FORMAT_BGRA_8888:
+ return DRM_FORMAT_ARGB8888;
+ case HAL_PIXEL_FORMAT_RGB_888:
+ return DRM_FORMAT_BGR888;
+ case HAL_PIXEL_FORMAT_RGB_565:
+ return DRM_FORMAT_BGR565;
+ case HAL_PIXEL_FORMAT_YV12:
+ return DRM_FORMAT_YVU420;
+ case HAL_PIXEL_FORMAT_YCbCr_420_888:
+ return DRM_FORMAT_YVU420;
+ case HAL_PIXEL_FORMAT_BLOB:
+ return DRM_FORMAT_R8;
+ default:
+ break;
+ }
+ ALOGE("%s unhandled hal format: %d", __FUNCTION__, hal_format);
+ return 0;
}
} // namespace aidl::android::hardware::graphics::composer3::impl
\ No newline at end of file
diff --git a/system/hwc3/DrmAtomicRequest.cpp b/system/hwc3/DrmAtomicRequest.cpp
new file mode 100644
index 0000000..63e5c10
--- /dev/null
+++ b/system/hwc3/DrmAtomicRequest.cpp
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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 "DrmAtomicRequest.h"
+
+namespace aidl::android::hardware::graphics::composer3::impl {
+
+std::unique_ptr<DrmAtomicRequest> DrmAtomicRequest::create() {
+ drmModeAtomicReqPtr request = drmModeAtomicAlloc();
+ if (!request) {
+ return nullptr;
+ }
+
+ return std::unique_ptr<DrmAtomicRequest>(new DrmAtomicRequest(request));
+}
+
+DrmAtomicRequest::~DrmAtomicRequest() {
+ if (mRequest) {
+ drmModeAtomicFree(mRequest);
+ }
+}
+
+bool DrmAtomicRequest::Set(uint32_t objectId, const DrmProperty& prop, uint64_t value) {
+ int ret = drmModeAtomicAddProperty(mRequest, objectId, prop.getId(), value);
+ if (ret < 0) {
+ ALOGE("%s: failed to set atomic request property %s to %" PRIu64 ": %s", __FUNCTION__,
+ prop.getName().c_str(), value, strerror(errno));
+ return false;
+ }
+ return true;
+}
+
+bool DrmAtomicRequest::Commit(::android::base::borrowed_fd drmFd) {
+ constexpr const uint32_t kCommitFlags = DRM_MODE_ATOMIC_ALLOW_MODESET;
+
+ int ret = drmModeAtomicCommit(drmFd.get(), mRequest, kCommitFlags, 0);
+ if (ret) {
+ ALOGE("%s:%d: atomic commit failed: %s\n", __FUNCTION__, __LINE__, strerror(errno));
+ return false;
+ }
+
+ return true;
+}
+
+} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/DrmAtomicRequest.h b/system/hwc3/DrmAtomicRequest.h
new file mode 100644
index 0000000..862ea2f
--- /dev/null
+++ b/system/hwc3/DrmAtomicRequest.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <android-base/logging.h>
+#include <android-base/unique_fd.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+#include "Common.h"
+#include "DrmMode.h"
+#include "DrmProperty.h"
+
+namespace aidl::android::hardware::graphics::composer3::impl {
+
+class DrmAtomicRequest {
+ public:
+ static std::unique_ptr<DrmAtomicRequest> create();
+ ~DrmAtomicRequest();
+
+ bool Set(uint32_t objectId, const DrmProperty& prop, uint64_t value);
+
+ bool Commit(::android::base::borrowed_fd drmFd);
+
+ private:
+ DrmAtomicRequest(drmModeAtomicReqPtr request) : mRequest(request) {}
+
+ drmModeAtomicReqPtr mRequest;
+};
+
+} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/DrmBuffer.cpp b/system/hwc3/DrmBuffer.cpp
new file mode 100644
index 0000000..68b5457
--- /dev/null
+++ b/system/hwc3/DrmBuffer.cpp
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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 "DrmBuffer.h"
+
+#include "DrmClient.h"
+
+namespace aidl::android::hardware::graphics::composer3::impl {
+
+DrmBuffer::DrmBuffer(DrmClient& DrmClient) : mDrmClient(DrmClient) {}
+
+DrmBuffer::~DrmBuffer() { mDrmClient.destroyDrmFramebuffer(this); }
+
+} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/DrmBuffer.h b/system/hwc3/DrmBuffer.h
new file mode 100644
index 0000000..1d5e30a
--- /dev/null
+++ b/system/hwc3/DrmBuffer.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <android-base/logging.h>
+#include <android-base/unique_fd.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <cstdint>
+#include <optional>
+#include <unordered_map>
+
+#include "Common.h"
+
+namespace aidl::android::hardware::graphics::composer3::impl {
+
+class DrmClient;
+
+// A RAII object that will clear a drm framebuffer upon destruction.
+class DrmBuffer {
+ public:
+ ~DrmBuffer();
+
+ DrmBuffer(const DrmBuffer&) = delete;
+ DrmBuffer& operator=(const DrmBuffer&) = delete;
+
+ DrmBuffer(DrmBuffer&&) = delete;
+ DrmBuffer& operator=(DrmBuffer&&) = delete;
+
+ private:
+ friend class DrmClient;
+ friend class DrmDisplay;
+ DrmBuffer(DrmClient& drmClient);
+
+ DrmClient& mDrmClient;
+
+ uint32_t mWidth = 0;
+ uint32_t mHeight = 0;
+ uint32_t mDrmFormat = 0;
+ uint32_t mPlaneFds[4] = {0, 0, 0, 0};
+ uint32_t mPlaneHandles[4] = {0, 0, 0, 0};
+ uint32_t mPlanePitches[4] = {0, 0, 0, 0};
+ uint32_t mPlaneOffsets[4] = {0, 0, 0, 0};
+ std::optional<uint32_t> mDrmFramebuffer;
+};
+
+} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/DrmClient.cpp b/system/hwc3/DrmClient.cpp
new file mode 100644
index 0000000..581544f
--- /dev/null
+++ b/system/hwc3/DrmClient.cpp
@@ -0,0 +1,310 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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 "DrmClient.h"
+
+#include <cros_gralloc_handle.h>
+
+using ::android::base::guest::AutoReadLock;
+using ::android::base::guest::AutoWriteLock;
+using ::android::base::guest::ReadWriteLock;
+
+namespace aidl::android::hardware::graphics::composer3::impl {
+
+DrmClient::~DrmClient() {
+ if (mFd > 0) {
+ drmDropMaster(mFd.get());
+ }
+}
+
+HWC3::Error DrmClient::init() {
+ DEBUG_LOG("%s", __FUNCTION__);
+
+ mFd = ::android::base::unique_fd(open("/dev/dri/card0", O_RDWR | O_CLOEXEC));
+ if (mFd < 0) {
+ ALOGE("%s: failed to open drm device: %s", __FUNCTION__, strerror(errno));
+ return HWC3::Error::NoResources;
+ }
+
+ int ret = drmSetClientCap(mFd.get(), DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
+ if (ret) {
+ ALOGE("%s: failed to set cap universal plane %s\n", __FUNCTION__, strerror(errno));
+ return HWC3::Error::NoResources;
+ }
+
+ ret = drmSetClientCap(mFd.get(), DRM_CLIENT_CAP_ATOMIC, 1);
+ if (ret) {
+ ALOGE("%s: failed to set cap atomic %s\n", __FUNCTION__, strerror(errno));
+ return HWC3::Error::NoResources;
+ }
+
+ drmSetMaster(mFd.get());
+
+ if (!drmIsMaster(mFd.get())) {
+ ALOGE("%s: failed to get master drm device", __FUNCTION__);
+ return HWC3::Error::NoResources;
+ }
+
+ {
+ AutoWriteLock lock(mDisplaysMutex);
+ bool success = loadDrmDisplays();
+ if (success) {
+ DEBUG_LOG("%s: Successfully initialized DRM backend", __FUNCTION__);
+ } else {
+ ALOGE("%s: Failed to initialize DRM backend", __FUNCTION__);
+ return HWC3::Error::NoResources;
+ }
+ }
+
+ mDrmEventListener = DrmEventListener::create(mFd, [this]() { handleHotplug(); });
+ if (!mDrmEventListener) {
+ ALOGE("%s: Failed to initialize DRM event listener", __FUNCTION__);
+ } else {
+ DEBUG_LOG("%s: Successfully initialized DRM event listener", __FUNCTION__);
+ }
+
+ DEBUG_LOG("%s: Successfully initialized.", __FUNCTION__);
+ return HWC3::Error::None;
+}
+
+HWC3::Error DrmClient::getDisplayConfigs(std::vector<DisplayConfig>* configs) const {
+ AutoReadLock lock(mDisplaysMutex);
+
+ configs->clear();
+
+ for (uint32_t i = 0; i < mDisplays.size(); i++) {
+ const auto& display = mDisplays[i];
+
+ configs->emplace_back(DisplayConfig{
+ .id = i,
+ .width = display->getWidth(),
+ .height = display->getHeight(),
+ .dpiX = 160, // static_cast<uint32_t>(connector.dpiX),
+ .dpiY = 160, // static_cast<uint32_t>(connector.dpiY),
+ .refreshRateHz = display->getRefreshRateUint(),
+ });
+ }
+
+ return HWC3::Error::None;
+}
+
+HWC3::Error DrmClient::registerOnHotplugCallback(const HotplugCallback& cb) {
+ mHotplugCallback = cb;
+ return HWC3::Error::None;
+}
+
+HWC3::Error DrmClient::unregisterOnHotplugCallback() {
+ mHotplugCallback.reset();
+ return HWC3::Error::None;
+}
+
+bool DrmClient::loadDrmDisplays() {
+ DEBUG_LOG("%s", __FUNCTION__);
+
+ std::vector<std::unique_ptr<DrmCrtc>> crtcs;
+ std::vector<std::unique_ptr<DrmConnector>> connectors;
+ std::vector<std::unique_ptr<DrmPlane>> planes;
+
+ drmModePlaneResPtr drmPlaneResources = drmModeGetPlaneResources(mFd.get());
+ for (uint32_t i = 0; i < drmPlaneResources->count_planes; ++i) {
+ const uint32_t planeId = drmPlaneResources->planes[i];
+
+ auto crtc = DrmPlane::create(mFd, planeId);
+ if (!crtc) {
+ ALOGE("%s: Failed to create DRM CRTC.", __FUNCTION__);
+ return false;
+ }
+
+ planes.emplace_back(std::move(crtc));
+ }
+ drmModeFreePlaneResources(drmPlaneResources);
+
+ drmModeRes* drmResources = drmModeGetResources(mFd.get());
+ for (uint32_t crtcIndex = 0; crtcIndex < drmResources->count_crtcs; crtcIndex++) {
+ const uint32_t crtcId = drmResources->crtcs[crtcIndex];
+
+ auto crtc = DrmCrtc::create(mFd, crtcId, crtcIndex);
+ if (!crtc) {
+ ALOGE("%s: Failed to create DRM CRTC.", __FUNCTION__);
+ return false;
+ }
+
+ crtcs.emplace_back(std::move(crtc));
+ }
+
+ for (uint32_t i = 0; i < drmResources->count_connectors; ++i) {
+ const uint32_t connectorId = drmResources->connectors[i];
+
+ auto connector = DrmConnector::create(mFd, connectorId);
+ if (!connector) {
+ ALOGE("%s: Failed to create DRM CRTC.", __FUNCTION__);
+ return false;
+ }
+
+ connectors.emplace_back(std::move(connector));
+ }
+
+ drmModeFreeResources(drmResources);
+
+ if (crtcs.size() != connectors.size()) {
+ ALOGE("%s: Failed assumption mCrtcs.size():%zu equals mConnectors.size():%zu", __FUNCTION__,
+ crtcs.size(), connectors.size());
+ return false;
+ }
+
+ for (uint32_t i = 0; i < crtcs.size(); i++) {
+ std::unique_ptr<DrmCrtc> crtc = std::move(crtcs[i]);
+ std::unique_ptr<DrmConnector> connector = std::move(connectors[i]);
+
+ auto planeIt =
+ std::find_if(planes.begin(), planes.end(), [&](const std::unique_ptr<DrmPlane>& plane) {
+ if (!plane->isOverlay() && !plane->isPrimary()) {
+ return false;
+ }
+ return plane->isCompatibleWith(*crtc);
+ });
+ if (planeIt == planes.end()) {
+ ALOGE("%s: Failed to find plane for display:%" PRIu32, __FUNCTION__, i);
+ return false;
+ }
+
+ std::unique_ptr<DrmPlane> plane = std::move(*planeIt);
+ planes.erase(planeIt);
+
+ auto display =
+ DrmDisplay::create(i, std::move(connector), std::move(crtc), std::move(plane), mFd);
+ if (!display) {
+ return false;
+ }
+ mDisplays.push_back(std::move(display));
+ }
+
+ return true;
+}
+
+std::tuple<HWC3::Error, std::shared_ptr<DrmBuffer>> DrmClient::create(
+ const native_handle_t* handle) {
+ cros_gralloc_handle* crosHandle = (cros_gralloc_handle*)handle;
+ if (crosHandle == nullptr) {
+ ALOGE("%s: invalid cros_gralloc_handle", __FUNCTION__);
+ return std::make_tuple(HWC3::Error::NoResources, nullptr);
+ }
+
+ DrmPrimeBufferHandle primeHandle = 0;
+ int ret = drmPrimeFDToHandle(mFd.get(), crosHandle->fds[0], &primeHandle);
+ if (ret) {
+ ALOGE("%s: drmPrimeFDToHandle failed: %s (errno %d)", __FUNCTION__, strerror(errno), errno);
+ return std::make_tuple(HWC3::Error::NoResources, nullptr);
+ }
+
+ auto buffer = std::shared_ptr<DrmBuffer>(new DrmBuffer(*this));
+ buffer->mWidth = crosHandle->width;
+ buffer->mHeight = crosHandle->height;
+ buffer->mDrmFormat = crosHandle->format;
+ buffer->mPlaneFds[0] = crosHandle->fds[0];
+ buffer->mPlaneHandles[0] = primeHandle;
+ buffer->mPlanePitches[0] = crosHandle->strides[0];
+ buffer->mPlaneOffsets[0] = crosHandle->offsets[0];
+
+ uint32_t framebuffer = 0;
+ ret = drmModeAddFB2(mFd.get(), buffer->mWidth, buffer->mHeight, buffer->mDrmFormat,
+ buffer->mPlaneHandles, buffer->mPlanePitches, buffer->mPlaneOffsets,
+ &framebuffer, 0);
+ if (ret) {
+ ALOGE("%s: drmModeAddFB2 failed: %s (errno %d)", __FUNCTION__, strerror(errno), errno);
+ return std::make_tuple(HWC3::Error::NoResources, nullptr);
+ }
+ DEBUG_LOG("%s: created framebuffer:%" PRIu32, __FUNCTION__, framebuffer);
+ buffer->mDrmFramebuffer = framebuffer;
+
+ return std::make_tuple(HWC3::Error::None, std::shared_ptr<DrmBuffer>(buffer));
+}
+
+HWC3::Error DrmClient::destroyDrmFramebuffer(DrmBuffer* buffer) {
+ if (buffer->mDrmFramebuffer) {
+ uint32_t framebuffer = *buffer->mDrmFramebuffer;
+ if (drmModeRmFB(mFd.get(), framebuffer)) {
+ ALOGE("%s: drmModeRmFB failed: %s (errno %d)", __FUNCTION__, strerror(errno), errno);
+ return HWC3::Error::NoResources;
+ }
+ DEBUG_LOG("%s: destroyed framebuffer:%" PRIu32, __FUNCTION__, framebuffer);
+ buffer->mDrmFramebuffer.reset();
+ }
+ if (buffer->mPlaneHandles[0]) {
+ struct drm_gem_close gem_close = {};
+ gem_close.handle = buffer->mPlaneHandles[0];
+ if (drmIoctl(mFd.get(), DRM_IOCTL_GEM_CLOSE, &gem_close)) {
+ ALOGE("%s: DRM_IOCTL_GEM_CLOSE failed: %s (errno %d)", __FUNCTION__, strerror(errno),
+ errno);
+ return HWC3::Error::NoResources;
+ }
+ }
+
+ return HWC3::Error::None;
+}
+
+bool DrmClient::handleHotplug() {
+ DEBUG_LOG("%s", __FUNCTION__);
+
+ AutoWriteLock lock(mDisplaysMutex);
+
+ for (auto& display : mDisplays) {
+ auto change = display->checkAndHandleHotplug(mFd);
+ if (change == DrmHotplugChange::kNoChange) {
+ continue;
+ }
+
+ if (mHotplugCallback) {
+ const bool connected = (change == DrmHotplugChange::kConnected);
+ (*mHotplugCallback)(connected, //
+ display->getId(), //
+ display->getWidth(), //
+ display->getHeight(), //
+ display->getDpiX(), //
+ display->getDpiY(), //
+ display->getRefreshRateUint());
+ }
+ }
+
+ return true;
+}
+
+std::tuple<HWC3::Error, ::android::base::unique_fd> DrmClient::flushToDisplay(
+ int displayId, const std::shared_ptr<DrmBuffer>& buffer,
+ ::android::base::borrowed_fd inSyncFd) {
+ ATRACE_CALL();
+
+ if (!buffer->mDrmFramebuffer) {
+ ALOGE("%s: failed, no framebuffer created.", __FUNCTION__);
+ return std::make_tuple(HWC3::Error::NoResources, ::android::base::unique_fd());
+ }
+
+ AutoReadLock lock(mDisplaysMutex);
+ return mDisplays[displayId]->flush(mFd, inSyncFd, buffer);
+}
+
+std::optional<std::vector<uint8_t>> DrmClient::getEdid(uint32_t displayId) {
+ AutoReadLock lock(mDisplaysMutex);
+
+ if (displayId >= mDisplays.size()) {
+ DEBUG_LOG("%s: invalid display:%" PRIu32, __FUNCTION__, displayId);
+ return std::nullopt;
+ }
+
+ return mDisplays[displayId]->getEdid(mFd);
+}
+
+} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/DrmClient.h b/system/hwc3/DrmClient.h
new file mode 100644
index 0000000..0f0dafd
--- /dev/null
+++ b/system/hwc3/DrmClient.h
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <android-base/unique_fd.h>
+#include <cutils/native_handle.h>
+
+#include <memory>
+#include <tuple>
+#include <vector>
+
+#include "Common.h"
+#include "DrmAtomicRequest.h"
+#include "DrmBuffer.h"
+#include "DrmConnector.h"
+#include "DrmCrtc.h"
+#include "DrmDisplay.h"
+#include "DrmEventListener.h"
+#include "DrmMode.h"
+#include "DrmPlane.h"
+#include "DrmProperty.h"
+#include "LruCache.h"
+#include "android/base/synchronization/AndroidLock.h"
+
+namespace aidl::android::hardware::graphics::composer3::impl {
+
+class DrmClient {
+ public:
+ DrmClient() = default;
+ ~DrmClient();
+
+ DrmClient(const DrmClient&) = delete;
+ DrmClient& operator=(const DrmClient&) = delete;
+
+ DrmClient(DrmClient&&) = delete;
+ DrmClient& operator=(DrmClient&&) = delete;
+
+ HWC3::Error init();
+
+ struct DisplayConfig {
+ uint32_t id;
+ uint32_t width;
+ uint32_t height;
+ uint32_t dpiX;
+ uint32_t dpiY;
+ uint32_t refreshRateHz;
+ };
+
+ HWC3::Error getDisplayConfigs(std::vector<DisplayConfig>* configs) const;
+
+ using HotplugCallback = std::function<void(bool /*connected*/, //
+ uint32_t /*id*/, //
+ uint32_t /*width*/, //
+ uint32_t /*height*/, //
+ uint32_t /*dpiX*/, //
+ uint32_t /*dpiY*/, //
+ uint32_t /*refreshRate*/)>;
+
+ HWC3::Error registerOnHotplugCallback(const HotplugCallback& cb);
+ HWC3::Error unregisterOnHotplugCallback();
+
+ uint32_t refreshRate() const { return mDisplays[0]->getRefreshRateUint(); }
+
+ std::tuple<HWC3::Error, std::shared_ptr<DrmBuffer>> create(const native_handle_t* handle);
+
+ std::tuple<HWC3::Error, ::android::base::unique_fd> flushToDisplay(
+ int display, const std::shared_ptr<DrmBuffer>& buffer,
+ ::android::base::borrowed_fd inWaitSyncFd);
+
+ std::optional<std::vector<uint8_t>> getEdid(uint32_t id);
+
+ private:
+ using DrmPrimeBufferHandle = uint32_t;
+
+ // Grant visibility to destroyDrmFramebuffer to DrmBuffer.
+ friend class DrmBuffer;
+ HWC3::Error destroyDrmFramebuffer(DrmBuffer* buffer);
+
+ // Grant visibility for handleHotplug to DrmEventListener.
+ bool handleHotplug();
+
+ bool loadDrmDisplays();
+
+ // Drm device.
+ ::android::base::unique_fd mFd;
+
+ mutable ::android::base::guest::ReadWriteLock mDisplaysMutex;
+ std::vector<std::unique_ptr<DrmDisplay>> mDisplays;
+
+ std::optional<HotplugCallback> mHotplugCallback;
+
+ std::unique_ptr<DrmEventListener> mDrmEventListener;
+};
+
+} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/DrmConnector.cpp b/system/hwc3/DrmConnector.cpp
new file mode 100644
index 0000000..2481beb
--- /dev/null
+++ b/system/hwc3/DrmConnector.cpp
@@ -0,0 +1,122 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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 "DrmConnector.h"
+
+namespace aidl::android::hardware::graphics::composer3::impl {
+namespace {
+
+static constexpr const int32_t kUmPerInch = 25400;
+
+} // namespace
+
+std::unique_ptr<DrmConnector> DrmConnector::create(::android::base::borrowed_fd drmFd,
+ uint32_t connectorId) {
+ std::unique_ptr<DrmConnector> connector(new DrmConnector(connectorId));
+
+ if (!LoadDrmProperties(drmFd, connectorId, DRM_MODE_OBJECT_CONNECTOR, GetPropertiesMap(),
+ connector.get())) {
+ ALOGE("%s: Failed to load connector properties.", __FUNCTION__);
+ return nullptr;
+ }
+
+ if (!connector->update(drmFd)) {
+ return nullptr;
+ }
+
+ return connector;
+}
+
+bool DrmConnector::update(::android::base::borrowed_fd drmFd) {
+ DEBUG_LOG("%s: Loading properties for connector:%" PRIu32, __FUNCTION__, mId);
+
+ drmModeConnector* drmConnector = drmModeGetConnector(drmFd.get(), mId);
+ if (!drmConnector) {
+ ALOGE("%s: Failed to load connector.", __FUNCTION__);
+ return false;
+ }
+
+ mStatus = drmConnector->connection;
+
+ mModes.clear();
+ for (uint32_t i = 0; i < drmConnector->count_modes; i++) {
+ auto mode = DrmMode::create(drmFd, drmConnector->modes[i]);
+ if (!mode) {
+ ALOGE("%s: Failed to create mode for connector.", __FUNCTION__);
+ return false;
+ }
+
+ mModes.push_back(std::move(mode));
+ }
+
+ mWidthMillimeters = drmConnector->mmWidth;
+ mHeightMillimeters = drmConnector->mmHeight;
+
+ drmModeFreeConnector(drmConnector);
+
+ return true;
+}
+
+uint32_t DrmConnector::getWidth() const {
+ if (mModes.empty()) {
+ return 0;
+ }
+ return mModes[0]->hdisplay;
+}
+
+uint32_t DrmConnector::getHeight() const {
+ if (mModes.empty()) {
+ return 0;
+ }
+ return mModes[0]->vdisplay;
+}
+
+int32_t DrmConnector::getDpiX() const {
+ if (mModes.empty()) {
+ return -1;
+ }
+
+ const auto& mode = mModes[0];
+ if (mWidthMillimeters) {
+ return (mode->hdisplay * kUmPerInch) / mWidthMillimeters;
+ }
+
+ return -1;
+}
+
+int32_t DrmConnector::getDpiY() const {
+ if (mModes.empty()) {
+ return -1;
+ }
+
+ const auto& mode = mModes[0];
+ if (mHeightMillimeters) {
+ return (mode->hdisplay * kUmPerInch) / mHeightMillimeters;
+ }
+
+ return -1;
+}
+
+float DrmConnector::getRefreshRate() const {
+ if (!mModes.empty()) {
+ const auto& mode = mModes[0];
+ return 1000.0f * mode->clock / ((float)mode->vtotal * (float)mode->htotal);
+ }
+
+ return -1.0f;
+}
+
+} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/DrmConnector.h b/system/hwc3/DrmConnector.h
new file mode 100644
index 0000000..58087b5
--- /dev/null
+++ b/system/hwc3/DrmConnector.h
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <android-base/logging.h>
+#include <android-base/unique_fd.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+#include "Common.h"
+#include "DrmMode.h"
+#include "DrmProperty.h"
+
+namespace aidl::android::hardware::graphics::composer3::impl {
+
+// A "cable" to the display (HDMI, DisplayPort, etc).
+class DrmConnector {
+ public:
+ static std::unique_ptr<DrmConnector> create(::android::base::borrowed_fd drmFd,
+ uint32_t connectorId);
+ ~DrmConnector(){};
+
+ uint32_t getId() const { return mId; }
+
+ uint32_t getWidth() const;
+ uint32_t getHeight() const;
+
+ int32_t getDpiX() const;
+ int32_t getDpiY() const;
+
+ float getRefreshRate() const;
+ uint32_t getRefreshRateUint() const { return (uint32_t)(getRefreshRate() + 0.5f); }
+
+ bool isConnected() const { return mStatus == DRM_MODE_CONNECTED; }
+
+ const DrmProperty& getCrtcProperty() const { return mCrtc; }
+ const DrmProperty& getEdidProperty() const { return mEdid; }
+ const DrmMode* getDefaultMode() const { return mModes[0].get(); }
+
+ bool update(::android::base::borrowed_fd drmFd);
+
+ private:
+ DrmConnector(uint32_t id) : mId(id) {}
+
+ const uint32_t mId;
+
+ drmModeConnection mStatus = DRM_MODE_UNKNOWNCONNECTION;
+ uint32_t mWidthMillimeters = -1;
+ uint32_t mHeightMillimeters = -1;
+ std::vector<std::unique_ptr<DrmMode>> mModes;
+
+ DrmProperty mCrtc;
+ DrmProperty mEdid;
+
+ static const auto& GetPropertiesMap() {
+ static const auto* sMap = []() {
+ return new DrmPropertyMemberMap<DrmConnector>{
+ {"CRTC_ID", &DrmConnector::mCrtc},
+ {"EDID", &DrmConnector::mEdid},
+ };
+ }();
+ return *sMap;
+ }
+};
+
+} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/DrmCrtc.cpp b/system/hwc3/DrmCrtc.cpp
new file mode 100644
index 0000000..4648a9f
--- /dev/null
+++ b/system/hwc3/DrmCrtc.cpp
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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 "DrmCrtc.h"
+
+namespace aidl::android::hardware::graphics::composer3::impl {
+
+std::unique_ptr<DrmCrtc> DrmCrtc::create(::android::base::borrowed_fd drmFd, uint32_t crtcId,
+ uint32_t crtcIndexInResourcesArray) {
+ std::unique_ptr<DrmCrtc> crtc(new DrmCrtc(crtcId, crtcIndexInResourcesArray));
+
+ DEBUG_LOG("%s: Loading properties for crtc:%" PRIu32, __FUNCTION__, crtcId);
+ if (!LoadDrmProperties(drmFd, crtcId, DRM_MODE_OBJECT_CRTC, GetPropertiesMap(), crtc.get())) {
+ ALOGE("%s: Failed to load crtc properties.", __FUNCTION__);
+ return nullptr;
+ }
+
+ return crtc;
+}
+
+} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/DrmCrtc.h b/system/hwc3/DrmCrtc.h
new file mode 100644
index 0000000..947ff51
--- /dev/null
+++ b/system/hwc3/DrmCrtc.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <android-base/logging.h>
+#include <android-base/unique_fd.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+#include "Common.h"
+#include "DrmProperty.h"
+
+namespace aidl::android::hardware::graphics::composer3::impl {
+
+class DrmCrtc {
+ public:
+ static std::unique_ptr<DrmCrtc> create(::android::base::borrowed_fd drmFd, uint32_t crtcId,
+ uint32_t crtcIndexInResourcesArray);
+ ~DrmCrtc() {}
+
+ uint32_t getId() const { return mId; }
+
+ const DrmProperty& getActiveProperty() const { return mActive; }
+ const DrmProperty& getModeProperty() const { return mMode; }
+ const DrmProperty& getOutFenceProperty() const { return mOutFence; }
+
+ private:
+ DrmCrtc(uint32_t id, uint32_t index) : mId(id), mIndexInResourcesArray(index) {}
+
+ friend class DrmPlane;
+
+ const uint32_t mId = -1;
+ const uint32_t mIndexInResourcesArray = -1;
+
+ DrmProperty mActive;
+ DrmProperty mMode;
+ DrmProperty mOutFence;
+
+ static const auto& GetPropertiesMap() {
+ static const auto* sMap = []() {
+ return new DrmPropertyMemberMap<DrmCrtc>{
+ {"ACTIVE", &DrmCrtc::mActive},
+ {"MODE_ID", &DrmCrtc::mMode},
+ {"OUT_FENCE_PTR", &DrmCrtc::mOutFence},
+ };
+ }();
+ return *sMap;
+ }
+};
+
+} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/DrmDisplay.cpp b/system/hwc3/DrmDisplay.cpp
new file mode 100644
index 0000000..ac9dc21
--- /dev/null
+++ b/system/hwc3/DrmDisplay.cpp
@@ -0,0 +1,214 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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 "DrmDisplay.h"
+
+#include "DrmAtomicRequest.h"
+
+namespace aidl::android::hardware::graphics::composer3::impl {
+namespace {
+
+template <typename T>
+uint64_t addressAsUint(T* pointer) {
+ return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(pointer));
+}
+
+} // namespace
+
+std::unique_ptr<DrmDisplay> DrmDisplay::create(uint32_t id, std::unique_ptr<DrmConnector> connector,
+ std::unique_ptr<DrmCrtc> crtc,
+ std::unique_ptr<DrmPlane> plane,
+ ::android::base::borrowed_fd drmFd) {
+ if (!crtc) {
+ ALOGE("%s: invalid crtc.", __FUNCTION__);
+ return nullptr;
+ }
+ if (!connector) {
+ ALOGE("%s: invalid connector.", __FUNCTION__);
+ return nullptr;
+ }
+ if (!plane) {
+ ALOGE("%s: invalid plane.", __FUNCTION__);
+ return nullptr;
+ }
+
+ if (connector->isConnected()) {
+ auto request = DrmAtomicRequest::create();
+ if (!request) {
+ ALOGE("%s: failed to create atomic request.", __FUNCTION__);
+ return nullptr;
+ }
+
+ bool okay = true;
+ okay &= request->Set(connector->getId(), connector->getCrtcProperty(), crtc->getId());
+ okay &= request->Set(crtc->getId(), crtc->getActiveProperty(), 1);
+ okay &= request->Set(crtc->getId(), crtc->getModeProperty(),
+ connector->getDefaultMode()->getBlobId());
+ okay &= request->Commit(drmFd);
+ if (!okay) {
+ ALOGE("%s: failed to set display mode.", __FUNCTION__);
+ return nullptr;
+ }
+ }
+
+ return std::unique_ptr<DrmDisplay>(
+ new DrmDisplay(id, std::move(connector), std::move(crtc), std::move(plane)));
+}
+
+std::optional<std::vector<uint8_t>> DrmDisplay::getEdid(::android::base::borrowed_fd drmFd) const {
+ DEBUG_LOG("%s: display:%" PRIu32, __FUNCTION__, mId);
+
+ if (!mConnector) {
+ ALOGE("%s: display:%" PRIu32 " is missing connector.", __FUNCTION__, mId);
+ return std::nullopt;
+ }
+
+ const DrmProperty& edidProp = mConnector->getEdidProperty();
+ if (edidProp.getId() == -1) {
+ ALOGW("%s: display:%" PRIu32 " does not have EDID.", __FUNCTION__, mId);
+ return std::nullopt;
+ }
+
+ const uint64_t edidBlobId = edidProp.getValue();
+
+ auto blob = drmModeGetPropertyBlob(drmFd.get(), edidBlobId);
+ if (!blob) {
+ ALOGE("%s: display:%" PRIu32 " failed to read EDID blob (%" PRIu64 "): %s", __FUNCTION__,
+ mId, edidBlobId, strerror(errno));
+ return std::nullopt;
+ }
+
+ std::vector<uint8_t> edid;
+ uint8_t* start = static_cast<uint8_t*>(blob->data);
+ edid.insert(edid.begin(), start, start + blob->length);
+
+ drmModeFreePropertyBlob(blob);
+
+ return edid;
+}
+
+std::tuple<HWC3::Error, ::android::base::unique_fd> DrmDisplay::flush(
+ ::android::base::borrowed_fd drmFd, ::android::base::borrowed_fd inSyncFd,
+ const std::shared_ptr<DrmBuffer>& buffer) {
+ std::unique_ptr<DrmAtomicRequest> request = DrmAtomicRequest::create();
+ if (!request) {
+ ALOGE("%s: failed to create atomic request.", __FUNCTION__);
+ return std::make_tuple(HWC3::Error::NoResources, ::android::base::unique_fd());
+ }
+
+ int flushFenceFd = -1;
+
+ bool okay = true;
+ okay &=
+ request->Set(mCrtc->getId(), mCrtc->getOutFenceProperty(), addressAsUint(&flushFenceFd));
+ okay &= request->Set(mPlane->getId(), mPlane->getCrtcProperty(), mCrtc->getId());
+ okay &= request->Set(mPlane->getId(), mPlane->getInFenceProperty(), inSyncFd.get());
+ okay &= request->Set(mPlane->getId(), mPlane->getFbProperty(), *buffer->mDrmFramebuffer);
+ okay &= request->Set(mPlane->getId(), mPlane->getCrtcXProperty(), 0);
+ okay &= request->Set(mPlane->getId(), mPlane->getCrtcYProperty(), 0);
+ okay &= request->Set(mPlane->getId(), mPlane->getCrtcWProperty(), buffer->mWidth);
+ okay &= request->Set(mPlane->getId(), mPlane->getCrtcHProperty(), buffer->mHeight);
+ okay &= request->Set(mPlane->getId(), mPlane->getSrcXProperty(), 0);
+ okay &= request->Set(mPlane->getId(), mPlane->getSrcYProperty(), 0);
+ okay &= request->Set(mPlane->getId(), mPlane->getSrcWProperty(), buffer->mWidth << 16);
+ okay &= request->Set(mPlane->getId(), mPlane->getSrcHProperty(), buffer->mHeight << 16);
+
+ okay &= request->Commit(drmFd);
+ if (!okay) {
+ ALOGE("%s: failed to flush to display.", __FUNCTION__);
+ return std::make_tuple(HWC3::Error::NoResources, ::android::base::unique_fd());
+ }
+
+ mPreviousBuffer = buffer;
+
+ DEBUG_LOG("%s: submitted atomic update, flush fence:%d\n", __FUNCTION__, flushFenceFd);
+ return std::make_tuple(HWC3::Error::None, ::android::base::unique_fd(flushFenceFd));
+}
+
+bool DrmDisplay::onConnect(::android::base::borrowed_fd drmFd) {
+ DEBUG_LOG("%s: display:%" PRIu32, __FUNCTION__, mId);
+
+ auto request = DrmAtomicRequest::create();
+ if (!request) {
+ ALOGE("%s: display:%" PRIu32 " failed to create atomic request.", __FUNCTION__, mId);
+ return false;
+ }
+
+ bool okay = true;
+ okay &= request->Set(mConnector->getId(), mConnector->getCrtcProperty(), mCrtc->getId());
+ okay &= request->Set(mCrtc->getId(), mCrtc->getActiveProperty(), 1);
+ okay &= request->Set(mCrtc->getId(), mCrtc->getModeProperty(),
+ mConnector->getDefaultMode()->getBlobId());
+
+ okay &= request->Commit(drmFd);
+ if (!okay) {
+ ALOGE("%s: display:%" PRIu32 " failed to set mode.", __FUNCTION__, mId);
+ return false;
+ }
+
+ return true;
+}
+
+bool DrmDisplay::onDisconnect(::android::base::borrowed_fd drmFd) {
+ DEBUG_LOG("%s: display:%" PRIu32, __FUNCTION__, mId);
+
+ auto request = DrmAtomicRequest::create();
+ if (!request) {
+ ALOGE("%s: display:%" PRIu32 " failed to create atomic request.", __FUNCTION__, mId);
+ return false;
+ }
+
+ bool okay = true;
+ okay &= request->Set(mPlane->getId(), mPlane->getCrtcProperty(), 0);
+ okay &= request->Set(mPlane->getId(), mPlane->getFbProperty(), 0);
+
+ okay &= request->Commit(drmFd);
+ if (!okay) {
+ ALOGE("%s: display:%" PRIu32 " failed to set mode", __FUNCTION__, mId);
+ }
+
+ mPreviousBuffer.reset();
+
+ return okay;
+}
+
+DrmHotplugChange DrmDisplay::checkAndHandleHotplug(::android::base::borrowed_fd drmFd) {
+ DEBUG_LOG("%s: display:%" PRIu32, __FUNCTION__, mId);
+
+ const bool oldConnected = mConnector->isConnected();
+ mConnector->update(drmFd);
+ const bool newConnected = mConnector->isConnected();
+
+ if (oldConnected == newConnected) {
+ return DrmHotplugChange::kNoChange;
+ }
+
+ if (newConnected) {
+ ALOGI("%s: display:%" PRIu32 " was connected.", __FUNCTION__, mId);
+ if (!onConnect(drmFd)) {
+ ALOGE("%s: display:%" PRIu32 " failed to connect.", __FUNCTION__, mId);
+ }
+ return DrmHotplugChange::kConnected;
+ } else {
+ ALOGI("%s: display:%" PRIu32 " was disconnected.", __FUNCTION__, mId);
+ if (!onDisconnect(drmFd)) {
+ ALOGE("%s: display:%" PRIu32 " failed to disconnect.", __FUNCTION__, mId);
+ }
+ return DrmHotplugChange::kDisconnected;
+ }
+}
+
+} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/DrmDisplay.h b/system/hwc3/DrmDisplay.h
new file mode 100644
index 0000000..af3e977
--- /dev/null
+++ b/system/hwc3/DrmDisplay.h
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <android-base/logging.h>
+#include <android-base/unique_fd.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+#include "Common.h"
+#include "DrmBuffer.h"
+#include "DrmConnector.h"
+#include "DrmCrtc.h"
+#include "DrmPlane.h"
+
+namespace aidl::android::hardware::graphics::composer3::impl {
+
+enum class DrmHotplugChange {
+ kNoChange,
+ kConnected,
+ kDisconnected,
+};
+
+class DrmDisplay {
+ public:
+ static std::unique_ptr<DrmDisplay> create(uint32_t id, std::unique_ptr<DrmConnector> connector,
+ std::unique_ptr<DrmCrtc> crtc,
+ std::unique_ptr<DrmPlane> plane,
+ ::android::base::borrowed_fd drmFd);
+
+ uint32_t getId() const { return mId; }
+
+ uint32_t getWidth() const { return mConnector->getWidth(); }
+ uint32_t getHeight() const { return mConnector->getHeight(); }
+
+ uint32_t getDpiX() const { return mConnector->getDpiX(); }
+ uint32_t getDpiY() const { return mConnector->getDpiY(); }
+
+ uint32_t getRefreshRateUint() const { return mConnector->getRefreshRateUint(); }
+
+ std::optional<std::vector<uint8_t>> getEdid(::android::base::borrowed_fd drmFd) const;
+
+ std::tuple<HWC3::Error, ::android::base::unique_fd> flush(
+ ::android::base::borrowed_fd drmFd, ::android::base::borrowed_fd inWaitSyncFd,
+ const std::shared_ptr<DrmBuffer>& buffer);
+
+ DrmHotplugChange checkAndHandleHotplug(::android::base::borrowed_fd drmFd);
+
+ private:
+ DrmDisplay(uint32_t id, std::unique_ptr<DrmConnector> connector, std::unique_ptr<DrmCrtc> crtc,
+ std::unique_ptr<DrmPlane> plane)
+ : mId(id),
+ mConnector(std::move(connector)),
+ mCrtc(std::move(crtc)),
+ mPlane(std::move(plane)) {}
+
+ bool onConnect(::android::base::borrowed_fd drmFd);
+
+ bool onDisconnect(::android::base::borrowed_fd drmFd);
+
+ const uint32_t mId;
+ std::unique_ptr<DrmConnector> mConnector;
+ std::unique_ptr<DrmCrtc> mCrtc;
+ std::unique_ptr<DrmPlane> mPlane;
+
+ // The last presented buffer / DRM framebuffer is cached until
+ // the next present to avoid toggling the display on and off.
+ std::shared_ptr<DrmBuffer> mPreviousBuffer;
+};
+
+} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/DrmEventListener.cpp b/system/hwc3/DrmEventListener.cpp
new file mode 100644
index 0000000..208824b
--- /dev/null
+++ b/system/hwc3/DrmEventListener.cpp
@@ -0,0 +1,103 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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 "DrmEventListener.h"
+
+#include <linux/netlink.h>
+#include <sys/socket.h>
+
+namespace aidl::android::hardware::graphics::composer3::impl {
+
+std::unique_ptr<DrmEventListener> DrmEventListener::create(::android::base::borrowed_fd drmFd,
+ std::function<void()> callback) {
+ std::unique_ptr<DrmEventListener> listener(new DrmEventListener(std::move(callback)));
+
+ if (!listener->init(drmFd)) {
+ return nullptr;
+ }
+
+ return listener;
+}
+
+bool DrmEventListener::init(::android::base::borrowed_fd drmFd) {
+ mEventFd = ::android::base::unique_fd(socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT));
+ if (!mEventFd.ok()) {
+ ALOGE("Failed to open uevent socket: %s", strerror(errno));
+ return false;
+ }
+ struct sockaddr_nl addr;
+ memset(&addr, 0, sizeof(addr));
+ addr.nl_family = AF_NETLINK;
+ addr.nl_pid = 0;
+ addr.nl_groups = 0xFFFFFFFF;
+
+ int ret = bind(mEventFd, (struct sockaddr*)&addr, sizeof(addr));
+ if (ret) {
+ ALOGE("Failed to bind uevent socket: %s", strerror(errno));
+ return false;
+ }
+
+ FD_ZERO(&mMonitoredFds);
+ FD_SET(drmFd.get(), &mMonitoredFds);
+ FD_SET(mEventFd.get(), &mMonitoredFds);
+ mMaxMonitoredFd = std::max(drmFd.get(), mEventFd.get());
+
+ mThread = std::thread([this]() { threadLoop(); });
+
+ return true;
+}
+
+void DrmEventListener::threadLoop() {
+ int ret;
+ do {
+ ret = select(mMaxMonitoredFd + 1, &mMonitoredFds, NULL, NULL, NULL);
+ } while (ret == -1 && errno == EINTR);
+
+ if (!FD_ISSET(mEventFd.get(), &mMonitoredFds)) {
+ ALOGE("%s: DrmEventListevener event fd unset?", __FUNCTION__);
+ return;
+ }
+
+ char buffer[1024];
+ while (true) {
+ ret = read(mEventFd.get(), &buffer, sizeof(buffer));
+ if (ret == 0) {
+ return;
+ } else if (ret < 0) {
+ ALOGE("Got error reading uevent %d", ret);
+ return;
+ }
+
+ bool drmEvent = false, hotplugEvent = false;
+ for (int i = 0; i < ret;) {
+ char* event = buffer + i;
+ if (strcmp(event, "DEVTYPE=drm_minor")) {
+ drmEvent = true;
+ } else if (strcmp(event, "HOTPLUG=1")) {
+ hotplugEvent = true;
+ }
+
+ i += strlen(event) + 1;
+ }
+
+ if (drmEvent && hotplugEvent) {
+ DEBUG_LOG("DrmEventListener detected hotplug event .");
+ mOnEventCallback();
+ }
+ }
+}
+
+} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/DrmEventListener.h b/system/hwc3/DrmEventListener.h
new file mode 100644
index 0000000..4ab29b6
--- /dev/null
+++ b/system/hwc3/DrmEventListener.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <android-base/logging.h>
+#include <android-base/unique_fd.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <cstdint>
+#include <functional>
+#include <optional>
+#include <thread>
+#include <unordered_map>
+
+#include "Common.h"
+
+namespace aidl::android::hardware::graphics::composer3::impl {
+
+class DrmEventListener {
+ public:
+ static std::unique_ptr<DrmEventListener> create(::android::base::borrowed_fd drmFd,
+ std::function<void()> callback);
+
+ ~DrmEventListener() {}
+
+ private:
+ DrmEventListener(std::function<void()> callback) : mOnEventCallback(std::move(callback)) {}
+
+ bool init(::android::base::borrowed_fd drmFd);
+
+ void threadLoop();
+
+ std::thread mThread;
+ std::function<void()> mOnEventCallback;
+ ::android::base::unique_fd mEventFd;
+ fd_set mMonitoredFds;
+ int mMaxMonitoredFd = 0;
+};
+
+} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/DrmMode.cpp b/system/hwc3/DrmMode.cpp
new file mode 100644
index 0000000..d65f0cc
--- /dev/null
+++ b/system/hwc3/DrmMode.cpp
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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 "DrmMode.h"
+
+namespace aidl::android::hardware::graphics::composer3::impl {
+
+std::unique_ptr<DrmMode> DrmMode::create(::android::base::borrowed_fd drmFd,
+ const drmModeModeInfo& info) {
+ uint32_t blobId = 0;
+
+ int ret = drmModeCreatePropertyBlob(drmFd.get(), &info, sizeof(info), &blobId);
+ if (ret != 0) {
+ ALOGE("%s: Failed to create mode blob: %s.", __FUNCTION__, strerror(errno));
+ return nullptr;
+ }
+
+ return std::unique_ptr<DrmMode>(new DrmMode(info, blobId));
+}
+
+DrmMode::~DrmMode() {
+ // TODO: don't leak the blob.
+}
+
+} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/DrmMode.h b/system/hwc3/DrmMode.h
new file mode 100644
index 0000000..23b170d
--- /dev/null
+++ b/system/hwc3/DrmMode.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <android-base/logging.h>
+#include <android-base/unique_fd.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <cstdint>
+#include <memory>
+
+#include "Common.h"
+
+namespace aidl::android::hardware::graphics::composer3::impl {
+
+class DrmMode {
+ public:
+ static std::unique_ptr<DrmMode> create(::android::base::borrowed_fd drmFd,
+ const drmModeModeInfo& info);
+
+ ~DrmMode();
+
+ const uint32_t clock;
+ const uint16_t hdisplay;
+ const uint16_t hsync_start;
+ const uint16_t hsync_end;
+ const uint16_t htotal;
+ const uint16_t hskew;
+ const uint16_t vdisplay;
+ const uint16_t vsync_start;
+ const uint16_t vsync_end;
+ const uint16_t vtotal;
+ const uint16_t vscan;
+ const uint32_t vrefresh;
+ const uint32_t flags;
+ const uint32_t type;
+ const std::string name;
+
+ uint32_t getBlobId() const { return mBlobId; }
+
+ private:
+ DrmMode(const drmModeModeInfo& info, uint32_t blobId)
+ : clock(info.clock),
+ hdisplay(info.hdisplay),
+ hsync_start(info.hsync_start),
+ hsync_end(info.hsync_end),
+ htotal(info.htotal),
+ hskew(info.hskew),
+ vdisplay(info.vdisplay),
+ vsync_start(info.vsync_start),
+ vsync_end(info.vsync_end),
+ vtotal(info.vtotal),
+ vscan(info.vscan),
+ vrefresh(info.vrefresh),
+ flags(info.flags),
+ type(info.type),
+ name(info.name),
+ mBlobId(blobId) {}
+
+ const uint32_t mBlobId;
+};
+
+} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/DrmPlane.cpp b/system/hwc3/DrmPlane.cpp
new file mode 100644
index 0000000..f2027ee
--- /dev/null
+++ b/system/hwc3/DrmPlane.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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 "DrmPlane.h"
+
+namespace aidl::android::hardware::graphics::composer3::impl {
+
+std::unique_ptr<DrmPlane> DrmPlane::create(::android::base::borrowed_fd drmFd, uint32_t planeId) {
+ std::unique_ptr<DrmPlane> plane(new DrmPlane(planeId));
+
+ DEBUG_LOG("%s: Loading properties for DRM plane:%" PRIu32, __FUNCTION__, planeId);
+ if (!LoadDrmProperties(drmFd, planeId, DRM_MODE_OBJECT_PLANE, GetPropertiesMap(),
+ plane.get())) {
+ ALOGE("%s: Failed to load plane properties.", __FUNCTION__);
+ return nullptr;
+ }
+
+ drmModePlanePtr drmPlane = drmModeGetPlane(drmFd.get(), planeId);
+ plane->mPossibleCrtcsMask = drmPlane->possible_crtcs;
+ drmModeFreePlane(drmPlane);
+
+ return plane;
+}
+
+bool DrmPlane::isPrimary() const { return mType.getValue() == DRM_PLANE_TYPE_PRIMARY; }
+
+bool DrmPlane::isOverlay() const { return mType.getValue() == DRM_PLANE_TYPE_OVERLAY; }
+
+bool DrmPlane::isCompatibleWith(const DrmCrtc& crtc) {
+ return ((0x1 << crtc.mIndexInResourcesArray) & mPossibleCrtcsMask);
+}
+
+} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/DrmPlane.h b/system/hwc3/DrmPlane.h
new file mode 100644
index 0000000..b244756
--- /dev/null
+++ b/system/hwc3/DrmPlane.h
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <android-base/logging.h>
+#include <android-base/unique_fd.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+#include "Common.h"
+#include "DrmCrtc.h"
+#include "DrmProperty.h"
+
+namespace aidl::android::hardware::graphics::composer3::impl {
+
+class DrmPlane {
+ public:
+ static std::unique_ptr<DrmPlane> create(::android::base::borrowed_fd drmFd, uint32_t planeId);
+ ~DrmPlane(){};
+
+ uint32_t getId() const { return mId; }
+
+ bool isPrimary() const;
+ bool isOverlay() const;
+
+ bool isCompatibleWith(const DrmCrtc& crtc);
+
+ const DrmProperty& getCrtcProperty() const { return mCrtc; }
+ const DrmProperty& getInFenceProperty() const { return mInFenceFd; }
+ const DrmProperty& getFbProperty() const { return mFb; }
+ const DrmProperty& getCrtcXProperty() const { return mCrtcX; }
+ const DrmProperty& getCrtcYProperty() const { return mCrtcY; }
+ const DrmProperty& getCrtcWProperty() const { return mCrtcW; }
+ const DrmProperty& getCrtcHProperty() const { return mCrtcH; }
+ const DrmProperty& getSrcXProperty() const { return mSrcX; }
+ const DrmProperty& getSrcYProperty() const { return mSrcY; }
+ const DrmProperty& getSrcWProperty() const { return mSrcW; }
+ const DrmProperty& getSrcHProperty() const { return mSrcH; }
+
+ private:
+ DrmPlane(uint32_t id) : mId(id){};
+
+ const uint32_t mId;
+
+ uint32_t mPossibleCrtcsMask = 0;
+
+ DrmProperty mCrtc;
+ DrmProperty mInFenceFd;
+ DrmProperty mFb;
+ DrmProperty mCrtcX;
+ DrmProperty mCrtcY;
+ DrmProperty mCrtcW;
+ DrmProperty mCrtcH;
+ DrmProperty mSrcX;
+ DrmProperty mSrcY;
+ DrmProperty mSrcW;
+ DrmProperty mSrcH;
+ DrmProperty mType;
+
+ static const auto& GetPropertiesMap() {
+ static const auto* sMap = []() {
+ return new DrmPropertyMemberMap<DrmPlane>{
+ {"CRTC_ID", &DrmPlane::mCrtc},
+ {"CRTC_X", &DrmPlane::mCrtcX},
+ {"CRTC_Y", &DrmPlane::mCrtcY},
+ {"CRTC_W", &DrmPlane::mCrtcW},
+ {"CRTC_H", &DrmPlane::mCrtcH},
+ {"FB_ID", &DrmPlane::mFb},
+ {"IN_FENCE_FD", &DrmPlane::mInFenceFd},
+ {"SRC_X", &DrmPlane::mSrcX},
+ {"SRC_Y", &DrmPlane::mSrcY},
+ {"SRC_W", &DrmPlane::mSrcW},
+ {"SRC_H", &DrmPlane::mSrcH},
+ {"type", &DrmPlane::mType},
+ };
+ }();
+ return *sMap;
+ }
+};
+
+} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/DrmPresenter.cpp b/system/hwc3/DrmPresenter.cpp
deleted file mode 100644
index b512277..0000000
--- a/system/hwc3/DrmPresenter.cpp
+++ /dev/null
@@ -1,750 +0,0 @@
-/*
- * Copyright 2022 The Android Open Source Project
- *
- * 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 "DrmPresenter.h"
-
-#include <cros_gralloc_handle.h>
-#include <linux/netlink.h>
-#include <sys/socket.h>
-
-#include <chrono>
-#include <thread>
-
-using ::android::base::guest::AutoReadLock;
-using ::android::base::guest::AutoWriteLock;
-using ::android::base::guest::ReadWriteLock;
-
-namespace aidl::android::hardware::graphics::composer3::impl {
-namespace {
-
-uint64_t addressAsUint(int* pointer) {
- return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(pointer));
-}
-
-} // namespace
-
-DrmPresenter::~DrmPresenter() {
- if (mFd > 0) {
- drmDropMaster(mFd.get());
- }
-}
-
-HWC3::Error DrmPresenter::init() {
- DEBUG_LOG("%s", __FUNCTION__);
-
- mFd = ::android::base::unique_fd(open("/dev/dri/card0", O_RDWR | O_CLOEXEC));
- if (mFd < 0) {
- ALOGE("%s: failed to open drm device: %s", __FUNCTION__, strerror(errno));
- return HWC3::Error::NoResources;
- }
-
- int ret = drmSetClientCap(mFd.get(), DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
- if (ret) {
- ALOGE("%s: failed to set cap universal plane %s\n", __FUNCTION__,
- strerror(errno));
- return HWC3::Error::NoResources;
- }
-
- ret = drmSetClientCap(mFd.get(), DRM_CLIENT_CAP_ATOMIC, 1);
- if (ret) {
- ALOGE("%s: failed to set cap atomic %s\n", __FUNCTION__, strerror(errno));
- return HWC3::Error::NoResources;
- }
-
- drmSetMaster(mFd.get());
-
- if (!drmIsMaster(mFd.get())) {
- ALOGE("%s: failed to get master drm device", __FUNCTION__);
- return HWC3::Error::NoResources;
- }
-
- {
- AutoWriteLock lock(mStateMutex);
- bool initDrmRet = initDrmElementsLocked();
- if (initDrmRet) {
- DEBUG_LOG("%s: Successfully initialized DRM backend", __FUNCTION__);
- } else {
- ALOGE("%s: Failed to initialize DRM backend", __FUNCTION__);
- return HWC3::Error::NoResources;
- }
-
- constexpr const std::size_t kCachedBuffersPerDisplay = 3;
- std::size_t numDisplays = 0;
- for (const DrmConnector& connector : mConnectors) {
- if (connector.connection == DRM_MODE_CONNECTED) {
- ++numDisplays;
- }
- }
- const std::size_t bufferCacheSize = kCachedBuffersPerDisplay * numDisplays;
- DEBUG_LOG("%s: initializing DRM buffer cache to size %zu",
- __FUNCTION__, bufferCacheSize);
- mBufferCache = std::make_unique<DrmBufferCache>(bufferCacheSize);
- }
-
- mDrmEventListener = ::android::sp<DrmEventListener>::make(*this);
- if (mDrmEventListener->init()) {
- DEBUG_LOG("%s: Successfully initialized DRM event listener", __FUNCTION__);
- } else {
- ALOGE("%s: Failed to initialize DRM event listener", __FUNCTION__);
- }
- mDrmEventListener->run("", ANDROID_PRIORITY_URGENT_DISPLAY);
-
- return HWC3::Error::None;
-}
-
-HWC3::Error DrmPresenter::getDisplayConfigs(std::vector<DisplayConfig>* configs) const {
- AutoReadLock lock(mStateMutex);
-
- configs->clear();
-
- for (uint32_t i = 0; i < mConnectors.size(); i++) {
- const auto& connector = mConnectors[i];
-
- if (connector.connection != DRM_MODE_CONNECTED) {
- continue;
- }
-
- configs->emplace_back(DisplayConfig{
- .id = i,
- .width = connector.mMode.hdisplay,
- .height = connector.mMode.vdisplay,
- .dpiX = 160, //static_cast<uint32_t>(connector.dpiX),
- .dpiY = 160, //static_cast<uint32_t>(connector.dpiY),
- .refreshRateHz = connector.mRefreshRateAsInteger,
- });
- }
-
- return HWC3::Error::None;
-}
-
-HWC3::Error DrmPresenter::registerOnHotplugCallback(const HotplugCallback& cb) {
- mHotplugCallback = cb;
- return HWC3::Error::None;
-}
-
-HWC3::Error DrmPresenter::unregisterOnHotplugCallback() {
- mHotplugCallback.reset();
- return HWC3::Error::None;
-}
-
-bool DrmPresenter::initDrmElementsLocked() {
- drmModeRes* res;
- static const int32_t kUmPerInch = 25400;
-
- res = drmModeGetResources(mFd.get());
- if (res == nullptr) {
- ALOGE("%s HWC3::Error reading drm resources: %d", __FUNCTION__, errno);
- mFd.reset();
- return false;
- }
-
- DEBUG_LOG(
- "drmModeRes count fbs %d crtc %d connector %d encoder %d min w %d max w "
- "%d min h %d max h %d",
- res->count_fbs, res->count_crtcs, res->count_connectors,
- res->count_encoders, res->min_width, res->max_width, res->min_height,
- res->max_height);
-
- for (uint32_t i = 0; i < res->count_crtcs; i++) {
- DrmCrtc crtc = {};
-
- drmModeCrtcPtr c = drmModeGetCrtc(mFd.get(), res->crtcs[i]);
- crtc.mId = c->crtc_id;
-
- drmModeObjectPropertiesPtr crtcProps =
- drmModeObjectGetProperties(mFd.get(), c->crtc_id, DRM_MODE_OBJECT_CRTC);
-
- for (uint32_t crtcPropsIndex = 0; crtcPropsIndex < crtcProps->count_props;
- crtcPropsIndex++) {
- drmModePropertyPtr crtcProp =
- drmModeGetProperty(mFd.get(), crtcProps->props[crtcPropsIndex]);
-
- if (!strcmp(crtcProp->name, "OUT_FENCE_PTR")) {
- crtc.mOutFencePtrPropertyId = crtcProp->prop_id;
- } else if (!strcmp(crtcProp->name, "ACTIVE")) {
- crtc.mActivePropertyId = crtcProp->prop_id;
- } else if (!strcmp(crtcProp->name, "MODE_ID")) {
- crtc.mModePropertyId = crtcProp->prop_id;
- }
-
- drmModeFreeProperty(crtcProp);
- }
-
- drmModeFreeObjectProperties(crtcProps);
-
- mCrtcs.push_back(crtc);
- }
-
- drmModePlaneResPtr planeRes = drmModeGetPlaneResources(mFd.get());
- for (uint32_t i = 0; i < planeRes->count_planes; ++i) {
- DrmPlane plane = {};
-
- drmModePlanePtr p = drmModeGetPlane(mFd.get(), planeRes->planes[i]);
- plane.mId = p->plane_id;
-
- DEBUG_LOG(
- "%s: plane id: %u crtcid %u fbid %u crtc xy %d %d xy %d %d "
- "possible ctrcs 0x%x",
- __FUNCTION__, p->plane_id, p->crtc_id, p->fb_id, p->crtc_x, p->crtc_y,
- p->x, p->y, p->possible_crtcs);
-
- drmModeObjectPropertiesPtr planeProps =
- drmModeObjectGetProperties(mFd.get(), plane.mId, DRM_MODE_OBJECT_PLANE);
-
- for (uint32_t planePropIndex = 0; planePropIndex < planeProps->count_props;
- ++planePropIndex) {
- drmModePropertyPtr planeProp =
- drmModeGetProperty(mFd.get(), planeProps->props[planePropIndex]);
-
- if (!strcmp(planeProp->name, "CRTC_ID")) {
- plane.mCrtcPropertyId = planeProp->prop_id;
- } else if (!strcmp(planeProp->name, "IN_FENCE_FD")) {
- plane.mInFenceFdPropertyId = planeProp->prop_id;
- } else if (!strcmp(planeProp->name, "FB_ID")) {
- plane.mFbPropertyId = planeProp->prop_id;
- } else if (!strcmp(planeProp->name, "CRTC_X")) {
- plane.mCrtcXPropertyId = planeProp->prop_id;
- } else if (!strcmp(planeProp->name, "CRTC_Y")) {
- plane.mCrtcYPropertyId = planeProp->prop_id;
- } else if (!strcmp(planeProp->name, "CRTC_W")) {
- plane.mCrtcWPropertyId = planeProp->prop_id;
- } else if (!strcmp(planeProp->name, "CRTC_H")) {
- plane.mCrtcHPropertyId = planeProp->prop_id;
- } else if (!strcmp(planeProp->name, "SRC_X")) {
- plane.mSrcXPropertyId = planeProp->prop_id;
- } else if (!strcmp(planeProp->name, "SRC_Y")) {
- plane.mSrcYPropertyId = planeProp->prop_id;
- } else if (!strcmp(planeProp->name, "SRC_W")) {
- plane.mSrcWPropertyId = planeProp->prop_id;
- } else if (!strcmp(planeProp->name, "SRC_H")) {
- plane.mSrcHPropertyId = planeProp->prop_id;
- } else if (!strcmp(planeProp->name, "type")) {
- plane.mTypePropertyId = planeProp->prop_id;
- uint64_t type = planeProp->values[0];
- switch (type) {
- case DRM_PLANE_TYPE_OVERLAY:
- plane.mType = type;
- DEBUG_LOG("%s: plane %" PRIu32 " is DRM_PLANE_TYPE_OVERLAY",
- __FUNCTION__, plane.mId);
- break;
- case DRM_PLANE_TYPE_PRIMARY:
- plane.mType = type;
- DEBUG_LOG("%s: plane %" PRIu32 " is DRM_PLANE_TYPE_PRIMARY",
- __FUNCTION__, plane.mId);
- break;
- default:
- break;
- }
- }
-
- drmModeFreeProperty(planeProp);
- }
-
- drmModeFreeObjectProperties(planeProps);
-
- bool isPrimaryOrOverlay = plane.mType == DRM_PLANE_TYPE_OVERLAY ||
- plane.mType == DRM_PLANE_TYPE_PRIMARY;
- if (isPrimaryOrOverlay) {
- for (uint32_t j = 0; j < mCrtcs.size(); j++) {
- if ((0x1 << j) & p->possible_crtcs) {
- DEBUG_LOG("%s: plane %" PRIu32 " compatible with crtc mask %" PRIu32,
- __FUNCTION__, plane.mId, p->possible_crtcs);
- if (mCrtcs[j].mPlaneId == -1) {
- mCrtcs[j].mPlaneId = plane.mId;
- DEBUG_LOG("%s: plane %" PRIu32 " associated with crtc %" PRIu32,
- __FUNCTION__, plane.mId, j);
- break;
- }
- }
- }
- }
-
- drmModeFreePlane(p);
- mPlanes[plane.mId] = plane;
- }
- drmModeFreePlaneResources(planeRes);
-
- for (uint32_t i = 0; i < res->count_connectors; ++i) {
- DrmConnector connector = {};
- connector.mId = res->connectors[i];
-
- {
- drmModeObjectPropertiesPtr connectorProps = drmModeObjectGetProperties(
- mFd.get(), connector.mId, DRM_MODE_OBJECT_CONNECTOR);
-
- for (uint32_t connectorPropIndex = 0;
- connectorPropIndex < connectorProps->count_props;
- ++connectorPropIndex) {
- drmModePropertyPtr connectorProp = drmModeGetProperty(
- mFd.get(), connectorProps->props[connectorPropIndex]);
- if (!strcmp(connectorProp->name, "CRTC_ID")) {
- connector.mCrtcPropertyId = connectorProp->prop_id;
- } else if (!strcmp(connectorProp->name, "EDID")) {
- connector.mEdidBlobId =
- connectorProps->prop_values[connectorPropIndex];
- }
- drmModeFreeProperty(connectorProp);
- }
-
- drmModeFreeObjectProperties(connectorProps);
- }
- {
- drmModeConnector* c = drmModeGetConnector(mFd.get(), connector.mId);
- if (c == nullptr) {
- ALOGE("%s: Failed to get connector %" PRIu32 ": %d", __FUNCTION__,
- connector.mId, errno);
- return false;
- }
- connector.connection = c->connection;
- if (c->count_modes > 0) {
- memcpy(&connector.mMode, &c->modes[0], sizeof(drmModeModeInfo));
- drmModeCreatePropertyBlob(mFd.get(), &connector.mMode,
- sizeof(connector.mMode),
- &connector.mModeBlobId);
-
- // Dots per 1000 inches
- connector.dpiX =
- c->mmWidth ? (c->modes[0].hdisplay * kUmPerInch) / (c->mmWidth)
- : -1;
- // Dots per 1000 inches
- connector.dpiY =
- c->mmHeight ? (c->modes[0].vdisplay * kUmPerInch) / (c->mmHeight)
- : -1;
- }
- DEBUG_LOG("%s connector %" PRIu32 " dpiX %" PRIi32 " dpiY %" PRIi32
- " connection %d",
- __FUNCTION__, connector.mId, connector.dpiX, connector.dpiY,
- connector.connection);
-
- drmModeFreeConnector(c);
-
- connector.mRefreshRateAsFloat =
- 1000.0f * connector.mMode.clock /
- ((float)connector.mMode.vtotal * (float)connector.mMode.htotal);
- connector.mRefreshRateAsInteger =
- (uint32_t)(connector.mRefreshRateAsFloat + 0.5f);
- }
-
- mConnectors.push_back(connector);
- }
-
- drmModeFreeResources(res);
- return true;
-}
-
-void DrmPresenter::resetDrmElementsLocked() {
- for (auto& c : mConnectors) {
- if (c.mModeBlobId) {
- if (drmModeDestroyPropertyBlob(mFd.get(), c.mModeBlobId)) {
- ALOGE("%s: Error destroy PropertyBlob %" PRIu32, __func__,
- c.mModeBlobId);
- }
- }
- }
- mConnectors.clear();
- mCrtcs.clear();
- mPlanes.clear();
-}
-
-std::tuple<HWC3::Error, std::shared_ptr<DrmBuffer>> DrmPresenter::create(
- const native_handle_t* handle) {
- cros_gralloc_handle* crosHandle = (cros_gralloc_handle*)handle;
- if (crosHandle == nullptr) {
- ALOGE("%s: invalid cros_gralloc_handle", __FUNCTION__);
- return std::make_tuple(HWC3::Error::NoResources, nullptr);
- }
-
- DrmPrimeBufferHandle primeHandle = 0;
- int ret = drmPrimeFDToHandle(mFd.get(), crosHandle->fds[0], &primeHandle);
- if (ret) {
- ALOGE("%s: drmPrimeFDToHandle failed: %s (errno %d)", __FUNCTION__,
- strerror(errno), errno);
- return std::make_tuple(HWC3::Error::NoResources, nullptr);
- }
-
- auto drmBufferPtr = mBufferCache->get(primeHandle);
- if (drmBufferPtr != nullptr) {
- return std::make_tuple(HWC3::Error::None,
- std::shared_ptr<DrmBuffer>(*drmBufferPtr));
- }
-
- auto buffer = std::shared_ptr<DrmBuffer>(new DrmBuffer(*this));
- buffer->mWidth = crosHandle->width;
- buffer->mHeight = crosHandle->height;
- buffer->mDrmFormat = crosHandle->format;
- buffer->mPlaneFds[0] = crosHandle->fds[0];
- buffer->mPlaneHandles[0] = primeHandle;
- buffer->mPlanePitches[0] = crosHandle->strides[0];
- buffer->mPlaneOffsets[0] = crosHandle->offsets[0];
-
- uint32_t framebuffer = 0;
- ret = drmModeAddFB2(mFd.get(),
- buffer->mWidth,
- buffer->mHeight,
- buffer->mDrmFormat,
- buffer->mPlaneHandles,
- buffer->mPlanePitches,
- buffer->mPlaneOffsets,
- &framebuffer,
- 0);
- if (ret) {
- ALOGE("%s: drmModeAddFB2 failed: %s (errno %d)", __FUNCTION__,
- strerror(errno), errno);
- return std::make_tuple(HWC3::Error::NoResources, nullptr);
- }
- DEBUG_LOG("%s: created framebuffer:%" PRIu32, __FUNCTION__, framebuffer);
- buffer->mDrmFramebuffer = framebuffer;
-
- mBufferCache->set(primeHandle, std::shared_ptr<DrmBuffer>(buffer));
-
- return std::make_tuple(HWC3::Error::None,
- std::shared_ptr<DrmBuffer>(buffer));
-}
-
-HWC3::Error DrmPresenter::destroyDrmFramebuffer(DrmBuffer* buffer) {
- if (buffer->mDrmFramebuffer) {
- uint32_t framebuffer = *buffer->mDrmFramebuffer;
- if (drmModeRmFB(mFd.get(), framebuffer)) {
- ALOGE("%s: drmModeRmFB failed: %s (errno %d)", __FUNCTION__,
- strerror(errno), errno);
- return HWC3::Error::NoResources;
- }
- DEBUG_LOG("%s: destroyed framebuffer:%" PRIu32, __FUNCTION__, framebuffer);
- buffer->mDrmFramebuffer.reset();
- }
- if (buffer->mPlaneHandles[0]) {
- struct drm_gem_close gem_close = {};
- gem_close.handle = buffer->mPlaneHandles[0];
- if (drmIoctl(mFd.get(), DRM_IOCTL_GEM_CLOSE, &gem_close)) {
- ALOGE("%s: DRM_IOCTL_GEM_CLOSE failed: %s (errno %d)", __FUNCTION__,
- strerror(errno), errno);
- return HWC3::Error::NoResources;
- }
-
- mBufferCache->remove(buffer->mPlaneHandles[0]);
- }
-
- return HWC3::Error::None;
-}
-
-bool DrmPresenter::handleHotplug() {
- std::vector<DrmConnector> oldConnectors(mConnectors);
- {
- AutoReadLock lock(mStateMutex);
- oldConnectors.assign(mConnectors.begin(), mConnectors.end());
- }
- {
- AutoWriteLock lock(mStateMutex);
- resetDrmElementsLocked();
- if (!initDrmElementsLocked()) {
- ALOGE(
- "%s: failed to initialize drm elements during hotplug. Displays may "
- "not function correctly!",
- __FUNCTION__);
- return false;
- }
- }
-
- AutoReadLock lock(mStateMutex);
- for (int i = 0; i < mConnectors.size(); i++) {
- bool changed =
- oldConnectors[i].dpiX != mConnectors[i].dpiX ||
- oldConnectors[i].dpiY != mConnectors[i].dpiY ||
- oldConnectors[i].connection != mConnectors[i].connection ||
- oldConnectors[i].mMode.hdisplay != mConnectors[i].mMode.hdisplay ||
- oldConnectors[i].mMode.vdisplay != mConnectors[i].mMode.vdisplay;
- if (changed) {
- if (i == 0) {
- ALOGE(
- "%s: Ignoring changes to display:0 which is not configurable by "
- "multi-display interface.",
- __FUNCTION__);
- continue;
- }
-
- const bool connected =
- mConnectors[i].connection == DRM_MODE_CONNECTED ? true : false;
- if (mHotplugCallback) {
- (*mHotplugCallback)(connected, //
- i, //
- mConnectors[i].mMode.hdisplay, //
- mConnectors[i].mMode.vdisplay, //
- mConnectors[i].dpiX, //
- mConnectors[i].dpiY, //
- mConnectors[i].mRefreshRateAsInteger);
- }
- }
- }
- return true;
-}
-
-std::tuple<HWC3::Error, ::android::base::unique_fd>
-DrmPresenter::flushToDisplay(int display, const DrmBuffer& buffer,
- ::android::base::borrowed_fd inSyncFd) {
- ATRACE_CALL();
-
- if (!buffer.mDrmFramebuffer) {
- ALOGE("%s: failed, no framebuffer created.", __FUNCTION__);
- return std::make_tuple(HWC3::Error::NoResources,
- ::android::base::unique_fd());
- }
-
- AutoReadLock lock(mStateMutex);
-
- DrmConnector& connector = mConnectors[display];
- DrmCrtc& crtc = mCrtcs[display];
-
- HWC3::Error error = HWC3::Error::None;
-
- drmModeAtomicReqPtr pset = drmModeAtomicAlloc();
-
- int ret;
-
- if (!crtc.mDidSetCrtc) {
- DEBUG_LOG("%s: Setting crtc.\n", __FUNCTION__);
- ret = drmModeAtomicAddProperty(pset, crtc.mId, crtc.mActivePropertyId, 1);
- if (ret < 0) {
- ALOGE("%s:%d: failed: %s\n", __FUNCTION__, __LINE__, strerror(errno));
- }
- ret = drmModeAtomicAddProperty(pset, crtc.mId, crtc.mModePropertyId,
- connector.mModeBlobId);
- if (ret < 0) {
- ALOGE("%s:%d: failed: %s\n", __FUNCTION__, __LINE__, strerror(errno));
- }
- ret = drmModeAtomicAddProperty(pset, connector.mId,
- connector.mCrtcPropertyId, crtc.mId);
- if (ret < 0) {
- ALOGE("%s:%d: failed: %s\n", __FUNCTION__, __LINE__, strerror(errno));
- }
-
- crtc.mDidSetCrtc = true;
- } else {
- DEBUG_LOG("%s: Already set crtc\n", __FUNCTION__);
- }
-
- int flushFenceFd = -1;
- ret = drmModeAtomicAddProperty(pset, crtc.mId, crtc.mOutFencePtrPropertyId,
- addressAsUint(&flushFenceFd));
- if (ret < 0) {
- ALOGE("%s:%d: set OUT_FENCE_PTR failed %d errno %d\n", __FUNCTION__,
- __LINE__, ret, errno);
- }
-
- if (crtc.mPlaneId == -1) {
- ALOGE("%s:%d: no plane available for crtc id %" PRIu32, __FUNCTION__,
- __LINE__, crtc.mId);
- return std::make_tuple(HWC3::Error::NoResources,
- ::android::base::unique_fd());
- }
-
- DrmPlane& plane = mPlanes[crtc.mPlaneId];
-
- DEBUG_LOG("%s: set plane: plane id %d crtc id %d fbid %d bo w h %d %d\n",
- __FUNCTION__, plane.mId, crtc.mId, *buffer.mDrmFramebuffer,
- buffer.mWidth, buffer.mHeight);
-
- ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mCrtcPropertyId,
- crtc.mId);
- if (ret < 0) {
- ALOGE("%s:%d: failed: %s\n", __FUNCTION__, __LINE__, strerror(errno));
- }
- ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mInFenceFdPropertyId,
- inSyncFd.get());
- if (ret < 0) {
- ALOGE("%s:%d: failed: %s\n", __FUNCTION__, __LINE__, strerror(errno));
- }
- ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mFbPropertyId,
- *buffer.mDrmFramebuffer);
- if (ret < 0) {
- ALOGE("%s:%d: failed: %s\n", __FUNCTION__, __LINE__, strerror(errno));
- }
- ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mCrtcXPropertyId, 0);
- if (ret < 0) {
- ALOGE("%s:%d: failed: %s\n", __FUNCTION__, __LINE__, strerror(errno));
- }
- ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mCrtcYPropertyId, 0);
- if (ret < 0) {
- ALOGE("%s:%d: failed: %s\n", __FUNCTION__, __LINE__, strerror(errno));
- }
- ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mCrtcWPropertyId,
- buffer.mWidth);
- if (ret < 0) {
- ALOGE("%s:%d: failed: %s\n", __FUNCTION__, __LINE__, strerror(errno));
- }
- ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mCrtcHPropertyId,
- buffer.mHeight);
- if (ret < 0) {
- ALOGE("%s:%d: failed: %s\n", __FUNCTION__, __LINE__, strerror(errno));
- }
- ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mSrcXPropertyId, 0);
- if (ret < 0) {
- ALOGE("%s:%d: failed: %s\n", __FUNCTION__, __LINE__, strerror(errno));
- }
- ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mSrcYPropertyId, 0);
- if (ret < 0) {
- ALOGE("%s:%d: failed: %s\n", __FUNCTION__, __LINE__, strerror(errno));
- }
- ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mSrcWPropertyId,
- buffer.mWidth << 16);
- if (ret < 0) {
- ALOGE("%s:%d: failed: %s\n", __FUNCTION__, __LINE__, strerror(errno));
- }
- ret = drmModeAtomicAddProperty(pset, plane.mId, plane.mSrcHPropertyId,
- buffer.mHeight << 16);
- if (ret < 0) {
- ALOGE("%s:%d: failed: %s\n", __FUNCTION__, __LINE__, strerror(errno));
- }
-
- constexpr const uint32_t kCommitFlags = DRM_MODE_ATOMIC_ALLOW_MODESET;
- ret = drmModeAtomicCommit(mFd.get(), pset, kCommitFlags, 0);
-
- if (ret) {
- ALOGE("%s:%d: atomic commit failed: %s\n", __FUNCTION__, __LINE__,
- strerror(errno));
- error = HWC3::Error::NoResources;
- flushFenceFd = -1;
- }
-
- if (pset) {
- drmModeAtomicFree(pset);
- }
-
- DEBUG_LOG("%s: flush fence:%d\n", __FUNCTION__, flushFenceFd);
- return std::make_tuple(error, ::android::base::unique_fd(flushFenceFd));
-}
-
-std::optional<std::vector<uint8_t>> DrmPresenter::getEdid(uint32_t id) {
- AutoReadLock lock(mStateMutex);
-
- if (mConnectors[id].mEdidBlobId == -1) {
- DEBUG_LOG("%s: EDID not supported", __func__);
- return std::nullopt;
- }
- drmModePropertyBlobPtr blob =
- drmModeGetPropertyBlob(mFd.get(), mConnectors[id].mEdidBlobId);
- if (!blob) {
- ALOGE("%s: fail to read EDID from DRM", __func__);
- return std::nullopt;
- }
-
- std::vector<uint8_t> edid;
- uint8_t* start = static_cast<uint8_t*>(blob->data);
- edid.insert(edid.begin(), start, start + blob->length);
-
- drmModeFreePropertyBlob(blob);
-
- return edid;
-}
-
-DrmBuffer::DrmBuffer(DrmPresenter& DrmPresenter)
- : mDrmPresenter(DrmPresenter) {}
-
-DrmBuffer::~DrmBuffer() { mDrmPresenter.destroyDrmFramebuffer(this); }
-
-DrmPresenter::DrmEventListener::DrmEventListener(DrmPresenter& presenter)
- : mPresenter(presenter) {}
-
-DrmPresenter::DrmEventListener::~DrmEventListener() {}
-
-bool DrmPresenter::DrmEventListener::init() {
- mEventFd = ::android::base::unique_fd(
- socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT));
- if (!mEventFd.ok()) {
- ALOGE("Failed to open uevent socket: %s", strerror(errno));
- return false;
- }
- struct sockaddr_nl addr;
- memset(&addr, 0, sizeof(addr));
- addr.nl_family = AF_NETLINK;
- addr.nl_pid = 0;
- addr.nl_groups = 0xFFFFFFFF;
-
- int ret = bind(mEventFd, (struct sockaddr*)&addr, sizeof(addr));
- if (ret) {
- ALOGE("Failed to bind uevent socket: %s", strerror(errno));
- return false;
- }
-
- FD_ZERO(&mMonitoredFds);
- FD_SET(mPresenter.mFd.get(), &mMonitoredFds);
- FD_SET(mEventFd.get(), &mMonitoredFds);
- mMaxFd = std::max(mPresenter.mFd.get(), mEventFd.get());
-
- return true;
-}
-
-bool DrmPresenter::DrmEventListener::threadLoop() {
- int ret;
- do {
- ret = select(mMaxFd + 1, &mMonitoredFds, NULL, NULL, NULL);
- } while (ret == -1 && errno == EINTR);
-
- // if (FD_ISSET(mPresenter.mFd, &mFds)) {
- // TODO: handle drm related events
- // }
-
- if (FD_ISSET(mEventFd.get(), &mMonitoredFds)) {
- eventThreadLoop();
- }
- return true;
-}
-
-void DrmPresenter::DrmEventListener::eventThreadLoop() {
- char buffer[1024];
- int ret;
-
- struct timespec ts;
- uint64_t timestamp = 0;
- ret = clock_gettime(CLOCK_MONOTONIC, &ts);
- if (!ret) {
- timestamp = ts.tv_sec * 1000 * 1000 * 1000 + ts.tv_nsec;
- } else {
- ALOGE("Failed to get monotonic clock on hotplug %d", ret);
- }
-
- while (true) {
- ret = read(mEventFd.get(), &buffer, sizeof(buffer));
- if (ret == 0) {
- return;
- } else if (ret < 0) {
- ALOGE("Got error reading uevent %d", ret);
- return;
- }
-
- bool drmEvent = false, hotplugEvent = false;
- for (int i = 0; i < ret;) {
- char* event = buffer + i;
- if (strcmp(event, "DEVTYPE=drm_minor")) {
- drmEvent = true;
- } else if (strcmp(event, "HOTPLUG=1")) {
- hotplugEvent = true;
- }
-
- i += strlen(event) + 1;
- }
-
- if (drmEvent && hotplugEvent) {
- processHotplug(timestamp);
- }
- }
-}
-
-void DrmPresenter::DrmEventListener::processHotplug(uint64_t timestamp) {
- ALOGD("DrmEventListener detected hotplug event %" PRIu64, timestamp);
- mPresenter.handleHotplug();
-}
-
-} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/DrmPresenter.h b/system/hwc3/DrmPresenter.h
deleted file mode 100644
index 72e3f5a..0000000
--- a/system/hwc3/DrmPresenter.h
+++ /dev/null
@@ -1,202 +0,0 @@
-/*
- * Copyright 2022 The Android Open Source Project
- *
- * 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 ANDROID_HWC_DRMPRESENTER_H
-#define ANDROID_HWC_DRMPRESENTER_H
-
-#include <android-base/unique_fd.h>
-#include <cutils/native_handle.h>
-#include <utils/Thread.h>
-#include <xf86drm.h>
-#include <xf86drmMode.h>
-
-#include <map>
-#include <memory>
-#include <tuple>
-#include <vector>
-
-#include "Common.h"
-#include "LruCache.h"
-#include "android/base/synchronization/AndroidLock.h"
-
-namespace aidl::android::hardware::graphics::composer3::impl {
-
-class DrmBuffer;
-class DrmPresenter;
-
-// A RAII object that will clear a drm framebuffer upon destruction.
-class DrmBuffer {
- public:
- ~DrmBuffer();
-
- DrmBuffer(const DrmBuffer&) = delete;
- DrmBuffer& operator=(const DrmBuffer&) = delete;
-
- DrmBuffer(DrmBuffer&&) = delete;
- DrmBuffer& operator=(DrmBuffer&&) = delete;
-
- private:
- friend class DrmPresenter;
- DrmBuffer(DrmPresenter& drmPresenter);
-
- DrmPresenter& mDrmPresenter;
-
- uint32_t mWidth = 0;
- uint32_t mHeight = 0;
- uint32_t mDrmFormat = 0;
- uint32_t mPlaneFds[4] = {0, 0, 0, 0};
- uint32_t mPlaneHandles[4] = {0, 0, 0, 0};
- uint32_t mPlanePitches[4] = {0, 0, 0, 0};
- uint32_t mPlaneOffsets[4] = {0, 0, 0, 0};
- std::optional<uint32_t> mDrmFramebuffer;
-};
-
-class DrmPresenter {
- public:
- DrmPresenter() = default;
- ~DrmPresenter();
-
- DrmPresenter(const DrmPresenter&) = delete;
- DrmPresenter& operator=(const DrmPresenter&) = delete;
-
- DrmPresenter(DrmPresenter&&) = delete;
- DrmPresenter& operator=(DrmPresenter&&) = delete;
-
- HWC3::Error init();
-
- struct DisplayConfig {
- uint32_t id;
- uint32_t width;
- uint32_t height;
- uint32_t dpiX;
- uint32_t dpiY;
- uint32_t refreshRateHz;
- };
-
- HWC3::Error getDisplayConfigs(std::vector<DisplayConfig>* configs) const;
-
- using HotplugCallback = std::function<void(bool /*connected*/, //
- uint32_t /*id*/, //
- uint32_t /*width*/, //
- uint32_t /*height*/, //
- uint32_t /*dpiX*/, //
- uint32_t /*dpiY*/, //
- uint32_t /*refreshRate*/)>;
-
- HWC3::Error registerOnHotplugCallback(const HotplugCallback& cb);
- HWC3::Error unregisterOnHotplugCallback();
-
- uint32_t refreshRate() const { return mConnectors[0].mRefreshRateAsInteger; }
-
- std::tuple<HWC3::Error, std::shared_ptr<DrmBuffer>> create(
- const native_handle_t* handle);
-
- std::tuple<HWC3::Error, ::android::base::unique_fd> flushToDisplay(
- int display, const DrmBuffer& buffer,
- ::android::base::borrowed_fd inWaitSyncFd);
-
- std::optional<std::vector<uint8_t>> getEdid(uint32_t id);
-
- private:
- // TODO: make this cache per display when enabling hotplug support.
- using DrmPrimeBufferHandle = uint32_t;
- using DrmBufferCache = LruCache<DrmPrimeBufferHandle, std::shared_ptr<DrmBuffer>>;
- std::unique_ptr<DrmBufferCache> mBufferCache;
-
- // Grant visibility to destroyDrmFramebuffer to DrmBuffer.
- friend class DrmBuffer;
- HWC3::Error destroyDrmFramebuffer(DrmBuffer* buffer);
-
- // Grant visibility for handleHotplug to DrmEventListener.
- bool handleHotplug();
-
- bool initDrmElementsLocked();
- void resetDrmElementsLocked();
-
- // Drm device.
- ::android::base::unique_fd mFd;
-
- std::optional<HotplugCallback> mHotplugCallback;
-
- // Protects access to the below drm structs.
- mutable ::android::base::guest::ReadWriteLock mStateMutex;
-
- struct DrmPlane {
- uint32_t mId = -1;
- uint32_t mCrtcPropertyId = -1;
- uint32_t mInFenceFdPropertyId = -1;
- uint32_t mFbPropertyId = -1;
- uint32_t mCrtcXPropertyId = -1;
- uint32_t mCrtcYPropertyId = -1;
- uint32_t mCrtcWPropertyId = -1;
- uint32_t mCrtcHPropertyId = -1;
- uint32_t mSrcXPropertyId = -1;
- uint32_t mSrcYPropertyId = -1;
- uint32_t mSrcWPropertyId = -1;
- uint32_t mSrcHPropertyId = -1;
- uint32_t mTypePropertyId = -1;
- uint64_t mType = -1;
- };
- std::map<uint32_t, DrmPlane> mPlanes;
-
- struct DrmCrtc {
- uint32_t mId = -1;
- uint32_t mActivePropertyId = -1;
- uint32_t mModePropertyId = -1;
- uint32_t mOutFencePtrPropertyId = -1;
- uint32_t mPlaneId = -1;
-
- bool mDidSetCrtc = false;
- };
- std::vector<DrmCrtc> mCrtcs;
-
- struct DrmConnector {
- uint32_t mId = -1;
- uint32_t mCrtcPropertyId = -1;
- drmModeModeInfo mMode;
- int32_t dpiX;
- int32_t dpiY;
- drmModeConnection connection;
- uint32_t mModeBlobId = 0;
- float mRefreshRateAsFloat;
- uint32_t mRefreshRateAsInteger;
- uint64_t mEdidBlobId = -1;
- };
- std::vector<DrmConnector> mConnectors;
-
- class DrmEventListener : public ::android::Thread {
- public:
- DrmEventListener(DrmPresenter& presenter);
- virtual ~DrmEventListener();
-
- bool init();
-
- private:
- bool threadLoop() final;
- void eventThreadLoop();
- void processHotplug(uint64_t timestamp);
-
- DrmPresenter& mPresenter;
- ::android::base::unique_fd mEventFd;
- int mMaxFd;
- fd_set mMonitoredFds;
- };
- ::android::sp<DrmEventListener> mDrmEventListener;
-};
-
-} // namespace aidl::android::hardware::graphics::composer3::impl
-
-#endif
diff --git a/system/hwc3/DrmProperty.h b/system/hwc3/DrmProperty.h
new file mode 100644
index 0000000..9e7b798
--- /dev/null
+++ b/system/hwc3/DrmProperty.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <android-base/logging.h>
+#include <android-base/unique_fd.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <cstdint>
+#include <string>
+#include <unordered_map>
+
+#include "Common.h"
+
+namespace aidl::android::hardware::graphics::composer3::impl {
+
+class DrmProperty {
+ public:
+ DrmProperty() {}
+ DrmProperty(uint32_t id, uint64_t value, std::string name)
+ : mId(id), mValue(value), mName(name) {}
+
+ ~DrmProperty() {}
+
+ uint32_t getId() const { return mId; }
+
+ uint64_t getValue() const { return mValue; }
+
+ const std::string& getName() const { return mName; }
+
+ private:
+ uint32_t mId = -1;
+ uint64_t mValue = -1;
+ std::string mName;
+};
+
+template <typename T>
+using DrmPropertyMember = DrmProperty T::*;
+
+template <typename T>
+using DrmPropertyMemberMap = std::unordered_map<std::string, DrmPropertyMember<T>>;
+
+// Helper to many DrmProperty members for DrmCrtc, DrmConnector, and DrmPlane.
+template <typename T>
+bool LoadDrmProperties(::android::base::borrowed_fd drmFd, uint32_t objectId, uint32_t objectType,
+ const DrmPropertyMemberMap<T>& objectPropertyMap, T* object) {
+ auto drmProperties = drmModeObjectGetProperties(drmFd.get(), objectId, objectType);
+ if (!drmProperties) {
+ ALOGE("%s: Failed to get properties: %s", __FUNCTION__, strerror(errno));
+ return false;
+ }
+
+ for (uint32_t i = 0; i < drmProperties->count_props; ++i) {
+ const auto propertyId = drmProperties->props[i];
+
+ auto drmProperty = drmModeGetProperty(drmFd.get(), propertyId);
+ if (!drmProperty) {
+ ALOGE("%s: Failed to get property: %s", __FUNCTION__, strerror(errno));
+ continue;
+ }
+
+ const auto propertyName = drmProperty->name;
+ const auto propertyValue = drmProperties->prop_values[i];
+
+ auto it = objectPropertyMap.find(propertyName);
+ if (it != objectPropertyMap.end()) {
+ DEBUG_LOG("%s: Loaded property:%" PRIu32 " (%s) val:%" PRIu64, __FUNCTION__, propertyId,
+ propertyName, propertyValue);
+
+ auto& objectPointerToMember = it->second;
+ object->*objectPointerToMember = DrmProperty(propertyId, propertyValue, propertyName);
+ }
+
+ drmModeFreeProperty(drmProperty);
+ }
+
+ drmModeFreeObjectProperties(drmProperties);
+
+ return true;
+}
+
+} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/FrameComposer.h b/system/hwc3/FrameComposer.h
index 794855b..70e0f00 100644
--- a/system/hwc3/FrameComposer.h
+++ b/system/hwc3/FrameComposer.h
@@ -26,7 +26,7 @@
#include "Common.h"
#include "DisplayChanges.h"
-#include "DrmPresenter.h"
+#include "DrmClient.h"
namespace aidl::android::hardware::graphics::composer3::impl {
@@ -70,7 +70,7 @@
virtual HWC3::Error onActiveConfigChange(Display* display) = 0;
- virtual const DrmPresenter* getDrmPresenter() const {
+ virtual const DrmClient* getDrmPresenter() const {
return nullptr;
}
};
diff --git a/system/hwc3/GuestFrameComposer.cpp b/system/hwc3/GuestFrameComposer.cpp
index b7d7322..d28f57c 100644
--- a/system/hwc3/GuestFrameComposer.cpp
+++ b/system/hwc3/GuestFrameComposer.cpp
@@ -410,9 +410,9 @@
HWC3::Error GuestFrameComposer::init() {
DEBUG_LOG("%s", __FUNCTION__);
- HWC3::Error error = mDrmPresenter.init();
+ HWC3::Error error = mDrmClient.init();
if (error != HWC3::Error::None) {
- ALOGE("%s: failed to initialize DrmPresenter", __FUNCTION__);
+ ALOGE("%s: failed to initialize DrmClient", __FUNCTION__);
return error;
}
@@ -421,12 +421,12 @@
HWC3::Error GuestFrameComposer::registerOnHotplugCallback(
const HotplugCallback& cb) {
- return mDrmPresenter.registerOnHotplugCallback(cb);
+ return mDrmClient.registerOnHotplugCallback(cb);
return HWC3::Error::None;
}
HWC3::Error GuestFrameComposer::unregisterOnHotplugCallback() {
- return mDrmPresenter.unregisterOnHotplugCallback();
+ return mDrmClient.unregisterOnHotplugCallback();
}
HWC3::Error GuestFrameComposer::onDisplayCreate(Display* display) {
@@ -487,7 +487,7 @@
displayInfo.compositionResultBuffer = bufferHandle;
- auto [drmBufferCreateError, drmBuffer] = mDrmPresenter.create(bufferHandle);
+ auto [drmBufferCreateError, drmBuffer] = mDrmClient.create(bufferHandle);
if (drmBufferCreateError != HWC3::Error::None) {
ALOGE("%s: failed to create drm buffer for display:%" PRIu64, __FUNCTION__,
displayId);
@@ -496,8 +496,8 @@
displayInfo.compositionResultDrmBuffer = std::move(drmBuffer);
if (displayId == 0) {
- auto [flushError, flushSyncFd] = mDrmPresenter.flushToDisplay(
- displayId, *displayInfo.compositionResultDrmBuffer, -1);
+ auto [flushError, flushSyncFd] = mDrmClient.flushToDisplay(
+ displayId, displayInfo.compositionResultDrmBuffer, -1);
if (flushError != HWC3::Error::None) {
ALOGW(
"%s: Initial display flush failed. HWComposer assuming that we are "
@@ -507,6 +507,11 @@
}
}
+ std::optional<std::vector<uint8_t>> edid = mDrmClient.getEdid(displayId);
+ if (edid) {
+ display->setEdid(*edid);
+ }
+
return HWC3::Error::None;
}
@@ -883,8 +888,8 @@
DEBUG_LOG("%s display:%" PRIu64 " flushing drm buffer", __FUNCTION__,
displayId);
- auto [error, fence] = mDrmPresenter.flushToDisplay(
- displayId, *displayInfo.compositionResultDrmBuffer, -1);
+ auto [error, fence] = mDrmClient.flushToDisplay(
+ displayId, displayInfo.compositionResultDrmBuffer, -1);
if (error != HWC3::Error::None) {
ALOGE("%s: display:%" PRIu64 " failed to flush drm buffer" PRIu64,
__FUNCTION__, displayId);
diff --git a/system/hwc3/GuestFrameComposer.h b/system/hwc3/GuestFrameComposer.h
index e37ff87..2df2f32 100644
--- a/system/hwc3/GuestFrameComposer.h
+++ b/system/hwc3/GuestFrameComposer.h
@@ -19,7 +19,7 @@
#include "Common.h"
#include "Display.h"
-#include "DrmPresenter.h"
+#include "DrmClient.h"
#include "FrameComposer.h"
#include "Gralloc.h"
#include "Layer.h"
@@ -62,8 +62,8 @@
HWC3::Error onActiveConfigChange(Display* /*display*/) override;
- const DrmPresenter* getDrmPresenter() const override {
- return &mDrmPresenter;
+ const DrmClient* getDrmPresenter() const override {
+ return &mDrmClient;
}
private:
@@ -102,7 +102,7 @@
Gralloc mGralloc;
- DrmPresenter mDrmPresenter;
+ DrmClient mDrmClient;
// Cuttlefish on QEMU does not have a display. Disable presenting to avoid
// spamming logcat with DRM commit failures.
diff --git a/system/hwc3/HostFrameComposer.cpp b/system/hwc3/HostFrameComposer.cpp
index f976e05..76ecf43 100644
--- a/system/hwc3/HostFrameComposer.cpp
+++ b/system/hwc3/HostFrameComposer.cpp
@@ -204,11 +204,11 @@
mUseAngle = useAngleFromProperty();
if (mIsMinigbm) {
- mDrmPresenter.emplace();
+ mDrmClient.emplace();
- HWC3::Error error = mDrmPresenter->init();
+ HWC3::Error error = mDrmClient->init();
if (error != HWC3::Error::None) {
- ALOGE("%s: failed to initialize DrmPresenter", __FUNCTION__);
+ ALOGE("%s: failed to initialize DrmClient", __FUNCTION__);
return error;
}
} else {
@@ -220,15 +220,15 @@
HWC3::Error HostFrameComposer::registerOnHotplugCallback(
const HotplugCallback& cb) {
- if (mDrmPresenter) {
- mDrmPresenter->registerOnHotplugCallback(cb);
+ if (mDrmClient) {
+ mDrmClient->registerOnHotplugCallback(cb);
}
return HWC3::Error::None;
}
HWC3::Error HostFrameComposer::unregisterOnHotplugCallback() {
- if (mDrmPresenter) {
- mDrmPresenter->unregisterOnHotplugCallback();
+ if (mDrmClient) {
+ mDrmClient->unregisterOnHotplugCallback();
}
return HWC3::Error::None;
}
@@ -280,9 +280,9 @@
return HWC3::Error::NoResources;
}
- if (mDrmPresenter) {
+ if (mDrmClient) {
auto [drmBufferCreateError, drmBuffer] =
- mDrmPresenter->create(displayInfo.compositionResultBuffer);
+ mDrmClient->create(displayInfo.compositionResultBuffer);
if (drmBufferCreateError != HWC3::Error::None) {
ALOGE("%s: display:%" PRIu64 " failed to create target drm buffer",
__FUNCTION__, displayId);
@@ -384,8 +384,8 @@
}
std::optional<std::vector<uint8_t>> edid;
- if (mDrmPresenter) {
- edid = mDrmPresenter->getEdid(displayId);
+ if (mDrmClient) {
+ edid = mDrmClient->getEdid(displayId);
if (edid) {
display->setEdid(*edid);
}
@@ -436,7 +436,7 @@
FencedBuffer& clientTargetFencedBuffer = display->getClientTarget();
auto [drmBufferCreateError, drmBuffer] =
- mDrmPresenter->create(clientTargetFencedBuffer.getBuffer());
+ mDrmClient->create(clientTargetFencedBuffer.getBuffer());
if (drmBufferCreateError != HWC3::Error::None) {
ALOGE("%s: display:%" PRIu64 " failed to create client target drm buffer",
__FUNCTION__, displayId);
@@ -586,8 +586,8 @@
if (displayClientTarget.getBuffer() != nullptr) {
::android::base::unique_fd fence = displayClientTarget.getFence();
if (mIsMinigbm) {
- auto [_, flushCompleteFence] = mDrmPresenter->flushToDisplay(
- displayId, *displayInfo.clientTargetDrmBuffer, fence);
+ auto [_, flushCompleteFence] = mDrmClient->flushToDisplay(
+ displayId, displayInfo.clientTargetDrmBuffer, fence);
*outDisplayFence = std::move(flushCompleteFence);
} else {
@@ -730,8 +730,8 @@
}
if (mIsMinigbm) {
- auto [_, fence] = mDrmPresenter->flushToDisplay(
- displayId, *displayInfo.compositionResultDrmBuffer, -1);
+ auto [_, fence] = mDrmClient->flushToDisplay(
+ displayId, displayInfo.compositionResultDrmBuffer, -1);
retire_fd = std::move(fence);
} else {
int fd;
@@ -761,8 +761,8 @@
::android::base::unique_fd displayClientTargetFence =
displayClientTarget.getFence();
if (mIsMinigbm) {
- auto [_, flushFence] = mDrmPresenter->flushToDisplay(
- displayId, *displayInfo.compositionResultDrmBuffer,
+ auto [_, flushFence] = mDrmClient->flushToDisplay(
+ displayId, displayInfo.compositionResultDrmBuffer,
displayClientTargetFence);
*outDisplayFence = std::move(flushFence);
} else {
diff --git a/system/hwc3/HostFrameComposer.h b/system/hwc3/HostFrameComposer.h
index 42eb43a..aebf716 100644
--- a/system/hwc3/HostFrameComposer.h
+++ b/system/hwc3/HostFrameComposer.h
@@ -23,7 +23,7 @@
#include <tuple>
#include "Common.h"
-#include "DrmPresenter.h"
+#include "DrmClient.h"
#include "FrameComposer.h"
#include "HostConnection.h"
@@ -65,9 +65,9 @@
HWC3::Error onActiveConfigChange(Display* display) override;
- const DrmPresenter* getDrmPresenter() const override {
- if (mDrmPresenter) {
- return &*mDrmPresenter;
+ const DrmClient* getDrmPresenter() const override {
+ if (mDrmClient) {
+ return &*mDrmClient;
}
return nullptr;
}
@@ -100,7 +100,7 @@
std::unordered_map<int64_t, HostComposerDisplayInfo> mDisplayInfos;
- std::optional<DrmPresenter> mDrmPresenter;
+ std::optional<DrmClient> mDrmClient;
};
} // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/system/hwc3/NoOpFrameComposer.h b/system/hwc3/NoOpFrameComposer.h
index 4722477..b773a3e 100644
--- a/system/hwc3/NoOpFrameComposer.h
+++ b/system/hwc3/NoOpFrameComposer.h
@@ -19,7 +19,7 @@
#include "Common.h"
#include "Display.h"
-#include "DrmPresenter.h"
+#include "DrmClient.h"
#include "FrameComposer.h"
#include "Gralloc.h"
#include "Layer.h"
diff --git a/system/profiler/CMakeLists.txt b/system/profiler/CMakeLists.txt
index 4a78b82..a00c889 100644
--- a/system/profiler/CMakeLists.txt
+++ b/system/profiler/CMakeLists.txt
@@ -7,4 +7,4 @@
target_include_directories(GoldfishProfiler PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/profiler ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest)
target_compile_definitions(GoldfishProfiler PRIVATE "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGFXSTREAM")
target_compile_options(GoldfishProfiler PRIVATE "-fvisibility=default" "-Wno-unused-parameter")
-target_link_libraries(GoldfishProfiler PRIVATE android-emu-shared vulkan_enc gui log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host cutils utils androidemu PRIVATE gralloc_cb_host GoldfishAddressSpace_host qemupipe_host)
\ No newline at end of file
+target_link_libraries(GoldfishProfiler PRIVATE android-emu-shared vulkan_enc gui log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host cutils utils androidemu PRIVATE gralloc_cb_host GoldfishAddressSpace_host platform_host qemupipe_host)
\ No newline at end of file
diff --git a/system/renderControl_enc/renderControl_client_context.cpp b/system/renderControl_enc/renderControl_client_context.cpp
index 27dd37e..ae73135 100644
--- a/system/renderControl_enc/renderControl_client_context.cpp
+++ b/system/renderControl_enc/renderControl_client_context.cpp
@@ -78,6 +78,8 @@
rcGetFBDisplayConfigsCount = (rcGetFBDisplayConfigsCount_client_proc_t) getProc("rcGetFBDisplayConfigsCount", userData);
rcGetFBDisplayConfigsParam = (rcGetFBDisplayConfigsParam_client_proc_t) getProc("rcGetFBDisplayConfigsParam", userData);
rcGetFBDisplayActiveConfig = (rcGetFBDisplayActiveConfig_client_proc_t) getProc("rcGetFBDisplayActiveConfig", userData);
+ rcSetProcessMetadata = (rcSetProcessMetadata_client_proc_t) getProc("rcSetProcessMetadata", userData);
+ rcGetHostExtensionsString = (rcGetHostExtensionsString_client_proc_t) getProc("rcGetHostExtensionsString", userData);
return 0;
}
diff --git a/system/renderControl_enc/renderControl_client_context.h b/system/renderControl_enc/renderControl_client_context.h
index bf79eaa..e85bd01 100644
--- a/system/renderControl_enc/renderControl_client_context.h
+++ b/system/renderControl_enc/renderControl_client_context.h
@@ -78,6 +78,8 @@
rcGetFBDisplayConfigsCount_client_proc_t rcGetFBDisplayConfigsCount;
rcGetFBDisplayConfigsParam_client_proc_t rcGetFBDisplayConfigsParam;
rcGetFBDisplayActiveConfig_client_proc_t rcGetFBDisplayActiveConfig;
+ rcSetProcessMetadata_client_proc_t rcSetProcessMetadata;
+ rcGetHostExtensionsString_client_proc_t rcGetHostExtensionsString;
virtual ~renderControl_client_context_t() {}
typedef renderControl_client_context_t *CONTEXT_ACCESSOR_TYPE(void);
diff --git a/system/renderControl_enc/renderControl_client_proc.h b/system/renderControl_enc/renderControl_client_proc.h
index 2c28127..c6a03ae 100644
--- a/system/renderControl_enc/renderControl_client_proc.h
+++ b/system/renderControl_enc/renderControl_client_proc.h
@@ -80,6 +80,8 @@
typedef int (renderControl_APIENTRY *rcGetFBDisplayConfigsCount_client_proc_t) (void * ctx);
typedef int (renderControl_APIENTRY *rcGetFBDisplayConfigsParam_client_proc_t) (void * ctx, int, EGLint);
typedef int (renderControl_APIENTRY *rcGetFBDisplayActiveConfig_client_proc_t) (void * ctx);
+typedef void (renderControl_APIENTRY *rcSetProcessMetadata_client_proc_t) (void * ctx, char*, RenderControlByte*, uint32_t);
+typedef int (renderControl_APIENTRY *rcGetHostExtensionsString_client_proc_t) (void * ctx, uint32_t, void*);
#endif
diff --git a/system/renderControl_enc/renderControl_enc.cpp b/system/renderControl_enc/renderControl_enc.cpp
index 017c7e4..3d3dc7e 100644
--- a/system/renderControl_enc/renderControl_enc.cpp
+++ b/system/renderControl_enc/renderControl_enc.cpp
@@ -2735,6 +2735,85 @@
return retval;
}
+void rcSetProcessMetadata_enc(void *self , char* key, RenderControlByte* valuePtr, uint32_t valueSize)
+{
+ ENCODER_DEBUG_LOG("rcSetProcessMetadata(key:%s, valuePtr:%p, valueSize:0x%08x)", key, valuePtr, valueSize);
+ AEMU_SCOPED_TRACE("rcSetProcessMetadata encode");
+
+ renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_key = (strlen(key) + 1);
+ const unsigned int __size_valuePtr = valueSize;
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + __size_key + __size_valuePtr + 4 + 2*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_rcSetProcessMetadata;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &__size_key, 4); ptr += 4;
+ memcpy(ptr, key, __size_key);ptr += __size_key;
+ memcpy(ptr, &__size_valuePtr, 4); ptr += 4;
+ memcpy(ptr, valuePtr, __size_valuePtr);ptr += __size_valuePtr;
+ memcpy(ptr, &valueSize, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+}
+
+int rcGetHostExtensionsString_enc(void *self , uint32_t bufferSize, void* buffer)
+{
+ ENCODER_DEBUG_LOG("rcGetHostExtensionsString(bufferSize:0x%08x, buffer:0x%08x)", bufferSize, buffer);
+ AEMU_SCOPED_TRACE("rcGetHostExtensionsString encode");
+
+ renderControl_encoder_context_t *ctx = (renderControl_encoder_context_t *)self;
+ IOStream *stream = ctx->m_stream;
+ ChecksumCalculator *checksumCalculator = ctx->m_checksumCalculator;
+ bool useChecksum = checksumCalculator->getVersion() > 0;
+
+ const unsigned int __size_buffer = bufferSize;
+ unsigned char *ptr;
+ unsigned char *buf;
+ const size_t sizeWithoutChecksum = 8 + 4 + 0 + 1*4;
+ const size_t checksumSize = checksumCalculator->checksumByteSize();
+ const size_t totalSize = sizeWithoutChecksum + checksumSize;
+ buf = stream->alloc(totalSize);
+ ptr = buf;
+ int tmp = OP_rcGetHostExtensionsString;memcpy(ptr, &tmp, 4); ptr += 4;
+ memcpy(ptr, &totalSize, 4); ptr += 4;
+
+ memcpy(ptr, &bufferSize, 4); ptr += 4;
+ memcpy(ptr, &__size_buffer, 4); ptr += 4;
+
+ if (useChecksum) checksumCalculator->addBuffer(buf, ptr-buf);
+ if (useChecksum) checksumCalculator->writeChecksum(ptr, checksumSize); ptr += checksumSize;
+
+ stream->readback(buffer, __size_buffer);
+ if (useChecksum) checksumCalculator->addBuffer(buffer, __size_buffer);
+
+ int retval;
+ stream->readback(&retval, 4);
+ if (useChecksum) checksumCalculator->addBuffer(&retval, 4);
+ if (useChecksum) {
+ unsigned char *checksumBufPtr = NULL;
+ unsigned char checksumBuf[ChecksumCalculator::kMaxChecksumSize];
+ if (checksumSize > 0) checksumBufPtr = &checksumBuf[0];
+ stream->readback(checksumBufPtr, checksumSize);
+ if (!checksumCalculator->validate(checksumBufPtr, checksumSize)) {
+ ALOGE("rcGetHostExtensionsString: GL communication error, please report this issue to b.android.com.\n");
+ abort();
+ }
+ }
+ return retval;
+}
+
} // namespace
renderControl_encoder_context_t::renderControl_encoder_context_t(IOStream *stream, ChecksumCalculator *checksumCalculator)
@@ -2810,5 +2889,7 @@
this->rcGetFBDisplayConfigsCount = &rcGetFBDisplayConfigsCount_enc;
this->rcGetFBDisplayConfigsParam = &rcGetFBDisplayConfigsParam_enc;
this->rcGetFBDisplayActiveConfig = &rcGetFBDisplayActiveConfig_enc;
+ this->rcSetProcessMetadata = &rcSetProcessMetadata_enc;
+ this->rcGetHostExtensionsString = &rcGetHostExtensionsString_enc;
}
diff --git a/system/renderControl_enc/renderControl_entry.cpp b/system/renderControl_enc/renderControl_entry.cpp
index e756322..859b004 100644
--- a/system/renderControl_enc/renderControl_entry.cpp
+++ b/system/renderControl_enc/renderControl_entry.cpp
@@ -73,6 +73,8 @@
int rcGetFBDisplayConfigsCount();
int rcGetFBDisplayConfigsParam(int configId, EGLint param);
int rcGetFBDisplayActiveConfig();
+ void rcSetProcessMetadata(char* key, RenderControlByte* valuePtr, uint32_t valueSize);
+ int rcGetHostExtensionsString(uint32_t bufferSize, void* buffer);
};
#ifndef GET_CONTEXT
@@ -489,3 +491,15 @@
return ctx->rcGetFBDisplayActiveConfig(ctx);
}
+void rcSetProcessMetadata(char* key, RenderControlByte* valuePtr, uint32_t valueSize)
+{
+ GET_CONTEXT;
+ ctx->rcSetProcessMetadata(ctx, key, valuePtr, valueSize);
+}
+
+int rcGetHostExtensionsString(uint32_t bufferSize, void* buffer)
+{
+ GET_CONTEXT;
+ return ctx->rcGetHostExtensionsString(ctx, bufferSize, buffer);
+}
+
diff --git a/system/renderControl_enc/renderControl_ftable.h b/system/renderControl_enc/renderControl_ftable.h
index 9a0f9e9..368cc79 100644
--- a/system/renderControl_enc/renderControl_ftable.h
+++ b/system/renderControl_enc/renderControl_ftable.h
@@ -76,6 +76,8 @@
{"rcGetFBDisplayConfigsCount", (void*)rcGetFBDisplayConfigsCount},
{"rcGetFBDisplayConfigsParam", (void*)rcGetFBDisplayConfigsParam},
{"rcGetFBDisplayActiveConfig", (void*)rcGetFBDisplayActiveConfig},
+ {"rcSetProcessMetadata", (void*)rcSetProcessMetadata},
+ {"rcGetHostExtensionsString", (void*)rcGetHostExtensionsString},
};
static const int renderControl_num_funcs = sizeof(renderControl_funcs_by_name) / sizeof(struct _renderControl_funcs_by_name);
diff --git a/system/renderControl_enc/renderControl_opcodes.h b/system/renderControl_enc/renderControl_opcodes.h
index cf4ff82..25cb345 100644
--- a/system/renderControl_enc/renderControl_opcodes.h
+++ b/system/renderControl_enc/renderControl_opcodes.h
@@ -71,7 +71,9 @@
#define OP_rcGetFBDisplayConfigsCount 10065
#define OP_rcGetFBDisplayConfigsParam 10066
#define OP_rcGetFBDisplayActiveConfig 10067
-#define OP_last 10068
+#define OP_rcSetProcessMetadata 10068
+#define OP_rcGetHostExtensionsString 10069
+#define OP_last 10070
#endif
diff --git a/system/renderControl_enc/renderControl_types.h b/system/renderControl_enc/renderControl_types.h
index da215bb..e2bb551 100644
--- a/system/renderControl_enc/renderControl_types.h
+++ b/system/renderControl_enc/renderControl_types.h
@@ -26,3 +26,5 @@
#define FB_FPS 5
#define FB_MIN_SWAP_INTERVAL 6
#define FB_MAX_SWAP_INTERVAL 7
+
+using RenderControlByte = char;
\ No newline at end of file
diff --git a/system/vulkan/Android.mk b/system/vulkan/Android.mk
index b323d35..4f71cbb 100644
--- a/system/vulkan/Android.mk
+++ b/system/vulkan/Android.mk
@@ -9,7 +9,7 @@
# Vulkan include dir
ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
-LOCAL_C_INCLUDES += $(HOST_EMUGL_PATH)/host/include
+LOCAL_C_INCLUDES += $(GFXSTREAM_PROTOCOLS_PATH)/include/vulkan/include
endif
@@ -21,7 +21,7 @@
LOCAL_HEADER_LIBRARIES += \
hwvulkan_headers \
- vulkan_headers \
+ gfxstream_vulkan_headers \
endif
diff --git a/system/vulkan/CMakeLists.txt b/system/vulkan/CMakeLists.txt
index 12a84a4..c9115d1 100644
--- a/system/vulkan/CMakeLists.txt
+++ b/system/vulkan/CMakeLists.txt
@@ -1,10 +1,10 @@
# This is an autogenerated file! Do not edit!
# instead run make from .../device/generic/goldfish-opengl
# which will re-generate this file.
-android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/vulkan/Android.mk" "26b21ee8d8cf1c8ba5b47850310695979178e1117283253befc931dfed43a727")
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/vulkan/Android.mk" "b02756b89a6ae61787d3f13657ab459dd74fb3856394dac0e9c8f9106fd2b1e7")
set(vulkan.ranchu_src goldfish_vulkan.cpp)
android_add_library(TARGET vulkan.ranchu SHARED LICENSE Apache-2.0 SRC goldfish_vulkan.cpp)
-target_include_directories(vulkan.ranchu PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon/bionic-include ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/bionic/libc/platform ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/shared/gralloc_cb/include ${GOLDFISH_DEVICE_ROOT}/shared/GoldfishAddressSpace/include ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include-types ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include ${GOLDFISH_DEVICE_ROOT}/system/vulkan ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/host/include)
+target_include_directories(vulkan.ranchu PRIVATE ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon/bionic-include ${GOLDFISH_DEVICE_ROOT}/system/OpenglSystemCommon ${GOLDFISH_DEVICE_ROOT}/bionic/libc/private ${GOLDFISH_DEVICE_ROOT}/bionic/libc/platform ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/shared/gralloc_cb/include ${GOLDFISH_DEVICE_ROOT}/shared/GoldfishAddressSpace/include ${GOLDFISH_DEVICE_ROOT}/platform/include ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv2_enc ${GOLDFISH_DEVICE_ROOT}/system/GLESv1_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include-types ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include ${GOLDFISH_DEVICE_ROOT}/system/vulkan ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/../../../gfxstream-protocols/include/vulkan/include)
target_compile_definitions(vulkan.ranchu PRIVATE "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGFXSTREAM" "-DLOG_TAG=\"goldfish_vulkan\"" "-DVK_USE_PLATFORM_ANDROID_KHR" "-DVK_NO_PROTOTYPES")
target_compile_options(vulkan.ranchu PRIVATE "-fvisibility=default" "-Wno-unused-parameter" "-Wno-missing-field-initializers" "-fvisibility=hidden" "-fstrict-aliasing" "-Wno-unused-function")
-target_link_libraries(vulkan.ranchu PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host cutils utils androidemu GoldfishProfiler PRIVATE gralloc_cb_host GoldfishAddressSpace_host qemupipe_host)
\ No newline at end of file
+target_link_libraries(vulkan.ranchu PRIVATE OpenglSystemCommon android-emu-shared vulkan_enc gui log _renderControl_enc GLESv2_enc GLESv1_enc OpenglCodecCommon_host cutils utils androidemu GoldfishProfiler PRIVATE gralloc_cb_host GoldfishAddressSpace_host platform_host qemupipe_host)
\ No newline at end of file
diff --git a/system/vulkan/goldfish_vulkan.cpp b/system/vulkan/goldfish_vulkan.cpp
index 5e8384b..7e0b8f9 100644
--- a/system/vulkan/goldfish_vulkan.cpp
+++ b/system/vulkan/goldfish_vulkan.cpp
@@ -236,63 +236,6 @@
AEMU_SCOPED_TRACE("vkstubhal::GetBufferCollectionPropertiesFUCHSIA");
return VK_SUCCESS;
}
-
-VkResult CreateBufferCollectionFUCHSIAX(
- VkDevice /*device*/,
- const VkBufferCollectionCreateInfoFUCHSIAX* /*pInfo*/,
- const VkAllocationCallbacks* /*pAllocator*/,
- VkBufferCollectionFUCHSIAX* /*pCollection*/) {
- AEMU_SCOPED_TRACE("vkstubhal::CreateBufferCollectionFUCHSIAX");
- return VK_SUCCESS;
-}
-
-void DestroyBufferCollectionFUCHSIAX(
- VkDevice /*device*/,
- VkBufferCollectionFUCHSIAX /*collection*/,
- const VkAllocationCallbacks* /*pAllocator*/) {
- AEMU_SCOPED_TRACE("vkstubhal::DestroyBufferCollectionFUCHSIAX");
-}
-
-VkResult SetBufferCollectionConstraintsFUCHSIAX(
- VkDevice /*device*/,
- VkBufferCollectionFUCHSIAX /*collection*/,
- const VkImageCreateInfo* /*pImageInfo*/) {
- AEMU_SCOPED_TRACE("vkstubhal::SetBufferCollectionConstraintsFUCHSIAX");
- return VK_SUCCESS;
-}
-
-VkResult SetBufferCollectionImageConstraintsFUCHSIAX(
- VkDevice /*device*/,
- VkBufferCollectionFUCHSIAX /*collection*/,
- const VkImageConstraintsInfoFUCHSIAX* /*pImageConstraintsInfo*/) {
- AEMU_SCOPED_TRACE("vkstubhal::SetBufferCollectionImageConstraintsFUCHSIAX");
- return VK_SUCCESS;
-}
-
-VkResult SetBufferCollectionBufferConstraintsFUCHSIAX(
- VkDevice /*device*/,
- VkBufferCollectionFUCHSIAX /*collection*/,
- const VkBufferConstraintsInfoFUCHSIAX* /*pBufferConstraintsInfo*/) {
- AEMU_SCOPED_TRACE(
- "vkstubhal::SetBufferCollectionBufferConstraintsFUCHSIAX");
- return VK_SUCCESS;
-}
-
-VkResult GetBufferCollectionPropertiesFUCHSIAX(
- VkDevice /*device*/,
- VkBufferCollectionFUCHSIAX /*collection*/,
- VkBufferCollectionPropertiesFUCHSIAX* /*pProperties*/) {
- AEMU_SCOPED_TRACE("vkstubhal::GetBufferCollectionPropertiesFUCHSIAX");
- return VK_SUCCESS;
-}
-
-VkResult GetBufferCollectionProperties2FUCHSIAX(
- VkDevice /*device*/,
- VkBufferCollectionFUCHSIAX /*collection*/,
- VkBufferCollectionProperties2FUCHSIAX* /*pProperties*/) {
- AEMU_SCOPED_TRACE("vkstubhal::GetBufferCollectionProperties2FUCHSIAX");
- return VK_SUCCESS;
-}
#endif
PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance,
@@ -353,27 +296,6 @@
if (strcmp(name, "vkGetBufferCollectionPropertiesFUCHSIA") == 0)
return reinterpret_cast<PFN_vkVoidFunction>(
GetBufferCollectionPropertiesFUCHSIA);
- if (strcmp(name, "vkCreateBufferCollectionFUCHSIAX") == 0)
- return reinterpret_cast<PFN_vkVoidFunction>(
- CreateBufferCollectionFUCHSIAX);
- if (strcmp(name, "vkDestroyBufferCollectionFUCHSIAX") == 0)
- return reinterpret_cast<PFN_vkVoidFunction>(
- DestroyBufferCollectionFUCHSIAX);
- if (strcmp(name, "vkSetBufferCollectionConstraintsFUCHSIAX") == 0)
- return reinterpret_cast<PFN_vkVoidFunction>(
- SetBufferCollectionConstraintsFUCHSIAX);
- if (strcmp(name, "vkSetBufferCollectionImageConstraintsFUCHSIAX") == 0)
- return reinterpret_cast<PFN_vkVoidFunction>(
- SetBufferCollectionImageConstraintsFUCHSIAX);
- if (strcmp(name, "vkSetBufferCollectionBufferConstraintsFUCHSIAX") == 0)
- return reinterpret_cast<PFN_vkVoidFunction>(
- SetBufferCollectionBufferConstraintsFUCHSIAX);
- if (strcmp(name, "vkGetBufferCollectionPropertiesFUCHSIAX") == 0)
- return reinterpret_cast<PFN_vkVoidFunction>(
- GetBufferCollectionPropertiesFUCHSIAX);
- if (strcmp(name, "vkGetBufferCollectionProperties2FUCHSIAX") == 0)
- return reinterpret_cast<PFN_vkVoidFunction>(
- GetBufferCollectionProperties2FUCHSIAX);
#endif
// Return NoOp for entrypoints that should never be called.
if (strcmp(name, "vkGetPhysicalDeviceFeatures") == 0 ||
@@ -696,157 +618,6 @@
return res;
}
-VKAPI_ATTR
-VkResult CreateBufferCollectionFUCHSIAX(
- VkDevice device,
- const VkBufferCollectionCreateInfoFUCHSIAX* pInfo,
- const VkAllocationCallbacks* pAllocator,
- VkBufferCollectionFUCHSIAX* pCollection) {
- AEMU_SCOPED_TRACE("goldfish_vulkan::CreateBufferCollectionFUCHSIAX");
-
- VK_HOST_CONNECTION(VK_ERROR_DEVICE_LOST)
-
- if (!hostSupportsVulkan) {
- return vkstubhal::CreateBufferCollectionFUCHSIAX(
- device, pInfo, pAllocator, pCollection);
- }
-
- VkResult res =
- goldfish_vk::ResourceTracker::get()
- ->on_vkCreateBufferCollectionFUCHSIAX(
- vkEnc, VK_SUCCESS, device, pInfo, pAllocator, pCollection);
-
- return res;
-}
-
-VKAPI_ATTR
-void DestroyBufferCollectionFUCHSIAX(VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- const VkAllocationCallbacks* pAllocator) {
- AEMU_SCOPED_TRACE("goldfish_vulkan::DestroyBufferCollectionFUCHSIAX");
-
- VK_HOST_CONNECTION()
-
- if (!hostSupportsVulkan) {
- vkstubhal::DestroyBufferCollectionFUCHSIAX(device, collection,
- pAllocator);
- return;
- }
-
- goldfish_vk::ResourceTracker::get()->on_vkDestroyBufferCollectionFUCHSIAX(
- vkEnc, VK_SUCCESS, device, collection, pAllocator);
-}
-
-VKAPI_ATTR
-VkResult SetBufferCollectionConstraintsFUCHSIAX(
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- const VkImageCreateInfo* pImageInfo) {
- AEMU_SCOPED_TRACE(
- "goldfish_vulkan::SetBufferCollectionConstraintsFUCHSIAX");
-
- VK_HOST_CONNECTION(VK_ERROR_DEVICE_LOST)
-
- if (!hostSupportsVulkan) {
- return vkstubhal::SetBufferCollectionConstraintsFUCHSIAX(
- device, collection, pImageInfo);
- }
-
- VkResult res = goldfish_vk::ResourceTracker::get()
- ->on_vkSetBufferCollectionConstraintsFUCHSIAX(
- vkEnc, VK_SUCCESS, device, collection, pImageInfo);
-
- return res;
-}
-
-VKAPI_ATTR
-VkResult SetBufferCollectionBufferConstraintsFUCHSIAX(
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- const VkBufferConstraintsInfoFUCHSIAX* pBufferConstraintsInfo) {
- AEMU_SCOPED_TRACE(
- "goldfish_vulkan::SetBufferCollectionBufferConstraintsFUCHSIAX");
-
- VK_HOST_CONNECTION(VK_ERROR_DEVICE_LOST)
-
- if (!hostSupportsVulkan) {
- return vkstubhal::SetBufferCollectionBufferConstraintsFUCHSIAX(
- device, collection, pBufferConstraintsInfo);
- }
-
- VkResult res =
- goldfish_vk::ResourceTracker::get()
- ->on_vkSetBufferCollectionBufferConstraintsFUCHSIAX(
- vkEnc, VK_SUCCESS, device, collection, pBufferConstraintsInfo);
-
- return res;
-}
-
-VKAPI_ATTR
-VkResult SetBufferCollectionImageConstraintsFUCHSIAX(
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- const VkImageConstraintsInfoFUCHSIAX* pImageConstraintsInfo) {
- AEMU_SCOPED_TRACE(
- "goldfish_vulkan::SetBufferCollectionBufferConstraintsFUCHSIAX");
-
- VK_HOST_CONNECTION(VK_ERROR_DEVICE_LOST)
-
- if (!hostSupportsVulkan) {
- return vkstubhal::SetBufferCollectionImageConstraintsFUCHSIAX(
- device, collection, pImageConstraintsInfo);
- }
-
- VkResult res =
- goldfish_vk::ResourceTracker::get()
- ->on_vkSetBufferCollectionImageConstraintsFUCHSIAX(
- vkEnc, VK_SUCCESS, device, collection, pImageConstraintsInfo);
-
- return res;
-}
-
-VKAPI_ATTR
-VkResult GetBufferCollectionPropertiesFUCHSIAX(
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- VkBufferCollectionPropertiesFUCHSIAX* pProperties) {
- AEMU_SCOPED_TRACE("goldfish_vulkan::GetBufferCollectionPropertiesFUCHSIAX");
-
- VK_HOST_CONNECTION(VK_ERROR_DEVICE_LOST)
-
- if (!hostSupportsVulkan) {
- return vkstubhal::GetBufferCollectionPropertiesFUCHSIAX(
- device, collection, pProperties);
- }
-
- VkResult res = goldfish_vk::ResourceTracker::get()
- ->on_vkGetBufferCollectionPropertiesFUCHSIAX(
- vkEnc, VK_SUCCESS, device, collection, pProperties);
-
- return res;
-}
-
-VKAPI_ATTR
-VkResult GetBufferCollectionProperties2FUCHSIAX(
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- VkBufferCollectionProperties2FUCHSIAX* pProperties) {
- AEMU_SCOPED_TRACE(
- "goldfish_vulkan::GetBufferCollectionProperties2FUCHSIAX");
-
- VK_HOST_CONNECTION(VK_ERROR_DEVICE_LOST)
-
- if (!hostSupportsVulkan) {
- return vkstubhal::GetBufferCollectionProperties2FUCHSIAX(
- device, collection, pProperties);
- }
-
- VkResult res = goldfish_vk::ResourceTracker::get()
- ->on_vkGetBufferCollectionProperties2FUCHSIAX(
- vkEnc, VK_SUCCESS, device, collection, pProperties);
-
- return res;
-}
#endif
uint64_t currGuestTimeNs() {
@@ -887,6 +658,7 @@
static PFN_vkVoidFunction sQueueSignalReleaseImageAndroidImpl = 0;
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
static VkResult
QueueSignalReleaseImageANDROID(
VkQueue queue,
@@ -899,6 +671,7 @@
((PFN_vkQueueSignalReleaseImageANDROID)sQueueSignalReleaseImageAndroidImpl)(queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd);
return VK_SUCCESS;
}
+#endif
static PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* name) {
AEMU_SCOPED_TRACE("goldfish_vulkan::GetDeviceProcAddr");
@@ -937,28 +710,8 @@
if (!strcmp(name, "vkGetBufferCollectionPropertiesFUCHSIA")) {
return (PFN_vkVoidFunction)GetBufferCollectionPropertiesFUCHSIA;
}
- if (!strcmp(name, "vkCreateBufferCollectionFUCHSIAX")) {
- return (PFN_vkVoidFunction)CreateBufferCollectionFUCHSIAX;
- }
- if (!strcmp(name, "vkDestroyBufferCollectionFUCHSIAX")) {
- return (PFN_vkVoidFunction)DestroyBufferCollectionFUCHSIAX;
- }
- if (!strcmp(name, "vkSetBufferCollectionConstraintsFUCHSIAX")) {
- return (PFN_vkVoidFunction)SetBufferCollectionConstraintsFUCHSIAX;
- }
- if (!strcmp(name, "vkSetBufferCollectionImageConstraintsFUCHSIAX")) {
- return (PFN_vkVoidFunction)SetBufferCollectionImageConstraintsFUCHSIAX;
- }
- if (!strcmp(name, "vkSetBufferCollectionBufferConstraintsFUCHSIAX")) {
- return (PFN_vkVoidFunction)SetBufferCollectionBufferConstraintsFUCHSIAX;
- }
- if (!strcmp(name, "vkGetBufferCollectionPropertiesFUCHSIAX")) {
- return (PFN_vkVoidFunction)GetBufferCollectionPropertiesFUCHSIAX;
- }
- if (!strcmp(name, "vkGetBufferCollectionProperties2FUCHSIAX")) {
- return (PFN_vkVoidFunction)GetBufferCollectionProperties2FUCHSIAX;
- }
#endif
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
if (!strcmp(name, "vkQueueSignalReleaseImageANDROID")) {
if (!sQueueSignalReleaseImageAndroidImpl) {
sQueueSignalReleaseImageAndroidImpl =
@@ -967,6 +720,7 @@
}
return (PFN_vkVoidFunction)QueueSignalReleaseImageANDROID;
}
+#endif
if (!strcmp(name, "vkGetDeviceProcAddr")) {
return (PFN_vkVoidFunction)(GetDeviceProcAddr);
}
@@ -992,6 +746,7 @@
if (!strcmp(name, "vkGetDeviceProcAddr")) {
return (PFN_vkVoidFunction)(GetDeviceProcAddr);
}
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
if (!strcmp(name, "vkQueueSignalReleaseImageANDROID")) {
if (!sQueueSignalReleaseImageAndroidImpl) {
sQueueSignalReleaseImageAndroidImpl =
@@ -1000,6 +755,7 @@
}
return (PFN_vkVoidFunction)QueueSignalReleaseImageANDROID;
}
+#endif
return (PFN_vkVoidFunction)(goldfish_vk::goldfish_vulkan_get_instance_proc_address(instance, name));
}
@@ -1079,7 +835,7 @@
};
void VulkanDevice::InitLogger() {
- auto log_service = ([] () -> std::optional<zx::socket> {
+ auto log_socket = ([] () -> std::optional<zx::socket> {
fidl::ClientEnd<fuchsia_logger::LogSink> channel{zx::channel{
GetConnectToServiceFunction()("/svc/fuchsia.logger.LogSink")}};
if (!channel.is_valid())
@@ -1097,14 +853,15 @@
return local_socket;
})();
- if (!log_service)
+ if (!log_socket)
return;
- fx_logger_config_t config = {.min_severity = FX_LOG_INFO,
- .console_fd = -1,
- .log_service_channel = log_service->release(),
- .tags = nullptr,
- .num_tags = 0};
+ fx_logger_config_t config = {
+ .min_severity = FX_LOG_INFO,
+ .log_sink_socket = log_socket->release(),
+ .tags = nullptr,
+ .num_tags = 0,
+ };
fx_log_reconfigure(&config);
}
diff --git a/system/vulkan_enc/Android.mk b/system/vulkan_enc/Android.mk
index 583d3bf..b26971b 100644
--- a/system/vulkan_enc/Android.mk
+++ b/system/vulkan_enc/Android.mk
@@ -5,9 +5,11 @@
$(call emugl-import,libOpenglCodecCommon$(GOLDFISH_OPENGL_LIB_SUFFIX) lib_renderControl_enc)
ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
$(call emugl-import,libandroidemu)
+$(call emugl-import,libplatform$(GOLDFISH_OPENGL_LIB_SUFFIX))
$(call emugl-import,libGoldfishAddressSpace$(GOLDFISH_OPENGL_LIB_SUFFIX))
else
$(call emugl-export,SHARED_LIBRARIES,libandroidemu)
+$(call emugl-export,STATIC_LIBRARIES,libplatform)
$(call emugl-export,STATIC_LIBRARIES,libGoldfishAddressSpace)
endif
@@ -15,8 +17,7 @@
ifeq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
LOCAL_C_INCLUDES += \
$(LOCAL_PATH) \
- $(HOST_EMUGL_PATH)/host/include \
- $(HOST_EMUGL_PATH)/host/include/vulkan
+ $(GFXSTREAM_PROTOCOLS_PATH)/include/vulkan/include
endif
ifneq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
@@ -28,7 +29,7 @@
LOCAL_HEADER_LIBRARIES += \
hwvulkan_headers \
- vulkan_headers \
+ gfxstream_vulkan_headers \
LOCAL_SHARED_LIBRARIES += libdrm
diff --git a/system/vulkan_enc/AndroidHardwareBuffer.cpp b/system/vulkan_enc/AndroidHardwareBuffer.cpp
index c49693d..48dfc57 100644
--- a/system/vulkan_enc/AndroidHardwareBuffer.cpp
+++ b/system/vulkan_enc/AndroidHardwareBuffer.cpp
@@ -14,6 +14,13 @@
// limitations under the License.
#include "AndroidHardwareBuffer.h"
+#if !defined(HOST_BUILD)
+#if defined(__ANDROID__) || defined(__linux__)
+#include <drm_fourcc.h>
+#define DRM_FORMAT_YVU420_ANDROID fourcc_code('9', '9', '9', '7')
+#endif
+#endif
+
#include "../OpenglSystemCommon/HostConnection.h"
#include "vk_format_info.h"
@@ -55,11 +62,14 @@
VkResult getAndroidHardwareBufferPropertiesANDROID(
Gralloc* grallocHelper,
- const HostVisibleMemoryVirtualizationInfo* hostMemVirtInfo,
+ const VkPhysicalDeviceMemoryProperties* memProps,
VkDevice,
const AHardwareBuffer* buffer,
VkAndroidHardwareBufferPropertiesANDROID* pProperties) {
+ const native_handle_t *handle =
+ AHardwareBuffer_getNativeHandle(buffer);
+
VkAndroidHardwareBufferFormatPropertiesANDROID* ahbFormatProps =
vk_find_struct<VkAndroidHardwareBufferFormatPropertiesANDROID>(pProperties);
@@ -146,6 +156,65 @@
ahbFormatProps->samplerYcbcrConversionComponents.b = VK_COMPONENT_SWIZZLE_IDENTITY;
ahbFormatProps->samplerYcbcrConversionComponents.a = VK_COMPONENT_SWIZZLE_IDENTITY;
+#if !defined(HOST_BUILD)
+#if defined(__ANDROID__) || defined(__linux__)
+ if (android_format_is_yuv(desc.format)) {
+ uint32_t drmFormat = grallocHelper->getFormatDrmFourcc(handle);
+ if (drmFormat) {
+ // The host renderer is not aware of the plane ordering for YUV formats used
+ // in the guest and simply knows that the format "layout" is one of:
+ //
+ // * VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16
+ // * VK_FORMAT_G8_B8R8_2PLANE_420_UNORM
+ // * VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM
+ //
+ // With this, the guest needs to adjust the component swizzle based on plane
+ // ordering to ensure that the channels are interpreted correctly.
+ //
+ // From the Vulkan spec's "Sampler Y'CBCR Conversion" section:
+ //
+ // * Y comes from the G-channel (after swizzle)
+ // * U (CB) comes from the B-channel (after swizzle)
+ // * V (CR) comes from the R-channel (after swizzle)
+ //
+ // See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#textures-sampler-YCbCr-conversion
+ //
+ // To match the above, the guest needs to swizzle such that:
+ //
+ // * Y ends up in the G-channel
+ // * U (CB) ends up in the B-channel
+ // * V (CB) ends up in the R-channel
+ switch (drmFormat) {
+ case DRM_FORMAT_NV12:
+ // NV12 is a Y-plane followed by a interleaved UV-plane and is
+ // VK_FORMAT_G8_B8R8_2PLANE_420_UNORM on the host.
+ case DRM_FORMAT_P010:
+ // P010 is a Y-plane followed by a interleaved UV-plane and is
+ // VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 on the host.
+ break;
+
+ case DRM_FORMAT_NV21:
+ // NV21 is a Y-plane followed by a interleaved VU-plane and is
+ // VK_FORMAT_G8_B8R8_2PLANE_420_UNORM on the host.
+ case DRM_FORMAT_YVU420:
+ // YV12 is a Y-plane, then a V-plane, and then a U-plane and is
+ // VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM on the host.
+ case DRM_FORMAT_YVU420_ANDROID:
+ // DRM_FORMAT_YVU420_ANDROID is the same as DRM_FORMAT_YVU420 with
+ // Android's extra alignement requirements.
+ ahbFormatProps->samplerYcbcrConversionComponents.r = VK_COMPONENT_SWIZZLE_B;
+ ahbFormatProps->samplerYcbcrConversionComponents.b = VK_COMPONENT_SWIZZLE_R;
+ break;
+
+ default:
+ ALOGE("%s: Unhandled YUV drm format:%" PRIu32, __FUNCTION__, drmFormat);
+ break;
+ }
+ }
+ }
+#endif
+#endif
+
ahbFormatProps->suggestedYcbcrModel =
android_format_is_yuv(desc.format) ?
VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 :
@@ -156,20 +225,18 @@
ahbFormatProps->suggestedYChromaOffset = VK_CHROMA_LOCATION_MIDPOINT;
}
- const native_handle_t *handle =
- AHardwareBuffer_getNativeHandle(buffer);
uint32_t colorBufferHandle =
grallocHelper->getHostHandle(handle);
if (!colorBufferHandle) {
return VK_ERROR_INVALID_EXTERNAL_HANDLE;
}
- // Disallow host visible and noflags heaps for now
- // (hard to make actual dedicated allocs)
+ // Disallow host visible (hard to make actual dedicated allocs)
uint32_t memoryTypeBits = 0;
- for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i) {
- if (isNoFlagsMemoryTypeIndexForGuest(hostMemVirtInfo, i)) continue;
- if (isHostVisibleMemoryTypeIndexForGuest(hostMemVirtInfo, i)) continue;
+ for (uint32_t i = 0; i < memProps->memoryTypeCount; ++i) {
+ if (isHostVisible(memProps, i))
+ continue;
+
memoryTypeBits |= (1 << i);
}
diff --git a/system/vulkan_enc/AndroidHardwareBuffer.h b/system/vulkan_enc/AndroidHardwareBuffer.h
index 6cd72bc..f3cedde 100644
--- a/system/vulkan_enc/AndroidHardwareBuffer.h
+++ b/system/vulkan_enc/AndroidHardwareBuffer.h
@@ -33,7 +33,7 @@
VkResult getAndroidHardwareBufferPropertiesANDROID(
Gralloc* grallocHelper,
- const HostVisibleMemoryVirtualizationInfo* hostMemVirtInfo,
+ const VkPhysicalDeviceMemoryProperties* memProps,
VkDevice device,
const AHardwareBuffer* buffer,
VkAndroidHardwareBufferPropertiesANDROID* pProperties);
diff --git a/system/vulkan_enc/CMakeLists.txt b/system/vulkan_enc/CMakeLists.txt
index c35e354..0191fa7 100644
--- a/system/vulkan_enc/CMakeLists.txt
+++ b/system/vulkan_enc/CMakeLists.txt
@@ -1,10 +1,10 @@
# This is an autogenerated file! Do not edit!
# instead run make from .../device/generic/goldfish-opengl
# which will re-generate this file.
-android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc/Android.mk" "c24e604f7cd8a39732ec2aae658ded8a919a8e566deee75b74389ccd718e3a36")
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc/Android.mk" "2162ab8d00c0b94fa77886dcdcf579d6c357b2a11b35a87754dbab19159f0460")
set(vulkan_enc_src AndroidHardwareBuffer.cpp CommandBufferStagingStream.cpp DescriptorSetVirtualization.cpp HostVisibleMemoryVirtualization.cpp Resources.cpp Validation.cpp VulkanStreamGuest.cpp VulkanHandleMapping.cpp ResourceTracker.cpp VkEncoder.cpp goldfish_vk_extension_structs_guest.cpp goldfish_vk_marshaling_guest.cpp goldfish_vk_reserved_marshaling_guest.cpp goldfish_vk_deepcopy_guest.cpp goldfish_vk_counting_guest.cpp goldfish_vk_handlemap_guest.cpp goldfish_vk_transform_guest.cpp func_table.cpp)
android_add_library(TARGET vulkan_enc SHARED LICENSE Apache-2.0 SRC AndroidHardwareBuffer.cpp CommandBufferStagingStream.cpp DescriptorSetVirtualization.cpp HostVisibleMemoryVirtualization.cpp Resources.cpp Validation.cpp VulkanStreamGuest.cpp VulkanHandleMapping.cpp ResourceTracker.cpp VkEncoder.cpp goldfish_vk_extension_structs_guest.cpp goldfish_vk_marshaling_guest.cpp goldfish_vk_reserved_marshaling_guest.cpp goldfish_vk_deepcopy_guest.cpp goldfish_vk_counting_guest.cpp goldfish_vk_handlemap_guest.cpp goldfish_vk_transform_guest.cpp func_table.cpp)
-target_include_directories(vulkan_enc PRIVATE ${GOLDFISH_DEVICE_ROOT}/shared/GoldfishAddressSpace/include ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include-types ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/host/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/host/include/vulkan)
+target_include_directories(vulkan_enc PRIVATE ${GOLDFISH_DEVICE_ROOT}/shared/GoldfishAddressSpace/include ${GOLDFISH_DEVICE_ROOT}/platform/include ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include-types ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/../../../gfxstream-protocols/include/vulkan/include)
target_compile_definitions(vulkan_enc PRIVATE "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGFXSTREAM" "-DLOG_TAG=\"goldfish_vulkan\"" "-DVK_ANDROID_native_buffer" "-DVK_EXT_device_memory_report" "-DVK_GOOGLE_gfxstream" "-DVK_USE_PLATFORM_ANDROID_KHR" "-DVK_NO_PROTOTYPES" "-DVIRTIO_GPU" "-D__ANDROID_API__=28")
target_compile_options(vulkan_enc PRIVATE "-fvisibility=default" "-Wno-unused-parameter" "-Wno-missing-field-initializers" "-Werror" "-fstrict-aliasing")
-target_link_libraries(vulkan_enc PRIVATE gui log android-emu-shared _renderControl_enc OpenglCodecCommon_host cutils utils androidemu PRIVATE GoldfishAddressSpace_host qemupipe_host)
\ No newline at end of file
+target_link_libraries(vulkan_enc PRIVATE gui log android-emu-shared _renderControl_enc OpenglCodecCommon_host cutils utils androidemu PRIVATE GoldfishAddressSpace_host platform_host qemupipe_host)
\ No newline at end of file
diff --git a/system/vulkan_enc/HostVisibleMemoryVirtualization.cpp b/system/vulkan_enc/HostVisibleMemoryVirtualization.cpp
index 13d7d6d..d3c4e02 100644
--- a/system/vulkan_enc/HostVisibleMemoryVirtualization.cpp
+++ b/system/vulkan_enc/HostVisibleMemoryVirtualization.cpp
@@ -14,358 +14,58 @@
// limitations under the License.
#include "HostVisibleMemoryVirtualization.h"
-#include "android/base/AndroidSubAllocator.h"
-
-#include "Resources.h"
-#include "VkEncoder.h"
-
-#include "../OpenglSystemCommon/EmulatorFeatureInfo.h"
-
#include <log/log.h>
#include <set>
-#if defined(__ANDROID__) || defined(__linux__)
-#include <unistd.h>
-#include <errno.h>
-#endif
-
-#include <sys/mman.h>
-
-#if !defined(HOST_BUILD) && defined(VIRTIO_GPU)
-#include <xf86drm.h>
-#endif
+#include "../OpenglSystemCommon/EmulatorFeatureInfo.h"
+#include "ResourceTracker.h"
+#include "Resources.h"
+#include "VkEncoder.h"
+#include "android/base/AndroidSubAllocator.h"
using android::base::guest::SubAllocator;
namespace goldfish_vk {
-bool canFitVirtualHostVisibleMemoryInfo(
- const VkPhysicalDeviceMemoryProperties* memoryProperties) {
- uint32_t typeCount =
- memoryProperties->memoryTypeCount;
- uint32_t heapCount =
- memoryProperties->memoryHeapCount;
-
- bool canFit = true;
-
- if (typeCount == VK_MAX_MEMORY_TYPES) {
- canFit = false;
- ALOGE("Underlying device has no free memory types");
- }
-
- if (heapCount == VK_MAX_MEMORY_HEAPS) {
- canFit = false;
- ALOGE("Underlying device has no free memory heaps");
- }
-
- uint32_t numFreeMemoryTypes = VK_MAX_MEMORY_TYPES - typeCount;
- uint32_t hostVisibleMemoryTypeCount = 0;
-
- if (hostVisibleMemoryTypeCount > numFreeMemoryTypes) {
- ALOGE("Underlying device has too many host visible memory types (%u)"
- "and not enough free types (%u)",
- hostVisibleMemoryTypeCount, numFreeMemoryTypes);
- canFit = false;
- }
-
- return canFit;
+bool isHostVisible(const VkPhysicalDeviceMemoryProperties* memoryProps, uint32_t index) {
+ return memoryProps->memoryTypes[index].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
}
-void initHostVisibleMemoryVirtualizationInfo(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceMemoryProperties* memoryProperties,
- const EmulatorFeatureInfo* featureInfo,
- HostVisibleMemoryVirtualizationInfo* info_out) {
-
- if (info_out->initialized) return;
-
- info_out->hostMemoryProperties = *memoryProperties;
- info_out->initialized = true;
-
- info_out->memoryPropertiesSupported =
- canFitVirtualHostVisibleMemoryInfo(memoryProperties);
-
- info_out->directMemSupported = featureInfo->hasDirectMem;
- info_out->virtioGpuNextSupported = featureInfo->hasVirtioGpuNext;
-
- if (!info_out->memoryPropertiesSupported ||
- (!info_out->directMemSupported &&
- !info_out->virtioGpuNextSupported)) {
- info_out->virtualizationSupported = false;
- return;
- }
-
- info_out->virtualizationSupported = true;
-
- info_out->physicalDevice = physicalDevice;
- info_out->guestMemoryProperties = *memoryProperties;
-
- uint32_t typeCount =
- memoryProperties->memoryTypeCount;
- uint32_t heapCount =
- memoryProperties->memoryHeapCount;
-
- uint32_t firstFreeTypeIndex = typeCount;
- uint32_t firstFreeHeapIndex = heapCount;
-
- for (uint32_t i = 0; i < typeCount; ++i) {
-
- // Set up identity mapping and not-both
- // by default, to be edited later.
- info_out->memoryTypeIndexMappingToHost[i] = i;
- info_out->memoryHeapIndexMappingToHost[i] = i;
-
- info_out->memoryTypeIndexMappingFromHost[i] = i;
- info_out->memoryHeapIndexMappingFromHost[i] = i;
-
- info_out->memoryTypeBitsShouldAdvertiseBoth[i] = false;
-
- const auto& type = memoryProperties->memoryTypes[i];
-
- if (type.propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
- uint32_t heapIndex = type.heapIndex;
-
- auto& guestMemoryType =
- info_out->guestMemoryProperties.memoryTypes[i];
-
- auto& newVirtualMemoryType =
- info_out->guestMemoryProperties.memoryTypes[firstFreeTypeIndex];
-
- auto& newVirtualMemoryHeap =
- info_out->guestMemoryProperties.memoryHeaps[firstFreeHeapIndex];
-
- // Remove all references to host visible in the guest memory type at
- // index i, while transferring them to the new virtual memory type.
- newVirtualMemoryType = type;
-
- // Set this memory type to have a separate heap.
- newVirtualMemoryType.heapIndex = firstFreeHeapIndex;
-
- newVirtualMemoryType.propertyFlags =
- type.propertyFlags &
- ~(VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
-
- guestMemoryType.propertyFlags =
- type.propertyFlags & \
- ~(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
- VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
- VK_MEMORY_PROPERTY_HOST_CACHED_BIT);
-
- // In the corresponding new memory heap, copy the information over,
- // remove device local flags, and resize it based on what is
- // supported by the PCI device.
- newVirtualMemoryHeap =
- memoryProperties->memoryHeaps[heapIndex];
- newVirtualMemoryHeap.flags =
- newVirtualMemoryHeap.flags &
- ~(VK_MEMORY_HEAP_DEVICE_LOCAL_BIT);
-
- // TODO: Figure out how to support bigger sizes
- newVirtualMemoryHeap.size = VIRTUAL_HOST_VISIBLE_HEAP_SIZE;
-
- info_out->memoryTypeIndexMappingToHost[firstFreeTypeIndex] = i;
- info_out->memoryHeapIndexMappingToHost[firstFreeHeapIndex] = i;
-
- info_out->memoryTypeIndexMappingFromHost[i] = firstFreeTypeIndex;
- info_out->memoryHeapIndexMappingFromHost[i] = firstFreeHeapIndex;
-
- // Was the original memory type also a device local type? If so,
- // advertise both types in resulting type bits.
- info_out->memoryTypeBitsShouldAdvertiseBoth[i] =
- type.propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT ||
- type.propertyFlags == 0;
-
- ++firstFreeTypeIndex;
-
- // Explicitly only create one new heap.
- // ++firstFreeHeapIndex;
- }
- }
-
- info_out->guestMemoryProperties.memoryTypeCount = firstFreeTypeIndex;
- info_out->guestMemoryProperties.memoryHeapCount = firstFreeHeapIndex + 1;
-
- for (uint32_t i = info_out->guestMemoryProperties.memoryTypeCount; i < VK_MAX_MEMORY_TYPES; ++i) {
- memset(&info_out->guestMemoryProperties.memoryTypes[i],
- 0x0, sizeof(VkMemoryType));
- }
+CoherentMemory::CoherentMemory(VirtGpuBlobMappingPtr blobMapping, uint64_t size, VkDevice device,
+ VkDeviceMemory memory)
+ : mSize(size), mBlobMapping(blobMapping), mDevice(device), mMemory(memory) {
+ mAllocator =
+ std::make_unique<android::base::guest::SubAllocator>(blobMapping->asRawPtr(), mSize, 4096);
}
-bool isHostVisibleMemoryTypeIndexForGuest(
- const HostVisibleMemoryVirtualizationInfo* info,
- uint32_t index) {
-
- const auto& props =
- info->virtualizationSupported ?
- info->guestMemoryProperties :
- info->hostMemoryProperties;
-
- return props.memoryTypes[index].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
+CoherentMemory::CoherentMemory(GoldfishAddressSpaceBlockPtr block, uint64_t gpuAddr, uint64_t size,
+ VkDevice device, VkDeviceMemory memory)
+ : mSize(size), mBlock(block), mDevice(device), mMemory(memory) {
+ void* address = block->mmap(gpuAddr);
+ mAllocator =
+ std::make_unique<android::base::guest::SubAllocator>(address, mSize, kLargestPageSize);
}
-bool isDeviceLocalMemoryTypeIndexForGuest(
- const HostVisibleMemoryVirtualizationInfo* info,
- uint32_t index) {
-
- const auto& props =
- info->virtualizationSupported ?
- info->guestMemoryProperties :
- info->hostMemoryProperties;
-
- return props.memoryTypes[index].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+CoherentMemory::~CoherentMemory() {
+ ResourceTracker::getThreadLocalEncoder()->vkFreeMemorySyncGOOGLE(mDevice, mMemory, nullptr,
+ false);
}
-VkResult finishHostMemAllocInit(
- VkEncoder*,
- VkDevice device,
- uint32_t memoryTypeIndex,
- VkDeviceSize nonCoherentAtomSize,
- VkDeviceSize allocSize,
- VkDeviceSize mappedSize,
- uint8_t* mappedPtr,
- HostMemAlloc* out) {
+VkDeviceMemory CoherentMemory::getDeviceMemory() const { return mMemory; }
- out->device = device;
- out->memoryTypeIndex = memoryTypeIndex;
- out->nonCoherentAtomSize = nonCoherentAtomSize;
- out->allocSize = allocSize;
- out->mappedSize = mappedSize;
- out->mappedPtr = mappedPtr;
+bool CoherentMemory::subAllocate(uint64_t size, uint8_t** ptr, uint64_t& offset) {
+ auto address = mAllocator->alloc(size);
+ if (!address) return false;
- // because it's not just nonCoherentAtomSize granularity,
- // people will also use it for uniform buffers, images, etc.
- // that need some bigger alignment
-// #define HIGHEST_BUFFER_OR_IMAGE_ALIGNMENT 1024
-// bug: 145153816
-// HACK: Make it 65k so yuv images are happy on vk cts 1.2.1
-// TODO: Use a munmap/mmap MAP_FIXED scheme to realign memories
-// if it's found that the buffer or image bind alignment will be violated
-#define HIGHEST_BUFFER_OR_IMAGE_ALIGNMENT 65536
-
- uint64_t neededPageSize = out->nonCoherentAtomSize;
- if (HIGHEST_BUFFER_OR_IMAGE_ALIGNMENT >
- neededPageSize) {
- neededPageSize = HIGHEST_BUFFER_OR_IMAGE_ALIGNMENT;
- }
-
- out->subAlloc = new
- SubAllocator(
- out->mappedPtr,
- out->mappedSize,
- neededPageSize);
-
- out->initialized = true;
- out->initResult = VK_SUCCESS;
- return VK_SUCCESS;
-}
-
-void destroyHostMemAlloc(
- bool freeMemorySyncSupported,
- VkEncoder* enc,
- VkDevice device,
- HostMemAlloc* toDestroy,
- bool doLock) {
-#if !defined(HOST_BUILD) && defined(VIRTIO_GPU)
- if (toDestroy->rendernodeFd >= 0) {
-
- if (toDestroy->memoryAddr) {
- int ret = munmap((void*)toDestroy->memoryAddr, toDestroy->memorySize);
- if (ret != 0) {
- ALOGE("%s: fail to unmap addr = 0x%" PRIx64", size = %d, ret = "
- "%d, errno = %d", __func__, toDestroy->memoryAddr,
- (int32_t)toDestroy->memorySize, ret, errno);
- }
- }
-
- if (toDestroy->boCreated) {
- ALOGV("%s: trying to destroy bo = %u\n", __func__,
- toDestroy->boHandle);
- struct drm_gem_close drmGemClose = {};
- drmGemClose.handle = toDestroy->boHandle;
- int ret = drmIoctl(toDestroy->rendernodeFd, DRM_IOCTL_GEM_CLOSE, &drmGemClose);
- if (ret != 0) {
- ALOGE("%s: fail to close gem = %u, ret = %d, errno = %d\n",
- __func__, toDestroy->boHandle, ret, errno);
- } else {
- ALOGV("%s: successfully close gem = %u, ret = %d\n", __func__,
- toDestroy->boHandle, ret);
- }
- }
- }
-#endif
-
- if (toDestroy->initResult != VK_SUCCESS) return;
- if (!toDestroy->initialized) return;
-
-
- if (freeMemorySyncSupported) {
- enc->vkFreeMemorySyncGOOGLE(device, toDestroy->memory, nullptr, doLock);
- } else {
- enc->vkFreeMemory(device, toDestroy->memory, nullptr, doLock);
- }
-
- delete toDestroy->subAlloc;
-}
-
-void subAllocHostMemory(
- HostMemAlloc* alloc,
- const VkMemoryAllocateInfo* pAllocateInfo,
- SubAlloc* out) {
-
- VkDeviceSize mappedSize =
- alloc->nonCoherentAtomSize * (
- (pAllocateInfo->allocationSize +
- alloc->nonCoherentAtomSize - 1) /
- alloc->nonCoherentAtomSize);
-
- ALOGV("%s: alloc size %u mapped size %u ncaSize %u\n", __func__,
- (unsigned int)pAllocateInfo->allocationSize,
- (unsigned int)mappedSize,
- (unsigned int)alloc->nonCoherentAtomSize);
-
- void* subMapped = alloc->subAlloc->alloc(mappedSize);
- out->mappedPtr = (uint8_t*)subMapped;
-
- out->subAllocSize = pAllocateInfo->allocationSize;
- out->subMappedSize = mappedSize;
-
- out->baseMemory = alloc->memory;
- out->baseOffset = alloc->subAlloc->getOffset(subMapped);
-
- out->subMemory = new_from_host_VkDeviceMemory(VK_NULL_HANDLE);
- out->subAlloc = alloc->subAlloc;
- out->isDeviceAddressMemoryAllocation = alloc->isDeviceAddressMemoryAllocation;
- out->memoryTypeIndex = alloc->memoryTypeIndex;
-}
-
-bool subFreeHostMemory(SubAlloc* toFree) {
- delete_goldfish_VkDeviceMemory(toFree->subMemory);
- toFree->subAlloc->free(toFree->mappedPtr);
- bool nowEmpty = toFree->subAlloc->empty();
- if (nowEmpty) {
- ALOGV("%s: We have an empty suballoc, time to free the block perhaps?\n", __func__);
- }
- memset(toFree, 0x0, sizeof(SubAlloc));
- return nowEmpty;
-}
-
-bool canSubAlloc(android::base::guest::SubAllocator* subAlloc, VkDeviceSize size) {
- auto ptr = subAlloc->alloc(size);
- if (!ptr) return false;
- subAlloc->free(ptr);
+ *ptr = (uint8_t*)address;
+ offset = mAllocator->getOffset(address);
return true;
}
-bool isNoFlagsMemoryTypeIndexForGuest(
- const HostVisibleMemoryVirtualizationInfo* info,
- uint32_t index) {
- const auto& props =
- info->virtualizationSupported ?
- info->guestMemoryProperties :
- info->hostMemoryProperties;
- return props.memoryTypes[index].propertyFlags == 0;
+bool CoherentMemory::release(uint8_t* ptr) {
+ mAllocator->free(ptr);
+ return true;
}
-
-} // namespace goldfish_vk
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/HostVisibleMemoryVirtualization.h b/system/vulkan_enc/HostVisibleMemoryVirtualization.h
index 66d6042..6ec9427 100644
--- a/system/vulkan_enc/HostVisibleMemoryVirtualization.h
+++ b/system/vulkan_enc/HostVisibleMemoryVirtualization.h
@@ -16,125 +16,54 @@
#include <vulkan/vulkan.h>
-#define VIRTUAL_HOST_VISIBLE_HEAP_SIZE 512ULL * (1048576ULL)
+#include "android/base/AndroidSubAllocator.h"
+#include "goldfish_address_space.h"
-struct EmulatorFeatureInfo;
+constexpr uint64_t kMegaBtye = 1048576;
-namespace android {
-namespace base {
-namespace guest {
+// This needs to be a power of 2 that is at least the min alignment needed
+// in HostVisibleMemoryVirtualization.cpp.
+// Some Windows drivers require a 64KB alignment for suballocated memory (b:152769369) for YUV
+// images.
+constexpr uint64_t kLargestPageSize = 65536;
-class SubAllocator;
+constexpr uint64_t kDefaultHostMemBlockSize = 16 * kMegaBtye; // 16 mb
+constexpr uint64_t kHostVisibleHeapSize = 512 * kMegaBtye; // 512 mb
-} // namespace guest
-} // namespace base
-} // namespace android
+#include "VirtGpu.h"
namespace goldfish_vk {
-class VkEncoder;
+bool isHostVisible(const VkPhysicalDeviceMemoryProperties* memoryProps, uint32_t index);
-struct HostVisibleMemoryVirtualizationInfo {
- bool initialized = false;
- bool memoryPropertiesSupported;
- bool directMemSupported;
- bool virtualizationSupported;
- bool virtioGpuNextSupported;
+using GoldfishAddressSpaceBlockPtr = std::shared_ptr<GoldfishAddressSpaceBlock>;
+using SubAllocatorPtr = std::unique_ptr<android::base::guest::SubAllocator>;
- VkPhysicalDevice physicalDevice;
+class CoherentMemory {
+ public:
+ CoherentMemory(VirtGpuBlobMappingPtr blobMapping, uint64_t size, VkDevice device,
+ VkDeviceMemory memory);
+ CoherentMemory(GoldfishAddressSpaceBlockPtr block, uint64_t gpuAddr, uint64_t size,
+ VkDevice device, VkDeviceMemory memory);
+ ~CoherentMemory();
- VkPhysicalDeviceMemoryProperties hostMemoryProperties;
- VkPhysicalDeviceMemoryProperties guestMemoryProperties;
+ VkDeviceMemory getDeviceMemory() const;
- uint32_t memoryTypeIndexMappingToHost[VK_MAX_MEMORY_TYPES];
- uint32_t memoryHeapIndexMappingToHost[VK_MAX_MEMORY_TYPES];
+ bool subAllocate(uint64_t size, uint8_t** ptr, uint64_t& offset);
+ bool release(uint8_t* ptr);
- uint32_t memoryTypeIndexMappingFromHost[VK_MAX_MEMORY_TYPES];
- uint32_t memoryHeapIndexMappingFromHost[VK_MAX_MEMORY_TYPES];
+ private:
+ CoherentMemory(CoherentMemory const&);
+ void operator=(CoherentMemory const&);
- bool memoryTypeBitsShouldAdvertiseBoth[VK_MAX_MEMORY_TYPES];
+ uint64_t mSize;
+ VirtGpuBlobMappingPtr mBlobMapping = nullptr;
+ GoldfishAddressSpaceBlockPtr mBlock = nullptr;
+ VkDevice mDevice;
+ VkDeviceMemory mMemory;
+ SubAllocatorPtr mAllocator;
};
-bool canFitVirtualHostVisibleMemoryInfo(
- const VkPhysicalDeviceMemoryProperties* memoryProperties);
+using CoherentMemoryPtr = std::shared_ptr<CoherentMemory>;
-void initHostVisibleMemoryVirtualizationInfo(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceMemoryProperties* memoryProperties,
- const EmulatorFeatureInfo* featureInfo,
- HostVisibleMemoryVirtualizationInfo* info_out);
-
-bool isHostVisibleMemoryTypeIndexForGuest(
- const HostVisibleMemoryVirtualizationInfo* info,
- uint32_t index);
-
-bool isDeviceLocalMemoryTypeIndexForGuest(
- const HostVisibleMemoryVirtualizationInfo* info,
- uint32_t index);
-
-struct HostMemAlloc {
- bool initialized = false;
- VkResult initResult = VK_SUCCESS;
- VkDevice device = nullptr;
- uint32_t memoryTypeIndex = 0;
- VkDeviceSize nonCoherentAtomSize = 0;
- VkDeviceMemory memory = VK_NULL_HANDLE;
- VkDeviceSize allocSize = 0;
- VkDeviceSize mappedSize = 0;
- uint8_t* mappedPtr = nullptr;
- android::base::guest::SubAllocator* subAlloc = nullptr;
- int rendernodeFd = -1;
- bool boCreated = false;
- uint32_t boHandle = 0;
- uint64_t memoryAddr = 0;
- size_t memorySize = 0;
- bool isDeviceAddressMemoryAllocation = false;
- bool isDedicated = false;
-};
-
-VkResult finishHostMemAllocInit(
- VkEncoder* enc,
- VkDevice device,
- uint32_t memoryTypeIndex,
- VkDeviceSize nonCoherentAtomSize,
- VkDeviceSize allocSize,
- VkDeviceSize mappedSize,
- uint8_t* mappedPtr,
- HostMemAlloc* out);
-
-void destroyHostMemAlloc(
- bool freeMemorySyncSupported,
- VkEncoder* enc,
- VkDevice device,
- HostMemAlloc* toDestroy,
- bool doLock);
-
-struct SubAlloc {
- uint8_t* mappedPtr = nullptr;
- VkDeviceSize subAllocSize = 0;
- VkDeviceSize subMappedSize = 0;
-
- VkDeviceMemory baseMemory = VK_NULL_HANDLE;
- VkDeviceSize baseOffset = 0;
- android::base::guest::SubAllocator* subAlloc = nullptr;
- VkDeviceMemory subMemory = VK_NULL_HANDLE;
- bool isDeviceAddressMemoryAllocation = false;
- uint32_t memoryTypeIndex = 0;
-};
-
-void subAllocHostMemory(
- HostMemAlloc* alloc,
- const VkMemoryAllocateInfo* pAllocateInfo,
- SubAlloc* out);
-
-// Returns true if the block would have been emptied.
-// In that case, we can then go back and tear down the block itself.
-bool subFreeHostMemory(SubAlloc* toFree);
-
-bool canSubAlloc(android::base::guest::SubAllocator* subAlloc, VkDeviceSize size);
-
-bool isNoFlagsMemoryTypeIndexForGuest(
- const HostVisibleMemoryVirtualizationInfo* info,
- uint32_t index);
-
-} // namespace goldfish_vk
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/ResourceTracker.cpp b/system/vulkan_enc/ResourceTracker.cpp
index c9a1606..72d5da3 100644
--- a/system/vulkan_enc/ResourceTracker.cpp
+++ b/system/vulkan_enc/ResourceTracker.cpp
@@ -27,6 +27,7 @@
#include "../OpenglSystemCommon/EmulatorFeatureInfo.h"
#include "../OpenglSystemCommon/HostConnection.h"
+#include "vulkan/vulkan_core.h"
/// Use installed headers or locally defined Fuchsia-specific bits
#ifdef VK_USE_PLATFORM_FUCHSIA
@@ -36,6 +37,7 @@
#include <fidl/fuchsia.sysmem/cpp/wire.h>
#include <lib/zx/channel.h>
#include <lib/zx/vmo.h>
+#include <optional>
#include <zircon/errors.h>
#include <zircon/process.h>
#include <zircon/rights.h>
@@ -49,7 +51,7 @@
#endif
#define GET_STATUS_SAFE(result, member) \
- ((result).ok() ? ((result).Unwrap()->member) : ZX_OK)
+ ((result).ok() ? ((result)->member) : ZX_OK)
#else
@@ -76,48 +78,6 @@
#include <android/hardware_buffer.h>
-native_handle_t *AHardwareBuffer_getNativeHandle(AHardwareBuffer*) { return NULL; }
-
-uint64_t getAndroidHardwareBufferUsageFromVkUsage(
- const VkImageCreateFlags vk_create,
- const VkImageUsageFlags vk_usage) {
- return AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
-}
-
-VkResult importAndroidHardwareBuffer(
- Gralloc *grallocHelper,
- const VkImportAndroidHardwareBufferInfoANDROID* info,
- struct AHardwareBuffer **importOut) {
- return VK_SUCCESS;
-}
-
-VkResult createAndroidHardwareBuffer(
- bool hasDedicatedImage,
- bool hasDedicatedBuffer,
- const VkExtent3D& imageExtent,
- uint32_t imageLayers,
- VkFormat imageFormat,
- VkImageUsageFlags imageUsage,
- VkImageCreateFlags imageCreateFlags,
- VkDeviceSize bufferSize,
- VkDeviceSize allocationInfoAllocSize,
- struct AHardwareBuffer **out) {
- return VK_SUCCESS;
-}
-
-namespace goldfish_vk {
-struct HostVisibleMemoryVirtualizationInfo;
-}
-
-VkResult getAndroidHardwareBufferPropertiesANDROID(
- Gralloc *grallocHelper,
- const goldfish_vk::HostVisibleMemoryVirtualizationInfo*,
- VkDevice,
- const AHardwareBuffer*,
- VkAndroidHardwareBufferPropertiesANDROID*) { return VK_SUCCESS; }
-
-VkResult getMemoryAndroidHardwareBufferANDROID(struct AHardwareBuffer **) { return VK_SUCCESS; }
-
#endif // VK_USE_PLATFORM_ANDROID_KHR
#include "HostVisibleMemoryVirtualization.h"
@@ -126,10 +86,13 @@
#include "android/base/AlignedBuf.h"
#include "android/base/synchronization/AndroidLock.h"
+#include "virtgpu_gfxstream_protocol.h"
#include "goldfish_address_space.h"
#include "goldfish_vk_private_defs.h"
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
#include "vk_format_info.h"
+#endif
#include "vk_struct_id.h"
#include "vk_util.h"
@@ -151,9 +114,6 @@
#ifdef HOST_BUILD
#include "android/utils/tempfile.h"
-#else
-#include "virtgpu_drm.h"
-#include <xf86drm.h>
#endif
static inline int
@@ -181,8 +141,6 @@
#endif
#endif
-using android::aligned_buf_alloc;
-using android::aligned_buf_free;
using android::base::Optional;
using android::base::guest::AutoLock;
using android::base::guest::RecursiveLock;
@@ -307,40 +265,34 @@
std::vector<VkPhysicalDevice> physicalDevices;
};
- using HostMemBlocks = std::vector<HostMemAlloc>;
- using HostMemBlockIndex = size_t;
-
-#define INVALID_HOST_MEM_BLOCK (-1)
-
struct VkDevice_Info {
VkPhysicalDevice physdev;
VkPhysicalDeviceProperties props;
VkPhysicalDeviceMemoryProperties memProps;
- std::vector<HostMemBlocks> hostMemBlocks { VK_MAX_MEMORY_TYPES };
uint32_t apiVersion;
std::set<std::string> enabledExtensions;
std::vector<std::pair<PFN_vkDeviceMemoryReportCallbackEXT, void *>> deviceMemoryReportCallbacks;
};
- struct VirtioGpuHostmemResourceInfo {
- uint32_t resourceId = 0;
- int primeFd = -1;
- };
-
struct VkDeviceMemory_Info {
- VkDeviceSize allocationSize = 0;
- VkDeviceSize mappedSize = 0;
- uint8_t* mappedPtr = nullptr;
- uint32_t memoryTypeIndex = 0;
- bool virtualHostVisibleBacking = false;
- bool directMapped = false;
- GoldfishAddressSpaceBlock*
- goldfishAddressSpaceBlock = nullptr;
- VirtioGpuHostmemResourceInfo resInfo;
- SubAlloc subAlloc;
- AHardwareBuffer* ahw = nullptr;
+ bool dedicated = false;
bool imported = false;
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+ AHardwareBuffer* ahw = nullptr;
+#endif
zx_handle_t vmoHandle = ZX_HANDLE_INVALID;
+ VkDevice device;
+
+ uint8_t* ptr = nullptr;
+
+ uint64_t allocationSize = 0;
+ uint32_t memoryTypeIndex = 0;
+ uint64_t coherentMemorySize = 0;
+ uint64_t coherentMemoryOffset = 0;
+
+ GoldfishAddressSpaceBlockPtr goldfishBlock = nullptr;
+ CoherentMemoryPtr coherentMemory = nullptr;
};
struct VkCommandBuffer_Info {
@@ -365,6 +317,7 @@
#ifdef VK_USE_PLATFORM_ANDROID_KHR
bool hasExternalFormat = false;
unsigned androidFormat = 0;
+ std::vector<int> pendingQsriSyncFds;
#endif
#ifdef VK_USE_PLATFORM_FUCHSIA
bool isSysmemBackedMemory = false;
@@ -390,7 +343,7 @@
VkDevice device;
zx_handle_t eventHandle = ZX_HANDLE_INVALID;
zx_koid_t eventKoid = ZX_KOID_INVALID;
- int syncFd = -1;
+ std::optional<int> syncFd = {};
};
struct VkDescriptorUpdateTemplate_Info {
@@ -450,20 +403,6 @@
#endif // VK_USE_PLATFORM_FUCHSIA
};
- struct VkBufferCollectionFUCHSIAX_Info {
-#ifdef VK_USE_PLATFORM_FUCHSIA
- android::base::Optional<
- fuchsia_sysmem::wire::BufferCollectionConstraints>
- constraints;
- android::base::Optional<VkBufferCollectionProperties2FUCHSIAX>
- properties;
-
- // the index of corresponding createInfo for each image format
- // constraints in |constraints|.
- std::vector<uint32_t> createInfoIndex;
-#endif // VK_USE_PLATFORM_FUCHSIA
- };
-
#define HANDLE_REGISTER_IMPL_IMPL(type) \
std::unordered_map<type, type##_Info> info_##type; \
void register_##type(type obj) { \
@@ -555,27 +494,16 @@
auto& memInfo = it->second;
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
if (memInfo.ahw) {
AHardwareBuffer_release(memInfo.ahw);
}
+#endif
if (memInfo.vmoHandle != ZX_HANDLE_INVALID) {
zx_handle_close(memInfo.vmoHandle);
}
- if (memInfo.mappedPtr &&
- !memInfo.virtualHostVisibleBacking &&
- !memInfo.directMapped) {
- aligned_buf_free(memInfo.mappedPtr);
- }
-
- if (memInfo.directMapped) {
- ALOGE("%s: warning: direct mapped memory never goes to unregister!\n", __func__);
- subFreeHostMemory(&memInfo.subAlloc);
- }
-
- delete memInfo.goldfishAddressSpaceBlock;
-
info_VkDeviceMemory.erase(mem);
}
@@ -612,8 +540,8 @@
}
#if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
- if (semInfo.syncFd >= 0) {
- close(semInfo.syncFd);
+ if (semInfo.syncFd.value_or(-1) >= 0) {
+ close(semInfo.syncFd.value());
}
#endif
@@ -669,14 +597,6 @@
}
#endif
-#ifdef VK_USE_PLATFORM_FUCHSIA
- void unregister_VkBufferCollectionFUCHSIAX(
- VkBufferCollectionFUCHSIAX collection) {
- AutoLock<RecursiveLock> lock(mLock);
- info_VkBufferCollectionFUCHSIAX.erase(collection);
- }
-#endif
-
void unregister_VkDescriptorSet_locked(VkDescriptorSet set) {
struct goldfish_VkDescriptorSet* ds = as_goldfish_VkDescriptorSet(set);
delete ds->reified;
@@ -854,10 +774,6 @@
info.physdev = physdev;
info.props = props;
info.memProps = memProps;
- initHostVisibleMemoryVirtualizationInfo(
- physdev, &memProps,
- mFeatureInfo.get(),
- &mHostVisibleMemoryVirtInfo);
info.apiVersion = props.apiVersion;
const VkBaseInStructure *extensionCreateInfo =
@@ -912,21 +828,21 @@
void setDeviceMemoryInfo(VkDevice device,
VkDeviceMemory memory,
VkDeviceSize allocationSize,
- VkDeviceSize mappedSize,
uint8_t* ptr,
uint32_t memoryTypeIndex,
AHardwareBuffer* ahw = nullptr,
bool imported = false,
zx_handle_t vmoHandle = ZX_HANDLE_INVALID) {
AutoLock<RecursiveLock> lock(mLock);
- auto& deviceInfo = info_VkDevice[device];
auto& info = info_VkDeviceMemory[memory];
+ info.device = device;
info.allocationSize = allocationSize;
- info.mappedSize = mappedSize;
- info.mappedPtr = ptr;
+ info.ptr = ptr;
info.memoryTypeIndex = memoryTypeIndex;
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
info.ahw = ahw;
+#endif
info.imported = imported;
info.vmoHandle = vmoHandle;
}
@@ -947,7 +863,7 @@
if (it == info_VkDeviceMemory.end()) return nullptr;
const auto& info = it->second;
- return info.mappedPtr;
+ return info.ptr;
}
VkDeviceSize getMappedSize(VkDeviceMemory memory) {
@@ -956,20 +872,7 @@
if (it == info_VkDeviceMemory.end()) return 0;
const auto& info = it->second;
- return info.mappedSize;
- }
-
- VkDeviceSize getNonCoherentExtendedSize(VkDevice device, VkDeviceSize basicSize) const {
- AutoLock<RecursiveLock> lock(mLock);
- const auto it = info_VkDevice.find(device);
- if (it == info_VkDevice.end()) return basicSize;
- const auto& info = it->second;
-
- VkDeviceSize nonCoherentAtomSize =
- info.props.limits.nonCoherentAtomSize;
- VkDeviceSize atoms =
- (basicSize + nonCoherentAtomSize - 1) / nonCoherentAtomSize;
- return atoms * nonCoherentAtomSize;
+ return info.allocationSize;
}
bool isValidMemoryRange(const VkMappedMemoryRange& range) const {
@@ -978,16 +881,16 @@
if (it == info_VkDeviceMemory.end()) return false;
const auto& info = it->second;
- if (!info.mappedPtr) return false;
+ if (!info.ptr) return false;
VkDeviceSize offset = range.offset;
VkDeviceSize size = range.size;
if (size == VK_WHOLE_SIZE) {
- return offset <= info.mappedSize;
+ return offset <= info.allocationSize;
}
- return offset + size <= info.mappedSize;
+ return offset + size <= info.allocationSize;
}
void setupFeatures(const EmulatorFeatureInfo* features) {
@@ -1045,12 +948,6 @@
if (mFeatureInfo->hasVulkanQueueSubmitWithCommands) {
ResourceTracker::streamFeatureBits |= VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
}
-#if !defined(HOST_BUILD) && defined(VIRTIO_GPU)
- if (mFeatureInfo->hasVirtioGpuNext) {
- mRendernodeFd =
- ResourceTracker::threadingCallbacks.hostConnectionGetFunc()->getRendernodeFd();
- }
-#endif
}
void setThreadingCallbacks(const ResourceTracker::ThreadingCallbacks& callbacks) {
@@ -1064,7 +961,7 @@
}
bool usingDirectMapping() const {
- return mHostVisibleMemoryVirtInfo.virtualizationSupported;
+ return true;
}
uint32_t getStreamFeatures() const {
@@ -1118,11 +1015,10 @@
(void)memoryCount;
(void)offsetCount;
(void)sizeCount;
-
- const auto& hostVirt =
- mHostVisibleMemoryVirtInfo;
-
- if (!hostVirt.virtualizationSupported) return;
+ (void)typeIndex;
+ (void)typeIndexCount;
+ (void)typeBits;
+ (void)typeBitsCount;
if (memory) {
AutoLock<RecursiveLock> lock (mLock);
@@ -1131,22 +1027,22 @@
VkDeviceMemory mem = memory[i];
auto it = info_VkDeviceMemory.find(mem);
- if (it == info_VkDeviceMemory.end()) return;
+ if (it == info_VkDeviceMemory.end())
+ return;
const auto& info = it->second;
- if (!info.directMapped) continue;
+ if (!info.coherentMemory)
+ continue;
- memory[i] = info.subAlloc.baseMemory;
+ memory[i] = info.coherentMemory->getDeviceMemory();
if (offset) {
- offset[i] = info.subAlloc.baseOffset + offset[i];
+ offset[i] = info.coherentMemoryOffset + offset[i];
}
- if (size) {
- if (size[i] == VK_WHOLE_SIZE) {
- size[i] = info.subAlloc.subMappedSize;
- }
+ if (size && size[i] == VK_WHOLE_SIZE) {
+ size[i] = info.allocationSize;
}
// TODO
@@ -1155,22 +1051,6 @@
(void)size;
}
}
-
- for (uint32_t i = 0; i < typeIndexCount; ++i) {
- typeIndex[i] =
- hostVirt.memoryTypeIndexMappingToHost[typeIndex[i]];
- }
-
- for (uint32_t i = 0; i < typeBitsCount; ++i) {
- uint32_t bits = 0;
- for (uint32_t j = 0; j < VK_MAX_MEMORY_TYPES; ++j) {
- bool guestHas = typeBits[i] & (1 << j);
- uint32_t hostIndex =
- hostVirt.memoryTypeIndexMappingToHost[j];
- bits |= guestHas ? (1 << hostIndex) : 0;
- }
- typeBits[i] = bits;
- }
}
void deviceMemoryTransform_fromhost(
@@ -1180,43 +1060,16 @@
uint32_t* typeIndex, uint32_t typeIndexCount,
uint32_t* typeBits, uint32_t typeBitsCount) {
+ (void)memory;
(void)memoryCount;
+ (void)offset;
(void)offsetCount;
+ (void)size;
(void)sizeCount;
-
- const auto& hostVirt =
- mHostVisibleMemoryVirtInfo;
-
- if (!hostVirt.virtualizationSupported) return;
-
- AutoLock<RecursiveLock> lock (mLock);
-
- for (uint32_t i = 0; i < memoryCount; ++i) {
- // TODO
- (void)memory;
- (void)offset;
- (void)size;
- }
-
- for (uint32_t i = 0; i < typeIndexCount; ++i) {
- typeIndex[i] =
- hostVirt.memoryTypeIndexMappingFromHost[typeIndex[i]];
- }
-
- for (uint32_t i = 0; i < typeBitsCount; ++i) {
- uint32_t bits = 0;
- for (uint32_t j = 0; j < VK_MAX_MEMORY_TYPES; ++j) {
- bool hostHas = typeBits[i] & (1 << j);
- uint32_t guestIndex =
- hostVirt.memoryTypeIndexMappingFromHost[j];
- bits |= hostHas ? (1 << guestIndex) : 0;
-
- if (hostVirt.memoryTypeBitsShouldAdvertiseBoth[j]) {
- bits |= hostHas ? (1 << j) : 0;
- }
- }
- typeBits[i] = bits;
- }
+ (void)typeIndex;
+ (void)typeIndexCount;
+ (void)typeBits;
+ (void)typeBitsCount;
}
void transformImpl_VkExternalMemoryProperties_fromhost(
@@ -1382,6 +1235,10 @@
"VK_KHR_external_fence_fd",
"VK_EXT_device_memory_report",
#endif
+#if !defined(VK_USE_PLATFORM_ANDROID_KHR) && defined(__linux__)
+ "VK_KHR_create_renderpass2",
+ "VK_KHR_imageless_framebuffer",
+#endif
};
VkEncoder* enc = (VkEncoder*)context;
@@ -1408,9 +1265,9 @@
getHostDeviceExtensionIndex(
"VK_KHR_external_semaphore_fd") != -1;
- ALOGD("%s: host has ext semaphore? win32 %d posix %d\n", __func__,
- hostHasWin32ExternalSemaphore,
- hostHasPosixExternalSemaphore);
+ D("%s: host has ext semaphore? win32 %d posix %d\n", __func__,
+ hostHasWin32ExternalSemaphore,
+ hostHasPosixExternalSemaphore);
bool hostSupportsExternalSemaphore =
hostHasWin32ExternalSemaphore ||
@@ -1485,8 +1342,6 @@
VkExtensionProperties { "VK_FUCHSIA_external_memory", 1});
filteredExts.push_back(
VkExtensionProperties { "VK_FUCHSIA_buffer_collection", 1 });
- filteredExts.push_back(
- VkExtensionProperties { "VK_FUCHSIA_buffer_collection_x", 1});
#endif
#if !defined(VK_USE_PLATFORM_ANDROID_KHR) && defined(__linux__)
filteredExts.push_back(
@@ -1680,15 +1535,10 @@
VkPhysicalDevice physdev,
VkPhysicalDeviceMemoryProperties* out) {
- initHostVisibleMemoryVirtualizationInfo(
- physdev,
- out,
- mFeatureInfo.get(),
- &mHostVisibleMemoryVirtInfo);
-
- if (mHostVisibleMemoryVirtInfo.virtualizationSupported) {
- *out = mHostVisibleMemoryVirtInfo.guestMemoryProperties;
- }
+ (void)physdev;
+ // gfxstream decides which physical device to expose to the guest on startup.
+ // Otherwise, we would need a physical device to properties mapping.
+ mMemoryProps = *out;
}
void on_vkGetPhysicalDeviceMemoryProperties2(
@@ -1696,15 +1546,7 @@
VkPhysicalDevice physdev,
VkPhysicalDeviceMemoryProperties2* out) {
- initHostVisibleMemoryVirtualizationInfo(
- physdev,
- &out->memoryProperties,
- mFeatureInfo.get(),
- &mHostVisibleMemoryVirtInfo);
-
- if (mHostVisibleMemoryVirtInfo.virtualizationSupported) {
- out->memoryProperties = mHostVisibleMemoryVirtInfo.guestMemoryProperties;
- }
+ on_vkGetPhysicalDeviceMemoryProperties(nullptr, physdev, &out->memoryProperties);
}
void on_vkGetDeviceQueue(void*,
@@ -1778,27 +1620,23 @@
VkDevice device,
const VkAllocationCallbacks*) {
+ (void)context;
AutoLock<RecursiveLock> lock(mLock);
auto it = info_VkDevice.find(device);
if (it == info_VkDevice.end()) return;
- auto info = it->second;
- lock.unlock();
-
- VkEncoder* enc = (VkEncoder*)context;
-
- bool freeMemorySyncSupported =
- mFeatureInfo->hasVulkanFreeMemorySync;
- for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i) {
- for (auto& block : info.hostMemBlocks[i]) {
- destroyHostMemAlloc(
- freeMemorySyncSupported,
- enc, device, &block, false);
+ for (auto itr = info_VkDeviceMemory.cbegin() ; itr != info_VkDeviceMemory.cend(); ) {
+ auto& memInfo = itr->second;
+ if (memInfo.device == device) {
+ itr = info_VkDeviceMemory.erase(itr);
+ } else {
+ itr++;
}
}
}
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
VkResult on_vkGetAndroidHardwareBufferPropertiesANDROID(
void*, VkResult,
VkDevice device,
@@ -1808,7 +1646,7 @@
ResourceTracker::threadingCallbacks.hostConnectionGetFunc()->grallocHelper();
return getAndroidHardwareBufferPropertiesANDROID(
grallocHelper,
- &mHostVisibleMemoryVirtInfo,
+ &mMemoryProps,
device, buffer, pProperties);
}
@@ -1846,6 +1684,7 @@
return queryRes;
}
+#endif
#ifdef VK_USE_PLATFORM_FUCHSIA
VkResult on_vkGetMemoryZirconHandleFUCHSIA(
@@ -1932,9 +1771,9 @@
result.status());
return VK_ERROR_INITIALIZATION_FAILED;
}
- if (result->result.is_response()) {
- memoryProperty = result->result.response().info.memory_property();
- } else if (result->result.err() == ZX_ERR_NOT_FOUND) {
+ if (result.value().is_ok()) {
+ memoryProperty = result.value().value()->info.memory_property();
+ } else if (result.value().error_value() == ZX_ERR_NOT_FOUND) {
// If an VMO is allocated while ColorBuffer/Buffer is not created,
// it must be a device-local buffer, since for host-visible buffers,
// ColorBuffer/Buffer is created at sysmem allocation time.
@@ -1945,7 +1784,7 @@
// VkMemoryZirconHandlePropertiesFUCHSIA with no available
// memoryType bits should be enough for clients. See fxbug.dev/24225
// for other issues this this flow.
- ALOGW("GetBufferHandleInfo failed: %d", result->result.err());
+ ALOGW("GetBufferHandleInfo failed: %d", result.value().error_value());
pProperties->memoryTypeBits = 0;
return VK_SUCCESS;
}
@@ -2110,59 +1949,6 @@
return VK_SUCCESS;
}
- VkResult on_vkCreateBufferCollectionFUCHSIAX(
- void*,
- VkResult,
- VkDevice,
- const VkBufferCollectionCreateInfoFUCHSIAX* pInfo,
- const VkAllocationCallbacks*,
- VkBufferCollectionFUCHSIAX* pCollection) {
- fidl::ClientEnd<::fuchsia_sysmem::BufferCollectionToken> token_client;
-
- if (pInfo->collectionToken) {
- token_client = fidl::ClientEnd<::fuchsia_sysmem::BufferCollectionToken>(
- zx::channel(pInfo->collectionToken));
- } else {
- auto endpoints =
- fidl::CreateEndpoints<::fuchsia_sysmem::BufferCollectionToken>();
- if (!endpoints.is_ok()) {
- ALOGE("zx_channel_create failed: %d", endpoints.status_value());
- return VK_ERROR_INITIALIZATION_FAILED;
- }
-
- auto result = mSysmemAllocator->AllocateSharedCollection(
- std::move(endpoints->server));
- if (!result.ok()) {
- ALOGE("AllocateSharedCollection failed: %d", result.status());
- return VK_ERROR_INITIALIZATION_FAILED;
- }
- token_client = std::move(endpoints->client);
- }
-
- auto endpoints = fidl::CreateEndpoints<::fuchsia_sysmem::BufferCollection>();
- if (!endpoints.is_ok()) {
- ALOGE("zx_channel_create failed: %d", endpoints.status_value());
- return VK_ERROR_INITIALIZATION_FAILED;
- }
- auto [collection_client, collection_server] = std::move(endpoints.value());
-
- auto result = mSysmemAllocator->BindSharedCollection(
- std::move(token_client), std::move(collection_server));
- if (!result.ok()) {
- ALOGE("BindSharedCollection failed: %d", result.status());
- return VK_ERROR_INITIALIZATION_FAILED;
- }
-
- auto* sysmem_collection =
- new fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>(
- std::move(collection_client));
- *pCollection =
- reinterpret_cast<VkBufferCollectionFUCHSIAX>(sysmem_collection);
-
- register_VkBufferCollectionFUCHSIAX(*pCollection);
- return VK_SUCCESS;
- }
-
void on_vkDestroyBufferCollectionFUCHSIA(
void*,
VkResult,
@@ -2180,22 +1966,6 @@
unregister_VkBufferCollectionFUCHSIA(collection);
}
- void on_vkDestroyBufferCollectionFUCHSIAX(
- void*,
- VkResult,
- VkDevice,
- VkBufferCollectionFUCHSIAX collection,
- const VkAllocationCallbacks*) {
- auto sysmem_collection = reinterpret_cast<
- fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>*>(collection);
- if (sysmem_collection) {
- (*sysmem_collection)->Close();
- }
- delete sysmem_collection;
-
- unregister_VkBufferCollectionFUCHSIAX(collection);
- }
-
inline fuchsia_sysmem::wire::BufferCollectionConstraints
defaultBufferCollectionConstraints(
size_t minSizeBytes,
@@ -2287,13 +2057,6 @@
return getBufferCollectionConstraintsVulkanBufferUsage(bufferUsage);
}
- uint32_t getBufferCollectionConstraintsVulkanBufferUsage(
- const VkBufferConstraintsInfoFUCHSIAX* pBufferConstraintsInfo) {
- VkBufferUsageFlags bufferUsage =
- pBufferConstraintsInfo->pBufferCreateInfo->usage;
- return getBufferCollectionConstraintsVulkanBufferUsage(bufferUsage);
- }
-
static fuchsia_sysmem::wire::PixelFormatType vkFormatTypeToSysmem(
VkFormat format) {
switch (format) {
@@ -2467,50 +2230,6 @@
enc, device, collection, &imageConstraints);
}
- VkResult setBufferCollectionConstraintsFUCHSIAX(
- VkEncoder* enc,
- VkDevice device,
- fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>* collection,
- const VkImageCreateInfo* pImageInfo) {
- if (pImageInfo == nullptr) {
- ALOGE("setBufferCollectionConstraints: pImageInfo cannot be null.");
- return VK_ERROR_OUT_OF_DEVICE_MEMORY;
- }
-
- std::vector<VkImageCreateInfo> createInfos;
- if (pImageInfo->format == VK_FORMAT_UNDEFINED) {
- const auto kFormats = {
- VK_FORMAT_B8G8R8A8_SRGB,
- VK_FORMAT_R8G8B8A8_SRGB,
- };
- for (auto format : kFormats) {
- // shallow copy, using pNext from pImageInfo directly.
- auto createInfo = *pImageInfo;
- createInfo.format = format;
- createInfos.push_back(createInfo);
- }
- } else {
- createInfos.push_back(*pImageInfo);
- }
-
- VkImageConstraintsInfoFUCHSIAX imageConstraints;
- imageConstraints.sType =
- VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIAX;
- imageConstraints.pNext = nullptr;
- imageConstraints.createInfoCount = createInfos.size();
- imageConstraints.pCreateInfos = createInfos.data();
- imageConstraints.pFormatConstraints = nullptr;
- imageConstraints.maxBufferCount = 0;
- imageConstraints.minBufferCount = 1;
- imageConstraints.minBufferCountForCamping = 0;
- imageConstraints.minBufferCountForDedicatedSlack = 0;
- imageConstraints.minBufferCountForSharedSlack = 0;
- imageConstraints.flags = 0u;
-
- return setBufferCollectionImageConstraintsFUCHSIAX(
- enc, device, collection, &imageConstraints);
- }
-
VkResult addImageBufferCollectionConstraintsFUCHSIA(
VkEncoder* enc,
VkDevice device,
@@ -2607,10 +2326,9 @@
enc->vkGetLinearImageLayout2GOOGLE(device, &createInfoDup, &offset,
&rowPitchAlignment,
true /* do lock */);
- ALOGD(
- "vkGetLinearImageLayout2GOOGLE: format %d offset %lu "
- "rowPitchAlignment = %lu",
- (int)createInfo->format, offset, rowPitchAlignment);
+ D("vkGetLinearImageLayout2GOOGLE: format %d offset %lu "
+ "rowPitchAlignment = %lu",
+ (int)createInfo->format, offset, rowPitchAlignment);
}
imageConstraints.min_coded_width = createInfo->extent.width;
@@ -2655,10 +2373,8 @@
const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) {
const auto& collection = *pCollection;
if (!pImageConstraintsInfo ||
- (pImageConstraintsInfo->sType !=
- VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIAX &&
pImageConstraintsInfo->sType !=
- VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA)) {
+ VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA) {
ALOGE("%s: invalid pImageConstraintsInfo", __func__);
return {VK_ERROR_INITIALIZATION_FAILED};
}
@@ -2826,104 +2542,6 @@
return VK_SUCCESS;
}
- VkResult setBufferCollectionImageConstraintsFUCHSIAX(
- VkEncoder* enc,
- VkDevice device,
- fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>* pCollection,
- const VkImageConstraintsInfoFUCHSIAX* pImageConstraintsInfo) {
- const auto& collection = *pCollection;
-
- const VkSysmemColorSpaceFUCHSIA kDefaultColorSpace = {
- .sType = VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA,
- .pNext = nullptr,
- .colorSpace = static_cast<uint32_t>(
- fuchsia_sysmem::wire::ColorSpaceType::kSrgb),
- };
-
- std::vector<VkImageFormatConstraintsInfoFUCHSIA> formatConstraints;
- for (size_t i = 0; i < pImageConstraintsInfo->createInfoCount; i++) {
- VkImageFormatConstraintsInfoFUCHSIA constraints = {
- .sType =
- VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA,
- .pNext = nullptr,
- .imageCreateInfo = pImageConstraintsInfo->pCreateInfos[i],
- .requiredFormatFeatures = {},
- .flags = {},
- .sysmemPixelFormat = 0u,
- .colorSpaceCount = 1u,
- .pColorSpaces = &kDefaultColorSpace,
- };
-
- if (pImageConstraintsInfo->pFormatConstraints) {
- const auto* formatConstraintsFUCHSIAX =
- &pImageConstraintsInfo->pFormatConstraints[i];
- constraints.pNext = formatConstraintsFUCHSIAX->pNext;
- constraints.requiredFormatFeatures =
- formatConstraintsFUCHSIAX->requiredFormatFeatures;
- constraints.flags =
- reinterpret_cast<VkImageFormatConstraintsFlagsFUCHSIA>(
- formatConstraintsFUCHSIAX->flags);
- constraints.sysmemPixelFormat =
- formatConstraintsFUCHSIAX->sysmemFormat;
- constraints.colorSpaceCount =
- formatConstraintsFUCHSIAX->colorSpaceCount > 0
- ? formatConstraintsFUCHSIAX->colorSpaceCount
- : 1;
- // VkSysmemColorSpaceFUCHSIA and VkSysmemColorSpaceFUCHSIAX have
- // identical definitions so we can just do a reinterpret_cast.
- constraints.pColorSpaces =
- formatConstraintsFUCHSIAX->colorSpaceCount > 0
- ? reinterpret_cast<const VkSysmemColorSpaceFUCHSIA*>(
- formatConstraintsFUCHSIAX->pColorSpaces)
- : &kDefaultColorSpace;
- }
- formatConstraints.push_back(constraints);
- }
-
- VkImageConstraintsInfoFUCHSIA imageConstraintsInfoFUCHSIA = {
- .sType = VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA,
- .pNext = pImageConstraintsInfo->pNext,
- .formatConstraintsCount = pImageConstraintsInfo->createInfoCount,
- .pFormatConstraints = formatConstraints.data(),
- .bufferCollectionConstraints =
- VkBufferCollectionConstraintsInfoFUCHSIA{
- .sType = VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA,
- .pNext = nullptr,
- .minBufferCount = pImageConstraintsInfo->minBufferCount,
- .maxBufferCount = pImageConstraintsInfo->maxBufferCount,
- .minBufferCountForCamping =
- pImageConstraintsInfo->minBufferCountForCamping,
- .minBufferCountForDedicatedSlack =
- pImageConstraintsInfo->minBufferCountForDedicatedSlack,
- .minBufferCountForSharedSlack =
- pImageConstraintsInfo->minBufferCountForSharedSlack,
- },
- .flags = pImageConstraintsInfo->flags,
- };
-
- auto setConstraintsResult = setBufferCollectionImageConstraintsImpl(
- enc, device, pCollection, &imageConstraintsInfoFUCHSIA);
- if (setConstraintsResult.result != VK_SUCCESS) {
- return setConstraintsResult.result;
- }
-
- // copy constraints to info_VkBufferCollectionFUCHSIAX if
- // |collection| is a valid VkBufferCollectionFUCHSIAX handle.
- AutoLock<RecursiveLock> lock(mLock);
- VkBufferCollectionFUCHSIAX buffer_collection =
- reinterpret_cast<VkBufferCollectionFUCHSIAX>(pCollection);
- if (info_VkBufferCollectionFUCHSIAX.find(buffer_collection) !=
- info_VkBufferCollectionFUCHSIAX.end()) {
- info_VkBufferCollectionFUCHSIAX[buffer_collection].constraints =
- android::base::makeOptional(
- std::move(setConstraintsResult.constraints));
- info_VkBufferCollectionFUCHSIAX[buffer_collection].createInfoIndex =
- std::move(setConstraintsResult.createInfoIndex);
- }
-
- return VK_SUCCESS;
- }
-
struct SetBufferCollectionBufferConstraintsResult {
VkResult result;
fuchsia_sysmem::wire::BufferCollectionConstraints constraints;
@@ -2987,47 +2605,6 @@
return VK_SUCCESS;
}
- VkResult setBufferCollectionBufferConstraintsFUCHSIAX(
- fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>* pCollection,
- const VkBufferConstraintsInfoFUCHSIAX* pBufferConstraintsInfo) {
- VkBufferConstraintsInfoFUCHSIA bufferConstraintsInfoFUCHSIA = {
- .sType = VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA,
- .pNext = pBufferConstraintsInfo->pNext,
- .createInfo = *pBufferConstraintsInfo->pBufferCreateInfo,
- .requiredFormatFeatures =
- pBufferConstraintsInfo->requiredFormatFeatures,
- .bufferCollectionConstraints =
- VkBufferCollectionConstraintsInfoFUCHSIA{
- .sType = VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA,
- .pNext = nullptr,
- .minBufferCount = pBufferConstraintsInfo->minCount,
- .maxBufferCount = 0,
- .minBufferCountForCamping = 0,
- .minBufferCountForDedicatedSlack = 0,
- .minBufferCountForSharedSlack = 0,
- },
- };
-
- auto setConstraintsResult = setBufferCollectionBufferConstraintsImpl(
- pCollection, &bufferConstraintsInfoFUCHSIA);
- if (setConstraintsResult.result != VK_SUCCESS) {
- return setConstraintsResult.result;
- }
-
- // copy constraints to info_VkBufferCollectionFUCHSIAX if
- // |collection| is a valid VkBufferCollectionFUCHSIAX handle.
- AutoLock<RecursiveLock> lock(mLock);
- VkBufferCollectionFUCHSIAX buffer_collection =
- reinterpret_cast<VkBufferCollectionFUCHSIAX>(pCollection);
- if (info_VkBufferCollectionFUCHSIAX.find(buffer_collection) !=
- info_VkBufferCollectionFUCHSIAX.end()) {
- info_VkBufferCollectionFUCHSIAX[buffer_collection].constraints =
- android::base::makeOptional(setConstraintsResult.constraints);
- }
-
- return VK_SUCCESS;
- }
-
VkResult on_vkSetBufferCollectionImageConstraintsFUCHSIA(
void* context,
VkResult,
@@ -3055,64 +2632,6 @@
sysmem_collection, pBufferConstraintsInfo);
}
- VkResult on_vkSetBufferCollectionConstraintsFUCHSIAX(
- void* context,
- VkResult,
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- const VkImageCreateInfo* pImageInfo) {
- VkEncoder* enc = (VkEncoder*)context;
- auto sysmem_collection = reinterpret_cast<
- fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>*>(collection);
- return setBufferCollectionConstraintsFUCHSIAX(
- enc, device, sysmem_collection, pImageInfo);
- }
-
- VkResult on_vkSetBufferCollectionImageConstraintsFUCHSIAX(
- void* context,
- VkResult,
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- const VkImageConstraintsInfoFUCHSIAX* pImageConstraintsInfo) {
- VkEncoder* enc = (VkEncoder*)context;
- auto sysmem_collection = reinterpret_cast<
- fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>*>(collection);
- return setBufferCollectionImageConstraintsFUCHSIAX(
- enc, device, sysmem_collection, pImageConstraintsInfo);
- }
-
- VkResult on_vkSetBufferCollectionBufferConstraintsFUCHSIAX(
- void*,
- VkResult,
- VkDevice,
- VkBufferCollectionFUCHSIAX collection,
- const VkBufferConstraintsInfoFUCHSIAX* pBufferConstraintsInfo) {
- auto sysmem_collection = reinterpret_cast<
- fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>*>(collection);
- return setBufferCollectionBufferConstraintsFUCHSIAX(
- sysmem_collection, pBufferConstraintsInfo);
- }
-
- VkResult on_vkGetBufferCollectionPropertiesFUCHSIAX(
- void* context,
- VkResult,
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- VkBufferCollectionPropertiesFUCHSIAX* pProperties) {
- VkBufferCollectionProperties2FUCHSIAX properties2 = {
- .sType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES2_FUCHSIAX,
- .pNext = nullptr};
- auto result = on_vkGetBufferCollectionProperties2FUCHSIAX(
- context, VK_SUCCESS, device, collection, &properties2);
- if (result != VK_SUCCESS) {
- return result;
- }
-
- pProperties->count = properties2.bufferCount;
- pProperties->memoryTypeBits = properties2.memoryTypeBits;
- return VK_SUCCESS;
- }
-
VkResult getBufferCollectionImageCreateInfoIndexLocked(
VkBufferCollectionFUCHSIA collection,
fuchsia_sysmem::wire::BufferCollectionInfo2& info,
@@ -3197,13 +2716,13 @@
collection);
auto result = sysmem_collection->WaitForBuffersAllocated();
- if (!result.ok() || result.Unwrap()->status != ZX_OK) {
+ if (!result.ok() || result->status != ZX_OK) {
ALOGE("Failed wait for allocation: %d %d", result.status(),
GET_STATUS_SAFE(result, status));
return VK_ERROR_INITIALIZATION_FAILED;
}
fuchsia_sysmem::wire::BufferCollectionInfo2 info =
- std::move(result.Unwrap()->buffer_collection_info);
+ std::move(result->buffer_collection_info);
bool is_host_visible =
info.settings.buffer_settings.heap ==
@@ -3346,247 +2865,160 @@
return storeProperties();
}
-
- VkResult getBufferCollectionImageCreateInfoIndexLocked(
- VkBufferCollectionFUCHSIAX collection,
- fuchsia_sysmem::wire::BufferCollectionInfo2& info,
- uint32_t* outCreateInfoIndex) {
- if (!info_VkBufferCollectionFUCHSIAX[collection]
- .constraints.hasValue()) {
- ALOGE("%s: constraints not set", __func__);
- return VK_ERROR_OUT_OF_DEVICE_MEMORY;
- }
-
- if (!info.settings.has_image_format_constraints) {
- // no image format constraints, skip getting createInfoIndex.
- return VK_SUCCESS;
- }
-
- const auto& constraints =
- *info_VkBufferCollectionFUCHSIAX[collection].constraints;
- const auto& createInfoIndices =
- info_VkBufferCollectionFUCHSIAX[collection].createInfoIndex;
- const auto& out = info.settings.image_format_constraints;
- bool foundCreateInfo = false;
-
- for (size_t imageFormatIndex = 0;
- imageFormatIndex < constraints.image_format_constraints_count;
- imageFormatIndex++) {
- const auto& in =
- constraints.image_format_constraints[imageFormatIndex];
- // These checks are sorted in order of how often they're expected to
- // mismatch, from most likely to least likely. They aren't always
- // equality comparisons, since sysmem may change some values in
- // compatible ways on behalf of the other participants.
- if ((out.pixel_format.type != in.pixel_format.type) ||
- (out.pixel_format.has_format_modifier !=
- in.pixel_format.has_format_modifier) ||
- (out.pixel_format.format_modifier.value !=
- in.pixel_format.format_modifier.value) ||
- (out.min_bytes_per_row < in.min_bytes_per_row) ||
- (out.required_max_coded_width < in.required_max_coded_width) ||
- (out.required_max_coded_height <
- in.required_max_coded_height) ||
- (out.bytes_per_row_divisor % in.bytes_per_row_divisor != 0)) {
- continue;
- }
- // Check if the out colorspaces are a subset of the in color spaces.
- bool all_color_spaces_found = true;
- for (uint32_t j = 0; j < out.color_spaces_count; j++) {
- bool found_matching_color_space = false;
- for (uint32_t k = 0; k < in.color_spaces_count; k++) {
- if (out.color_space[j].type == in.color_space[k].type) {
- found_matching_color_space = true;
- break;
- }
- }
- if (!found_matching_color_space) {
- all_color_spaces_found = false;
- break;
- }
- }
- if (!all_color_spaces_found) {
- continue;
- }
-
- // Choose the first valid format for now.
- *outCreateInfoIndex = createInfoIndices[imageFormatIndex];
- return VK_SUCCESS;
- }
-
- ALOGE("%s: cannot find a valid image format in constraints", __func__);
- return VK_ERROR_OUT_OF_DEVICE_MEMORY;
- }
-
- VkResult on_vkGetBufferCollectionProperties2FUCHSIAX(
- void* context,
- VkResult,
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- VkBufferCollectionProperties2FUCHSIAX* pProperties) {
- VkEncoder* enc = (VkEncoder*)context;
- const auto& sysmem_collection = *reinterpret_cast<
- fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>*>(collection);
-
- auto result = sysmem_collection->WaitForBuffersAllocated();
- if (!result.ok() || result.Unwrap()->status != ZX_OK) {
- ALOGE("Failed wait for allocation: %d %d", result.status(),
- GET_STATUS_SAFE(result, status));
- return VK_ERROR_INITIALIZATION_FAILED;
- }
- fuchsia_sysmem::wire::BufferCollectionInfo2 info =
- std::move(result.Unwrap()->buffer_collection_info);
-
- bool is_host_visible = info.settings.buffer_settings.heap ==
- fuchsia_sysmem::wire::HeapType::kGoldfishHostVisible;
- bool is_device_local = info.settings.buffer_settings.heap ==
- fuchsia_sysmem::wire::HeapType::kGoldfishDeviceLocal;
- if (!is_host_visible && !is_device_local) {
- ALOGE("buffer collection uses a non-goldfish heap (type 0x%lu)",
- static_cast<uint64_t>(info.settings.buffer_settings.heap));
- return VK_ERROR_INITIALIZATION_FAILED;
- }
-
- // memoryTypeBits
- // ====================================================================
- {
- AutoLock<RecursiveLock> lock(mLock);
- auto deviceIt = info_VkDevice.find(device);
- if (deviceIt == info_VkDevice.end()) {
- return VK_ERROR_INITIALIZATION_FAILED;
- }
- auto& deviceInfo = deviceIt->second;
-
- // Device local memory type supported.
- pProperties->memoryTypeBits = 0;
- for (uint32_t i = 0; i < deviceInfo.memProps.memoryTypeCount; ++i) {
- if ((is_device_local &&
- (deviceInfo.memProps.memoryTypes[i].propertyFlags &
- VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)) ||
- (is_host_visible &&
- (deviceInfo.memProps.memoryTypes[i].propertyFlags &
- VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT))) {
- pProperties->memoryTypeBits |= 1ull << i;
- }
- }
- }
-
- // bufferCount
- // ====================================================================
- pProperties->bufferCount = info.buffer_count;
-
- auto storeProperties = [this, collection, pProperties]() -> VkResult {
- // store properties to storage
- AutoLock<RecursiveLock> lock(mLock);
- if (info_VkBufferCollectionFUCHSIAX.find(collection) ==
- info_VkBufferCollectionFUCHSIAX.end()) {
- return VK_ERROR_OUT_OF_DEVICE_MEMORY;
- }
-
- info_VkBufferCollectionFUCHSIAX[collection].properties =
- android::base::makeOptional(*pProperties);
-
- // We only do a shallow copy so we should remove all pNext pointers.
- info_VkBufferCollectionFUCHSIAX[collection].properties->pNext =
- nullptr;
- info_VkBufferCollectionFUCHSIAX[collection]
- .properties->colorSpace.pNext = nullptr;
- return VK_SUCCESS;
- };
-
- // The fields below only apply to buffer collections with image formats.
- if (!info.settings.has_image_format_constraints) {
- ALOGD("%s: buffer collection doesn't have image format constraints",
- __func__);
- return storeProperties();
- }
-
- // sysmemFormat
- // ====================================================================
-
- pProperties->sysmemFormat = static_cast<uint64_t>(
- info.settings.image_format_constraints.pixel_format.type);
-
- // colorSpace
- // ====================================================================
- if (info.settings.image_format_constraints.color_spaces_count == 0) {
- ALOGE(
- "%s: color space missing from allocated buffer collection "
- "constraints",
- __func__);
- return VK_ERROR_OUT_OF_DEVICE_MEMORY;
- }
- // Only report first colorspace for now.
- pProperties->colorSpace.colorSpace = static_cast<uint32_t>(
- info.settings.image_format_constraints.color_space[0].type);
-
- // createInfoIndex
- // ====================================================================
- {
- AutoLock<RecursiveLock> lock(mLock);
- auto getIndexResult = getBufferCollectionImageCreateInfoIndexLocked(
- collection, info, &pProperties->createInfoIndex);
- if (getIndexResult != VK_SUCCESS) {
- return getIndexResult;
- }
- }
-
- // formatFeatures
- // ====================================================================
- VkPhysicalDevice physicalDevice;
- {
- AutoLock<RecursiveLock> lock(mLock);
- auto deviceIt = info_VkDevice.find(device);
- if (deviceIt == info_VkDevice.end()) {
- return VK_ERROR_INITIALIZATION_FAILED;
- }
- physicalDevice = deviceIt->second.physdev;
- }
-
- VkFormat vkFormat = sysmemPixelFormatTypeToVk(
- info.settings.image_format_constraints.pixel_format.type);
- VkFormatProperties formatProperties;
- enc->vkGetPhysicalDeviceFormatProperties(
- physicalDevice, vkFormat, &formatProperties, true /* do lock */);
- if (is_device_local) {
- pProperties->formatFeatures =
- formatProperties.optimalTilingFeatures;
- }
- if (is_host_visible) {
- pProperties->formatFeatures = formatProperties.linearTilingFeatures;
- }
-
- // YCbCr properties
- // ====================================================================
- // TODO(59804): Implement this correctly when we support YUV pixel
- // formats in goldfish ICD.
- pProperties->samplerYcbcrConversionComponents.r =
- VK_COMPONENT_SWIZZLE_IDENTITY;
- pProperties->samplerYcbcrConversionComponents.g =
- VK_COMPONENT_SWIZZLE_IDENTITY;
- pProperties->samplerYcbcrConversionComponents.b =
- VK_COMPONENT_SWIZZLE_IDENTITY;
- pProperties->samplerYcbcrConversionComponents.a =
- VK_COMPONENT_SWIZZLE_IDENTITY;
- pProperties->suggestedYcbcrModel =
- VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
- pProperties->suggestedYcbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_FULL;
- pProperties->suggestedXChromaOffset = VK_CHROMA_LOCATION_MIDPOINT;
- pProperties->suggestedYChromaOffset = VK_CHROMA_LOCATION_MIDPOINT;
-
- return storeProperties();
- }
#endif
- HostMemBlockIndex getOrAllocateHostMemBlockLocked(
- HostMemBlocks& blocks,
- const VkMemoryAllocateInfo* pAllocateInfo,
- VkEncoder* enc,
- VkDevice device,
- const VkDevice_Info& deviceInfo) {
+ CoherentMemoryPtr createCoherentMemory(VkDevice device,
+ VkDeviceMemory mem,
+ const VkMemoryAllocateInfo& hostAllocationInfo,
+ VkEncoder* enc,
+ VkResult& res)
+ {
+ CoherentMemoryPtr coherentMemory = nullptr;
+ if (mFeatureInfo->hasDirectMem) {
+ uint64_t gpuAddr = 0;
+ GoldfishAddressSpaceBlockPtr block = nullptr;
+ res = enc->vkMapMemoryIntoAddressSpaceGOOGLE(device, mem, &gpuAddr, true);
+ if (res != VK_SUCCESS) {
+ return coherentMemory;
+ }
+ {
+ AutoLock<RecursiveLock> lock(mLock);
+ auto it = info_VkDeviceMemory.find(mem);
+ if (it == info_VkDeviceMemory.end()) {
+ res = VK_ERROR_OUT_OF_HOST_MEMORY;
+ return coherentMemory;
+ }
+ auto& info = it->second;
+ block = info.goldfishBlock;
+ info.goldfishBlock = nullptr;
- HostMemBlockIndex res = 0;
- bool found = false;
+ coherentMemory =
+ std::make_shared<CoherentMemory>(block, gpuAddr, hostAllocationInfo.allocationSize, device, mem);
+ }
+ } else if (mFeatureInfo->hasVirtioGpuNext) {
+ struct VirtGpuCreateBlob createBlob = { 0 };
+ uint64_t hvaSizeId[3];
+ res = enc->vkGetMemoryHostAddressInfoGOOGLE(device, mem,
+ &hvaSizeId[0], &hvaSizeId[1], &hvaSizeId[2], true /* do lock */);
+ if(res != VK_SUCCESS) {
+ return coherentMemory;
+ }
+ {
+ AutoLock<RecursiveLock> lock(mLock);
+ VirtGpuDevice& instance = VirtGpuDevice::getInstance((enum VirtGpuCapset)3);
+ createBlob.blobMem = kBlobMemHost3d;
+ createBlob.flags = kBlobFlagMappable;
+ createBlob.blobId = hvaSizeId[2];
+ createBlob.size = hostAllocationInfo.allocationSize;
+
+ auto blob = instance.createBlob(createBlob);
+ if (!blob) {
+ res = VK_ERROR_OUT_OF_DEVICE_MEMORY;
+ return coherentMemory;
+ }
+
+ VirtGpuBlobMappingPtr mapping = blob->createMapping();
+ if (!mapping) {
+ res = VK_ERROR_OUT_OF_DEVICE_MEMORY;
+ return coherentMemory;
+ }
+
+ coherentMemory =
+ std::make_shared<CoherentMemory>(mapping, createBlob.size, device, mem);
+ }
+ } else {
+ ALOGE("FATAL: Unsupported virtual memory feature");
+ abort();
+ }
+ return coherentMemory;
+ }
+
+ VkResult allocateCoherentMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo,
+ VkEncoder *enc, VkDeviceMemory* pMemory) {
+ uint64_t offset = 0;
+ uint8_t *ptr = nullptr;
+ VkMemoryAllocateFlagsInfo allocFlagsInfo;
+ VkMemoryOpaqueCaptureAddressAllocateInfo opaqueCaptureAddressAllocInfo;
+
+ const VkMemoryAllocateFlagsInfo* allocFlagsInfoPtr =
+ vk_find_struct<VkMemoryAllocateFlagsInfo>(pAllocateInfo);
+ const VkMemoryOpaqueCaptureAddressAllocateInfo* opaqueCaptureAddressAllocInfoPtr =
+ vk_find_struct<VkMemoryOpaqueCaptureAddressAllocateInfo>(pAllocateInfo);
+
+ bool deviceAddressMemoryAllocation =
+ allocFlagsInfoPtr &&
+ ((allocFlagsInfoPtr->flags & VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT) ||
+ (allocFlagsInfoPtr->flags & VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT));
+
+ bool dedicated = deviceAddressMemoryAllocation;
+
+ VkMemoryAllocateInfo hostAllocationInfo = vk_make_orphan_copy(*pAllocateInfo);
+ vk_struct_chain_iterator structChainIter = vk_make_chain_iterator(&hostAllocationInfo);
+
+ if (dedicated) {
+ hostAllocationInfo.allocationSize =
+ ((pAllocateInfo->allocationSize + kLargestPageSize - 1) / kLargestPageSize);
+ } else {
+ VkDeviceSize roundedUpAllocSize =
+ kMegaBtye * ((pAllocateInfo->allocationSize + kMegaBtye - 1) / kMegaBtye);
+ hostAllocationInfo.allocationSize = std::max(roundedUpAllocSize,
+ kDefaultHostMemBlockSize);
+ }
+
+ // Support device address capture/replay allocations
+ if (deviceAddressMemoryAllocation) {
+ if (allocFlagsInfoPtr) {
+ ALOGV("%s: has alloc flags\n", __func__);
+ allocFlagsInfo = *allocFlagsInfoPtr;
+ vk_append_struct(&structChainIter, &allocFlagsInfo);
+ }
+
+ if (opaqueCaptureAddressAllocInfoPtr) {
+ ALOGV("%s: has opaque capture address\n", __func__);
+ opaqueCaptureAddressAllocInfo = *opaqueCaptureAddressAllocInfoPtr;
+ vk_append_struct(&structChainIter, &opaqueCaptureAddressAllocInfo);
+ }
+ }
+
+ VkDeviceMemory mem = VK_NULL_HANDLE;
+ VkResult host_res =
+ enc->vkAllocateMemory(device, &hostAllocationInfo, nullptr,
+ &mem, true /* do lock */);
+ if(host_res != VK_SUCCESS) {
+ return host_res;
+ }
+ struct VkDeviceMemory_Info info;
+ info.coherentMemorySize = hostAllocationInfo.allocationSize;
+ info.memoryTypeIndex = hostAllocationInfo.memoryTypeIndex;
+ info.device = device;
+ info.dedicated = dedicated;
+ {
+ // createCoherentMemory inside need to access info_VkDeviceMemory
+ // information. set it before use.
+ AutoLock<RecursiveLock> lock(mLock);
+ info_VkDeviceMemory[mem] = info;
+ }
+ auto coherentMemory = createCoherentMemory(device, mem, hostAllocationInfo, enc, host_res);
+ if(coherentMemory) {
+ AutoLock<RecursiveLock> lock(mLock);
+ coherentMemory->subAllocate(pAllocateInfo->allocationSize, &ptr, offset);
+ info.allocationSize = pAllocateInfo->allocationSize;
+ info.coherentMemoryOffset = offset;
+ info.coherentMemory = coherentMemory;
+ info.ptr = ptr;
+ info_VkDeviceMemory[mem] = info;
+ *pMemory = mem;
+ }
+ else {
+ enc->vkFreeMemory(device, mem, nullptr, true);
+ AutoLock<RecursiveLock> lock(mLock);
+ info_VkDeviceMemory.erase(mem);
+ }
+ return host_res;
+ }
+
+ VkResult getCoherentMemory(const VkMemoryAllocateInfo* pAllocateInfo, VkEncoder* enc,
+ VkDevice device, VkDeviceMemory* pMemory) {
VkMemoryAllocateFlagsInfo allocFlagsInfo;
VkMemoryOpaqueCaptureAddressAllocateInfo opaqueCaptureAddressAllocInfo;
@@ -3594,230 +3026,48 @@
// Add buffer device address capture structs
const VkMemoryAllocateFlagsInfo* allocFlagsInfoPtr =
vk_find_struct<VkMemoryAllocateFlagsInfo>(pAllocateInfo);
- const VkMemoryOpaqueCaptureAddressAllocateInfo* opaqueCaptureAddressAllocInfoPtr =
- vk_find_struct<VkMemoryOpaqueCaptureAddressAllocateInfo>(pAllocateInfo);
- bool isDeviceAddressMemoryAllocation =
- allocFlagsInfoPtr && ((allocFlagsInfoPtr->flags & VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT) ||
- (allocFlagsInfoPtr->flags & VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT));
- bool isDedicated = isDeviceAddressMemoryAllocation;
+ bool dedicated = allocFlagsInfoPtr &&
+ ((allocFlagsInfoPtr->flags & VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT) ||
+ (allocFlagsInfoPtr->flags & VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT));
- while (!found) {
- // If we need a dedicated host mapping, found = true necessarily
- if (isDedicated) {
- found = true;
- } else {
- for (HostMemBlockIndex i = 0; i < blocks.size(); ++i) {
- if (blocks[i].initialized &&
- blocks[i].initResult == VK_SUCCESS &&
- !blocks[i].isDedicated &&
- blocks[i].isDeviceAddressMemoryAllocation == isDeviceAddressMemoryAllocation &&
- canSubAlloc(
- blocks[i].subAlloc,
- pAllocateInfo->allocationSize)) {
- res = i;
- found = true;
- return res;
- }
- }
+ CoherentMemoryPtr coherentMemory = nullptr;
+ uint8_t *ptr = nullptr;
+ uint64_t offset = 0;
+ {
+ AutoLock<RecursiveLock> lock(mLock);
+ for (const auto &[memory, info] : info_VkDeviceMemory) {
+ if (info.memoryTypeIndex != pAllocateInfo->memoryTypeIndex)
+ continue;
+
+ if (info.dedicated || dedicated)
+ continue;
+
+ if (!info.coherentMemory)
+ continue;
+
+ if (!info.coherentMemory->subAllocate(pAllocateInfo->allocationSize, &ptr, offset))
+ continue;
+
+ coherentMemory = info.coherentMemory;
+ break;
}
+ if (coherentMemory) {
+ struct VkDeviceMemory_Info info;
+ info.coherentMemoryOffset = offset;
+ info.ptr = ptr;
+ info.memoryTypeIndex = pAllocateInfo->memoryTypeIndex;
+ info.allocationSize = pAllocateInfo->allocationSize;
+ info.coherentMemory = coherentMemory;
+ info.device = device;
- blocks.push_back({});
-
- auto& hostMemAlloc = blocks.back();
-
- hostMemAlloc.isDedicated = isDedicated;
-
- // Uninitialized block; allocate on host.
- static constexpr VkDeviceSize oneMb = 1048576;
- // This needs to be a power of 2 that is at least the min alignment needed in HostVisibleMemoryVirtualization.cpp.
- static constexpr VkDeviceSize biggestPage = 65536;
- static constexpr VkDeviceSize kDefaultHostMemBlockSize =
- 16 * oneMb; // 16 mb
- VkDeviceSize roundedUpAllocSize =
- oneMb * ((pAllocateInfo->allocationSize + oneMb - 1) / oneMb);
-
- // If dedicated, use a smaller "page rounded alloc size".
- VkDeviceSize pageRoundedAllocSize =
- biggestPage * ((pAllocateInfo->allocationSize + biggestPage - 1) / biggestPage);
-
- VkDeviceSize virtualHeapSize = VIRTUAL_HOST_VISIBLE_HEAP_SIZE;
-
- VkDeviceSize blockSizeNeeded =
- std::max(roundedUpAllocSize,
- std::min(virtualHeapSize,
- kDefaultHostMemBlockSize));
-
- VkMemoryAllocateInfo allocInfoForHost = vk_make_orphan_copy(*pAllocateInfo);
- vk_struct_chain_iterator structChainIter = vk_make_chain_iterator(&allocInfoForHost);
-
- allocInfoForHost.allocationSize = blockSizeNeeded;
-
- if (isDedicated) {
- allocInfoForHost.allocationSize = pageRoundedAllocSize;
- }
-
- // TODO: Support dedicated/external host visible allocation
-
- // Support device address capture/replay allocations
- if (isDeviceAddressMemoryAllocation) {
- hostMemAlloc.isDeviceAddressMemoryAllocation = true;
- if (allocFlagsInfoPtr) {
- ALOGV("%s: has alloc flags\n", __func__);
- allocFlagsInfo = *allocFlagsInfoPtr;
- vk_append_struct(&structChainIter, &allocFlagsInfo);
- }
-
- if (opaqueCaptureAddressAllocInfoPtr) {
- ALOGV("%s: has opaque capture address\n", __func__);
- opaqueCaptureAddressAllocInfo = *opaqueCaptureAddressAllocInfoPtr;
- vk_append_struct(&structChainIter, &opaqueCaptureAddressAllocInfo);
- }
- }
-
- mLock.unlock();
- VkResult host_res =
- enc->vkAllocateMemory(
- device,
- &allocInfoForHost,
- nullptr,
- &hostMemAlloc.memory, true /* do lock */);
- mLock.lock();
-
- if (host_res != VK_SUCCESS) {
- ALOGE("Could not allocate backing for virtual host visible memory: %d",
- host_res);
- hostMemAlloc.initialized = true;
- hostMemAlloc.initResult = host_res;
- return INVALID_HOST_MEM_BLOCK;
- }
-
- auto& hostMemInfo = info_VkDeviceMemory[hostMemAlloc.memory];
- hostMemInfo.allocationSize = allocInfoForHost.allocationSize;
- VkDeviceSize nonCoherentAtomSize =
- deviceInfo.props.limits.nonCoherentAtomSize;
- hostMemInfo.mappedSize = hostMemInfo.allocationSize;
- hostMemInfo.memoryTypeIndex =
- pAllocateInfo->memoryTypeIndex;
- hostMemAlloc.nonCoherentAtomSize = nonCoherentAtomSize;
-
- uint64_t directMappedAddr = 0;
-
- VkResult directMapResult = VK_SUCCESS;
- if (mFeatureInfo->hasDirectMem) {
- mLock.unlock();
- directMapResult =
- enc->vkMapMemoryIntoAddressSpaceGOOGLE(
- device, hostMemAlloc.memory, &directMappedAddr, true /* do lock */);
- ALOGV("%s: direct mapped addr 0x%llx\n", __func__,
- (unsigned long long)directMappedAddr);
- mLock.lock();
- } else if (mFeatureInfo->hasVirtioGpuNext) {
-#if !defined(HOST_BUILD) && defined(VIRTIO_GPU)
- uint64_t hvaSizeId[3];
-
- mLock.unlock();
- enc->vkGetMemoryHostAddressInfoGOOGLE(
- device, hostMemAlloc.memory,
- &hvaSizeId[0], &hvaSizeId[1], &hvaSizeId[2], true /* do lock */);
- ALOGD("%s: hvaOff, size: 0x%llx 0x%llx id: 0x%llx\n", __func__,
- (unsigned long long)hvaSizeId[0],
- (unsigned long long)hvaSizeId[1],
- (unsigned long long)hvaSizeId[2]);
- mLock.lock();
-
- struct drm_virtgpu_resource_create_blob drm_rc_blob = { 0 };
- drm_rc_blob.blob_mem = VIRTGPU_BLOB_MEM_HOST3D;
- drm_rc_blob.blob_flags = VIRTGPU_BLOB_FLAG_USE_MAPPABLE;
- drm_rc_blob.blob_id = hvaSizeId[2];
- drm_rc_blob.size = hvaSizeId[1];
-
- int res = drmIoctl(
- mRendernodeFd, DRM_IOCTL_VIRTGPU_RESOURCE_CREATE_BLOB, &drm_rc_blob);
-
- if (res) {
- ALOGE("%s: Failed to resource create blob: sterror: %s errno: %d\n", __func__,
- strerror(errno), errno);
- abort();
- }
- hostMemAlloc.boCreated = true;
- hostMemAlloc.boHandle = drm_rc_blob.bo_handle;
-
- drm_virtgpu_map map_info;
- memset(&map_info, 0, sizeof(map_info));
- map_info.handle = drm_rc_blob.bo_handle;
-
- res = drmIoctl(mRendernodeFd, DRM_IOCTL_VIRTGPU_MAP, &map_info);
- if (res) {
- ALOGE("%s: Failed to virtgpu map: sterror: %s errno: %d\n", __func__,
- strerror(errno), errno);
- abort();
- }
-
- void* mapRes = mmap64(
- 0, hvaSizeId[1], PROT_WRITE, MAP_SHARED, mRendernodeFd, map_info.offset);
-
- if (mapRes == MAP_FAILED || mapRes == nullptr) {
- ALOGE("%s: mmap of virtio gpu resource failed: sterror: %s errno: %d\n\n",
- __func__, strerror(errno), errno);
- directMapResult = VK_ERROR_OUT_OF_DEVICE_MEMORY;
- } else {
- directMappedAddr = (uint64_t)(uintptr_t)mapRes;
- // Does not take ownership for the device.
- hostMemAlloc.rendernodeFd = mRendernodeFd;
- hostMemAlloc.memoryAddr = directMappedAddr;
- hostMemAlloc.memorySize = hvaSizeId[1];
- // add the host's page offset
- directMappedAddr += (uint64_t)(uintptr_t)(hvaSizeId[0]) & (PAGE_SIZE - 1);
- directMapResult = VK_SUCCESS;
- }
-
-#endif // VK_USE_PLATFORM_ANDROID_KHR
- }
-
- if (directMapResult != VK_SUCCESS) {
- ALOGE("%s: error: directMapResult != VK_SUCCESS\n", __func__);
- hostMemAlloc.initialized = true;
- hostMemAlloc.initResult = directMapResult;
- mLock.unlock();
- destroyHostMemAlloc(
- mFeatureInfo->hasDirectMem,
- enc,
- device,
- &hostMemAlloc,
- true) /* doLock */;
- mLock.lock();
- return INVALID_HOST_MEM_BLOCK;
- }
-
- hostMemInfo.mappedPtr =
- (uint8_t*)(uintptr_t)directMappedAddr;
- hostMemInfo.virtualHostVisibleBacking = true;
- ALOGV("%s: Set mapped ptr to %p\n", __func__, hostMemInfo.mappedPtr);
-
- VkResult hostMemAllocRes =
- finishHostMemAllocInit(
- enc,
- device,
- pAllocateInfo->memoryTypeIndex,
- nonCoherentAtomSize,
- hostMemInfo.allocationSize,
- hostMemInfo.mappedSize,
- hostMemInfo.mappedPtr,
- &hostMemAlloc);
-
- if (hostMemAllocRes != VK_SUCCESS) {
- return INVALID_HOST_MEM_BLOCK;
- }
-
- if (isDedicated) {
- ALOGV("%s: New dedicated block at %zu\n", __func__, blocks.size() - 1);
- return blocks.size() - 1;
+ auto mem = new_from_host_VkDeviceMemory(VK_NULL_HANDLE);
+ info_VkDeviceMemory[mem] = info;
+ *pMemory = mem;
+ return VK_SUCCESS;
}
}
-
- // unreacheable, but we need to make Werror happy
- return INVALID_HOST_MEM_BLOCK;
+ return allocateCoherentMemory(device, pAllocateInfo, enc, pMemory);
}
uint64_t getAHardwareBufferId(AHardwareBuffer* ahw) {
@@ -3914,8 +3164,12 @@
const VkExportMemoryAllocateInfo* exportAllocateInfoPtr =
vk_find_struct<VkExportMemoryAllocateInfo>(pAllocateInfo);
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
const VkImportAndroidHardwareBufferInfoANDROID* importAhbInfoPtr =
vk_find_struct<VkImportAndroidHardwareBufferInfoANDROID>(pAllocateInfo);
+#else
+ const void* importAhbInfoPtr = nullptr;
+#endif
#ifdef VK_USE_PLATFORM_FUCHSIA
const VkImportMemoryBufferCollectionFUCHSIA*
@@ -3923,17 +3177,11 @@
vk_find_struct<VkImportMemoryBufferCollectionFUCHSIA>(
pAllocateInfo);
- const VkImportMemoryBufferCollectionFUCHSIAX*
- importBufferCollectionInfoPtrX =
- vk_find_struct<VkImportMemoryBufferCollectionFUCHSIAX>(
- pAllocateInfo);
-
const VkImportMemoryZirconHandleInfoFUCHSIA* importVmoInfoPtr =
vk_find_struct<VkImportMemoryZirconHandleInfoFUCHSIA>(
pAllocateInfo);
#else
const void* importBufferCollectionInfoPtr = nullptr;
- const void* importBufferCollectionInfoPtrX = nullptr;
const void* importVmoInfoPtr = nullptr;
#endif // VK_USE_PLATFORM_FUCHSIA
@@ -3942,20 +3190,18 @@
bool shouldPassThroughDedicatedAllocInfo =
!exportAllocateInfoPtr && !importAhbInfoPtr &&
- !importBufferCollectionInfoPtr && !importBufferCollectionInfoPtrX &&
+ !importBufferCollectionInfoPtr &&
!importVmoInfoPtr;
#if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
shouldPassThroughDedicatedAllocInfo &=
- !isHostVisibleMemoryTypeIndexForGuest(
- &mHostVisibleMemoryVirtInfo, pAllocateInfo->memoryTypeIndex);
+ !isHostVisible(&mMemoryProps, pAllocateInfo->memoryTypeIndex);
if (!exportAllocateInfoPtr &&
(importAhbInfoPtr || importBufferCollectionInfoPtr ||
- importBufferCollectionInfoPtrX || importVmoInfoPtr) &&
+ importVmoInfoPtr) &&
dedicatedAllocInfoPtr &&
- isHostVisibleMemoryTypeIndexForGuest(
- &mHostVisibleMemoryVirtInfo, pAllocateInfo->memoryTypeIndex)) {
+ isHostVisible(&mMemoryProps, pAllocateInfo->memoryTypeIndex)) {
ALOGE(
"FATAL: It is not yet supported to import-allocate "
"external memory that is both host visible and dedicated.");
@@ -3974,7 +3220,6 @@
bool exportVmo = false;
bool importAhb = false;
bool importBufferCollection = false;
- bool importBufferCollectionX = false;
bool importVmo = false;
(void)exportVmo;
@@ -4001,14 +3246,13 @@
importAhb = true;
} else if (importBufferCollectionInfoPtr) {
importBufferCollection = true;
- } else if (importBufferCollectionInfoPtrX) {
- importBufferCollectionX = true;
} else if (importVmoInfoPtr) {
importVmo = true;
}
bool isImport = importAhb || importBufferCollection ||
- importBufferCollectionX || importVmo;
+ importVmo;
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
if (exportAhb) {
bool hasDedicatedImage = dedicatedAllocInfoPtr &&
(dedicatedAllocInfoPtr->image != VK_NULL_HANDLE);
@@ -4078,13 +3322,22 @@
}
if (ahw) {
- ALOGD("%s: Import AHardwareBuffer", __func__);
- importCbInfo.colorBuffer =
- ResourceTracker::threadingCallbacks.hostConnectionGetFunc()->grallocHelper()->
- getHostHandle(AHardwareBuffer_getNativeHandle(ahw));
- vk_append_struct(&structChainIter, &importCbInfo);
- }
+ D("%s: Import AHardwareBuffer", __func__);
+ const uint32_t hostHandle =
+ ResourceTracker::threadingCallbacks.hostConnectionGetFunc()->grallocHelper()
+ ->getHostHandle(AHardwareBuffer_getNativeHandle(ahw));
+ AHardwareBuffer_Desc ahbDesc = {};
+ AHardwareBuffer_describe(ahw, &ahbDesc);
+ if (ahbDesc.format == AHARDWAREBUFFER_FORMAT_BLOB) {
+ importBufferInfo.buffer = hostHandle;
+ vk_append_struct(&structChainIter, &importBufferInfo);
+ } else {
+ importCbInfo.colorBuffer = hostHandle;
+ vk_append_struct(&structChainIter, &importCbInfo);
+ }
+ }
+#endif
zx_handle_t vmo_handle = ZX_HANDLE_INVALID;
#ifdef VK_USE_PLATFORM_FUCHSIA
@@ -4093,13 +3346,13 @@
fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>*>(
importBufferCollectionInfoPtr->collection);
auto result = collection->WaitForBuffersAllocated();
- if (!result.ok() || result.Unwrap()->status != ZX_OK) {
+ if (!result.ok() || result->status != ZX_OK) {
ALOGE("WaitForBuffersAllocated failed: %d %d", result.status(),
GET_STATUS_SAFE(result, status));
_RETURN_FAILURE_WITH_DEVICE_MEMORY_REPORT(VK_ERROR_INITIALIZATION_FAILED);
}
fuchsia_sysmem::wire::BufferCollectionInfo2& info =
- result.Unwrap()->buffer_collection_info;
+ result->buffer_collection_info;
uint32_t index = importBufferCollectionInfoPtr->index;
if (info.buffer_count < index) {
ALOGE("Invalid buffer index: %d %d", index);
@@ -4108,28 +3361,6 @@
vmo_handle = info.buffers[index].vmo.release();
}
- if (importBufferCollectionX) {
- const auto& collection = *reinterpret_cast<
- fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>*>(
- importBufferCollectionInfoPtrX->collection);
- auto result = collection->WaitForBuffersAllocated();
- if (!result.ok() || result.Unwrap()->status != ZX_OK) {
- ALOGE("WaitForBuffersAllocated failed: %d %d", result.status(),
- GET_STATUS_SAFE(result, status));
- _RETURN_FAILURE_WITH_DEVICE_MEMORY_REPORT(
- VK_ERROR_INITIALIZATION_FAILED);
- }
- fuchsia_sysmem::wire::BufferCollectionInfo2& info =
- result.Unwrap()->buffer_collection_info;
- uint32_t index = importBufferCollectionInfoPtrX->index;
- if (info.buffer_count < index) {
- ALOGE("Invalid buffer index: %d %d", index);
- _RETURN_FAILURE_WITH_DEVICE_MEMORY_REPORT(
- VK_ERROR_INITIALIZATION_FAILED);
- }
- vmo_handle = info.buffers[index].vmo.release();
- }
-
if (importVmo) {
vmo_handle = importVmoInfoPtr->handle;
}
@@ -4265,9 +3496,9 @@
{
auto result = collection->WaitForBuffersAllocated();
- if (result.ok() && result.Unwrap()->status == ZX_OK) {
+ if (result.ok() && result->status == ZX_OK) {
fuchsia_sysmem::wire::BufferCollectionInfo2& info =
- result.Unwrap()->buffer_collection_info;
+ result->buffer_collection_info;
if (!info.buffer_count) {
ALOGE(
"WaitForBuffersAllocated returned "
@@ -4293,17 +3524,15 @@
abort();
}
- bool isHostVisible = isHostVisibleMemoryTypeIndexForGuest(
- &mHostVisibleMemoryVirtInfo,
- pAllocateInfo->memoryTypeIndex);
-
- // Only device-local images need to create color buffer; for
- // host-visible images, the color buffer is already created when
- // sysmem allocates memory.
- if (!isHostVisible) {
- if (pImageCreateInfo) {
- fuchsia_hardware_goldfish::wire::
- ColorBufferFormatType format;
+ if (pImageCreateInfo) {
+ // Only device-local images need to create color buffer; for
+ // host-visible images, the color buffer is already created
+ // when sysmem allocates memory. Here we use the |tiling|
+ // field of image creation info to determine if it uses
+ // host-visible memory.
+ bool isLinear = pImageCreateInfo->tiling == VK_IMAGE_TILING_LINEAR;
+ if (!isLinear) {
+ fuchsia_hardware_goldfish::wire::ColorBufferFormatType format;
switch (pImageCreateInfo->format) {
case VK_FORMAT_B8G8R8A8_SINT:
case VK_FORMAT_B8G8R8A8_UNORM:
@@ -4311,8 +3540,8 @@
case VK_FORMAT_B8G8R8A8_SNORM:
case VK_FORMAT_B8G8R8A8_SSCALED:
case VK_FORMAT_B8G8R8A8_USCALED:
- format = fuchsia_hardware_goldfish::wire::
- ColorBufferFormatType::kBgra;
+ format = fuchsia_hardware_goldfish::wire::ColorBufferFormatType::
+ kBgra;
break;
case VK_FORMAT_R8G8B8A8_SINT:
case VK_FORMAT_R8G8B8A8_UNORM:
@@ -4320,8 +3549,8 @@
case VK_FORMAT_R8G8B8A8_SNORM:
case VK_FORMAT_R8G8B8A8_SSCALED:
case VK_FORMAT_R8G8B8A8_USCALED:
- format = fuchsia_hardware_goldfish::wire::
- ColorBufferFormatType::kRgba;
+ format = fuchsia_hardware_goldfish::wire::ColorBufferFormatType::
+ kRgba;
break;
case VK_FORMAT_R8_UNORM:
case VK_FORMAT_R8_UINT:
@@ -4330,8 +3559,8 @@
case VK_FORMAT_R8_SINT:
case VK_FORMAT_R8_SSCALED:
case VK_FORMAT_R8_SRGB:
- format = fuchsia_hardware_goldfish::wire::
- ColorBufferFormatType::kLuminance;
+ format = fuchsia_hardware_goldfish::wire::ColorBufferFormatType::
+ kLuminance;
break;
case VK_FORMAT_R8G8_UNORM:
case VK_FORMAT_R8G8_UINT:
@@ -4340,8 +3569,8 @@
case VK_FORMAT_R8G8_SINT:
case VK_FORMAT_R8G8_SSCALED:
case VK_FORMAT_R8G8_SRGB:
- format = fuchsia_hardware_goldfish::wire::
- ColorBufferFormatType::kRg;
+ format =
+ fuchsia_hardware_goldfish::wire::ColorBufferFormatType::kRg;
break;
default:
ALOGE("Unsupported format: %d",
@@ -4351,21 +3580,20 @@
fidl::Arena arena;
fuchsia_hardware_goldfish::wire::CreateColorBuffer2Params createParams(
- arena);
+ arena);
createParams.set_width(pImageCreateInfo->extent.width)
- .set_height(pImageCreateInfo->extent.height)
- .set_format(format)
- .set_memory_property(
- fuchsia_hardware_goldfish::wire::kMemoryPropertyDeviceLocal);
+ .set_height(pImageCreateInfo->extent.height)
+ .set_format(format)
+ .set_memory_property(fuchsia_hardware_goldfish::wire::
+ kMemoryPropertyDeviceLocal);
- auto result = mControlDevice->CreateColorBuffer2(
- std::move(vmo_copy), std::move(createParams));
- if (!result.ok() || result.Unwrap()->res != ZX_OK) {
+ auto result = mControlDevice->CreateColorBuffer2(std::move(vmo_copy),
+ std::move(createParams));
+ if (!result.ok() || result->res != ZX_OK) {
if (result.ok() &&
- result.Unwrap()->res == ZX_ERR_ALREADY_EXISTS) {
- ALOGD(
- "CreateColorBuffer: color buffer already "
- "exists\n");
+ result->res == ZX_ERR_ALREADY_EXISTS) {
+ ALOGD("CreateColorBuffer: color buffer already "
+ "exists\n");
} else {
ALOGE("CreateColorBuffer failed: %d:%d",
result.status(),
@@ -4387,12 +3615,16 @@
auto result =
mControlDevice->CreateBuffer2(std::move(vmo_copy), std::move(createParams));
- if (!result.ok() || result.Unwrap()->result.is_err()) {
+ if (!result.ok() || result->is_error()) {
ALOGE("CreateBuffer2 failed: %d:%d", result.status(),
- GET_STATUS_SAFE(result, result.err()));
+ GET_STATUS_SAFE(result, error_value()));
abort();
}
}
+ } else {
+ ALOGW("Dedicated image / buffer not available. Cannot create "
+ "BufferCollection to export VMOs.");
+ return VK_ERROR_OUT_OF_DEVICE_MEMORY;
}
}
@@ -4408,13 +3640,13 @@
zx_status_t status2 = ZX_OK;
auto result = mControlDevice->GetBufferHandle(std::move(vmo_copy));
- if (!result.ok() || result.Unwrap()->res != ZX_OK) {
+ if (!result.ok() || result->res != ZX_OK) {
ALOGE("GetBufferHandle failed: %d:%d", result.status(),
GET_STATUS_SAFE(result, res));
} else {
fuchsia_hardware_goldfish::wire::BufferHandleType
- handle_type = result.Unwrap()->type;
- uint32_t buffer_handle = result.Unwrap()->id;
+ handle_type = result->type;
+ uint32_t buffer_handle = result->id;
if (handle_type == fuchsia_hardware_goldfish::wire::
BufferHandleType::kBuffer) {
@@ -4428,9 +3660,7 @@
}
#endif
- if (!isHostVisibleMemoryTypeIndexForGuest(
- &mHostVisibleMemoryVirtInfo,
- finalAllocInfo.memoryTypeIndex)) {
+ if (!isHostVisible(&mMemoryProps, finalAllocInfo.memoryTypeIndex)) {
input_result =
enc->vkAllocateMemory(
device, &finalAllocInfo, pAllocator, pMemory, true /* do lock */);
@@ -4440,7 +3670,6 @@
VkDeviceSize allocationSize = finalAllocInfo.allocationSize;
setDeviceMemoryInfo(
device, *pMemory,
- finalAllocInfo.allocationSize,
0, nullptr,
finalAllocInfo.memoryTypeIndex,
ahw,
@@ -4487,96 +3716,18 @@
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
- D("host visible alloc (external): "
- "size 0x%llx host ptr %p mapped size 0x%llx",
- (unsigned long long)finalAllocInfo.allocationSize, mappedPtr,
- (unsigned long long)mappedSize);
setDeviceMemoryInfo(device, *pMemory,
- finalAllocInfo.allocationSize, finalAllocInfo.allocationSize,
+ finalAllocInfo.allocationSize,
reinterpret_cast<uint8_t*>(addr), finalAllocInfo.memoryTypeIndex,
/*ahw=*/nullptr, isImport, vmo_handle);
return VK_SUCCESS;
}
#endif
- // Host visible memory, non external
- bool directMappingSupported = usingDirectMapping();
- if (!directMappingSupported) {
- input_result =
- enc->vkAllocateMemory(
- device, &finalAllocInfo, pAllocator, pMemory, true /* do lock */);
-
- if (input_result != VK_SUCCESS) return input_result;
-
- VkDeviceSize mappedSize =
- getNonCoherentExtendedSize(device,
- finalAllocInfo.allocationSize);
- uint8_t* mappedPtr = (uint8_t*)aligned_buf_alloc(4096, mappedSize);
- D("host visible alloc (non-direct): "
- "size 0x%llx host ptr %p mapped size 0x%llx",
- (unsigned long long)finalAllocInfo.allocationSize, mappedPtr,
- (unsigned long long)mappedSize);
- setDeviceMemoryInfo(
- device, *pMemory,
- finalAllocInfo.allocationSize,
- mappedSize, mappedPtr,
- finalAllocInfo.memoryTypeIndex);
- _RETURN_SCUCCESS_WITH_DEVICE_MEMORY_REPORT;
- }
-
- // Host visible memory with direct mapping via
- // VkImportPhysicalAddressGOOGLE
- // if (importPhysAddr) {
- // vkAllocateMemory(device, &finalAllocInfo, pAllocator, pMemory);
- // host maps the host pointer to the guest physical address
- // TODO: the host side page offset of the
- // host pointer needs to be returned somehow.
- // }
-
// Host visible memory with direct mapping
- AutoLock<RecursiveLock> lock(mLock);
-
- auto it = info_VkDevice.find(device);
- if (it == info_VkDevice.end()) _RETURN_FAILURE_WITH_DEVICE_MEMORY_REPORT(VK_ERROR_DEVICE_LOST);
- auto& deviceInfo = it->second;
-
- auto& hostMemBlocksForTypeIndex =
- deviceInfo.hostMemBlocks[finalAllocInfo.memoryTypeIndex];
-
- HostMemBlockIndex blockIndex =
- getOrAllocateHostMemBlockLocked(
- hostMemBlocksForTypeIndex,
- &finalAllocInfo,
- enc,
- device,
- deviceInfo);
-
- if (blockIndex == (HostMemBlockIndex) INVALID_HOST_MEM_BLOCK) {
- _RETURN_FAILURE_WITH_DEVICE_MEMORY_REPORT(VK_ERROR_OUT_OF_HOST_MEMORY);
- }
-
- VkDeviceMemory_Info virtualMemInfo;
-
- subAllocHostMemory(
- &hostMemBlocksForTypeIndex[blockIndex],
- &finalAllocInfo,
- &virtualMemInfo.subAlloc);
-
- virtualMemInfo.allocationSize = virtualMemInfo.subAlloc.subAllocSize;
- virtualMemInfo.mappedSize = virtualMemInfo.subAlloc.subMappedSize;
- virtualMemInfo.mappedPtr = virtualMemInfo.subAlloc.mappedPtr;
- virtualMemInfo.memoryTypeIndex = finalAllocInfo.memoryTypeIndex;
- virtualMemInfo.directMapped = true;
-
- D("host visible alloc (direct, suballoc): "
- "size 0x%llx ptr %p mapped size 0x%llx",
- (unsigned long long)virtualMemInfo.allocationSize, virtualMemInfo.mappedPtr,
- (unsigned long long)virtualMemInfo.mappedSize);
-
- info_VkDeviceMemory[
- virtualMemInfo.subAlloc.subMemory] = virtualMemInfo;
-
- *pMemory = virtualMemInfo.subAlloc.subMemory;
+ VkResult result = getCoherentMemory(&finalAllocInfo, enc, device, pMemory);
+ if (result != VK_SUCCESS)
+ return result;
_RETURN_SCUCCESS_WITH_DEVICE_MEMORY_REPORT;
}
@@ -4593,9 +3744,11 @@
if (it == info_VkDeviceMemory.end()) return;
auto& info = it->second;
uint64_t memoryObjectId = (uint64_t)(void*)memory;
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
if (info.ahw) {
memoryObjectId = getAHardwareBufferId(info.ahw);
}
+#endif
emitDeviceMemoryReport(
info_VkDevice[device],
info.imported ? VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT
@@ -4607,77 +3760,34 @@
);
#ifdef VK_USE_PLATFORM_FUCHSIA
- if (info.vmoHandle && info.mappedPtr) {
+ if (info.vmoHandle && info.ptr) {
zx_status_t status = zx_vmar_unmap(
- zx_vmar_root_self(), reinterpret_cast<zx_paddr_t>(info.mappedPtr), info.mappedSize);
+ zx_vmar_root_self(), reinterpret_cast<zx_paddr_t>(info.ptr), info.allocationSize);
if (status != ZX_OK) {
- ALOGE("%s: Cannot unmap mappedPtr: status %d", status);
+ ALOGE("%s: Cannot unmap ptr: status %d", status);
}
- info.mappedPtr = nullptr;
+ info.ptr = nullptr;
}
#endif
- if (!info.directMapped) {
+ if (!info.coherentMemory) {
lock.unlock();
VkEncoder* enc = (VkEncoder*)context;
enc->vkFreeMemory(device, memory, pAllocateInfo, true /* do lock */);
return;
}
- VkDeviceMemory baseMemory = info.subAlloc.baseMemory;
- uint32_t memoryTypeIndex = info.subAlloc.memoryTypeIndex;
- bool isDeviceAddressMemoryAllocation = info.subAlloc.isDeviceAddressMemoryAllocation;
- // If this was a device address memory allocation,
- // free it right away.
- // TODO: Retest with eagerly freeing other kinds of host visible
- // allocs as well
- if (subFreeHostMemory(&info.subAlloc) && isDeviceAddressMemoryAllocation) {
- ALOGV("%s: Last free for this device-address block, "
- "free on host and clear block contents\n", __func__);
- ALOGV("%s: baseMem 0x%llx this mem 0x%llx\n", __func__,
- (unsigned long long)baseMemory,
- (unsigned long long)memory);
- VkEncoder* enc = (VkEncoder*)context;
- bool freeMemorySyncSupported =
- mFeatureInfo->hasVulkanFreeMemorySync;
-
- auto it = info_VkDevice.find(device);
- if (it == info_VkDevice.end()) {
- ALOGE("%s: Last free: could not find device\n", __func__);
- return;
+ if (info.coherentMemory && info.ptr) {
+ if (info.coherentMemory->getDeviceMemory() != memory) {
+ delete_goldfish_VkDeviceMemory(memory);
}
- auto& deviceInfo = it->second;
-
- auto& hostMemBlocksForTypeIndex =
- deviceInfo.hostMemBlocks[memoryTypeIndex];
-
- size_t indexToRemove = 0;
- bool found = false;
- for (const auto& allocInfo : hostMemBlocksForTypeIndex) {
- if (baseMemory == allocInfo.memory) {
- found = true;
- break;
- }
- ++indexToRemove;
+ if (info.ptr) {
+ info.coherentMemory->release(info.ptr);
+ info.ptr = nullptr;
}
- if (!found) {
- ALOGE("%s: Last free: could not find original block\n", __func__);
- return;
- }
-
- ALOGV("%s: Destroying host mem alloc block at index %zu\n", __func__, indexToRemove);
-
- destroyHostMemAlloc(
- freeMemorySyncSupported,
- enc, device,
- hostMemBlocksForTypeIndex.data() + indexToRemove,
- false);
-
- ALOGV("%s: Destroying host mem alloc block at index %zu (done)\n", __func__, indexToRemove);
-
- hostMemBlocksForTypeIndex.erase(hostMemBlocksForTypeIndex.begin() + indexToRemove);
+ info.coherentMemory = nullptr;
}
}
@@ -4706,13 +3816,13 @@
auto& info = it->second;
- if (!info.mappedPtr) {
- ALOGE("%s: mappedPtr null\n", __func__);
+ if (!info.ptr) {
+ ALOGE("%s: ptr null\n", __func__);
return VK_ERROR_MEMORY_MAP_FAILED;
}
if (size != VK_WHOLE_SIZE &&
- (info.mappedPtr + offset + size > info.mappedPtr + info.allocationSize)) {
+ (info.ptr + offset + size > info.ptr + info.allocationSize)) {
ALOGE("%s: size is too big. alloc size 0x%llx while we wanted offset 0x%llx size 0x%llx total 0x%llx\n", __func__,
(unsigned long long)info.allocationSize,
(unsigned long long)offset,
@@ -4721,7 +3831,7 @@
return VK_ERROR_MEMORY_MAP_FAILED;
}
- *ppData = info.mappedPtr + offset;
+ *ppData = info.ptr + offset;
return host_result;
}
@@ -4750,8 +3860,7 @@
for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i) {
bool shouldAcceptMemoryIndex = normalBits & (1 << i);
#if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
- shouldAcceptMemoryIndex &= !isHostVisibleMemoryTypeIndexForGuest(
- &mHostVisibleMemoryVirtInfo, i);
+ shouldAcceptMemoryIndex &= !isHostVisible(&mMemoryProps, i);
#endif // VK_USE_PLATFORM_FUCHSIA
if (shouldAcceptMemoryIndex) {
@@ -4928,12 +4037,6 @@
vk_find_struct<VkBufferCollectionImageCreateInfoFUCHSIA>(
pCreateInfo);
- if (!extBufferCollectionPtr) {
- extBufferCollectionPtr = reinterpret_cast<
- const VkBufferCollectionImageCreateInfoFUCHSIA*>(
- vk_find_struct<VkBufferCollectionImageCreateInfoFUCHSIAX>(
- pCreateInfo));
- }
bool isSysmemBackedMemory = false;
if (extImgCiPtr &&
@@ -4952,8 +4055,8 @@
fuchsia_sysmem::wire::BufferCollectionInfo2 info;
auto result = collection->WaitForBuffersAllocated();
- if (result.ok() && result.Unwrap()->status == ZX_OK) {
- info = std::move(result.Unwrap()->buffer_collection_info);
+ if (result.ok() && result->status == ZX_OK) {
+ info = std::move(result->buffer_collection_info);
if (index < info.buffer_count && info.settings.has_image_format_constraints) {
vmo = std::move(info.buffers[index].vmo);
}
@@ -5011,10 +4114,10 @@
auto result =
mControlDevice->CreateColorBuffer2(std::move(vmo), std::move(createParams));
- if (result.ok() && result.Unwrap()->res == ZX_ERR_ALREADY_EXISTS) {
+ if (result.ok() && result->res == ZX_ERR_ALREADY_EXISTS) {
ALOGD(
"CreateColorBuffer: color buffer already exists\n");
- } else if (!result.ok() || result.Unwrap()->res != ZX_OK) {
+ } else if (!result.ok() || result->res != ZX_OK) {
ALOGE("CreateColorBuffer failed: %d:%d", result.status(),
GET_STATUS_SAFE(result, res));
}
@@ -5059,10 +4162,12 @@
info.createInfo = *pCreateInfo;
info.createInfo.pNext = nullptr;
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
if (extFormatAndroidPtr && extFormatAndroidPtr->externalFormat) {
info.hasExternalFormat = true;
info.androidFormat = extFormatAndroidPtr->externalFormat;
}
+#endif // VK_USE_PLATFORM_ANDROID_KHR
if (supportsCreateResourcesWithRequirements()) {
info.baseRequirementsKnown = true;
@@ -5251,7 +4356,7 @@
VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT |
VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT;
- ALOGD("%s: asked for sync fd, set the features\n", __func__);
+ D("%s: asked for sync fd, set the features\n", __func__);
#endif
}
@@ -5273,11 +4378,6 @@
exportFenceInfoPtr &&
(exportFenceInfoPtr->handleTypes &
VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT);
-
- if (exportSyncFd) {
- ALOGV("%s: exporting sync fd, do not send pNext to host\n", __func__);
- finalCreateInfo.pNext = nullptr;
- }
#endif
input_result = enc->vkCreateFence(
@@ -5416,6 +4516,29 @@
#endif
}
+ VkResult createFence(VkDevice device, uint64_t hostFenceHandle, int64_t& osHandle) {
+ struct VirtGpuExecBuffer exec = { };
+ struct gfxstreamCreateExportSyncVK exportSync = { };
+ VirtGpuDevice& instance = VirtGpuDevice::getInstance();
+
+ uint64_t hostDeviceHandle = get_host_u64_VkDevice(device);
+
+ exportSync.hdr.opCode = GFXSTREAM_CREATE_EXPORT_SYNC_VK;
+ exportSync.deviceHandleLo = (uint32_t)hostDeviceHandle;
+ exportSync.deviceHandleHi = (uint32_t)(hostDeviceHandle >> 32);
+ exportSync.fenceHandleLo = (uint32_t)hostFenceHandle;
+ exportSync.fenceHandleHi = (uint32_t)(hostFenceHandle >> 32);
+
+ exec.command = static_cast<void*>(&exportSync);
+ exec.command_size = sizeof(exportSync);
+ exec.flags = kFenceOut | kRingIdx;
+ if (instance.execBuffer(exec, nullptr))
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+ osHandle = exec.handle.osHandle;
+ return VK_SUCCESS;
+ }
+
VkResult on_vkGetFenceFdKHR(
void* context,
VkResult,
@@ -5480,46 +4603,15 @@
}
if (mFeatureInfo->hasVirtioGpuNativeSync) {
-#if !defined(HOST_BUILD) && defined(VK_USE_PLATFORM_ANDROID_KHR)
+ VkResult result;
+ int64_t osHandle;
uint64_t hostFenceHandle = get_host_u64_VkFence(pGetFdInfo->fence);
- uint32_t hostFenceHandleLo = (uint32_t)hostFenceHandle;
- uint32_t hostFenceHandleHi = (uint32_t)(hostFenceHandle >> 32);
- uint64_t hostDeviceHandle = get_host_u64_VkDevice(device);
- uint32_t hostDeviceHandleLo = (uint32_t)hostDeviceHandle;
- uint32_t hostDeviceHandleHi = (uint32_t)(hostFenceHandle >> 32);
+ result = createFence(device, hostFenceHandle, osHandle);
+ if (result != VK_SUCCESS)
+ return result;
- #define VIRTIO_GPU_NATIVE_SYNC_VULKAN_CREATE_EXPORT_FD 0xa000
-
- uint32_t cmdDwords[5] = {
- VIRTIO_GPU_NATIVE_SYNC_VULKAN_CREATE_EXPORT_FD,
- hostDeviceHandleLo,
- hostDeviceHandleHi,
- hostFenceHandleLo,
- hostFenceHandleHi,
- };
-
- struct drm_virtgpu_execbuffer execbuffer = {
- .flags = (uint32_t)(mFeatureInfo->hasVulkanAsyncQsri ?
- (VIRTGPU_EXECBUF_FENCE_FD_OUT | VIRTGPU_EXECBUF_RING_IDX) :
- VIRTGPU_EXECBUF_FENCE_FD_OUT),
- .size = 5 * sizeof(uint32_t),
- .command = (uint64_t)(cmdDwords),
- .bo_handles = 0,
- .num_bo_handles = 0,
- .fence_fd = -1,
- .ring_idx = 0,
- };
-
- int res = drmIoctl(mRendernodeFd, DRM_IOCTL_VIRTGPU_EXECBUFFER, &execbuffer);
- if (res) {
- ALOGE("%s: Failed to virtgpu execbuffer: sterror: %s errno: %d\n", __func__,
- strerror(errno), errno);
- abort();
- }
-
- *pFd = execbuffer.fence_fd;
-#endif
+ *pFd = osHandle;
} else {
goldfish_sync_queue_work(
mSyncDeviceFd,
@@ -5901,6 +4993,32 @@
void on_vkDestroyImage(
void* context,
VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) {
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+ {
+ AutoLock<RecursiveLock> lock(mLock); // do not guard encoder may cause
+ // deadlock b/243339973
+
+ // Wait for any pending QSRIs to prevent a race between the Gfxstream host
+ // potentially processing the below `vkDestroyImage()` from the VK encoder
+ // command stream before processing a previously submitted
+ // `VIRTIO_GPU_NATIVE_SYNC_VULKAN_QSRI_EXPORT` from the virtio-gpu command
+ // stream which relies on the image existing.
+ auto imageInfoIt = info_VkImage.find(image);
+ if (imageInfoIt != info_VkImage.end()) {
+ auto& imageInfo = imageInfoIt->second;
+ for (int syncFd : imageInfo.pendingQsriSyncFds) {
+ int syncWaitRet = sync_wait(syncFd, 3000);
+ if (syncWaitRet < 0) {
+ ALOGE("%s: Failed to wait for pending QSRI sync: sterror: %s errno: %d",
+ __func__, strerror(errno), errno);
+ }
+ close(syncFd);
+ }
+ imageInfo.pendingQsriSyncFds.clear();
+ }
+ }
+#endif
VkEncoder* enc = (VkEncoder*)context;
enc->vkDestroyImage(device, image, pAllocator, true /* do lock */);
}
@@ -5980,6 +5098,11 @@
VkDevice device, VkImage image, VkDeviceMemory memory,
VkDeviceSize memoryOffset) {
VkEncoder* enc = (VkEncoder*)context;
+ // Do not forward calls with invalid handles to host.
+ if (info_VkDeviceMemory.find(memory) == info_VkDeviceMemory.end() ||
+ info_VkImage.find(image) == info_VkImage.end()) {
+ return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+ }
return enc->vkBindImageMemory(device, image, memory, memoryOffset, true /* do lock */);
}
@@ -5987,6 +5110,13 @@
void* context, VkResult,
VkDevice device, uint32_t bindingCount, const VkBindImageMemoryInfo* pBindInfos) {
VkEncoder* enc = (VkEncoder*)context;
+ // Do not forward calls with invalid handles to host.
+ if (!pBindInfos ||
+ info_VkDeviceMemory.find(pBindInfos->memory) ==
+ info_VkDeviceMemory.end() ||
+ info_VkImage.find(pBindInfos->image) == info_VkImage.end()) {
+ return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+ }
return enc->vkBindImageMemory2(device, bindingCount, pBindInfos, true /* do lock */);
}
@@ -5994,6 +5124,13 @@
void* context, VkResult,
VkDevice device, uint32_t bindingCount, const VkBindImageMemoryInfo* pBindInfos) {
VkEncoder* enc = (VkEncoder*)context;
+ // Do not forward calls with invalid handles to host.
+ if (!pBindInfos ||
+ info_VkDeviceMemory.find(pBindInfos->memory) ==
+ info_VkDeviceMemory.end() ||
+ info_VkImage.find(pBindInfos->image) == info_VkImage.end()) {
+ return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+ }
return enc->vkBindImageMemory2KHR(device, bindingCount, pBindInfos, true /* do lock */);
}
@@ -6004,12 +5141,22 @@
VkBuffer *pBuffer) {
VkEncoder* enc = (VkEncoder*)context;
+ VkBufferCreateInfo localCreateInfo = vk_make_orphan_copy(*pCreateInfo);
+ vk_struct_chain_iterator structChainIter =
+ vk_make_chain_iterator(&localCreateInfo);
+ VkExternalMemoryBufferCreateInfo localExtBufCi;
+
+ const VkExternalMemoryBufferCreateInfo* extBufCiPtr =
+ vk_find_struct<VkExternalMemoryBufferCreateInfo>(pCreateInfo);
+ if (extBufCiPtr) {
+ localExtBufCi = vk_make_orphan_copy(*extBufCiPtr);
+ vk_append_struct(&structChainIter, &localExtBufCi);
+ }
+
#ifdef VK_USE_PLATFORM_FUCHSIA
Optional<zx::vmo> vmo;
bool isSysmemBackedMemory = false;
- const VkExternalMemoryBufferCreateInfo* extBufCiPtr =
- vk_find_struct<VkExternalMemoryBufferCreateInfo>(pCreateInfo);
if (extBufCiPtr &&
(extBufCiPtr->handleTypes &
VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA)) {
@@ -6020,13 +5167,6 @@
vk_find_struct<VkBufferCollectionBufferCreateInfoFUCHSIA>(
pCreateInfo);
- if (extBufferCollectionPtr == nullptr) {
- extBufferCollectionPtr = reinterpret_cast<
- const VkBufferCollectionBufferCreateInfoFUCHSIA*>(
- vk_find_struct<VkBufferCollectionBufferCreateInfoFUCHSIAX>(
- pCreateInfo));
- }
-
if (extBufferCollectionPtr) {
const auto& collection = *reinterpret_cast<
fidl::WireSyncClient<fuchsia_sysmem::BufferCollection>*>(
@@ -6034,8 +5174,8 @@
uint32_t index = extBufferCollectionPtr->index;
auto result = collection->WaitForBuffersAllocated();
- if (result.ok() && result.Unwrap()->status == ZX_OK) {
- auto& info = result.Unwrap()->buffer_collection_info;
+ if (result.ok() && result->status == ZX_OK) {
+ auto& info = result->buffer_collection_info;
if (index < info.buffer_count) {
vmo = android::base::makeOptional(
std::move(info.buffers[index].vmo));
@@ -6055,10 +5195,10 @@
auto result =
mControlDevice->CreateBuffer2(std::move(*vmo), createParams);
if (!result.ok() ||
- (result.Unwrap()->result.is_err() != ZX_OK &&
- result.Unwrap()->result.err() != ZX_ERR_ALREADY_EXISTS)) {
+ (result->is_error() != ZX_OK &&
+ result->error_value() != ZX_ERR_ALREADY_EXISTS)) {
ALOGE("CreateBuffer2 failed: %d:%d", result.status(),
- GET_STATUS_SAFE(result, result.err()));
+ GET_STATUS_SAFE(result, error_value()));
}
isSysmemBackedMemory = true;
}
@@ -6069,9 +5209,12 @@
VkMemoryRequirements memReqs;
if (supportsCreateResourcesWithRequirements()) {
- res = enc->vkCreateBufferWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pBuffer, &memReqs, true /* do lock */);
+ res = enc->vkCreateBufferWithRequirementsGOOGLE(
+ device, &localCreateInfo, pAllocator, pBuffer, &memReqs,
+ true /* do lock */);
} else {
- res = enc->vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer, true /* do lock */);
+ res = enc->vkCreateBuffer(device, &localCreateInfo, pAllocator,
+ pBuffer, true /* do lock */);
}
if (res != VK_SUCCESS) return res;
@@ -6083,19 +5226,16 @@
auto& info = it->second;
- info.createInfo = *pCreateInfo;
+ info.createInfo = localCreateInfo;
info.createInfo.pNext = nullptr;
if (supportsCreateResourcesWithRequirements()) {
info.baseRequirementsKnown = true;
}
- const VkExternalMemoryBufferCreateInfo* extBufCi =
- vk_find_struct<VkExternalMemoryBufferCreateInfo>(pCreateInfo);
-
- if (extBufCi) {
+ if (extBufCiPtr) {
info.external = true;
- info.externalCreateInfo = *extBufCi;
+ info.externalCreateInfo = *extBufCiPtr;
}
#ifdef VK_USE_PLATFORM_FUCHSIA
@@ -6271,46 +5411,15 @@
#if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
if (exportSyncFd) {
if (mFeatureInfo->hasVirtioGpuNativeSync) {
-#if !defined(HOST_BUILD)
+ VkResult result;
+ int64_t osHandle;
uint64_t hostFenceHandle = get_host_u64_VkSemaphore(*pSemaphore);
- uint32_t hostFenceHandleLo = (uint32_t)hostFenceHandle;
- uint32_t hostFenceHandleHi = (uint32_t)(hostFenceHandle >> 32);
- uint64_t hostDeviceHandle = get_host_u64_VkDevice(device);
- uint32_t hostDeviceHandleLo = (uint32_t)hostDeviceHandle;
- uint32_t hostDeviceHandleHi = (uint32_t)(hostFenceHandle >> 32);
+ result = createFence(device, hostFenceHandle, osHandle);
+ if (result != VK_SUCCESS)
+ return result;
- #define VIRTIO_GPU_NATIVE_SYNC_VULKAN_CREATE_EXPORT_FD 0xa000
-
- uint32_t cmdDwords[5] = {
- VIRTIO_GPU_NATIVE_SYNC_VULKAN_CREATE_EXPORT_FD,
- hostDeviceHandleLo,
- hostDeviceHandleHi,
- hostFenceHandleLo,
- hostFenceHandleHi,
- };
-
- struct drm_virtgpu_execbuffer execbuffer = {
- .flags = (uint32_t)(mFeatureInfo->hasVulkanAsyncQsri ?
- (VIRTGPU_EXECBUF_FENCE_FD_OUT | VIRTGPU_EXECBUF_RING_IDX) :
- VIRTGPU_EXECBUF_FENCE_FD_OUT),
- .size = 5 * sizeof(uint32_t),
- .command = (uint64_t)(cmdDwords),
- .bo_handles = 0,
- .num_bo_handles = 0,
- .fence_fd = -1,
- .ring_idx = 0,
- };
-
- int res = drmIoctl(mRendernodeFd, DRM_IOCTL_VIRTGPU_EXECBUFFER, &execbuffer);
- if (res) {
- ALOGE("%s: Failed to virtgpu execbuffer: sterror: %s errno: %d\n", __func__,
- strerror(errno), errno);
- abort();
- }
-
- info.syncFd = execbuffer.fence_fd;
-#endif
+ info.syncFd.emplace(osHandle);
} else {
ensureSyncDeviceFd();
@@ -6321,7 +5430,7 @@
get_host_u64_VkSemaphore(*pSemaphore) /* the handle */,
GOLDFISH_SYNC_VULKAN_SEMAPHORE_SYNC /* thread handle (doubling as type field) */,
&syncFd);
- info.syncFd = syncFd;
+ info.syncFd.emplace(syncFd);
}
}
}
@@ -6355,7 +5464,8 @@
auto it = info_VkSemaphore.find(pGetFdInfo->semaphore);
if (it == info_VkSemaphore.end()) return VK_ERROR_OUT_OF_HOST_MEMORY;
auto& semInfo = it->second;
- *pFd = dup(semInfo.syncFd);
+ // syncFd is supposed to have value.
+ *pFd = dup(semInfo.syncFd.value_or(-1));
return VK_SUCCESS;
} else {
// opaque fd
@@ -6396,11 +5506,11 @@
auto semaphoreIt = info_VkSemaphore.find(pImportSemaphoreFdInfo->semaphore);
auto& info = semaphoreIt->second;
- if (info.syncFd >= 0) {
- close(info.syncFd);
+ if (info.syncFd.value_or(-1) >= 0) {
+ close(info.syncFd.value());
}
- info.syncFd = pImportSemaphoreFdInfo->fd;
+ info.syncFd.emplace(pImportSemaphoreFdInfo->fd);
return VK_SUCCESS;
} else {
@@ -6690,8 +5800,8 @@
}
#endif
#if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
- if (semInfo.syncFd != 0) {
- pre_signal_sync_fds.push_back(semInfo.syncFd);
+ if (semInfo.syncFd.has_value()) {
+ pre_signal_sync_fds.push_back(semInfo.syncFd.value());
pre_signal_semaphores.push_back(pSubmits[i].pWaitSemaphores[j]);
}
#endif
@@ -6719,8 +5829,8 @@
}
#endif
#if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
- if (semInfo.syncFd >= 0) {
- post_wait_sync_fds.push_back(semInfo.syncFd);
+ if (semInfo.syncFd.value_or(-1) >= 0) {
+ post_wait_sync_fds.push_back(semInfo.syncFd.value());
}
#endif
}
@@ -6878,6 +5988,7 @@
return enc->vkQueueWaitIdle(queue, true /* do lock */);
}
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
void unwrap_VkNativeBufferANDROID(
const VkImageCreateInfo* pCreateInfo,
VkImageCreateInfo* local_pCreateInfo) {
@@ -6909,7 +6020,6 @@
}
void unwrap_vkAcquireImageANDROID_nativeFenceFd(int fd, int*) {
-#if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
if (fd != -1) {
AEMU_SCOPED_TRACE("waitNativeFenceInAcquire");
// Implicit Synchronization
@@ -6927,8 +6037,8 @@
// Therefore, assume contract where we need to close fd in this driver
close(fd);
}
-#endif
}
+#endif
// Action of vkMapMemoryIntoAddressSpaceGOOGLE:
// 1. preprocess (on_vkMapMemoryIntoAddressSpaceGOOGLE_pre):
@@ -6958,15 +6068,12 @@
}
auto& memInfo = it->second;
- memInfo.goldfishAddressSpaceBlock =
- new GoldfishAddressSpaceBlock;
- auto& block = *(memInfo.goldfishAddressSpaceBlock);
- block.allocate(
- mGoldfishAddressSpaceBlockProvider.get(),
- memInfo.mappedSize);
+ GoldfishAddressSpaceBlockPtr block = std::make_shared<GoldfishAddressSpaceBlock>();
+ block->allocate(mGoldfishAddressSpaceBlockProvider.get(), memInfo.coherentMemorySize);
- *pAddress = block.physAddr();
+ memInfo.goldfishBlock = block;
+ *pAddress = block->physAddr();
return VK_SUCCESS;
}
@@ -6977,35 +6084,13 @@
VkDevice,
VkDeviceMemory memory,
uint64_t* pAddress) {
+ (void)memory;
+ (void)pAddress;
if (input_result != VK_SUCCESS) {
return input_result;
}
- // Now pAddress points to the gpu addr from host.
- AutoLock<RecursiveLock> lock(mLock);
-
- auto it = info_VkDeviceMemory.find(memory);
- if (it == info_VkDeviceMemory.end()) {
- return VK_ERROR_OUT_OF_HOST_MEMORY;
- }
-
- auto& memInfo = it->second;
- auto& block = *(memInfo.goldfishAddressSpaceBlock);
-
- uint64_t gpuAddr = *pAddress;
-
- void* userPtr = block.mmap(gpuAddr);
-
- D("%s: Got new host visible alloc. "
- "Sizeof void: %zu map size: %zu Range: [%p %p]",
- __func__,
- sizeof(void*), (size_t)memInfo.mappedSize,
- userPtr,
- (unsigned char*)userPtr + memInfo.mappedSize);
-
- *pAddress = (uint64_t)(uintptr_t)userPtr;
-
return input_result;
}
@@ -7332,8 +6417,10 @@
}
#endif
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
VkAndroidHardwareBufferUsageANDROID* output_ahw_usage =
vk_find_struct<VkAndroidHardwareBufferUsageANDROID>(pImageFormatProperties);
+#endif
VkResult hostRes;
@@ -7370,12 +6457,14 @@
}
#endif
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
if (output_ahw_usage) {
output_ahw_usage->androidHardwareBufferUsage =
getAndroidHardwareBufferUsageFromVkUsage(
pImageFormatInfo->flags,
pImageFormatInfo->usage);
}
+#endif
return hostRes;
}
@@ -7593,7 +6682,7 @@
VkImageViewCreateInfo localCreateInfo = vk_make_orphan_copy(*pCreateInfo);
vk_struct_chain_iterator structChainIter = vk_make_chain_iterator(&localCreateInfo);
-#if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
if (pCreateInfo->format == VK_FORMAT_UNDEFINED) {
AutoLock<RecursiveLock> lock(mLock);
@@ -7684,6 +6773,65 @@
true /* do lock */);
}
+ void on_vkCmdPipelineBarrier(
+ void* context,
+ 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) {
+
+ VkEncoder* enc = (VkEncoder*)context;
+
+ std::vector<VkImageMemoryBarrier> updatedImageMemoryBarriers;
+ updatedImageMemoryBarriers.reserve(imageMemoryBarrierCount);
+ for (uint32_t i = 0; i < imageMemoryBarrierCount; i++) {
+ VkImageMemoryBarrier barrier = pImageMemoryBarriers[i];
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+ // Unfortunetly, Android does not yet have a mechanism for sharing the expected
+ // VkImageLayout when passing around AHardwareBuffer-s so many existing users
+ // that import AHardwareBuffer-s into VkImage-s/VkDeviceMemory-s simply use
+ // VK_IMAGE_LAYOUT_UNDEFINED. However, the Vulkan spec's image layout transition
+ // sections says "If the old layout is VK_IMAGE_LAYOUT_UNDEFINED, the contents of
+ // that range may be discarded." Some Vulkan drivers have been observed to actually
+ // perform the discard which leads to AHardwareBuffer-s being unintentionally
+ // cleared. See go/ahb-vkimagelayout for more information.
+ if (barrier.srcQueueFamilyIndex != barrier.dstQueueFamilyIndex &&
+ (barrier.srcQueueFamilyIndex == VK_QUEUE_FAMILY_EXTERNAL ||
+ barrier.srcQueueFamilyIndex == VK_QUEUE_FAMILY_FOREIGN_EXT) &&
+ barrier.oldLayout == VK_IMAGE_LAYOUT_UNDEFINED) {
+ // This is not a complete solution as the Vulkan spec does not require that
+ // Vulkan drivers perform a no-op in the case when oldLayout equals newLayout
+ // but this has been observed to be enough to work for now to avoid clearing
+ // out images.
+ // TODO(b/236179843): figure out long term solution.
+ barrier.oldLayout = barrier.newLayout;
+ }
+#endif
+
+ updatedImageMemoryBarriers.push_back(barrier);
+ }
+
+ enc->vkCmdPipelineBarrier(
+ commandBuffer,
+ srcStageMask,
+ dstStageMask,
+ dependencyFlags,
+ memoryBarrierCount,
+ pMemoryBarriers,
+ bufferMemoryBarrierCount,
+ pBufferMemoryBarriers,
+ updatedImageMemoryBarriers.size(),
+ updatedImageMemoryBarriers.data(),
+ true /* do lock */);
+ }
+
void decDescriptorSetLayoutRef(
void* context,
VkDevice device,
@@ -7730,55 +6878,71 @@
return res;
}
- int exportSyncFdForQSRI(VkImage image) {
- int fd = -1;
-#if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
+#if defined(VK_USE_PLATFORM_ANDROID_KHR)
+ VkResult exportSyncFdForQSRILocked(VkImage image, int *fd) {
+
ALOGV("%s: call for image %p hos timage handle 0x%llx\n", __func__, (void*)image,
- (unsigned long long)get_host_u64_VkImage(image));
+ (unsigned long long)get_host_u64_VkImage(image));
+
if (mFeatureInfo->hasVirtioGpuNativeSync) {
-#ifndef HOST_BUILD
+ struct VirtGpuExecBuffer exec = { };
+ struct gfxstreamCreateQSRIExportVK exportQSRI = { };
+ VirtGpuDevice& instance = VirtGpuDevice::getInstance();
+
uint64_t hostImageHandle = get_host_u64_VkImage(image);
- uint32_t hostImageHandleLo = (uint32_t)hostImageHandle;
- uint32_t hostImageHandleHi = (uint32_t)(hostImageHandle >> 32);
-#define VIRTIO_GPU_NATIVE_SYNC_VULKAN_QSRI_EXPORT 0xa002
+ exportQSRI.hdr.opCode = GFXSTREAM_CREATE_QSRI_EXPORT_VK;
+ exportQSRI.imageHandleLo = (uint32_t)hostImageHandle;
+ exportQSRI.imageHandleHi = (uint32_t)(hostImageHandle >> 32);
- uint32_t cmdDwords[3] = {
- VIRTIO_GPU_NATIVE_SYNC_VULKAN_QSRI_EXPORT,
- hostImageHandleLo,
- hostImageHandleHi,
- };
+ exec.command = static_cast<void*>(&exportQSRI);
+ exec.command_size = sizeof(exportQSRI);
+ exec.flags = kFenceOut | kRingIdx;
+ if (instance.execBuffer(exec, nullptr))
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
- struct drm_virtgpu_execbuffer execbuffer = {
- // Assume fence context support if we enabled hasVulkanAsyncQsri
- .flags = VIRTGPU_EXECBUF_FENCE_FD_OUT | VIRTGPU_EXECBUF_RING_IDX,
- .size = sizeof(cmdDwords),
- .command = (uint64_t)(cmdDwords),
- .bo_handles = 0,
- .num_bo_handles = 0,
- .fence_fd = -1,
- .ring_idx = 0,
- };
-
- int res = drmIoctl(mRendernodeFd, DRM_IOCTL_VIRTGPU_EXECBUFFER, &execbuffer);
- if (res) {
- ALOGE("%s: Failed to virtgpu execbuffer: sterror: %s errno: %d\n", __func__,
- strerror(errno), errno);
- abort();
- }
-
- fd = execbuffer.fence_fd;
-#endif // !defined(HOST_BUILD)
+ *fd = exec.handle.osHandle;
} else {
goldfish_sync_queue_work(
mSyncDeviceFd,
get_host_u64_VkImage(image) /* the handle */,
GOLDFISH_SYNC_VULKAN_QSRI /* thread handle (doubling as type field) */,
- &fd);
+ fd);
}
- ALOGV("%s: got fd: %d\n", __func__, fd);
-#endif
- return fd;
+
+ ALOGV("%s: got fd: %d\n", __func__, *fd);
+ auto imageInfoIt = info_VkImage.find(image);
+ if (imageInfoIt != info_VkImage.end()) {
+ auto& imageInfo = imageInfoIt->second;
+
+ // Remove any pending QSRI sync fds that are already signaled.
+ auto syncFdIt = imageInfo.pendingQsriSyncFds.begin();
+ while (syncFdIt != imageInfo.pendingQsriSyncFds.end()) {
+ int syncFd = *syncFdIt;
+ int syncWaitRet = sync_wait(syncFd, /*timeout msecs*/0);
+ if (syncWaitRet == 0) {
+ // Sync fd is signaled.
+ syncFdIt = imageInfo.pendingQsriSyncFds.erase(syncFdIt);
+ close(syncFd);
+ } else {
+ if (errno != ETIME) {
+ ALOGE("%s: Failed to wait for pending QSRI sync: sterror: %s errno: %d",
+ __func__, strerror(errno), errno);
+ }
+ break;
+ }
+ }
+
+ int syncFdDup = dup(*fd);
+ if (syncFdDup < 0) {
+ ALOGE("%s: Failed to dup() QSRI sync fd : sterror: %s errno: %d",
+ __func__, strerror(errno), errno);
+ } else {
+ imageInfo.pendingQsriSyncFds.push_back(syncFdDup);
+ }
+ }
+
+ return VK_SUCCESS;
}
VkResult on_vkQueueSignalReleaseImageANDROID(
@@ -7792,35 +6956,39 @@
(void)input_result;
-#if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
VkEncoder* enc = (VkEncoder*)context;
if (!mFeatureInfo->hasVulkanAsyncQsri) {
return enc->vkQueueSignalReleaseImageANDROID(queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd, true /* lock */);
}
- AutoLock<RecursiveLock> lock(mLock);
-
- auto it = info_VkImage.find(image);
- if (it == info_VkImage.end()) {
- if (pNativeFenceFd) *pNativeFenceFd = -1;
- return VK_ERROR_INITIALIZATION_FAILED;
+ {
+ AutoLock<RecursiveLock> lock(mLock);
+ auto it = info_VkImage.find(image);
+ if (it == info_VkImage.end()) {
+ if (pNativeFenceFd) *pNativeFenceFd = -1;
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
}
- auto& imageInfo = it->second;
-
enc->vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(queue, waitSemaphoreCount, pWaitSemaphores, image, true /* lock */);
+ AutoLock<RecursiveLock> lock(mLock);
+ VkResult result;
if (pNativeFenceFd) {
- *pNativeFenceFd =
- exportSyncFdForQSRI(image);
+ result =
+ exportSyncFdForQSRILocked(image, pNativeFenceFd);
} else {
- int syncFd = exportSyncFdForQSRI(image);
- if (syncFd >= 0) close(syncFd);
+ int syncFd;
+ result = exportSyncFdForQSRILocked(image, &syncFd);
+
+ if (syncFd >= 0)
+ close(syncFd);
}
-#endif
- return VK_SUCCESS;
+
+ return result;
}
+#endif
VkResult on_vkCreateGraphicsPipelines(
void* context,
@@ -8003,7 +7171,7 @@
private:
mutable RecursiveLock mLock;
- HostVisibleMemoryVirtualizationInfo mHostVisibleMemoryVirtInfo;
+ VkPhysicalDeviceMemoryProperties mMemoryProps;
std::unique_ptr<EmulatorFeatureInfo> mFeatureInfo;
std::unique_ptr<GoldfishAddressSpaceBlockProvider> mGoldfishAddressSpaceBlockProvider;
@@ -8012,7 +7180,6 @@
#if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
int mSyncDeviceFd = -1;
- int mRendernodeFd = -1;
#endif
#ifdef VK_USE_PLATFORM_FUCHSIA
@@ -8072,10 +7239,6 @@
return mImpl->getMappedSize(memory);
}
-VkDeviceSize ResourceTracker::getNonCoherentExtendedSize(VkDevice device, VkDeviceSize basicSize) const {
- return mImpl->getNonCoherentExtendedSize(device, basicSize);
-}
-
bool ResourceTracker::isValidMemoryRange(const VkMappedMemoryRange& range) const {
return mImpl->isValidMemoryRange(range);
}
@@ -8520,11 +7683,15 @@
void ResourceTracker::unwrap_VkNativeBufferANDROID(
const VkImageCreateInfo* pCreateInfo,
VkImageCreateInfo* local_pCreateInfo) {
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
mImpl->unwrap_VkNativeBufferANDROID(pCreateInfo, local_pCreateInfo);
+#endif
}
void ResourceTracker::unwrap_vkAcquireImageANDROID_nativeFenceFd(int fd, int* fd_out) {
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
mImpl->unwrap_vkAcquireImageANDROID_nativeFenceFd(fd, fd_out);
+#endif
}
#ifdef VK_USE_PLATFORM_FUCHSIA
@@ -8614,79 +7781,9 @@
return mImpl->on_vkGetBufferCollectionPropertiesFUCHSIA(
context, input_result, device, collection, pProperties);
}
-
-VkResult ResourceTracker::on_vkCreateBufferCollectionFUCHSIAX(
- void* context,
- VkResult input_result,
- VkDevice device,
- const VkBufferCollectionCreateInfoFUCHSIAX* pInfo,
- const VkAllocationCallbacks* pAllocator,
- VkBufferCollectionFUCHSIAX* pCollection) {
- return mImpl->on_vkCreateBufferCollectionFUCHSIAX(
- context, input_result, device, pInfo, pAllocator, pCollection);
-}
-
-void ResourceTracker::on_vkDestroyBufferCollectionFUCHSIAX(
- void* context,
- VkResult input_result,
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- const VkAllocationCallbacks* pAllocator) {
- return mImpl->on_vkDestroyBufferCollectionFUCHSIAX(
- context, input_result, device, collection, pAllocator);
-}
-
-VkResult ResourceTracker::on_vkSetBufferCollectionConstraintsFUCHSIAX(
- void* context,
- VkResult input_result,
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- const VkImageCreateInfo* pImageInfo) {
- return mImpl->on_vkSetBufferCollectionConstraintsFUCHSIAX(
- context, input_result, device, collection, pImageInfo);
-}
-
-VkResult ResourceTracker::on_vkSetBufferCollectionBufferConstraintsFUCHSIAX(
- void* context,
- VkResult input_result,
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- const VkBufferConstraintsInfoFUCHSIAX* pBufferDConstraintsInfo) {
- return mImpl->on_vkSetBufferCollectionBufferConstraintsFUCHSIAX(
- context, input_result, device, collection, pBufferDConstraintsInfo);
-}
-
-VkResult ResourceTracker::on_vkSetBufferCollectionImageConstraintsFUCHSIAX(
- void* context,
- VkResult input_result,
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- const VkImageConstraintsInfoFUCHSIAX* pImageConstraintsInfo) {
- return mImpl->on_vkSetBufferCollectionImageConstraintsFUCHSIAX(
- context, input_result, device, collection, pImageConstraintsInfo);
-}
-
-VkResult ResourceTracker::on_vkGetBufferCollectionPropertiesFUCHSIAX(
- void* context,
- VkResult input_result,
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- VkBufferCollectionPropertiesFUCHSIAX* pProperties) {
- return mImpl->on_vkGetBufferCollectionPropertiesFUCHSIAX(
- context, input_result, device, collection, pProperties);
-}
-
-VkResult ResourceTracker::on_vkGetBufferCollectionProperties2FUCHSIAX(
- void* context,
- VkResult input_result,
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- VkBufferCollectionProperties2FUCHSIAX* pProperties) {
- return mImpl->on_vkGetBufferCollectionProperties2FUCHSIAX(
- context, input_result, device, collection, pProperties);
-}
#endif
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
VkResult ResourceTracker::on_vkGetAndroidHardwareBufferPropertiesANDROID(
void* context, VkResult input_result,
VkDevice device,
@@ -8704,6 +7801,7 @@
context, input_result,
device, pInfo, pBuffer);
}
+#endif
VkResult ResourceTracker::on_vkCreateSamplerYcbcrConversion(
void* context, VkResult input_result,
@@ -9081,6 +8179,32 @@
pDynamicOffsets);
}
+void ResourceTracker::on_vkCmdPipelineBarrier(
+ void* context,
+ 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) {
+ mImpl->on_vkCmdPipelineBarrier(
+ context,
+ commandBuffer,
+ srcStageMask,
+ dstStageMask,
+ dependencyFlags,
+ memoryBarrierCount,
+ pMemoryBarriers,
+ bufferMemoryBarrierCount,
+ pBufferMemoryBarriers,
+ imageMemoryBarrierCount,
+ pImageMemoryBarriers);
+}
+
void ResourceTracker::on_vkDestroyDescriptorSetLayout(
void* context,
VkDevice device,
@@ -9098,6 +8222,7 @@
return mImpl->on_vkAllocateCommandBuffers(context, input_result, device, pAllocateInfo, pCommandBuffers);
}
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
VkResult ResourceTracker::on_vkQueueSignalReleaseImageANDROID(
void* context,
VkResult input_result,
@@ -9108,6 +8233,7 @@
int* pNativeFenceFd) {
return mImpl->on_vkQueueSignalReleaseImageANDROID(context, input_result, queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd);
}
+#endif
VkResult ResourceTracker::on_vkCreateGraphicsPipelines(
void* context,
diff --git a/system/vulkan_enc/ResourceTracker.h b/system/vulkan_enc/ResourceTracker.h
index b50635d..5d1891e 100644
--- a/system/vulkan_enc/ResourceTracker.h
+++ b/system/vulkan_enc/ResourceTracker.h
@@ -312,51 +312,9 @@
VkDevice device,
VkBufferCollectionFUCHSIA collection,
VkBufferCollectionPropertiesFUCHSIA* pProperties);
- VkResult on_vkCreateBufferCollectionFUCHSIAX(
- void* context,
- VkResult input_result,
- VkDevice device,
- const VkBufferCollectionCreateInfoFUCHSIAX* pInfo,
- const VkAllocationCallbacks* pAllocator,
- VkBufferCollectionFUCHSIAX* pCollection);
- void on_vkDestroyBufferCollectionFUCHSIAX(
- void* context,
- VkResult input_result,
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- const VkAllocationCallbacks* pAllocator);
- VkResult on_vkSetBufferCollectionConstraintsFUCHSIAX(
- void* context,
- VkResult input_result,
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- const VkImageCreateInfo* pImageInfo);
- VkResult on_vkSetBufferCollectionBufferConstraintsFUCHSIAX(
- void* context,
- VkResult input_result,
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- const VkBufferConstraintsInfoFUCHSIAX* pBufferConstraintsInfo);
- VkResult on_vkSetBufferCollectionImageConstraintsFUCHSIAX(
- void* context,
- VkResult input_result,
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- const VkImageConstraintsInfoFUCHSIAX* pImageConstraintsInfo);
- VkResult on_vkGetBufferCollectionPropertiesFUCHSIAX(
- void* context,
- VkResult input_result,
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- VkBufferCollectionPropertiesFUCHSIAX* pProperties);
- VkResult on_vkGetBufferCollectionProperties2FUCHSIAX(
- void* context,
- VkResult input_result,
- VkDevice device,
- VkBufferCollectionFUCHSIAX collection,
- VkBufferCollectionProperties2FUCHSIAX* pProperties);
#endif
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
VkResult on_vkGetAndroidHardwareBufferPropertiesANDROID(
void* context, VkResult input_result,
VkDevice device,
@@ -367,6 +325,7 @@
VkDevice device,
const VkMemoryGetAndroidHardwareBufferInfoANDROID *pInfo,
struct AHardwareBuffer** pBuffer);
+#endif
VkResult on_vkCreateSamplerYcbcrConversion(
void* context, VkResult input_result,
@@ -605,6 +564,19 @@
uint32_t dynamicOffsetCount,
const uint32_t* pDynamicOffsets);
+ void on_vkCmdPipelineBarrier(
+ void* context,
+ 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);
+
void on_vkDestroyDescriptorSetLayout(
void* context,
VkDevice device,
diff --git a/system/vulkan_enc/VkEncoder.cpp b/system/vulkan_enc/VkEncoder.cpp
index f7eef9d..48a757d 100644
--- a/system/vulkan_enc/VkEncoder.cpp
+++ b/system/vulkan_enc/VkEncoder.cpp
@@ -14,129 +14,164 @@
// limitations under the License.
// Autogenerated module VkEncoder
-// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal -o ../qemu/android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+//
+// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
+// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
-// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+//
+// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
+// $CEREAL_OUTPUT_DIR
+//
#include "VkEncoder.h"
+#include <cutils/properties.h>
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "EncoderDebug.h"
#include "IOStream.h"
-#include "Resources.h"
#include "ResourceTracker.h"
+#include "Resources.h"
#include "Validation.h"
#include "VulkanStreamGuest.h"
-
#include "android/base/AlignedBuf.h"
#include "android/base/BumpPool.h"
#include "android/base/synchronization/AndroidLock.h"
-
-#include <cutils/properties.h>
-
-#include "goldfish_vk_marshaling_guest.h"
-#include "goldfish_vk_reserved_marshaling_guest.h"
-#include "goldfish_vk_deepcopy_guest.h"
#include "goldfish_vk_counting_guest.h"
+#include "goldfish_vk_deepcopy_guest.h"
#include "goldfish_vk_handlemap_guest.h"
+#include "goldfish_vk_marshaling_guest.h"
#include "goldfish_vk_private_defs.h"
+#include "goldfish_vk_reserved_marshaling_guest.h"
#include "goldfish_vk_transform_guest.h"
-#include <unordered_map>
-
-
-
namespace goldfish_vk {
-
-
using namespace goldfish_vk;
-using android::aligned_buf_alloc;
-using android::aligned_buf_free;
+using android::base::BumpPool;
using android::base::guest::AutoLock;
using android::base::guest::Lock;
-using android::base::BumpPool;
#include "VkEncoder.cpp.inl"
-#define VALIDATE_RET(retType, success, validate) \
+#define VALIDATE_RET(retType, success, validate) \
retType goldfish_vk_validateResult = validate; \
- if (goldfish_vk_validateResult != success) return goldfish_vk_validateResult; \
+ if (goldfish_vk_validateResult != success) return goldfish_vk_validateResult;
-#define VALIDATE_VOID(validate) \
+#define VALIDATE_VOID(validate) \
VkResult goldfish_vk_validateResult = validate; \
- if (goldfish_vk_validateResult != VK_SUCCESS) return; \
+ if (goldfish_vk_validateResult != VK_SUCCESS) return;
#ifdef VK_VERSION_1_0
-VkResult VkEncoder::vkCreateInstance(
- const VkInstanceCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkInstance* pInstance,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkInstance* pInstance,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateInstance in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCreateInstance(pCreateInfo:%p, pAllocator:%p, pInstance:%p)", pCreateInfo,
+ pAllocator, pInstance);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
VkInstanceCreateInfo* local_pCreateInfo;
VkAllocationCallbacks* local_pAllocator;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
+ if (pCreateInfo) {
local_pCreateInfo = (VkInstanceCreateInfo*)pool->alloc(sizeof(const VkInstanceCreateInfo));
- deepcopy_VkInstanceCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkInstanceCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkInstanceCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkInstanceCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkInstanceCreateInfo(sResourceTracker, (VkInstanceCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkInstanceCreateInfo(sResourceTracker,
+ (VkInstanceCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
- count_VkInstanceCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkInstanceCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkInstanceCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkInstanceCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_0;
*countPtr += 8;
}
uint32_t packetSize_vkCreateInstance = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateInstance);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateInstance);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateInstance = OP_vkCreateInstance;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateInstance, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateInstance, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
- reservedmarshal_VkInstanceCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkInstanceCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateInstance, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateInstance, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
+ reservedmarshal_VkInstanceCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkInstanceCreateInfo*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_1;
@@ -151,10 +186,11 @@
stream->unsetHandleMapping();
VkResult vkCreateInstance_VkResult_return = (VkResult)0;
stream->read(&vkCreateInstance_VkResult_return, sizeof(VkResult));
- sResourceTracker->on_vkCreateInstance(this, vkCreateInstance_VkResult_return, pCreateInfo, pAllocator, pInstance);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ sResourceTracker->on_vkCreateInstance(this, vkCreateInstance_VkResult_return, pCreateInfo,
+ pAllocator, pInstance);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -162,13 +198,34 @@
return vkCreateInstance_VkResult_return;
}
-void VkEncoder::vkDestroyInstance(
- VkInstance instance,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyInstance in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyInstance(instance:%p, pAllocator:%p)", instance, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -176,15 +233,15 @@
VkAllocationCallbacks* local_pAllocator;
local_instance = instance;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -193,19 +250,28 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyInstance = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyInstance =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyInstance);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyInstance);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyInstance = OP_vkDestroyInstance;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyInstance, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyInstance, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyInstance, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyInstance, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -215,29 +281,53 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkInstance((VkInstance*)&instance);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkEnumeratePhysicalDevices(
- VkInstance instance,
- uint32_t* pPhysicalDeviceCount,
- VkPhysicalDevice* pPhysicalDevices,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount,
+ VkPhysicalDevice* pPhysicalDevices,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkEnumeratePhysicalDevices in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkEnumeratePhysicalDevices(instance:%p, pPhysicalDeviceCount:%p, pPhysicalDevices:%p)",
+ instance, pPhysicalDeviceCount, pPhysicalDevices);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -250,28 +340,34 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pPhysicalDeviceCount)
- {
+ if (pPhysicalDeviceCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pPhysicalDevices)
- {
- if ((*(pPhysicalDeviceCount)))
- {
+ if (pPhysicalDevices) {
+ if ((*(pPhysicalDeviceCount))) {
*countPtr += (*(pPhysicalDeviceCount)) * 8;
}
}
}
- uint32_t packetSize_vkEnumeratePhysicalDevices = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkEnumeratePhysicalDevices =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkEnumeratePhysicalDevices);
uint8_t* streamPtr = stream->reserve(packetSize_vkEnumeratePhysicalDevices);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkEnumeratePhysicalDevices = OP_vkEnumeratePhysicalDevices;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkEnumeratePhysicalDevices, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkEnumeratePhysicalDevices, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkEnumeratePhysicalDevices, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkEnumeratePhysicalDevices, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -281,8 +377,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPhysicalDeviceCount)
- {
+ if (pPhysicalDeviceCount) {
memcpy(*streamPtrPtr, (uint32_t*)pPhysicalDeviceCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -292,15 +387,11 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPhysicalDevices)
- {
- if ((*(pPhysicalDeviceCount)))
- {
+ if (pPhysicalDevices) {
+ if ((*(pPhysicalDeviceCount))) {
uint8_t* cgen_var_2_0_ptr = (uint8_t*)(*streamPtrPtr);
- if (pPhysicalDeviceCount)
- {
- for (uint32_t k = 0; k < (*(pPhysicalDeviceCount)); ++k)
- {
+ if (pPhysicalDeviceCount) {
+ for (uint32_t k = 0; k < (*(pPhysicalDeviceCount)); ++k) {
uint64_t tmpval = (uint64_t)(pPhysicalDevices[k]);
memcpy(cgen_var_2_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -312,10 +403,8 @@
// WARNING PTR CHECK
uint32_t* check_pPhysicalDeviceCount;
check_pPhysicalDeviceCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pPhysicalDeviceCount)
- {
- if (!(check_pPhysicalDeviceCount))
- {
+ if (pPhysicalDeviceCount) {
+ if (!(check_pPhysicalDeviceCount)) {
fprintf(stderr, "fatal: pPhysicalDeviceCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pPhysicalDeviceCount, sizeof(uint32_t));
@@ -324,26 +413,24 @@
// WARNING PTR CHECK
VkPhysicalDevice* check_pPhysicalDevices;
check_pPhysicalDevices = (VkPhysicalDevice*)(uintptr_t)stream->getBe64();
- if (pPhysicalDevices)
- {
- if (!(check_pPhysicalDevices))
- {
+ if (pPhysicalDevices) {
+ if (!(check_pPhysicalDevices)) {
fprintf(stderr, "fatal: pPhysicalDevices inconsistent between guest and host\n");
}
- if ((*(pPhysicalDeviceCount)))
- {
+ if ((*(pPhysicalDeviceCount))) {
uint64_t* cgen_var_4_0;
stream->alloc((void**)&cgen_var_4_0, (*(pPhysicalDeviceCount)) * 8);
stream->read((uint64_t*)cgen_var_4_0, (*(pPhysicalDeviceCount)) * 8);
- stream->handleMapping()->mapHandles_u64_VkPhysicalDevice(cgen_var_4_0, (VkPhysicalDevice*)pPhysicalDevices, (*(pPhysicalDeviceCount)));
+ stream->handleMapping()->mapHandles_u64_VkPhysicalDevice(
+ cgen_var_4_0, (VkPhysicalDevice*)pPhysicalDevices, (*(pPhysicalDeviceCount)));
}
}
stream->unsetHandleMapping();
VkResult vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0;
stream->read(&vkEnumeratePhysicalDevices_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -351,13 +438,35 @@
return vkEnumeratePhysicalDevices_VkResult_return;
}
-void VkEncoder::vkGetPhysicalDeviceFeatures(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures* pFeatures,
- uint32_t doLock)
-{
+void VkEncoder::vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures* pFeatures, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetPhysicalDeviceFeatures in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetPhysicalDeviceFeatures(physicalDevice:%p, pFeatures:%p)",
+ physicalDevice, pFeatures);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -368,43 +477,79 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceFeatures(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFeatures*)(pFeatures), countPtr);
+ count_VkPhysicalDeviceFeatures(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceFeatures*)(pFeatures), countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceFeatures = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceFeatures =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetPhysicalDeviceFeatures);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceFeatures);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceFeatures = OP_vkGetPhysicalDeviceFeatures;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceFeatures, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceFeatures, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceFeatures, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceFeatures, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceFeatures(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFeatures*)(pFeatures), streamPtrPtr);
- unmarshal_VkPhysicalDeviceFeatures(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFeatures*)(pFeatures));
- if (pFeatures)
- {
- transform_fromhost_VkPhysicalDeviceFeatures(sResourceTracker, (VkPhysicalDeviceFeatures*)(pFeatures));
+ reservedmarshal_VkPhysicalDeviceFeatures(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceFeatures*)(pFeatures), streamPtrPtr);
+ unmarshal_VkPhysicalDeviceFeatures(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceFeatures*)(pFeatures));
+ if (pFeatures) {
+ transform_fromhost_VkPhysicalDeviceFeatures(sResourceTracker,
+ (VkPhysicalDeviceFeatures*)(pFeatures));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkGetPhysicalDeviceFormatProperties(
- VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties* pFormatProperties,
- uint32_t doLock)
-{
+void VkEncoder::vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties* pFormatProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetPhysicalDeviceFormatProperties in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceFormatProperties(physicalDevice:%p, format:%d, pFormatProperties:%p)",
+ physicalDevice, format, pFormatProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -418,31 +563,44 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(VkFormat);
- count_VkFormatProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFormatProperties*)(pFormatProperties), countPtr);
+ count_VkFormatProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkFormatProperties*)(pFormatProperties), countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceFormatProperties = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceFormatProperties =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceFormatProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceFormatProperties);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceFormatProperties = OP_vkGetPhysicalDeviceFormatProperties;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceFormatProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceFormatProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceFormatProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceFormatProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkFormat*)&local_format, sizeof(VkFormat));
*streamPtrPtr += sizeof(VkFormat);
- reservedmarshal_VkFormatProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFormatProperties*)(pFormatProperties), streamPtrPtr);
- unmarshal_VkFormatProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFormatProperties*)(pFormatProperties));
- if (pFormatProperties)
- {
- transform_fromhost_VkFormatProperties(sResourceTracker, (VkFormatProperties*)(pFormatProperties));
+ reservedmarshal_VkFormatProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkFormatProperties*)(pFormatProperties), streamPtrPtr);
+ unmarshal_VkFormatProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkFormatProperties*)(pFormatProperties));
+ if (pFormatProperties) {
+ transform_fromhost_VkFormatProperties(sResourceTracker,
+ (VkFormatProperties*)(pFormatProperties));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -450,17 +608,39 @@
}
VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties(
- VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkImageType type,
- VkImageTiling tiling,
- VkImageUsageFlags usage,
- VkImageCreateFlags flags,
- VkImageFormatProperties* pImageFormatProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling,
+ VkImageUsageFlags usage, VkImageCreateFlags flags,
+ VkImageFormatProperties* pImageFormatProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceImageFormatProperties in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceImageFormatProperties(physicalDevice:%p, format:%d, usage:%d, "
+ "flags:%d, pImageFormatProperties:%p)",
+ physicalDevice, format, usage, flags, pImageFormatProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -486,16 +666,28 @@
*countPtr += sizeof(VkImageTiling);
*countPtr += sizeof(VkImageUsageFlags);
*countPtr += sizeof(VkImageCreateFlags);
- count_VkImageFormatProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageFormatProperties*)(pImageFormatProperties), countPtr);
+ count_VkImageFormatProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageFormatProperties*)(pImageFormatProperties), countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceImageFormatProperties = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceImageFormatProperties =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceImageFormatProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceImageFormatProperties);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceImageFormatProperties = OP_vkGetPhysicalDeviceImageFormatProperties;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceImageFormatProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceImageFormatProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceImageFormatProperties =
+ OP_vkGetPhysicalDeviceImageFormatProperties;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceImageFormatProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceImageFormatProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -510,17 +702,20 @@
*streamPtrPtr += sizeof(VkImageUsageFlags);
memcpy(*streamPtrPtr, (VkImageCreateFlags*)&local_flags, sizeof(VkImageCreateFlags));
*streamPtrPtr += sizeof(VkImageCreateFlags);
- reservedmarshal_VkImageFormatProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageFormatProperties*)(pImageFormatProperties), streamPtrPtr);
- unmarshal_VkImageFormatProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageFormatProperties*)(pImageFormatProperties));
- if (pImageFormatProperties)
- {
- transform_fromhost_VkImageFormatProperties(sResourceTracker, (VkImageFormatProperties*)(pImageFormatProperties));
+ reservedmarshal_VkImageFormatProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageFormatProperties*)(pImageFormatProperties),
+ streamPtrPtr);
+ unmarshal_VkImageFormatProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageFormatProperties*)(pImageFormatProperties));
+ if (pImageFormatProperties) {
+ transform_fromhost_VkImageFormatProperties(
+ sResourceTracker, (VkImageFormatProperties*)(pImageFormatProperties));
}
VkResult vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDeviceImageFormatProperties_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -528,13 +723,36 @@
return vkGetPhysicalDeviceImageFormatProperties_VkResult_return;
}
-void VkEncoder::vkGetPhysicalDeviceProperties(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties* pProperties,
- uint32_t doLock)
-{
+void VkEncoder::vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties* pProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetPhysicalDeviceProperties in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetPhysicalDeviceProperties(physicalDevice:%p, pProperties:%p)",
+ physicalDevice, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -545,30 +763,44 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceProperties*)(pProperties), countPtr);
+ count_VkPhysicalDeviceProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceProperties*)(pProperties), countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceProperties = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceProperties =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceProperties);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceProperties = OP_vkGetPhysicalDeviceProperties;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceProperties*)(pProperties), streamPtrPtr);
- unmarshal_VkPhysicalDeviceProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceProperties*)(pProperties));
- if (pProperties)
- {
- transform_fromhost_VkPhysicalDeviceProperties(sResourceTracker, (VkPhysicalDeviceProperties*)(pProperties));
+ reservedmarshal_VkPhysicalDeviceProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceProperties*)(pProperties),
+ streamPtrPtr);
+ unmarshal_VkPhysicalDeviceProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceProperties*)(pProperties));
+ if (pProperties) {
+ transform_fromhost_VkPhysicalDeviceProperties(sResourceTracker,
+ (VkPhysicalDeviceProperties*)(pProperties));
}
sResourceTracker->on_vkGetPhysicalDeviceProperties(this, physicalDevice, pProperties);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -576,13 +808,38 @@
}
void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties(
- VkPhysicalDevice physicalDevice,
- uint32_t* pQueueFamilyPropertyCount,
- VkQueueFamilyProperties* pQueueFamilyProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties* pQueueFamilyProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceQueueFamilyProperties in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice:%p, pQueueFamilyPropertyCount:%p, "
+ "pQueueFamilyProperties:%p)",
+ physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -595,31 +852,40 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pQueueFamilyPropertyCount)
- {
+ if (pQueueFamilyPropertyCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pQueueFamilyProperties)
- {
- if (pQueueFamilyPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
- {
- count_VkQueueFamilyProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i), countPtr);
+ if (pQueueFamilyProperties) {
+ if (pQueueFamilyPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
+ count_VkQueueFamilyProperties(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkQueueFamilyProperties*)(pQueueFamilyProperties + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPhysicalDeviceQueueFamilyProperties = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceQueueFamilyProperties =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceQueueFamilyProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceQueueFamilyProperties);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceQueueFamilyProperties = OP_vkGetPhysicalDeviceQueueFamilyProperties;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceQueueFamilyProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceQueueFamilyProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceQueueFamilyProperties =
+ OP_vkGetPhysicalDeviceQueueFamilyProperties;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceQueueFamilyProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceQueueFamilyProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -629,8 +895,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pQueueFamilyPropertyCount)
- {
+ if (pQueueFamilyPropertyCount) {
memcpy(*streamPtrPtr, (uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -639,54 +904,49 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pQueueFamilyProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
- {
- reservedmarshal_VkQueueFamilyProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i), streamPtrPtr);
+ if (pQueueFamilyProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
+ reservedmarshal_VkQueueFamilyProperties(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkQueueFamilyProperties*)(pQueueFamilyProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pQueueFamilyPropertyCount;
check_pQueueFamilyPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pQueueFamilyPropertyCount)
- {
- if (!(check_pQueueFamilyPropertyCount))
- {
- fprintf(stderr, "fatal: pQueueFamilyPropertyCount inconsistent between guest and host\n");
+ if (pQueueFamilyPropertyCount) {
+ if (!(check_pQueueFamilyPropertyCount)) {
+ fprintf(stderr,
+ "fatal: pQueueFamilyPropertyCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
VkQueueFamilyProperties* check_pQueueFamilyProperties;
check_pQueueFamilyProperties = (VkQueueFamilyProperties*)(uintptr_t)stream->getBe64();
- if (pQueueFamilyProperties)
- {
- if (!(check_pQueueFamilyProperties))
- {
+ if (pQueueFamilyProperties) {
+ if (!(check_pQueueFamilyProperties)) {
fprintf(stderr, "fatal: pQueueFamilyProperties inconsistent between guest and host\n");
}
- if (pQueueFamilyPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
- {
- unmarshal_VkQueueFamilyProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i));
+ if (pQueueFamilyPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
+ unmarshal_VkQueueFamilyProperties(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkQueueFamilyProperties*)(pQueueFamilyProperties + i));
}
}
}
- if (pQueueFamilyPropertyCount)
- {
- if (pQueueFamilyProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
- {
- transform_fromhost_VkQueueFamilyProperties(sResourceTracker, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i));
+ if (pQueueFamilyPropertyCount) {
+ if (pQueueFamilyProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
+ transform_fromhost_VkQueueFamilyProperties(
+ sResourceTracker, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i));
}
}
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -694,12 +954,36 @@
}
void VkEncoder::vkGetPhysicalDeviceMemoryProperties(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceMemoryProperties* pMemoryProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetPhysicalDeviceMemoryProperties in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceMemoryProperties(physicalDevice:%p, pMemoryProperties:%p)",
+ physicalDevice, pMemoryProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -710,43 +994,80 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceMemoryProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties), countPtr);
+ count_VkPhysicalDeviceMemoryProperties(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties), countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceMemoryProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceMemoryProperties);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceMemoryProperties = OP_vkGetPhysicalDeviceMemoryProperties;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceMemoryProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceMemoryProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceMemoryProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceMemoryProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceMemoryProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties), streamPtrPtr);
- unmarshal_VkPhysicalDeviceMemoryProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties));
- if (pMemoryProperties)
- {
- transform_fromhost_VkPhysicalDeviceMemoryProperties(sResourceTracker, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties));
+ reservedmarshal_VkPhysicalDeviceMemoryProperties(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties),
+ streamPtrPtr);
+ unmarshal_VkPhysicalDeviceMemoryProperties(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties));
+ if (pMemoryProperties) {
+ transform_fromhost_VkPhysicalDeviceMemoryProperties(
+ sResourceTracker, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties));
}
- sResourceTracker->on_vkGetPhysicalDeviceMemoryProperties(this, physicalDevice, pMemoryProperties);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ sResourceTracker->on_vkGetPhysicalDeviceMemoryProperties(this, physicalDevice,
+ pMemoryProperties);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-PFN_vkVoidFunction VkEncoder::vkGetInstanceProcAddr(
- VkInstance instance,
- const char* pName,
- uint32_t doLock)
-{
+PFN_vkVoidFunction VkEncoder::vkGetInstanceProcAddr(VkInstance instance, const char* pName,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetInstanceProcAddr in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetInstanceProcAddr(instance:%p, pName:%p)", instance, pName);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -762,20 +1083,29 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t) + (local_pName ? strlen(local_pName) : 0);
}
- uint32_t packetSize_vkGetInstanceProcAddr = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetInstanceProcAddr =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetInstanceProcAddr);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetInstanceProcAddr);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetInstanceProcAddr = OP_vkGetInstanceProcAddr;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetInstanceProcAddr, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetInstanceProcAddr, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetInstanceProcAddr, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetInstanceProcAddr, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
{
- uint32_t l = local_pName ? strlen(local_pName): 0;
+ uint32_t l = local_pName ? strlen(local_pName) : 0;
memcpy(*streamPtrPtr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*streamPtrPtr);
*streamPtrPtr += sizeof(uint32_t);
@@ -784,9 +1114,9 @@
}
PFN_vkVoidFunction vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
stream->read(&vkGetInstanceProcAddr_PFN_vkVoidFunction_return, sizeof(PFN_vkVoidFunction));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -794,13 +1124,34 @@
return vkGetInstanceProcAddr_PFN_vkVoidFunction_return;
}
-PFN_vkVoidFunction VkEncoder::vkGetDeviceProcAddr(
- VkDevice device,
- const char* pName,
- uint32_t doLock)
-{
+PFN_vkVoidFunction VkEncoder::vkGetDeviceProcAddr(VkDevice device, const char* pName,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetDeviceProcAddr in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetDeviceProcAddr(device:%p, pName:%p)", device, pName);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -816,20 +1167,29 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t) + (local_pName ? strlen(local_pName) : 0);
}
- uint32_t packetSize_vkGetDeviceProcAddr = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDeviceProcAddr =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetDeviceProcAddr);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceProcAddr);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDeviceProcAddr = OP_vkGetDeviceProcAddr;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDeviceProcAddr, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDeviceProcAddr, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDeviceProcAddr, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDeviceProcAddr, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
{
- uint32_t l = local_pName ? strlen(local_pName): 0;
+ uint32_t l = local_pName ? strlen(local_pName) : 0;
memcpy(*streamPtrPtr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*streamPtrPtr);
*streamPtrPtr += sizeof(uint32_t);
@@ -838,9 +1198,9 @@
}
PFN_vkVoidFunction vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
stream->read(&vkGetDeviceProcAddr_PFN_vkVoidFunction_return, sizeof(PFN_vkVoidFunction));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -848,15 +1208,38 @@
return vkGetDeviceProcAddr_PFN_vkVoidFunction_return;
}
-VkResult VkEncoder::vkCreateDevice(
- VkPhysicalDevice physicalDevice,
- const VkDeviceCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDevice* pDevice,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateDevice(VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkDevice* pDevice,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateDevice in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateDevice(physicalDevice:%p, pCreateInfo:%p, pAllocator:%p, pDevice:%p)",
+ physicalDevice, pCreateInfo, pAllocator, pDevice);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -865,62 +1248,73 @@
VkAllocationCallbacks* local_pAllocator;
local_physicalDevice = physicalDevice;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
+ if (pCreateInfo) {
local_pCreateInfo = (VkDeviceCreateInfo*)pool->alloc(sizeof(const VkDeviceCreateInfo));
- deepcopy_VkDeviceCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDeviceCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkDeviceCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkDeviceCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkDeviceCreateInfo(sResourceTracker, (VkDeviceCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkDeviceCreateInfo(sResourceTracker,
+ (VkDeviceCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDeviceCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkDeviceCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDeviceCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
uint32_t packetSize_vkCreateDevice = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateDevice);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateDevice);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateDevice = OP_vkCreateDevice;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateDevice, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateDevice, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateDevice, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateDevice, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDeviceCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkDeviceCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDeviceCreateInfo*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -935,10 +1329,11 @@
stream->unsetHandleMapping();
VkResult vkCreateDevice_VkResult_return = (VkResult)0;
stream->read(&vkCreateDevice_VkResult_return, sizeof(VkResult));
- sResourceTracker->on_vkCreateDevice(this, vkCreateDevice_VkResult_return, physicalDevice, pCreateInfo, pAllocator, pDevice);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ sResourceTracker->on_vkCreateDevice(this, vkCreateDevice_VkResult_return, physicalDevice,
+ pCreateInfo, pAllocator, pDevice);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -946,13 +1341,34 @@
return vkCreateDevice_VkResult_return;
}
-void VkEncoder::vkDestroyDevice(
- VkDevice device,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyDevice in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyDevice(device:%p, pAllocator:%p)", device, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
sResourceTracker->on_vkDestroyDevice_pre(this, device, pAllocator);
auto stream = mImpl->stream();
@@ -961,15 +1377,15 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -978,19 +1394,27 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyDevice = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyDevice);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyDevice);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyDevice = OP_vkDestroyDevice;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyDevice, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyDevice, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyDevice, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyDevice, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -1000,29 +1424,55 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkDevice((VkDevice*)&device);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkEnumerateInstanceExtensionProperties(
- const char* pLayerName,
- uint32_t* pPropertyCount,
- VkExtensionProperties* pProperties,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkEnumerateInstanceExtensionProperties(const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkEnumerateInstanceExtensionProperties in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkEnumerateInstanceExtensionProperties(pLayerName:%p, pPropertyCount:%p, pProperties:%p)",
+ pLayerName, pPropertyCount, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -1032,57 +1482,60 @@
size_t count = 0;
size_t* countPtr = &count;
{
- if (sFeatureBits & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
- {
+ if (sFeatureBits & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pLayerName)
- {
+ if (local_pLayerName) {
*countPtr += sizeof(uint32_t) + (local_pLayerName ? strlen(local_pLayerName) : 0);
}
- }
- else
- {
+ } else {
*countPtr += sizeof(uint32_t) + (local_pLayerName ? strlen(local_pLayerName) : 0);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pProperties)
- {
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- count_VkExtensionProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtensionProperties*)(pProperties + i), countPtr);
+ if (pProperties) {
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ count_VkExtensionProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExtensionProperties*)(pProperties + i),
+ countPtr);
}
}
}
}
- uint32_t packetSize_vkEnumerateInstanceExtensionProperties = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkEnumerateInstanceExtensionProperties =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkEnumerateInstanceExtensionProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkEnumerateInstanceExtensionProperties);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkEnumerateInstanceExtensionProperties = OP_vkEnumerateInstanceExtensionProperties;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkEnumerateInstanceExtensionProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkEnumerateInstanceExtensionProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
- if (stream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
- {
+ uint32_t opcode_vkEnumerateInstanceExtensionProperties =
+ OP_vkEnumerateInstanceExtensionProperties;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkEnumerateInstanceExtensionProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkEnumerateInstanceExtensionProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
+ if (stream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)local_pLayerName;
memcpy((*streamPtrPtr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pLayerName)
- {
+ if (local_pLayerName) {
{
- uint32_t l = local_pLayerName ? strlen(local_pLayerName): 0;
+ uint32_t l = local_pLayerName ? strlen(local_pLayerName) : 0;
memcpy(*streamPtrPtr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*streamPtrPtr);
*streamPtrPtr += sizeof(uint32_t);
@@ -1090,11 +1543,9 @@
*streamPtrPtr += l;
}
}
- }
- else
- {
+ } else {
{
- uint32_t l = local_pLayerName ? strlen(local_pLayerName): 0;
+ uint32_t l = local_pLayerName ? strlen(local_pLayerName) : 0;
memcpy(*streamPtrPtr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*streamPtrPtr);
*streamPtrPtr += sizeof(uint32_t);
@@ -1107,8 +1558,7 @@
memcpy((*streamPtrPtr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
memcpy(*streamPtrPtr, (uint32_t*)pPropertyCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -1117,20 +1567,18 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- reservedmarshal_VkExtensionProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtensionProperties*)(pProperties + i), streamPtrPtr);
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ reservedmarshal_VkExtensionProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExtensionProperties*)(pProperties + i),
+ streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pPropertyCount)
- {
- if (!(check_pPropertyCount))
- {
+ if (pPropertyCount) {
+ if (!(check_pPropertyCount)) {
fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
@@ -1138,35 +1586,30 @@
// WARNING PTR CHECK
VkExtensionProperties* check_pProperties;
check_pProperties = (VkExtensionProperties*)(uintptr_t)stream->getBe64();
- if (pProperties)
- {
- if (!(check_pProperties))
- {
+ if (pProperties) {
+ if (!(check_pProperties)) {
fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
}
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- unmarshal_VkExtensionProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtensionProperties*)(pProperties + i));
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ unmarshal_VkExtensionProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExtensionProperties*)(pProperties + i));
}
}
}
- if (pPropertyCount)
- {
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- transform_fromhost_VkExtensionProperties(sResourceTracker, (VkExtensionProperties*)(pProperties + i));
+ if (pPropertyCount) {
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ transform_fromhost_VkExtensionProperties(sResourceTracker,
+ (VkExtensionProperties*)(pProperties + i));
}
}
}
VkResult vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0;
stream->read(&vkEnumerateInstanceExtensionProperties_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -1174,15 +1617,40 @@
return vkEnumerateInstanceExtensionProperties_VkResult_return;
}
-VkResult VkEncoder::vkEnumerateDeviceExtensionProperties(
- VkPhysicalDevice physicalDevice,
- const char* pLayerName,
- uint32_t* pPropertyCount,
- VkExtensionProperties* pProperties,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkEnumerateDeviceExtensionProperties in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkEnumerateDeviceExtensionProperties(physicalDevice:%p, pLayerName:%p, pPropertyCount:%p, "
+ "pProperties:%p)",
+ physicalDevice, pLayerName, pPropertyCount, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -1196,61 +1664,63 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- if (sFeatureBits & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
- {
+ if (sFeatureBits & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pLayerName)
- {
+ if (local_pLayerName) {
*countPtr += sizeof(uint32_t) + (local_pLayerName ? strlen(local_pLayerName) : 0);
}
- }
- else
- {
+ } else {
*countPtr += sizeof(uint32_t) + (local_pLayerName ? strlen(local_pLayerName) : 0);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pProperties)
- {
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- count_VkExtensionProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtensionProperties*)(pProperties + i), countPtr);
+ if (pProperties) {
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ count_VkExtensionProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExtensionProperties*)(pProperties + i),
+ countPtr);
}
}
}
}
- uint32_t packetSize_vkEnumerateDeviceExtensionProperties = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkEnumerateDeviceExtensionProperties =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkEnumerateDeviceExtensionProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkEnumerateDeviceExtensionProperties);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkEnumerateDeviceExtensionProperties = OP_vkEnumerateDeviceExtensionProperties;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkEnumerateDeviceExtensionProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkEnumerateDeviceExtensionProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkEnumerateDeviceExtensionProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkEnumerateDeviceExtensionProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- if (stream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
- {
+ if (stream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
// WARNING PTR CHECK
uint64_t cgen_var_0_0 = (uint64_t)(uintptr_t)local_pLayerName;
memcpy((*streamPtrPtr), &cgen_var_0_0, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pLayerName)
- {
+ if (local_pLayerName) {
{
- uint32_t l = local_pLayerName ? strlen(local_pLayerName): 0;
+ uint32_t l = local_pLayerName ? strlen(local_pLayerName) : 0;
memcpy(*streamPtrPtr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*streamPtrPtr);
*streamPtrPtr += sizeof(uint32_t);
@@ -1258,11 +1728,9 @@
*streamPtrPtr += l;
}
}
- }
- else
- {
+ } else {
{
- uint32_t l = local_pLayerName ? strlen(local_pLayerName): 0;
+ uint32_t l = local_pLayerName ? strlen(local_pLayerName) : 0;
memcpy(*streamPtrPtr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*streamPtrPtr);
*streamPtrPtr += sizeof(uint32_t);
@@ -1275,8 +1743,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
memcpy(*streamPtrPtr, (uint32_t*)pPropertyCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -1285,20 +1752,18 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- reservedmarshal_VkExtensionProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtensionProperties*)(pProperties + i), streamPtrPtr);
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ reservedmarshal_VkExtensionProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExtensionProperties*)(pProperties + i),
+ streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pPropertyCount)
- {
- if (!(check_pPropertyCount))
- {
+ if (pPropertyCount) {
+ if (!(check_pPropertyCount)) {
fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
@@ -1306,35 +1771,30 @@
// WARNING PTR CHECK
VkExtensionProperties* check_pProperties;
check_pProperties = (VkExtensionProperties*)(uintptr_t)stream->getBe64();
- if (pProperties)
- {
- if (!(check_pProperties))
- {
+ if (pProperties) {
+ if (!(check_pProperties)) {
fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
}
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- unmarshal_VkExtensionProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtensionProperties*)(pProperties + i));
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ unmarshal_VkExtensionProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExtensionProperties*)(pProperties + i));
}
}
}
- if (pPropertyCount)
- {
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- transform_fromhost_VkExtensionProperties(sResourceTracker, (VkExtensionProperties*)(pProperties + i));
+ if (pPropertyCount) {
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ transform_fromhost_VkExtensionProperties(sResourceTracker,
+ (VkExtensionProperties*)(pProperties + i));
}
}
}
VkResult vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
stream->read(&vkEnumerateDeviceExtensionProperties_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -1342,13 +1802,36 @@
return vkEnumerateDeviceExtensionProperties_VkResult_return;
}
-VkResult VkEncoder::vkEnumerateInstanceLayerProperties(
- uint32_t* pPropertyCount,
- VkLayerProperties* pProperties,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkEnumerateInstanceLayerProperties in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkEnumerateInstanceLayerProperties(pPropertyCount:%p, pProperties:%p)",
+ pPropertyCount, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -1357,38 +1840,44 @@
{
// WARNING PTR CHECK
*countPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pProperties)
- {
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- count_VkLayerProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkLayerProperties*)(pProperties + i), countPtr);
+ if (pProperties) {
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ count_VkLayerProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkLayerProperties*)(pProperties + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkEnumerateInstanceLayerProperties = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkEnumerateInstanceLayerProperties =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkEnumerateInstanceLayerProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkEnumerateInstanceLayerProperties);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkEnumerateInstanceLayerProperties = OP_vkEnumerateInstanceLayerProperties;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkEnumerateInstanceLayerProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkEnumerateInstanceLayerProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkEnumerateInstanceLayerProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkEnumerateInstanceLayerProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)pPropertyCount;
memcpy((*streamPtrPtr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
memcpy(*streamPtrPtr, (uint32_t*)pPropertyCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -1397,20 +1886,17 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- reservedmarshal_VkLayerProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkLayerProperties*)(pProperties + i), streamPtrPtr);
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ reservedmarshal_VkLayerProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkLayerProperties*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pPropertyCount)
- {
- if (!(check_pPropertyCount))
- {
+ if (pPropertyCount) {
+ if (!(check_pPropertyCount)) {
fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
@@ -1418,35 +1904,30 @@
// WARNING PTR CHECK
VkLayerProperties* check_pProperties;
check_pProperties = (VkLayerProperties*)(uintptr_t)stream->getBe64();
- if (pProperties)
- {
- if (!(check_pProperties))
- {
+ if (pProperties) {
+ if (!(check_pProperties)) {
fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
}
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- unmarshal_VkLayerProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkLayerProperties*)(pProperties + i));
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ unmarshal_VkLayerProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkLayerProperties*)(pProperties + i));
}
}
}
- if (pPropertyCount)
- {
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- transform_fromhost_VkLayerProperties(sResourceTracker, (VkLayerProperties*)(pProperties + i));
+ if (pPropertyCount) {
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ transform_fromhost_VkLayerProperties(sResourceTracker,
+ (VkLayerProperties*)(pProperties + i));
}
}
}
VkResult vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
stream->read(&vkEnumerateInstanceLayerProperties_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -1454,14 +1935,38 @@
return vkEnumerateInstanceLayerProperties_VkResult_return;
}
-VkResult VkEncoder::vkEnumerateDeviceLayerProperties(
- VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkLayerProperties* pProperties,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkEnumerateDeviceLayerProperties in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkEnumerateDeviceLayerProperties(physicalDevice:%p, pPropertyCount:%p, pProperties:%p)",
+ physicalDevice, pPropertyCount, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -1474,31 +1979,38 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pProperties)
- {
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- count_VkLayerProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkLayerProperties*)(pProperties + i), countPtr);
+ if (pProperties) {
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ count_VkLayerProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkLayerProperties*)(pProperties + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkEnumerateDeviceLayerProperties = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkEnumerateDeviceLayerProperties =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkEnumerateDeviceLayerProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkEnumerateDeviceLayerProperties);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkEnumerateDeviceLayerProperties = OP_vkEnumerateDeviceLayerProperties;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkEnumerateDeviceLayerProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkEnumerateDeviceLayerProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkEnumerateDeviceLayerProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkEnumerateDeviceLayerProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -1508,8 +2020,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
memcpy(*streamPtrPtr, (uint32_t*)pPropertyCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -1518,20 +2029,17 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- reservedmarshal_VkLayerProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkLayerProperties*)(pProperties + i), streamPtrPtr);
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ reservedmarshal_VkLayerProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkLayerProperties*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pPropertyCount)
- {
- if (!(check_pPropertyCount))
- {
+ if (pPropertyCount) {
+ if (!(check_pPropertyCount)) {
fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
@@ -1539,35 +2047,30 @@
// WARNING PTR CHECK
VkLayerProperties* check_pProperties;
check_pProperties = (VkLayerProperties*)(uintptr_t)stream->getBe64();
- if (pProperties)
- {
- if (!(check_pProperties))
- {
+ if (pProperties) {
+ if (!(check_pProperties)) {
fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
}
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- unmarshal_VkLayerProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkLayerProperties*)(pProperties + i));
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ unmarshal_VkLayerProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkLayerProperties*)(pProperties + i));
}
}
}
- if (pPropertyCount)
- {
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- transform_fromhost_VkLayerProperties(sResourceTracker, (VkLayerProperties*)(pProperties + i));
+ if (pPropertyCount) {
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ transform_fromhost_VkLayerProperties(sResourceTracker,
+ (VkLayerProperties*)(pProperties + i));
}
}
}
VkResult vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
stream->read(&vkEnumerateDeviceLayerProperties_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -1575,15 +2078,35 @@
return vkEnumerateDeviceLayerProperties_VkResult_return;
}
-void VkEncoder::vkGetDeviceQueue(
- VkDevice device,
- uint32_t queueFamilyIndex,
- uint32_t queueIndex,
- VkQueue* pQueue,
- uint32_t doLock)
-{
+void VkEncoder::vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex,
+ VkQueue* pQueue, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetDeviceQueue in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetDeviceQueue(device:%p, queueFamilyIndex:%d, queueIndex:%d, pQueue:%p)",
+ device, queueFamilyIndex, queueIndex, pQueue);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -1604,13 +2127,21 @@
*countPtr += 8;
}
uint32_t packetSize_vkGetDeviceQueue = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetDeviceQueue);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceQueue);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDeviceQueue = OP_vkGetDeviceQueue;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDeviceQueue, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDeviceQueue, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDeviceQueue, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDeviceQueue, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -1631,24 +2162,44 @@
stream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_2, (VkQueue*)pQueue, 1);
stream->unsetHandleMapping();
sResourceTracker->on_vkGetDeviceQueue(this, device, queueFamilyIndex, queueIndex, pQueue);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkQueueSubmit(
- VkQueue queue,
- uint32_t submitCount,
- const VkSubmitInfo* pSubmits,
- VkFence fence,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits,
+ VkFence fence, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkQueueSubmit in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkQueueSubmit(queue:%p, submitCount:%d, pSubmits:%p, fence:%p)", queue,
+ submitCount, pSubmits, fence);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -1659,19 +2210,16 @@
local_queue = queue;
local_submitCount = submitCount;
local_pSubmits = nullptr;
- if (pSubmits)
- {
+ if (pSubmits) {
local_pSubmits = (VkSubmitInfo*)pool->alloc(((submitCount)) * sizeof(const VkSubmitInfo));
- for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
- {
- deepcopy_VkSubmitInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubmits + i, (VkSubmitInfo*)(local_pSubmits + i));
+ for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
+ deepcopy_VkSubmitInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubmits + i,
+ (VkSubmitInfo*)(local_pSubmits + i));
}
}
local_fence = fence;
- if (local_pSubmits)
- {
- for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
- {
+ if (local_pSubmits) {
+ for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
transform_tohost_VkSubmitInfo(sResourceTracker, (VkSubmitInfo*)(local_pSubmits + i));
}
}
@@ -1681,30 +2229,38 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
- {
- count_VkSubmitInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubmitInfo*)(local_pSubmits + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
+ count_VkSubmitInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubmitInfo*)(local_pSubmits + i), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 1 * 8;
}
uint32_t packetSize_vkQueueSubmit = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkQueueSubmit);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueSubmit);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueSubmit = OP_vkQueueSubmit;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkQueueSubmit, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkQueueSubmit, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkQueueSubmit, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkQueueSubmit, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_submitCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
- {
- reservedmarshal_VkSubmitInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubmitInfo*)(local_pSubmits + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
+ reservedmarshal_VkSubmitInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubmitInfo*)(local_pSubmits + i), streamPtrPtr);
}
uint64_t cgen_var_1;
*&cgen_var_1 = get_host_u64_VkFence((*&local_fence));
@@ -1712,9 +2268,9 @@
*streamPtrPtr += 1 * 8;
VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
stream->read(&vkQueueSubmit_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -1722,12 +2278,33 @@
return vkQueueSubmit_VkResult_return;
}
-VkResult VkEncoder::vkQueueWaitIdle(
- VkQueue queue,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkQueueWaitIdle(VkQueue queue, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkQueueWaitIdle in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkQueueWaitIdle(queue:%p)", queue);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -1740,22 +2317,30 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkQueueWaitIdle = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkQueueWaitIdle);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueWaitIdle);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueWaitIdle = OP_vkQueueWaitIdle;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkQueueWaitIdle, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkQueueWaitIdle, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkQueueWaitIdle, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkQueueWaitIdle, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
stream->read(&vkQueueWaitIdle_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -1763,12 +2348,33 @@
return vkQueueWaitIdle_VkResult_return;
}
-VkResult VkEncoder::vkDeviceWaitIdle(
- VkDevice device,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkDeviceWaitIdle(VkDevice device, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDeviceWaitIdle in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDeviceWaitIdle(device:%p)", device);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -1781,22 +2387,30 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkDeviceWaitIdle = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDeviceWaitIdle);
uint8_t* streamPtr = stream->reserve(packetSize_vkDeviceWaitIdle);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDeviceWaitIdle = OP_vkDeviceWaitIdle;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDeviceWaitIdle, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDeviceWaitIdle, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDeviceWaitIdle, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDeviceWaitIdle, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
stream->read(&vkDeviceWaitIdle_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -1804,15 +2418,36 @@
return vkDeviceWaitIdle_VkResult_return;
}
-VkResult VkEncoder::vkAllocateMemory(
- VkDevice device,
- const VkMemoryAllocateInfo* pAllocateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDeviceMemory* pMemory,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkAllocateMemory in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkAllocateMemory(device:%p, pAllocateInfo:%p, pAllocator:%p, pMemory:%p)",
+ device, pAllocateInfo, pAllocator, pMemory);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -1821,62 +2456,75 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pAllocateInfo = nullptr;
- if (pAllocateInfo)
- {
- local_pAllocateInfo = (VkMemoryAllocateInfo*)pool->alloc(sizeof(const VkMemoryAllocateInfo));
- deepcopy_VkMemoryAllocateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocateInfo, (VkMemoryAllocateInfo*)(local_pAllocateInfo));
+ if (pAllocateInfo) {
+ local_pAllocateInfo =
+ (VkMemoryAllocateInfo*)pool->alloc(sizeof(const VkMemoryAllocateInfo));
+ deepcopy_VkMemoryAllocateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocateInfo,
+ (VkMemoryAllocateInfo*)(local_pAllocateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocateInfo)
- {
- transform_tohost_VkMemoryAllocateInfo(sResourceTracker, (VkMemoryAllocateInfo*)(local_pAllocateInfo));
+ if (local_pAllocateInfo) {
+ transform_tohost_VkMemoryAllocateInfo(sResourceTracker,
+ (VkMemoryAllocateInfo*)(local_pAllocateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkMemoryAllocateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryAllocateInfo*)(local_pAllocateInfo), countPtr);
+ count_VkMemoryAllocateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryAllocateInfo*)(local_pAllocateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
uint32_t packetSize_vkAllocateMemory = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkAllocateMemory);
uint8_t* streamPtr = stream->reserve(packetSize_vkAllocateMemory);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkAllocateMemory = OP_vkAllocateMemory;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkAllocateMemory, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkAllocateMemory, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkAllocateMemory, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkAllocateMemory, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkMemoryAllocateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryAllocateInfo*)(local_pAllocateInfo), streamPtrPtr);
+ reservedmarshal_VkMemoryAllocateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryAllocateInfo*)(local_pAllocateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -1887,13 +2535,14 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_3, (VkDeviceMemory*)pMemory, 1);
+ stream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_3, (VkDeviceMemory*)pMemory,
+ 1);
stream->unsetHandleMapping();
VkResult vkAllocateMemory_VkResult_return = (VkResult)0;
stream->read(&vkAllocateMemory_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -1901,14 +2550,35 @@
return vkAllocateMemory_VkResult_return;
}
-void VkEncoder::vkFreeMemory(
- VkDevice device,
- VkDeviceMemory memory,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkFreeMemory(VkDevice device, VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkFreeMemory in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkFreeMemory(device:%p, memory:%p, pAllocator:%p)", device, memory,
+ pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -1918,13 +2588,15 @@
local_device = device;
local_memory = memory;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- sResourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ sResourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0,
+ (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
size_t count = 0;
size_t* countPtr = &count;
{
@@ -1934,19 +2606,27 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkFreeMemory = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkFreeMemory);
uint8_t* streamPtr = stream->reserve(packetSize_vkFreeMemory);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkFreeMemory = OP_vkFreeMemory;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkFreeMemory, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkFreeMemory, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkFreeMemory, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkFreeMemory, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -1960,55 +2640,113 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkDeviceMemory((VkDeviceMemory*)&memory);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkMapMemory(
- VkDevice device,
- VkDeviceMemory memory,
- VkDeviceSize offset,
- VkDeviceSize size,
- VkMemoryMapFlags flags,
- void** ppData,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset,
+ VkDeviceSize size, VkMemoryMapFlags flags, void** ppData,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkMapMemory in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
(void)doLock;
VkResult vkMapMemory_VkResult_return = (VkResult)0;
- vkMapMemory_VkResult_return = sResourceTracker->on_vkMapMemory(this, VK_SUCCESS, device, memory, offset, size, flags, ppData);
+ vkMapMemory_VkResult_return = sResourceTracker->on_vkMapMemory(this, VK_SUCCESS, device, memory,
+ offset, size, flags, ppData);
return vkMapMemory_VkResult_return;
}
-void VkEncoder::vkUnmapMemory(
- VkDevice device,
- VkDeviceMemory memory,
- uint32_t doLock)
-{
+void VkEncoder::vkUnmapMemory(VkDevice device, VkDeviceMemory memory, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkUnmapMemory in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
(void)doLock;
sResourceTracker->on_vkUnmapMemory(this, device, memory);
}
-VkResult VkEncoder::vkFlushMappedMemoryRanges(
- VkDevice device,
- uint32_t memoryRangeCount,
- const VkMappedMemoryRange* pMemoryRanges,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkFlushMappedMemoryRanges in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
- VALIDATE_RET(VkResult, VK_SUCCESS, mImpl->validation()->on_vkFlushMappedMemoryRanges(this, VK_SUCCESS, device, memoryRangeCount, pMemoryRanges));
+ VALIDATE_RET(VkResult, VK_SUCCESS,
+ mImpl->validation()->on_vkFlushMappedMemoryRanges(
+ this, VK_SUCCESS, device, memoryRangeCount, pMemoryRanges));
auto stream = mImpl->stream();
auto pool = mImpl->pool();
VkDevice local_device;
@@ -2017,19 +2755,18 @@
local_device = device;
local_memoryRangeCount = memoryRangeCount;
local_pMemoryRanges = nullptr;
- if (pMemoryRanges)
- {
- local_pMemoryRanges = (VkMappedMemoryRange*)pool->alloc(((memoryRangeCount)) * sizeof(const VkMappedMemoryRange));
- for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
- {
- deepcopy_VkMappedMemoryRange(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMemoryRanges + i, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
+ if (pMemoryRanges) {
+ local_pMemoryRanges = (VkMappedMemoryRange*)pool->alloc(((memoryRangeCount)) *
+ sizeof(const VkMappedMemoryRange));
+ for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i) {
+ deepcopy_VkMappedMemoryRange(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMemoryRanges + i,
+ (VkMappedMemoryRange*)(local_pMemoryRanges + i));
}
}
- if (local_pMemoryRanges)
- {
- for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
- {
- transform_tohost_VkMappedMemoryRange(sResourceTracker, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
+ if (local_pMemoryRanges) {
+ for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i) {
+ transform_tohost_VkMappedMemoryRange(sResourceTracker,
+ (VkMappedMemoryRange*)(local_pMemoryRanges + i));
}
}
size_t count = 0;
@@ -2038,42 +2775,57 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
- {
- count_VkMappedMemoryRange(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMappedMemoryRange*)(local_pMemoryRanges + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i) {
+ count_VkMappedMemoryRange(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMappedMemoryRange*)(local_pMemoryRanges + i), countPtr);
}
}
- uint32_t packetSize_vkFlushMappedMemoryRanges = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkFlushMappedMemoryRanges =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkFlushMappedMemoryRanges);
uint8_t* streamPtr = stream->reserve(packetSize_vkFlushMappedMemoryRanges);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkFlushMappedMemoryRanges = OP_vkFlushMappedMemoryRanges;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkFlushMappedMemoryRanges, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkFlushMappedMemoryRanges, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkFlushMappedMemoryRanges, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkFlushMappedMemoryRanges, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_memoryRangeCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
- {
- reservedmarshal_VkMappedMemoryRange(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMappedMemoryRange*)(local_pMemoryRanges + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i) {
+ reservedmarshal_VkMappedMemoryRange(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMappedMemoryRange*)(local_pMemoryRanges + i),
+ streamPtrPtr);
}
- if (!sResourceTracker->usingDirectMapping())
- {
- for (uint32_t i = 0; i < memoryRangeCount; ++i)
- {
+ if (!sResourceTracker->usingDirectMapping()) {
+ for (uint32_t i = 0; i < memoryRangeCount; ++i) {
auto range = pMemoryRanges[i];
auto memory = pMemoryRanges[i].memory;
auto size = pMemoryRanges[i].size;
auto offset = pMemoryRanges[i].offset;
uint64_t streamSize = 0;
- if (!memory) { stream->write(&streamSize, sizeof(uint64_t)); continue; };
+ if (!memory) {
+ stream->write(&streamSize, sizeof(uint64_t));
+ continue;
+ };
auto hostPtr = sResourceTracker->getMappedPointer(memory);
- auto actualSize = size == VK_WHOLE_SIZE ? sResourceTracker->getMappedSize(memory) : size;
- if (!hostPtr) { stream->write(&streamSize, sizeof(uint64_t)); continue; };
+ auto actualSize =
+ size == VK_WHOLE_SIZE ? sResourceTracker->getMappedSize(memory) : size;
+ if (!hostPtr) {
+ stream->write(&streamSize, sizeof(uint64_t));
+ continue;
+ };
streamSize = actualSize;
stream->write(&streamSize, sizeof(uint64_t));
uint8_t* targetRange = hostPtr + offset;
@@ -2082,9 +2834,9 @@
}
VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
stream->read(&vkFlushMappedMemoryRanges_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -2092,16 +2844,38 @@
return vkFlushMappedMemoryRanges_VkResult_return;
}
-VkResult VkEncoder::vkInvalidateMappedMemoryRanges(
- VkDevice device,
- uint32_t memoryRangeCount,
- const VkMappedMemoryRange* pMemoryRanges,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkInvalidateMappedMemoryRanges in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
- VALIDATE_RET(VkResult, VK_SUCCESS, mImpl->validation()->on_vkInvalidateMappedMemoryRanges(this, VK_SUCCESS, device, memoryRangeCount, pMemoryRanges));
+ VALIDATE_RET(VkResult, VK_SUCCESS,
+ mImpl->validation()->on_vkInvalidateMappedMemoryRanges(
+ this, VK_SUCCESS, device, memoryRangeCount, pMemoryRanges));
auto stream = mImpl->stream();
auto pool = mImpl->pool();
VkDevice local_device;
@@ -2110,19 +2884,18 @@
local_device = device;
local_memoryRangeCount = memoryRangeCount;
local_pMemoryRanges = nullptr;
- if (pMemoryRanges)
- {
- local_pMemoryRanges = (VkMappedMemoryRange*)pool->alloc(((memoryRangeCount)) * sizeof(const VkMappedMemoryRange));
- for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
- {
- deepcopy_VkMappedMemoryRange(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMemoryRanges + i, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
+ if (pMemoryRanges) {
+ local_pMemoryRanges = (VkMappedMemoryRange*)pool->alloc(((memoryRangeCount)) *
+ sizeof(const VkMappedMemoryRange));
+ for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i) {
+ deepcopy_VkMappedMemoryRange(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMemoryRanges + i,
+ (VkMappedMemoryRange*)(local_pMemoryRanges + i));
}
}
- if (local_pMemoryRanges)
- {
- for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
- {
- transform_tohost_VkMappedMemoryRange(sResourceTracker, (VkMappedMemoryRange*)(local_pMemoryRanges + i));
+ if (local_pMemoryRanges) {
+ for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i) {
+ transform_tohost_VkMappedMemoryRange(sResourceTracker,
+ (VkMappedMemoryRange*)(local_pMemoryRanges + i));
}
}
size_t count = 0;
@@ -2131,53 +2904,69 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
- {
- count_VkMappedMemoryRange(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMappedMemoryRange*)(local_pMemoryRanges + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i) {
+ count_VkMappedMemoryRange(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMappedMemoryRange*)(local_pMemoryRanges + i), countPtr);
}
}
- uint32_t packetSize_vkInvalidateMappedMemoryRanges = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkInvalidateMappedMemoryRanges =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkInvalidateMappedMemoryRanges);
uint8_t* streamPtr = stream->reserve(packetSize_vkInvalidateMappedMemoryRanges);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkInvalidateMappedMemoryRanges = OP_vkInvalidateMappedMemoryRanges;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkInvalidateMappedMemoryRanges, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkInvalidateMappedMemoryRanges, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkInvalidateMappedMemoryRanges, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkInvalidateMappedMemoryRanges, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_memoryRangeCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i)
- {
- reservedmarshal_VkMappedMemoryRange(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMappedMemoryRange*)(local_pMemoryRanges + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((memoryRangeCount)); ++i) {
+ reservedmarshal_VkMappedMemoryRange(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMappedMemoryRange*)(local_pMemoryRanges + i),
+ streamPtrPtr);
}
VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
stream->read(&vkInvalidateMappedMemoryRanges_VkResult_return, sizeof(VkResult));
- if (!sResourceTracker->usingDirectMapping())
- {
- for (uint32_t i = 0; i < memoryRangeCount; ++i)
- {
+ if (!sResourceTracker->usingDirectMapping()) {
+ for (uint32_t i = 0; i < memoryRangeCount; ++i) {
auto range = pMemoryRanges[i];
auto memory = pMemoryRanges[i].memory;
auto size = pMemoryRanges[i].size;
auto offset = pMemoryRanges[i].offset;
uint64_t streamSize = 0;
- if (!memory) { stream->read(&streamSize, sizeof(uint64_t)); continue; };
+ if (!memory) {
+ stream->read(&streamSize, sizeof(uint64_t));
+ continue;
+ };
auto hostPtr = sResourceTracker->getMappedPointer(memory);
- auto actualSize = size == VK_WHOLE_SIZE ? sResourceTracker->getMappedSize(memory) : size;
- if (!hostPtr) { stream->read(&streamSize, sizeof(uint64_t)); continue; };
+ auto actualSize =
+ size == VK_WHOLE_SIZE ? sResourceTracker->getMappedSize(memory) : size;
+ if (!hostPtr) {
+ stream->read(&streamSize, sizeof(uint64_t));
+ continue;
+ };
streamSize = actualSize;
stream->read(&streamSize, sizeof(uint64_t));
uint8_t* targetRange = hostPtr + offset;
stream->read(targetRange, actualSize);
}
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -2185,14 +2974,37 @@
return vkInvalidateMappedMemoryRanges_VkResult_return;
}
-void VkEncoder::vkGetDeviceMemoryCommitment(
- VkDevice device,
- VkDeviceMemory memory,
- VkDeviceSize* pCommittedMemoryInBytes,
- uint32_t doLock)
-{
+void VkEncoder::vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
+ VkDeviceSize* pCommittedMemoryInBytes,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetDeviceMemoryCommitment in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetDeviceMemoryCommitment(device:%p, memory:%p, pCommittedMemoryInBytes:%p)", device,
+ memory, pCommittedMemoryInBytes);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -2200,7 +3012,9 @@
VkDeviceMemory local_memory;
local_device = device;
local_memory = memory;
- sResourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ sResourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0,
+ (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
size_t count = 0;
size_t* countPtr = &count;
{
@@ -2210,14 +3024,23 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkDeviceSize);
}
- uint32_t packetSize_vkGetDeviceMemoryCommitment = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDeviceMemoryCommitment =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetDeviceMemoryCommitment);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceMemoryCommitment);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDeviceMemoryCommitment = OP_vkGetDeviceMemoryCommitment;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDeviceMemoryCommitment, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDeviceMemoryCommitment, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDeviceMemoryCommitment, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDeviceMemoryCommitment, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -2229,24 +3052,44 @@
memcpy(*streamPtrPtr, (VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize));
*streamPtrPtr += sizeof(VkDeviceSize);
stream->read((VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkBindBufferMemory(
- VkDevice device,
- VkBuffer buffer,
- VkDeviceMemory memory,
- VkDeviceSize memoryOffset,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
+ VkDeviceSize memoryOffset, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkBindBufferMemory in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkBindBufferMemory(device:%p, buffer:%p, memory:%p, memoryOffset:%ld)",
+ device, buffer, memory, memoryOffset);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -2258,7 +3101,9 @@
local_buffer = buffer;
local_memory = memory;
local_memoryOffset = memoryOffset;
- sResourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)&local_memoryOffset, 1, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ sResourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)&local_memoryOffset, 1,
+ (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
size_t count = 0;
size_t* countPtr = &count;
{
@@ -2270,14 +3115,23 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkDeviceSize);
}
- uint32_t packetSize_vkBindBufferMemory = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkBindBufferMemory =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkBindBufferMemory);
uint8_t* streamPtr = stream->reserve(packetSize_vkBindBufferMemory);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkBindBufferMemory = OP_vkBindBufferMemory;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkBindBufferMemory, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkBindBufferMemory, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkBindBufferMemory, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkBindBufferMemory, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -2294,9 +3148,9 @@
*streamPtrPtr += sizeof(VkDeviceSize);
VkResult vkBindBufferMemory_VkResult_return = (VkResult)0;
stream->read(&vkBindBufferMemory_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -2304,15 +3158,35 @@
return vkBindBufferMemory_VkResult_return;
}
-VkResult VkEncoder::vkBindImageMemory(
- VkDevice device,
- VkImage image,
- VkDeviceMemory memory,
- VkDeviceSize memoryOffset,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory,
+ VkDeviceSize memoryOffset, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkBindImageMemory in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkBindImageMemory(device:%p, image:%p, memory:%p, memoryOffset:%ld)", device,
+ image, memory, memoryOffset);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -2324,7 +3198,9 @@
local_image = image;
local_memory = memory;
local_memoryOffset = memoryOffset;
- sResourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)&local_memoryOffset, 1, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ sResourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)&local_memoryOffset, 1,
+ (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
size_t count = 0;
size_t* countPtr = &count;
{
@@ -2336,14 +3212,23 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkDeviceSize);
}
- uint32_t packetSize_vkBindImageMemory = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkBindImageMemory =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkBindImageMemory);
uint8_t* streamPtr = stream->reserve(packetSize_vkBindImageMemory);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkBindImageMemory = OP_vkBindImageMemory;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkBindImageMemory, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkBindImageMemory, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkBindImageMemory, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkBindImageMemory, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -2360,9 +3245,9 @@
*streamPtrPtr += sizeof(VkDeviceSize);
VkResult vkBindImageMemory_VkResult_return = (VkResult)0;
stream->read(&vkBindImageMemory_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -2370,14 +3255,36 @@
return vkBindImageMemory_VkResult_return;
}
-void VkEncoder::vkGetBufferMemoryRequirements(
- VkDevice device,
- VkBuffer buffer,
- VkMemoryRequirements* pMemoryRequirements,
- uint32_t doLock)
-{
+void VkEncoder::vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
+ VkMemoryRequirements* pMemoryRequirements,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetBufferMemoryRequirements in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetBufferMemoryRequirements(device:%p, buffer:%p, pMemoryRequirements:%p)",
+ device, buffer, pMemoryRequirements);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -2392,16 +3299,27 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkMemoryRequirements(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements*)(pMemoryRequirements), countPtr);
+ count_VkMemoryRequirements(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements*)(pMemoryRequirements), countPtr);
}
- uint32_t packetSize_vkGetBufferMemoryRequirements = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetBufferMemoryRequirements =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetBufferMemoryRequirements);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferMemoryRequirements);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetBufferMemoryRequirements = OP_vkGetBufferMemoryRequirements;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetBufferMemoryRequirements, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetBufferMemoryRequirements, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetBufferMemoryRequirements, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetBufferMemoryRequirements, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -2410,29 +3328,54 @@
*&cgen_var_1 = get_host_u64_VkBuffer((*&local_buffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements*)(pMemoryRequirements), streamPtrPtr);
- unmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements*)(pMemoryRequirements));
- if (pMemoryRequirements)
- {
- transform_fromhost_VkMemoryRequirements(sResourceTracker, (VkMemoryRequirements*)(pMemoryRequirements));
+ reservedmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements*)(pMemoryRequirements),
+ streamPtrPtr);
+ unmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements*)(pMemoryRequirements));
+ if (pMemoryRequirements) {
+ transform_fromhost_VkMemoryRequirements(sResourceTracker,
+ (VkMemoryRequirements*)(pMemoryRequirements));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkGetImageMemoryRequirements(
- VkDevice device,
- VkImage image,
- VkMemoryRequirements* pMemoryRequirements,
- uint32_t doLock)
-{
+void VkEncoder::vkGetImageMemoryRequirements(VkDevice device, VkImage image,
+ VkMemoryRequirements* pMemoryRequirements,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetImageMemoryRequirements in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetImageMemoryRequirements(device:%p, image:%p, pMemoryRequirements:%p)",
+ device, image, pMemoryRequirements);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -2447,16 +3390,27 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkMemoryRequirements(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements*)(pMemoryRequirements), countPtr);
+ count_VkMemoryRequirements(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements*)(pMemoryRequirements), countPtr);
}
- uint32_t packetSize_vkGetImageMemoryRequirements = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetImageMemoryRequirements =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetImageMemoryRequirements);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageMemoryRequirements);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetImageMemoryRequirements = OP_vkGetImageMemoryRequirements;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetImageMemoryRequirements, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetImageMemoryRequirements, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetImageMemoryRequirements, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetImageMemoryRequirements, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -2465,15 +3419,18 @@
*&cgen_var_1 = get_host_u64_VkImage((*&local_image));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements*)(pMemoryRequirements), streamPtrPtr);
- unmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements*)(pMemoryRequirements));
- if (pMemoryRequirements)
- {
- transform_fromhost_VkMemoryRequirements(sResourceTracker, (VkMemoryRequirements*)(pMemoryRequirements));
+ reservedmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements*)(pMemoryRequirements),
+ streamPtrPtr);
+ unmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements*)(pMemoryRequirements));
+ if (pMemoryRequirements) {
+ transform_fromhost_VkMemoryRequirements(sResourceTracker,
+ (VkMemoryRequirements*)(pMemoryRequirements));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -2481,14 +3438,37 @@
}
void VkEncoder::vkGetImageSparseMemoryRequirements(
- VkDevice device,
- VkImage image,
- uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements* pSparseMemoryRequirements,
- uint32_t doLock)
-{
+ VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements* pSparseMemoryRequirements, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetImageSparseMemoryRequirements in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetImageSparseMemoryRequirements(device:%p, image:%p, pSparseMemoryRequirementCount:%p, "
+ "pSparseMemoryRequirements:%p)",
+ device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -2505,31 +3485,40 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pSparseMemoryRequirementCount)
- {
+ if (pSparseMemoryRequirementCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pSparseMemoryRequirements)
- {
- if (pSparseMemoryRequirementCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
- {
- count_VkSparseImageMemoryRequirements(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i), countPtr);
+ if (pSparseMemoryRequirements) {
+ if (pSparseMemoryRequirementCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
+ count_VkSparseImageMemoryRequirements(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i),
+ countPtr);
}
}
}
}
- uint32_t packetSize_vkGetImageSparseMemoryRequirements = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetImageSparseMemoryRequirements =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetImageSparseMemoryRequirements);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageSparseMemoryRequirements);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetImageSparseMemoryRequirements = OP_vkGetImageSparseMemoryRequirements;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetImageSparseMemoryRequirements, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetImageSparseMemoryRequirements, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetImageSparseMemoryRequirements, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetImageSparseMemoryRequirements, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -2543,8 +3532,7 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pSparseMemoryRequirementCount)
- {
+ if (pSparseMemoryRequirementCount) {
memcpy(*streamPtrPtr, (uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -2553,54 +3541,52 @@
memcpy((*streamPtrPtr), &cgen_var_3, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pSparseMemoryRequirements)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
- {
- reservedmarshal_VkSparseImageMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i), streamPtrPtr);
+ if (pSparseMemoryRequirements) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
+ reservedmarshal_VkSparseImageMemoryRequirements(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pSparseMemoryRequirementCount;
check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pSparseMemoryRequirementCount)
- {
- if (!(check_pSparseMemoryRequirementCount))
- {
- fprintf(stderr, "fatal: pSparseMemoryRequirementCount inconsistent between guest and host\n");
+ if (pSparseMemoryRequirementCount) {
+ if (!(check_pSparseMemoryRequirementCount)) {
+ fprintf(stderr,
+ "fatal: pSparseMemoryRequirementCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
VkSparseImageMemoryRequirements* check_pSparseMemoryRequirements;
- check_pSparseMemoryRequirements = (VkSparseImageMemoryRequirements*)(uintptr_t)stream->getBe64();
- if (pSparseMemoryRequirements)
- {
- if (!(check_pSparseMemoryRequirements))
- {
- fprintf(stderr, "fatal: pSparseMemoryRequirements inconsistent between guest and host\n");
+ check_pSparseMemoryRequirements =
+ (VkSparseImageMemoryRequirements*)(uintptr_t)stream->getBe64();
+ if (pSparseMemoryRequirements) {
+ if (!(check_pSparseMemoryRequirements)) {
+ fprintf(stderr,
+ "fatal: pSparseMemoryRequirements inconsistent between guest and host\n");
}
- if (pSparseMemoryRequirementCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
- {
- unmarshal_VkSparseImageMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i));
+ if (pSparseMemoryRequirementCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
+ unmarshal_VkSparseImageMemoryRequirements(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i));
}
}
}
- if (pSparseMemoryRequirementCount)
- {
- if (pSparseMemoryRequirements)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
- {
- transform_fromhost_VkSparseImageMemoryRequirements(sResourceTracker, (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i));
+ if (pSparseMemoryRequirementCount) {
+ if (pSparseMemoryRequirements) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
+ transform_fromhost_VkSparseImageMemoryRequirements(
+ sResourceTracker,
+ (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i));
}
}
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -2608,18 +3594,39 @@
}
void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties(
- VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkImageType type,
- VkSampleCountFlagBits samples,
- VkImageUsageFlags usage,
- VkImageTiling tiling,
- uint32_t* pPropertyCount,
- VkSparseImageFormatProperties* pProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
+ VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling,
+ uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceSparseImageFormatProperties in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice:%p, format:%d, usage:%d, "
+ "pPropertyCount:%p, pProperties:%p)",
+ physicalDevice, format, usage, pPropertyCount, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -2647,31 +3654,40 @@
*countPtr += sizeof(VkImageTiling);
// WARNING PTR CHECK
*countPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pProperties)
- {
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- count_VkSparseImageFormatProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageFormatProperties*)(pProperties + i), countPtr);
+ if (pProperties) {
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ count_VkSparseImageFormatProperties(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageFormatProperties*)(pProperties + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPhysicalDeviceSparseImageFormatProperties = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceSparseImageFormatProperties =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceSparseImageFormatProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceSparseImageFormatProperties);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceSparseImageFormatProperties = OP_vkGetPhysicalDeviceSparseImageFormatProperties;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSparseImageFormatProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSparseImageFormatProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceSparseImageFormatProperties =
+ OP_vkGetPhysicalDeviceSparseImageFormatProperties;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSparseImageFormatProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSparseImageFormatProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -2691,8 +3707,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
memcpy(*streamPtrPtr, (uint32_t*)pPropertyCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -2701,20 +3716,18 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- reservedmarshal_VkSparseImageFormatProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageFormatProperties*)(pProperties + i), streamPtrPtr);
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ reservedmarshal_VkSparseImageFormatProperties(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageFormatProperties*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pPropertyCount)
- {
- if (!(check_pPropertyCount))
- {
+ if (pPropertyCount) {
+ if (!(check_pPropertyCount)) {
fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
@@ -2722,48 +3735,65 @@
// WARNING PTR CHECK
VkSparseImageFormatProperties* check_pProperties;
check_pProperties = (VkSparseImageFormatProperties*)(uintptr_t)stream->getBe64();
- if (pProperties)
- {
- if (!(check_pProperties))
- {
+ if (pProperties) {
+ if (!(check_pProperties)) {
fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
}
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- unmarshal_VkSparseImageFormatProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageFormatProperties*)(pProperties + i));
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ unmarshal_VkSparseImageFormatProperties(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageFormatProperties*)(pProperties + i));
}
}
}
- if (pPropertyCount)
- {
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- transform_fromhost_VkSparseImageFormatProperties(sResourceTracker, (VkSparseImageFormatProperties*)(pProperties + i));
+ if (pPropertyCount) {
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ transform_fromhost_VkSparseImageFormatProperties(
+ sResourceTracker, (VkSparseImageFormatProperties*)(pProperties + i));
}
}
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkQueueBindSparse(
- VkQueue queue,
- uint32_t bindInfoCount,
- const VkBindSparseInfo* pBindInfo,
- VkFence fence,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo, VkFence fence,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkQueueBindSparse in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkQueueBindSparse(queue:%p, bindInfoCount:%d, pBindInfo:%p, fence:%p)",
+ queue, bindInfoCount, pBindInfo, fence);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -2774,20 +3804,19 @@
local_queue = queue;
local_bindInfoCount = bindInfoCount;
local_pBindInfo = nullptr;
- if (pBindInfo)
- {
- local_pBindInfo = (VkBindSparseInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindSparseInfo));
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- deepcopy_VkBindSparseInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfo + i, (VkBindSparseInfo*)(local_pBindInfo + i));
+ if (pBindInfo) {
+ local_pBindInfo =
+ (VkBindSparseInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindSparseInfo));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ deepcopy_VkBindSparseInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfo + i,
+ (VkBindSparseInfo*)(local_pBindInfo + i));
}
}
local_fence = fence;
- if (local_pBindInfo)
- {
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- transform_tohost_VkBindSparseInfo(sResourceTracker, (VkBindSparseInfo*)(local_pBindInfo + i));
+ if (local_pBindInfo) {
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ transform_tohost_VkBindSparseInfo(sResourceTracker,
+ (VkBindSparseInfo*)(local_pBindInfo + i));
}
}
size_t count = 0;
@@ -2796,30 +3825,39 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- count_VkBindSparseInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindSparseInfo*)(local_pBindInfo + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ count_VkBindSparseInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBindSparseInfo*)(local_pBindInfo + i), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 1 * 8;
}
- uint32_t packetSize_vkQueueBindSparse = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkQueueBindSparse =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkQueueBindSparse);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueBindSparse);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueBindSparse = OP_vkQueueBindSparse;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkQueueBindSparse, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkQueueBindSparse, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkQueueBindSparse, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkQueueBindSparse, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- reservedmarshal_VkBindSparseInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindSparseInfo*)(local_pBindInfo + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ reservedmarshal_VkBindSparseInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBindSparseInfo*)(local_pBindInfo + i), streamPtrPtr);
}
uint64_t cgen_var_1;
*&cgen_var_1 = get_host_u64_VkFence((*&local_fence));
@@ -2827,9 +3865,9 @@
*streamPtrPtr += 1 * 8;
VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
stream->read(&vkQueueBindSparse_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -2837,15 +3875,36 @@
return vkQueueBindSparse_VkResult_return;
}
-VkResult VkEncoder::vkCreateFence(
- VkDevice device,
- const VkFenceCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkFence* pFence,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkFence* pFence,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateFence in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCreateFence(device:%p, pCreateInfo:%p, pAllocator:%p, pFence:%p)", device,
+ pCreateInfo, pAllocator, pFence);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -2854,62 +3913,73 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
+ if (pCreateInfo) {
local_pCreateInfo = (VkFenceCreateInfo*)pool->alloc(sizeof(const VkFenceCreateInfo));
- deepcopy_VkFenceCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkFenceCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkFenceCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkFenceCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkFenceCreateInfo(sResourceTracker, (VkFenceCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkFenceCreateInfo(sResourceTracker,
+ (VkFenceCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkFenceCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFenceCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkFenceCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkFenceCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
uint32_t packetSize_vkCreateFence = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateFence);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateFence);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateFence = OP_vkCreateFence;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateFence, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateFence, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateFence, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateFence, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkFenceCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFenceCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkFenceCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkFenceCreateInfo*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -2924,9 +3994,9 @@
stream->unsetHandleMapping();
VkResult vkCreateFence_VkResult_return = (VkResult)0;
stream->read(&vkCreateFence_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -2934,14 +4004,35 @@
return vkCreateFence_VkResult_return;
}
-void VkEncoder::vkDestroyFence(
- VkDevice device,
- VkFence fence,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyFence(VkDevice device, VkFence fence,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyFence in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyFence(device:%p, fence:%p, pAllocator:%p)", device, fence,
+ pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -2951,15 +4042,15 @@
local_device = device;
local_fence = fence;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -2970,19 +4061,27 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyFence = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyFence);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyFence);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyFence = OP_vkDestroyFence;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyFence, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyFence, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyFence, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyFence, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -2996,29 +4095,51 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkFence((VkFence*)&fence);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkResetFences(
- VkDevice device,
- uint32_t fenceCount,
- const VkFence* pFences,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkResetFences in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkResetFences(device:%p, fenceCount:%d, pFences:%p)", device, fenceCount,
+ pFences);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -3035,30 +4156,35 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- if (((fenceCount)))
- {
+ if (((fenceCount))) {
*countPtr += ((fenceCount)) * 8;
}
}
uint32_t packetSize_vkResetFences = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkResetFences);
uint8_t* streamPtr = stream->reserve(packetSize_vkResetFences);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkResetFences = OP_vkResetFences;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkResetFences, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkResetFences, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkResetFences, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkResetFences, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_fenceCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (((fenceCount)))
- {
+ if (((fenceCount))) {
uint8_t* cgen_var_1_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((fenceCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((fenceCount)); ++k) {
uint64_t tmpval = get_host_u64_VkFence(local_pFences[k]);
memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -3066,9 +4192,9 @@
}
VkResult vkResetFences_VkResult_return = (VkResult)0;
stream->read(&vkResetFences_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -3076,13 +4202,33 @@
return vkResetFences_VkResult_return;
}
-VkResult VkEncoder::vkGetFenceStatus(
- VkDevice device,
- VkFence fence,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetFenceStatus(VkDevice device, VkFence fence, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetFenceStatus in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetFenceStatus(device:%p, fence:%p)", device, fence);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -3099,13 +4245,21 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkGetFenceStatus = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetFenceStatus);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetFenceStatus);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetFenceStatus = OP_vkGetFenceStatus;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetFenceStatus, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetFenceStatus, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetFenceStatus, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetFenceStatus, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -3116,9 +4270,9 @@
*streamPtrPtr += 1 * 8;
VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
stream->read(&vkGetFenceStatus_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -3126,16 +4280,36 @@
return vkGetFenceStatus_VkResult_return;
}
-VkResult VkEncoder::vkWaitForFences(
- VkDevice device,
- uint32_t fenceCount,
- const VkFence* pFences,
- VkBool32 waitAll,
- uint64_t timeout,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences,
+ VkBool32 waitAll, uint64_t timeout, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkWaitForFences in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkWaitForFences(device:%p, fenceCount:%d, pFences:%p, waitAll:%d, timeout:%ld)", device,
+ fenceCount, pFences, waitAll, timeout);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -3156,32 +4330,37 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- if (((fenceCount)))
- {
+ if (((fenceCount))) {
*countPtr += ((fenceCount)) * 8;
}
*countPtr += sizeof(VkBool32);
*countPtr += sizeof(uint64_t);
}
uint32_t packetSize_vkWaitForFences = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkWaitForFences);
uint8_t* streamPtr = stream->reserve(packetSize_vkWaitForFences);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkWaitForFences = OP_vkWaitForFences;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkWaitForFences, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkWaitForFences, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkWaitForFences, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkWaitForFences, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_fenceCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (((fenceCount)))
- {
+ if (((fenceCount))) {
uint8_t* cgen_var_1_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((fenceCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((fenceCount)); ++k) {
uint64_t tmpval = get_host_u64_VkFence(local_pFences[k]);
memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -3193,9 +4372,9 @@
*streamPtrPtr += sizeof(uint64_t);
VkResult vkWaitForFences_VkResult_return = (VkResult)0;
stream->read(&vkWaitForFences_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -3203,15 +4382,36 @@
return vkWaitForFences_VkResult_return;
}
-VkResult VkEncoder::vkCreateSemaphore(
- VkDevice device,
- const VkSemaphoreCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSemaphore* pSemaphore,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSemaphore* pSemaphore, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateSemaphore in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCreateSemaphore(device:%p, pCreateInfo:%p, pAllocator:%p, pSemaphore:%p)",
+ device, pCreateInfo, pAllocator, pSemaphore);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -3220,62 +4420,76 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkSemaphoreCreateInfo*)pool->alloc(sizeof(const VkSemaphoreCreateInfo));
- deepcopy_VkSemaphoreCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkSemaphoreCreateInfo*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkSemaphoreCreateInfo*)pool->alloc(sizeof(const VkSemaphoreCreateInfo));
+ deepcopy_VkSemaphoreCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkSemaphoreCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkSemaphoreCreateInfo(sResourceTracker, (VkSemaphoreCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkSemaphoreCreateInfo(sResourceTracker,
+ (VkSemaphoreCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSemaphoreCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSemaphoreCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkSemaphoreCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSemaphoreCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateSemaphore = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateSemaphore =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateSemaphore);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateSemaphore);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateSemaphore = OP_vkCreateSemaphore;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateSemaphore, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateSemaphore, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateSemaphore, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateSemaphore, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSemaphoreCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSemaphoreCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkSemaphoreCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSemaphoreCreateInfo*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -3290,9 +4504,9 @@
stream->unsetHandleMapping();
VkResult vkCreateSemaphore_VkResult_return = (VkResult)0;
stream->read(&vkCreateSemaphore_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -3300,14 +4514,35 @@
return vkCreateSemaphore_VkResult_return;
}
-void VkEncoder::vkDestroySemaphore(
- VkDevice device,
- VkSemaphore semaphore,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroySemaphore(VkDevice device, VkSemaphore semaphore,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroySemaphore in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroySemaphore(device:%p, semaphore:%p, pAllocator:%p)", device,
+ semaphore, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -3317,15 +4552,15 @@
local_device = device;
local_semaphore = semaphore;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -3336,19 +4571,28 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroySemaphore = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroySemaphore =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroySemaphore);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroySemaphore);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroySemaphore = OP_vkDestroySemaphore;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroySemaphore, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroySemaphore, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroySemaphore, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroySemaphore, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -3362,30 +4606,52 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkSemaphore((VkSemaphore*)&semaphore);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkCreateEvent(
- VkDevice device,
- const VkEventCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkEvent* pEvent,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkEvent* pEvent,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateEvent in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCreateEvent(device:%p, pCreateInfo:%p, pAllocator:%p, pEvent:%p)", device,
+ pCreateInfo, pAllocator, pEvent);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -3394,62 +4660,73 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
+ if (pCreateInfo) {
local_pCreateInfo = (VkEventCreateInfo*)pool->alloc(sizeof(const VkEventCreateInfo));
- deepcopy_VkEventCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkEventCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkEventCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkEventCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkEventCreateInfo(sResourceTracker, (VkEventCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkEventCreateInfo(sResourceTracker,
+ (VkEventCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkEventCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkEventCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkEventCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkEventCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
uint32_t packetSize_vkCreateEvent = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateEvent);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateEvent);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateEvent = OP_vkCreateEvent;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateEvent, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateEvent, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateEvent, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateEvent, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkEventCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkEventCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkEventCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkEventCreateInfo*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -3464,9 +4741,9 @@
stream->unsetHandleMapping();
VkResult vkCreateEvent_VkResult_return = (VkResult)0;
stream->read(&vkCreateEvent_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -3474,14 +4751,35 @@
return vkCreateEvent_VkResult_return;
}
-void VkEncoder::vkDestroyEvent(
- VkDevice device,
- VkEvent event,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyEvent(VkDevice device, VkEvent event,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyEvent in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyEvent(device:%p, event:%p, pAllocator:%p)", device, event,
+ pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -3491,15 +4789,15 @@
local_device = device;
local_event = event;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -3510,19 +4808,27 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyEvent = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyEvent);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyEvent);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyEvent = OP_vkDestroyEvent;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyEvent, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyEvent, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyEvent, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyEvent, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -3536,28 +4842,49 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkEvent((VkEvent*)&event);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkGetEventStatus(
- VkDevice device,
- VkEvent event,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetEventStatus(VkDevice device, VkEvent event, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetEventStatus in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetEventStatus(device:%p, event:%p)", device, event);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -3574,13 +4901,21 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkGetEventStatus = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetEventStatus);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetEventStatus);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetEventStatus = OP_vkGetEventStatus;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetEventStatus, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetEventStatus, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetEventStatus, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetEventStatus, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -3591,9 +4926,9 @@
*streamPtrPtr += 1 * 8;
VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
stream->read(&vkGetEventStatus_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -3601,13 +4936,33 @@
return vkGetEventStatus_VkResult_return;
}
-VkResult VkEncoder::vkSetEvent(
- VkDevice device,
- VkEvent event,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkSetEvent(VkDevice device, VkEvent event, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkSetEvent in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkSetEvent(device:%p, event:%p)", device, event);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -3624,13 +4979,21 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkSetEvent = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkSetEvent);
uint8_t* streamPtr = stream->reserve(packetSize_vkSetEvent);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkSetEvent = OP_vkSetEvent;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkSetEvent, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkSetEvent, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkSetEvent, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkSetEvent, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -3641,9 +5004,9 @@
*streamPtrPtr += 1 * 8;
VkResult vkSetEvent_VkResult_return = (VkResult)0;
stream->read(&vkSetEvent_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -3651,13 +5014,33 @@
return vkSetEvent_VkResult_return;
}
-VkResult VkEncoder::vkResetEvent(
- VkDevice device,
- VkEvent event,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkResetEvent(VkDevice device, VkEvent event, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkResetEvent in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkResetEvent(device:%p, event:%p)", device, event);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -3674,13 +5057,21 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkResetEvent = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkResetEvent);
uint8_t* streamPtr = stream->reserve(packetSize_vkResetEvent);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkResetEvent = OP_vkResetEvent;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkResetEvent, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkResetEvent, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkResetEvent, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkResetEvent, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -3691,9 +5082,9 @@
*streamPtrPtr += 1 * 8;
VkResult vkResetEvent_VkResult_return = (VkResult)0;
stream->read(&vkResetEvent_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -3701,15 +5092,36 @@
return vkResetEvent_VkResult_return;
}
-VkResult VkEncoder::vkCreateQueryPool(
- VkDevice device,
- const VkQueryPoolCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkQueryPool* pQueryPool,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkQueryPool* pQueryPool, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateQueryPool in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCreateQueryPool(device:%p, pCreateInfo:%p, pAllocator:%p, pQueryPool:%p)",
+ device, pCreateInfo, pAllocator, pQueryPool);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -3718,62 +5130,76 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkQueryPoolCreateInfo*)pool->alloc(sizeof(const VkQueryPoolCreateInfo));
- deepcopy_VkQueryPoolCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkQueryPoolCreateInfo*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkQueryPoolCreateInfo*)pool->alloc(sizeof(const VkQueryPoolCreateInfo));
+ deepcopy_VkQueryPoolCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkQueryPoolCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkQueryPoolCreateInfo(sResourceTracker, (VkQueryPoolCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkQueryPoolCreateInfo(sResourceTracker,
+ (VkQueryPoolCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkQueryPoolCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueryPoolCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkQueryPoolCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkQueryPoolCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateQueryPool = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateQueryPool =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateQueryPool);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateQueryPool);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateQueryPool = OP_vkCreateQueryPool;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateQueryPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateQueryPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateQueryPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateQueryPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkQueryPoolCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueryPoolCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkQueryPoolCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkQueryPoolCreateInfo*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -3788,9 +5214,9 @@
stream->unsetHandleMapping();
VkResult vkCreateQueryPool_VkResult_return = (VkResult)0;
stream->read(&vkCreateQueryPool_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -3798,14 +5224,35 @@
return vkCreateQueryPool_VkResult_return;
}
-void VkEncoder::vkDestroyQueryPool(
- VkDevice device,
- VkQueryPool queryPool,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyQueryPool in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyQueryPool(device:%p, queryPool:%p, pAllocator:%p)", device,
+ queryPool, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -3815,15 +5262,15 @@
local_device = device;
local_queryPool = queryPool;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -3834,19 +5281,28 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyQueryPool = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyQueryPool =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyQueryPool);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyQueryPool);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyQueryPool = OP_vkDestroyQueryPool;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyQueryPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyQueryPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyQueryPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyQueryPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -3860,34 +5316,55 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkQueryPool((VkQueryPool*)&queryPool);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkGetQueryPoolResults(
- VkDevice device,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t queryCount,
- size_t dataSize,
- void* pData,
- VkDeviceSize stride,
- VkQueryResultFlags flags,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool,
+ uint32_t firstQuery, uint32_t queryCount, size_t dataSize,
+ void* pData, VkDeviceSize stride,
+ VkQueryResultFlags flags, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetQueryPoolResults in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetQueryPoolResults(device:%p, queryPool:%p, firstQuery:%d, queryCount:%d, "
+ "dataSize:%ld, pData:%p, stride:%ld, flags:%d)",
+ device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -3919,14 +5396,23 @@
*countPtr += sizeof(VkDeviceSize);
*countPtr += sizeof(VkQueryResultFlags);
}
- uint32_t packetSize_vkGetQueryPoolResults = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetQueryPoolResults =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetQueryPoolResults);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetQueryPoolResults);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetQueryPoolResults = OP_vkGetQueryPoolResults;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetQueryPoolResults, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetQueryPoolResults, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetQueryPoolResults, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetQueryPoolResults, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -3952,9 +5438,9 @@
stream->read((void*)pData, ((dataSize)) * sizeof(uint8_t));
VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0;
stream->read(&vkGetQueryPoolResults_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -3962,15 +5448,36 @@
return vkGetQueryPoolResults_VkResult_return;
}
-VkResult VkEncoder::vkCreateBuffer(
- VkDevice device,
- const VkBufferCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkBuffer* pBuffer,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateBuffer in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCreateBuffer(device:%p, pCreateInfo:%p, pAllocator:%p, pBuffer:%p)",
+ device, pCreateInfo, pAllocator, pBuffer);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -3979,62 +5486,73 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
+ if (pCreateInfo) {
local_pCreateInfo = (VkBufferCreateInfo*)pool->alloc(sizeof(const VkBufferCreateInfo));
- deepcopy_VkBufferCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkBufferCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkBufferCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkBufferCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkBufferCreateInfo(sResourceTracker, (VkBufferCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkBufferCreateInfo(sResourceTracker,
+ (VkBufferCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkBufferCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
uint32_t packetSize_vkCreateBuffer = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateBuffer);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateBuffer);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateBuffer = OP_vkCreateBuffer;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateBuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateBuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateBuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateBuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkBufferCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferCreateInfo*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -4049,9 +5567,9 @@
stream->unsetHandleMapping();
VkResult vkCreateBuffer_VkResult_return = (VkResult)0;
stream->read(&vkCreateBuffer_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -4059,14 +5577,35 @@
return vkCreateBuffer_VkResult_return;
}
-void VkEncoder::vkDestroyBuffer(
- VkDevice device,
- VkBuffer buffer,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyBuffer(VkDevice device, VkBuffer buffer,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyBuffer in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyBuffer(device:%p, buffer:%p, pAllocator:%p)", device, buffer,
+ pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -4076,15 +5615,15 @@
local_device = device;
local_buffer = buffer;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -4095,19 +5634,27 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyBuffer = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyBuffer);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyBuffer);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyBuffer = OP_vkDestroyBuffer;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyBuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyBuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyBuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyBuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -4121,30 +5668,52 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkBuffer((VkBuffer*)&buffer);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkCreateBufferView(
- VkDevice device,
- const VkBufferViewCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkBufferView* pView,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkBufferView* pView,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateBufferView in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCreateBufferView(device:%p, pCreateInfo:%p, pAllocator:%p, pView:%p)",
+ device, pCreateInfo, pAllocator, pView);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -4153,62 +5722,76 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkBufferViewCreateInfo*)pool->alloc(sizeof(const VkBufferViewCreateInfo));
- deepcopy_VkBufferViewCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkBufferViewCreateInfo*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkBufferViewCreateInfo*)pool->alloc(sizeof(const VkBufferViewCreateInfo));
+ deepcopy_VkBufferViewCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkBufferViewCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkBufferViewCreateInfo(sResourceTracker, (VkBufferViewCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkBufferViewCreateInfo(sResourceTracker,
+ (VkBufferViewCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferViewCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferViewCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkBufferViewCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferViewCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateBufferView = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateBufferView =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateBufferView);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateBufferView);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateBufferView = OP_vkCreateBufferView;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateBufferView, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateBufferView, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateBufferView, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateBufferView, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferViewCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferViewCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkBufferViewCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferViewCreateInfo*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -4223,9 +5806,9 @@
stream->unsetHandleMapping();
VkResult vkCreateBufferView_VkResult_return = (VkResult)0;
stream->read(&vkCreateBufferView_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -4233,14 +5816,35 @@
return vkCreateBufferView_VkResult_return;
}
-void VkEncoder::vkDestroyBufferView(
- VkDevice device,
- VkBufferView bufferView,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyBufferView(VkDevice device, VkBufferView bufferView,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyBufferView in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyBufferView(device:%p, bufferView:%p, pAllocator:%p)", device,
+ bufferView, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -4250,15 +5854,15 @@
local_device = device;
local_bufferView = bufferView;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -4269,19 +5873,28 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyBufferView = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyBufferView =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyBufferView);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyBufferView);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyBufferView = OP_vkDestroyBufferView;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyBufferView, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyBufferView, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyBufferView, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyBufferView, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -4295,30 +5908,50 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkBufferView((VkBufferView*)&bufferView);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkCreateImage(
- VkDevice device,
- const VkImageCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkImage* pImage,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkImage* pImage,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateImage in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -4327,63 +5960,75 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
+ if (pCreateInfo) {
local_pCreateInfo = (VkImageCreateInfo*)pool->alloc(sizeof(const VkImageCreateInfo));
- deepcopy_VkImageCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkImageCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkImageCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkImageCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
sResourceTracker->unwrap_VkNativeBufferANDROID(pCreateInfo, local_pCreateInfo);
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkImageCreateInfo(sResourceTracker, (VkImageCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ sResourceTracker->transformImpl_VkImageCreateInfo_tohost(local_pCreateInfo, 1);
+ transform_tohost_VkImageCreateInfo(sResourceTracker,
+ (VkImageCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImageCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkImageCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
uint32_t packetSize_vkCreateImage = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateImage);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateImage);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateImage = OP_vkCreateImage;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateImage, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateImage, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateImage, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateImage, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkImageCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageCreateInfo*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -4398,9 +6043,9 @@
stream->unsetHandleMapping();
VkResult vkCreateImage_VkResult_return = (VkResult)0;
stream->read(&vkCreateImage_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -4408,14 +6053,35 @@
return vkCreateImage_VkResult_return;
}
-void VkEncoder::vkDestroyImage(
- VkDevice device,
- VkImage image,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyImage(VkDevice device, VkImage image,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyImage in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyImage(device:%p, image:%p, pAllocator:%p)", device, image,
+ pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -4425,15 +6091,15 @@
local_device = device;
local_image = image;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -4444,19 +6110,27 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroyImage = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyImage);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyImage);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyImage = OP_vkDestroyImage;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyImage, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyImage, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyImage, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyImage, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -4470,30 +6144,53 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkImage((VkImage*)&image);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkGetImageSubresourceLayout(
- VkDevice device,
- VkImage image,
- const VkImageSubresource* pSubresource,
- VkSubresourceLayout* pLayout,
- uint32_t doLock)
-{
+void VkEncoder::vkGetImageSubresourceLayout(VkDevice device, VkImage image,
+ const VkImageSubresource* pSubresource,
+ VkSubresourceLayout* pLayout, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetImageSubresourceLayout in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetImageSubresourceLayout(device:%p, image:%p, pSubresource:%p, pLayout:%p)", device,
+ image, pSubresource, pLayout);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -4503,14 +6200,14 @@
local_device = device;
local_image = image;
local_pSubresource = nullptr;
- if (pSubresource)
- {
+ if (pSubresource) {
local_pSubresource = (VkImageSubresource*)pool->alloc(sizeof(const VkImageSubresource));
- deepcopy_VkImageSubresource(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubresource, (VkImageSubresource*)(local_pSubresource));
+ deepcopy_VkImageSubresource(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubresource,
+ (VkImageSubresource*)(local_pSubresource));
}
- if (local_pSubresource)
- {
- transform_tohost_VkImageSubresource(sResourceTracker, (VkImageSubresource*)(local_pSubresource));
+ if (local_pSubresource) {
+ transform_tohost_VkImageSubresource(sResourceTracker,
+ (VkImageSubresource*)(local_pSubresource));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -4519,17 +6216,28 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkImageSubresource(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageSubresource*)(local_pSubresource), countPtr);
- count_VkSubresourceLayout(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubresourceLayout*)(pLayout), countPtr);
+ count_VkImageSubresource(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageSubresource*)(local_pSubresource), countPtr);
+ count_VkSubresourceLayout(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubresourceLayout*)(pLayout), countPtr);
}
- uint32_t packetSize_vkGetImageSubresourceLayout = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetImageSubresourceLayout =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetImageSubresourceLayout);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageSubresourceLayout);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetImageSubresourceLayout = OP_vkGetImageSubresourceLayout;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetImageSubresourceLayout, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetImageSubresourceLayout, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetImageSubresourceLayout, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetImageSubresourceLayout, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -4538,31 +6246,54 @@
*&cgen_var_1 = get_host_u64_VkImage((*&local_image));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageSubresource(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageSubresource*)(local_pSubresource), streamPtrPtr);
- reservedmarshal_VkSubresourceLayout(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubresourceLayout*)(pLayout), streamPtrPtr);
- unmarshal_VkSubresourceLayout(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubresourceLayout*)(pLayout));
- if (pLayout)
- {
+ reservedmarshal_VkImageSubresource(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageSubresource*)(local_pSubresource), streamPtrPtr);
+ reservedmarshal_VkSubresourceLayout(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubresourceLayout*)(pLayout), streamPtrPtr);
+ unmarshal_VkSubresourceLayout(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubresourceLayout*)(pLayout));
+ if (pLayout) {
transform_fromhost_VkSubresourceLayout(sResourceTracker, (VkSubresourceLayout*)(pLayout));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkCreateImageView(
- VkDevice device,
- const VkImageViewCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkImageView* pView,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkImageView* pView,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateImageView in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCreateImageView(device:%p, pCreateInfo:%p, pAllocator:%p, pView:%p)",
+ device, pCreateInfo, pAllocator, pView);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -4571,62 +6302,76 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkImageViewCreateInfo*)pool->alloc(sizeof(const VkImageViewCreateInfo));
- deepcopy_VkImageViewCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkImageViewCreateInfo*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkImageViewCreateInfo*)pool->alloc(sizeof(const VkImageViewCreateInfo));
+ deepcopy_VkImageViewCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkImageViewCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkImageViewCreateInfo(sResourceTracker, (VkImageViewCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkImageViewCreateInfo(sResourceTracker,
+ (VkImageViewCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImageViewCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageViewCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkImageViewCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageViewCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateImageView = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateImageView =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateImageView);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateImageView);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateImageView = OP_vkCreateImageView;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateImageView, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateImageView, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateImageView, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateImageView, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageViewCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageViewCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkImageViewCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageViewCreateInfo*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -4641,9 +6386,9 @@
stream->unsetHandleMapping();
VkResult vkCreateImageView_VkResult_return = (VkResult)0;
stream->read(&vkCreateImageView_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -4651,14 +6396,35 @@
return vkCreateImageView_VkResult_return;
}
-void VkEncoder::vkDestroyImageView(
- VkDevice device,
- VkImageView imageView,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyImageView(VkDevice device, VkImageView imageView,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyImageView in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyImageView(device:%p, imageView:%p, pAllocator:%p)", device,
+ imageView, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -4668,15 +6434,15 @@
local_device = device;
local_imageView = imageView;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -4687,19 +6453,28 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyImageView = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyImageView =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyImageView);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyImageView);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyImageView = OP_vkDestroyImageView;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyImageView, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyImageView, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyImageView, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyImageView, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -4713,30 +6488,54 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkImageView((VkImageView*)&imageView);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkCreateShaderModule(
- VkDevice device,
- const VkShaderModuleCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkShaderModule* pShaderModule,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateShaderModule(VkDevice device,
+ const VkShaderModuleCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkShaderModule* pShaderModule, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateShaderModule in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateShaderModule(device:%p, pCreateInfo:%p, pAllocator:%p, pShaderModule:%p)", device,
+ pCreateInfo, pAllocator, pShaderModule);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -4745,62 +6544,76 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkShaderModuleCreateInfo*)pool->alloc(sizeof(const VkShaderModuleCreateInfo));
- deepcopy_VkShaderModuleCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkShaderModuleCreateInfo*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkShaderModuleCreateInfo*)pool->alloc(sizeof(const VkShaderModuleCreateInfo));
+ deepcopy_VkShaderModuleCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkShaderModuleCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkShaderModuleCreateInfo(sResourceTracker, (VkShaderModuleCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkShaderModuleCreateInfo(sResourceTracker,
+ (VkShaderModuleCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkShaderModuleCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkShaderModuleCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkShaderModuleCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkShaderModuleCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateShaderModule = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateShaderModule =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateShaderModule);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateShaderModule);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateShaderModule = OP_vkCreateShaderModule;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateShaderModule, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateShaderModule, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateShaderModule, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateShaderModule, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkShaderModuleCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkShaderModuleCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkShaderModuleCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkShaderModuleCreateInfo*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -4811,13 +6624,14 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkShaderModule(&cgen_var_3, (VkShaderModule*)pShaderModule, 1);
+ stream->handleMapping()->mapHandles_u64_VkShaderModule(&cgen_var_3,
+ (VkShaderModule*)pShaderModule, 1);
stream->unsetHandleMapping();
VkResult vkCreateShaderModule_VkResult_return = (VkResult)0;
stream->read(&vkCreateShaderModule_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -4825,14 +6639,35 @@
return vkCreateShaderModule_VkResult_return;
}
-void VkEncoder::vkDestroyShaderModule(
- VkDevice device,
- VkShaderModule shaderModule,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyShaderModule in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyShaderModule(device:%p, shaderModule:%p, pAllocator:%p)", device,
+ shaderModule, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -4842,15 +6677,15 @@
local_device = device;
local_shaderModule = shaderModule;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -4861,19 +6696,28 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyShaderModule = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyShaderModule =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyShaderModule);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyShaderModule);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyShaderModule = OP_vkDestroyShaderModule;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyShaderModule, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyShaderModule, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyShaderModule, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyShaderModule, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -4887,30 +6731,54 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkShaderModule((VkShaderModule*)&shaderModule);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkCreatePipelineCache(
- VkDevice device,
- const VkPipelineCacheCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPipelineCache* pPipelineCache,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreatePipelineCache(VkDevice device,
+ const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineCache* pPipelineCache, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreatePipelineCache in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreatePipelineCache(device:%p, pCreateInfo:%p, pAllocator:%p, pPipelineCache:%p)",
+ device, pCreateInfo, pAllocator, pPipelineCache);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -4919,62 +6787,76 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkPipelineCacheCreateInfo*)pool->alloc(sizeof(const VkPipelineCacheCreateInfo));
- deepcopy_VkPipelineCacheCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkPipelineCacheCreateInfo*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkPipelineCacheCreateInfo*)pool->alloc(sizeof(const VkPipelineCacheCreateInfo));
+ deepcopy_VkPipelineCacheCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkPipelineCacheCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkPipelineCacheCreateInfo(sResourceTracker, (VkPipelineCacheCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkPipelineCacheCreateInfo(sResourceTracker,
+ (VkPipelineCacheCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPipelineCacheCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineCacheCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkPipelineCacheCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPipelineCacheCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreatePipelineCache = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreatePipelineCache =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreatePipelineCache);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreatePipelineCache);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreatePipelineCache = OP_vkCreatePipelineCache;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreatePipelineCache, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreatePipelineCache, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreatePipelineCache, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreatePipelineCache, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPipelineCacheCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineCacheCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkPipelineCacheCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPipelineCacheCreateInfo*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -4985,13 +6867,14 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkPipelineCache(&cgen_var_3, (VkPipelineCache*)pPipelineCache, 1);
+ stream->handleMapping()->mapHandles_u64_VkPipelineCache(&cgen_var_3,
+ (VkPipelineCache*)pPipelineCache, 1);
stream->unsetHandleMapping();
VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0;
stream->read(&vkCreatePipelineCache_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -4999,14 +6882,35 @@
return vkCreatePipelineCache_VkResult_return;
}
-void VkEncoder::vkDestroyPipelineCache(
- VkDevice device,
- VkPipelineCache pipelineCache,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyPipelineCache in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyPipelineCache(device:%p, pipelineCache:%p, pAllocator:%p)", device,
+ pipelineCache, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -5016,15 +6920,15 @@
local_device = device;
local_pipelineCache = pipelineCache;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -5035,19 +6939,28 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyPipelineCache = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyPipelineCache =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyPipelineCache);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyPipelineCache);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyPipelineCache = OP_vkDestroyPipelineCache;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyPipelineCache, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyPipelineCache, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyPipelineCache, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyPipelineCache, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -5061,30 +6974,52 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
- sResourceTracker->destroyMapping()->mapHandles_VkPipelineCache((VkPipelineCache*)&pipelineCache);
+ sResourceTracker->destroyMapping()->mapHandles_VkPipelineCache(
+ (VkPipelineCache*)&pipelineCache);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkGetPipelineCacheData(
- VkDevice device,
- VkPipelineCache pipelineCache,
- size_t* pDataSize,
- void* pData,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
+ size_t* pDataSize, void* pData, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetPipelineCacheData in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetPipelineCacheData(device:%p, pipelineCache:%p, pDataSize:%p, pData:%p)",
+ device, pipelineCache, pDataSize, pData);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -5101,28 +7036,34 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pDataSize)
- {
+ if (pDataSize) {
*countPtr += 8;
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pData)
- {
- if (pDataSize)
- {
+ if (pData) {
+ if (pDataSize) {
*countPtr += (*(pDataSize)) * sizeof(uint8_t);
}
}
}
- uint32_t packetSize_vkGetPipelineCacheData = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPipelineCacheData =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetPipelineCacheData);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPipelineCacheData);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPipelineCacheData = OP_vkGetPipelineCacheData;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPipelineCacheData, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPipelineCacheData, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPipelineCacheData, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPipelineCacheData, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -5136,8 +7077,7 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pDataSize)
- {
+ if (pDataSize) {
uint64_t cgen_var_2_0 = (uint64_t)(*pDataSize);
memcpy((*streamPtrPtr), &cgen_var_2_0, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
@@ -5148,18 +7088,15 @@
memcpy((*streamPtrPtr), &cgen_var_3, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pData)
- {
+ if (pData) {
memcpy(*streamPtrPtr, (void*)pData, (*(pDataSize)) * sizeof(uint8_t));
*streamPtrPtr += (*(pDataSize)) * sizeof(uint8_t);
}
// WARNING PTR CHECK
size_t* check_pDataSize;
check_pDataSize = (size_t*)(uintptr_t)stream->getBe64();
- if (pDataSize)
- {
- if (!(check_pDataSize))
- {
+ if (pDataSize) {
+ if (!(check_pDataSize)) {
fprintf(stderr, "fatal: pDataSize inconsistent between guest and host\n");
}
(*pDataSize) = (size_t)stream->getBe64();
@@ -5167,19 +7104,17 @@
// WARNING PTR CHECK
void* check_pData;
check_pData = (void*)(uintptr_t)stream->getBe64();
- if (pData)
- {
- if (!(check_pData))
- {
+ if (pData) {
+ if (!(check_pData)) {
fprintf(stderr, "fatal: pData inconsistent between guest and host\n");
}
stream->read((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
}
VkResult vkGetPipelineCacheData_VkResult_return = (VkResult)0;
stream->read(&vkGetPipelineCacheData_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -5187,15 +7122,37 @@
return vkGetPipelineCacheData_VkResult_return;
}
-VkResult VkEncoder::vkMergePipelineCaches(
- VkDevice device,
- VkPipelineCache dstCache,
- uint32_t srcCacheCount,
- const VkPipelineCache* pSrcCaches,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
+ uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkMergePipelineCaches in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkMergePipelineCaches(device:%p, dstCache:%p, srcCacheCount:%d, pSrcCaches:%p)", device,
+ dstCache, srcCacheCount, pSrcCaches);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -5216,19 +7173,27 @@
uint64_t cgen_var_1;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- if (((srcCacheCount)))
- {
+ if (((srcCacheCount))) {
*countPtr += ((srcCacheCount)) * 8;
}
}
- uint32_t packetSize_vkMergePipelineCaches = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkMergePipelineCaches =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkMergePipelineCaches);
uint8_t* streamPtr = stream->reserve(packetSize_vkMergePipelineCaches);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkMergePipelineCaches = OP_vkMergePipelineCaches;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkMergePipelineCaches, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkMergePipelineCaches, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkMergePipelineCaches, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkMergePipelineCaches, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -5239,11 +7204,9 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_srcCacheCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (((srcCacheCount)))
- {
+ if (((srcCacheCount))) {
uint8_t* cgen_var_2_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((srcCacheCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((srcCacheCount)); ++k) {
uint64_t tmpval = get_host_u64_VkPipelineCache(local_pSrcCaches[k]);
memcpy(cgen_var_2_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -5251,9 +7214,9 @@
}
VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0;
stream->read(&vkMergePipelineCaches_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -5261,17 +7224,40 @@
return vkMergePipelineCaches_VkResult_return;
}
-VkResult VkEncoder::vkCreateGraphicsPipelines(
- VkDevice device,
- VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkGraphicsPipelineCreateInfo* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateGraphicsPipelines in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateGraphicsPipelines(device:%p, pipelineCache:%p, createInfoCount:%d, "
+ "pCreateInfos:%p, pAllocator:%p, pPipelines:%p)",
+ device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -5284,31 +7270,31 @@
local_pipelineCache = pipelineCache;
local_createInfoCount = createInfoCount;
local_pCreateInfos = nullptr;
- if (pCreateInfos)
- {
- local_pCreateInfos = (VkGraphicsPipelineCreateInfo*)pool->alloc(((createInfoCount)) * sizeof(const VkGraphicsPipelineCreateInfo));
- for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
- {
- deepcopy_VkGraphicsPipelineCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfos + i, (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i));
+ if (pCreateInfos) {
+ local_pCreateInfos = (VkGraphicsPipelineCreateInfo*)pool->alloc(
+ ((createInfoCount)) * sizeof(const VkGraphicsPipelineCreateInfo));
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+ deepcopy_VkGraphicsPipelineCreateInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfos + i,
+ (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i));
}
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
- {
- transform_tohost_VkGraphicsPipelineCreateInfo(sResourceTracker, (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i));
+ if (local_pCreateInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+ transform_tohost_VkGraphicsPipelineCreateInfo(
+ sResourceTracker, (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i));
}
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -5318,29 +7304,38 @@
uint64_t cgen_var_1;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
- {
- count_VkGraphicsPipelineCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+ count_VkGraphicsPipelineCreateInfo(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i), countPtr);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
- if (((createInfoCount)))
- {
+ if (((createInfoCount))) {
*countPtr += ((createInfoCount)) * 8;
}
}
- uint32_t packetSize_vkCreateGraphicsPipelines = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateGraphicsPipelines =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateGraphicsPipelines);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateGraphicsPipelines);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateGraphicsPipelines = OP_vkCreateGraphicsPipelines;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateGraphicsPipelines, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateGraphicsPipelines, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateGraphicsPipelines, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateGraphicsPipelines, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -5351,25 +7346,25 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_createInfoCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
- {
- reservedmarshal_VkGraphicsPipelineCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+ reservedmarshal_VkGraphicsPipelineCreateInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkGraphicsPipelineCreateInfo*)(local_pCreateInfos + i), streamPtrPtr);
}
// WARNING PTR CHECK
uint64_t cgen_var_2 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
- if (((createInfoCount)))
- {
+ if (((createInfoCount))) {
uint8_t* cgen_var_3_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((createInfoCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((createInfoCount)); ++k) {
uint64_t tmpval = (uint64_t)(pPipelines[k]);
memcpy(cgen_var_3_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -5377,19 +7372,19 @@
}
/* is handle, possibly out */;
stream->setHandleMapping(sResourceTracker->createMapping());
- if (((createInfoCount)))
- {
+ if (((createInfoCount))) {
uint64_t* cgen_var_4;
stream->alloc((void**)&cgen_var_4, ((createInfoCount)) * 8);
stream->read((uint64_t*)cgen_var_4, ((createInfoCount)) * 8);
- stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_4, (VkPipeline*)pPipelines, ((createInfoCount)));
+ stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_4, (VkPipeline*)pPipelines,
+ ((createInfoCount)));
}
stream->unsetHandleMapping();
VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
stream->read(&vkCreateGraphicsPipelines_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -5397,17 +7392,40 @@
return vkCreateGraphicsPipelines_VkResult_return;
}
-VkResult VkEncoder::vkCreateComputePipelines(
- VkDevice device,
- VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkComputePipelineCreateInfo* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkComputePipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateComputePipelines in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateComputePipelines(device:%p, pipelineCache:%p, createInfoCount:%d, "
+ "pCreateInfos:%p, pAllocator:%p, pPipelines:%p)",
+ device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -5420,31 +7438,31 @@
local_pipelineCache = pipelineCache;
local_createInfoCount = createInfoCount;
local_pCreateInfos = nullptr;
- if (pCreateInfos)
- {
- local_pCreateInfos = (VkComputePipelineCreateInfo*)pool->alloc(((createInfoCount)) * sizeof(const VkComputePipelineCreateInfo));
- for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
- {
- deepcopy_VkComputePipelineCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfos + i, (VkComputePipelineCreateInfo*)(local_pCreateInfos + i));
+ if (pCreateInfos) {
+ local_pCreateInfos = (VkComputePipelineCreateInfo*)pool->alloc(
+ ((createInfoCount)) * sizeof(const VkComputePipelineCreateInfo));
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+ deepcopy_VkComputePipelineCreateInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfos + i,
+ (VkComputePipelineCreateInfo*)(local_pCreateInfos + i));
}
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
- {
- transform_tohost_VkComputePipelineCreateInfo(sResourceTracker, (VkComputePipelineCreateInfo*)(local_pCreateInfos + i));
+ if (local_pCreateInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+ transform_tohost_VkComputePipelineCreateInfo(
+ sResourceTracker, (VkComputePipelineCreateInfo*)(local_pCreateInfos + i));
}
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -5454,29 +7472,38 @@
uint64_t cgen_var_1;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
- {
- count_VkComputePipelineCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkComputePipelineCreateInfo*)(local_pCreateInfos + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+ count_VkComputePipelineCreateInfo(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkComputePipelineCreateInfo*)(local_pCreateInfos + i), countPtr);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
- if (((createInfoCount)))
- {
+ if (((createInfoCount))) {
*countPtr += ((createInfoCount)) * 8;
}
}
- uint32_t packetSize_vkCreateComputePipelines = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateComputePipelines =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateComputePipelines);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateComputePipelines);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateComputePipelines = OP_vkCreateComputePipelines;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateComputePipelines, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateComputePipelines, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateComputePipelines, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateComputePipelines, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -5487,25 +7514,25 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_createInfoCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
- {
- reservedmarshal_VkComputePipelineCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkComputePipelineCreateInfo*)(local_pCreateInfos + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+ reservedmarshal_VkComputePipelineCreateInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkComputePipelineCreateInfo*)(local_pCreateInfos + i), streamPtrPtr);
}
// WARNING PTR CHECK
uint64_t cgen_var_2 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
- if (((createInfoCount)))
- {
+ if (((createInfoCount))) {
uint8_t* cgen_var_3_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((createInfoCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((createInfoCount)); ++k) {
uint64_t tmpval = (uint64_t)(pPipelines[k]);
memcpy(cgen_var_3_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -5513,19 +7540,19 @@
}
/* is handle, possibly out */;
stream->setHandleMapping(sResourceTracker->createMapping());
- if (((createInfoCount)))
- {
+ if (((createInfoCount))) {
uint64_t* cgen_var_4;
stream->alloc((void**)&cgen_var_4, ((createInfoCount)) * 8);
stream->read((uint64_t*)cgen_var_4, ((createInfoCount)) * 8);
- stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_4, (VkPipeline*)pPipelines, ((createInfoCount)));
+ stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_4, (VkPipeline*)pPipelines,
+ ((createInfoCount)));
}
stream->unsetHandleMapping();
VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0;
stream->read(&vkCreateComputePipelines_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -5533,14 +7560,35 @@
return vkCreateComputePipelines_VkResult_return;
}
-void VkEncoder::vkDestroyPipeline(
- VkDevice device,
- VkPipeline pipeline,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyPipeline(VkDevice device, VkPipeline pipeline,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyPipeline in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyPipeline(device:%p, pipeline:%p, pAllocator:%p)", device, pipeline,
+ pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -5550,15 +7598,15 @@
local_device = device;
local_pipeline = pipeline;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -5569,19 +7617,28 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyPipeline = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyPipeline =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyPipeline);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyPipeline);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyPipeline = OP_vkDestroyPipeline;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyPipeline, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyPipeline, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyPipeline, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyPipeline, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -5595,30 +7652,54 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkPipeline((VkPipeline*)&pipeline);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkCreatePipelineLayout(
- VkDevice device,
- const VkPipelineLayoutCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPipelineLayout* pPipelineLayout,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreatePipelineLayout(VkDevice device,
+ const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineLayout* pPipelineLayout, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreatePipelineLayout in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreatePipelineLayout(device:%p, pCreateInfo:%p, pAllocator:%p, pPipelineLayout:%p)",
+ device, pCreateInfo, pAllocator, pPipelineLayout);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -5627,62 +7708,77 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkPipelineLayoutCreateInfo*)pool->alloc(sizeof(const VkPipelineLayoutCreateInfo));
- deepcopy_VkPipelineLayoutCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkPipelineLayoutCreateInfo*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkPipelineLayoutCreateInfo*)pool->alloc(sizeof(const VkPipelineLayoutCreateInfo));
+ deepcopy_VkPipelineLayoutCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkPipelineLayoutCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkPipelineLayoutCreateInfo(sResourceTracker, (VkPipelineLayoutCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkPipelineLayoutCreateInfo(
+ sResourceTracker, (VkPipelineLayoutCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPipelineLayoutCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineLayoutCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkPipelineLayoutCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPipelineLayoutCreateInfo*)(local_pCreateInfo),
+ countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreatePipelineLayout = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreatePipelineLayout =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreatePipelineLayout);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreatePipelineLayout);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreatePipelineLayout = OP_vkCreatePipelineLayout;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreatePipelineLayout, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreatePipelineLayout, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreatePipelineLayout, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreatePipelineLayout, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPipelineLayoutCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineLayoutCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkPipelineLayoutCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPipelineLayoutCreateInfo*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -5693,13 +7789,14 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_3, (VkPipelineLayout*)pPipelineLayout, 1);
+ stream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_3,
+ (VkPipelineLayout*)pPipelineLayout, 1);
stream->unsetHandleMapping();
VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0;
stream->read(&vkCreatePipelineLayout_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -5707,14 +7804,35 @@
return vkCreatePipelineLayout_VkResult_return;
}
-void VkEncoder::vkDestroyPipelineLayout(
- VkDevice device,
- VkPipelineLayout pipelineLayout,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyPipelineLayout in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyPipelineLayout(device:%p, pipelineLayout:%p, pAllocator:%p)",
+ device, pipelineLayout, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -5724,15 +7842,15 @@
local_device = device;
local_pipelineLayout = pipelineLayout;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -5743,19 +7861,28 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyPipelineLayout = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyPipelineLayout =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyPipelineLayout);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyPipelineLayout);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyPipelineLayout = OP_vkDestroyPipelineLayout;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyPipelineLayout, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyPipelineLayout, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyPipelineLayout, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyPipelineLayout, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -5769,30 +7896,53 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
- sResourceTracker->destroyMapping()->mapHandles_VkPipelineLayout((VkPipelineLayout*)&pipelineLayout);
+ sResourceTracker->destroyMapping()->mapHandles_VkPipelineLayout(
+ (VkPipelineLayout*)&pipelineLayout);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkCreateSampler(
- VkDevice device,
- const VkSamplerCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSampler* pSampler,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSampler* pSampler,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateSampler in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCreateSampler(device:%p, pCreateInfo:%p, pAllocator:%p, pSampler:%p)",
+ device, pCreateInfo, pAllocator, pSampler);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -5801,62 +7951,73 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
+ if (pCreateInfo) {
local_pCreateInfo = (VkSamplerCreateInfo*)pool->alloc(sizeof(const VkSamplerCreateInfo));
- deepcopy_VkSamplerCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkSamplerCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkSamplerCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkSamplerCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkSamplerCreateInfo(sResourceTracker, (VkSamplerCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkSamplerCreateInfo(sResourceTracker,
+ (VkSamplerCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSamplerCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSamplerCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkSamplerCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSamplerCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
uint32_t packetSize_vkCreateSampler = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateSampler);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateSampler);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateSampler = OP_vkCreateSampler;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateSampler, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateSampler, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateSampler, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateSampler, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSamplerCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSamplerCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkSamplerCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSamplerCreateInfo*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -5871,9 +8032,9 @@
stream->unsetHandleMapping();
VkResult vkCreateSampler_VkResult_return = (VkResult)0;
stream->read(&vkCreateSampler_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -5881,14 +8042,35 @@
return vkCreateSampler_VkResult_return;
}
-void VkEncoder::vkDestroySampler(
- VkDevice device,
- VkSampler sampler,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroySampler(VkDevice device, VkSampler sampler,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroySampler in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroySampler(device:%p, sampler:%p, pAllocator:%p)", device, sampler,
+ pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -5898,15 +8080,15 @@
local_device = device;
local_sampler = sampler;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -5917,19 +8099,27 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
uint32_t packetSize_vkDestroySampler = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroySampler);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroySampler);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroySampler = OP_vkDestroySampler;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroySampler, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroySampler, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroySampler, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroySampler, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -5943,30 +8133,55 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkSampler((VkSampler*)&sampler);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkCreateDescriptorSetLayout(
- VkDevice device,
- const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDescriptorSetLayout* pSetLayout,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateDescriptorSetLayout(VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorSetLayout* pSetLayout,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateDescriptorSetLayout in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateDescriptorSetLayout(device:%p, pCreateInfo:%p, pAllocator:%p, pSetLayout:%p)",
+ device, pCreateInfo, pAllocator, pSetLayout);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -5975,62 +8190,78 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkDescriptorSetLayoutCreateInfo*)pool->alloc(sizeof(const VkDescriptorSetLayoutCreateInfo));
- deepcopy_VkDescriptorSetLayoutCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkDescriptorSetLayoutCreateInfo*)pool->alloc(
+ sizeof(const VkDescriptorSetLayoutCreateInfo));
+ deepcopy_VkDescriptorSetLayoutCreateInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkDescriptorSetLayoutCreateInfo(sResourceTracker, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkDescriptorSetLayoutCreateInfo(
+ sResourceTracker, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDescriptorSetLayoutCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkDescriptorSetLayoutCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo),
+ countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateDescriptorSetLayout = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateDescriptorSetLayout =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateDescriptorSetLayout);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateDescriptorSetLayout);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateDescriptorSetLayout = OP_vkCreateDescriptorSetLayout;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateDescriptorSetLayout, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateDescriptorSetLayout, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateDescriptorSetLayout, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateDescriptorSetLayout, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDescriptorSetLayoutCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkDescriptorSetLayoutCreateInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -6041,13 +8272,14 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(&cgen_var_3, (VkDescriptorSetLayout*)pSetLayout, 1);
+ stream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(
+ &cgen_var_3, (VkDescriptorSetLayout*)pSetLayout, 1);
stream->unsetHandleMapping();
VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
stream->read(&vkCreateDescriptorSetLayout_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -6055,14 +8287,38 @@
return vkCreateDescriptorSetLayout_VkResult_return;
}
-void VkEncoder::vkDestroyDescriptorSetLayout(
- VkDevice device,
- VkDescriptorSetLayout descriptorSetLayout,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyDescriptorSetLayout(VkDevice device,
+ VkDescriptorSetLayout descriptorSetLayout,
+ const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyDescriptorSetLayout in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkDestroyDescriptorSetLayout(device:%p, descriptorSetLayout:%p, pAllocator:%p)", device,
+ descriptorSetLayout, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -6072,15 +8328,15 @@
local_device = device;
local_descriptorSetLayout = descriptorSetLayout;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -6091,19 +8347,29 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyDescriptorSetLayout = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyDescriptorSetLayout =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkDestroyDescriptorSetLayout);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyDescriptorSetLayout);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyDescriptorSetLayout = OP_vkDestroyDescriptorSetLayout;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyDescriptorSetLayout, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyDescriptorSetLayout, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyDescriptorSetLayout, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyDescriptorSetLayout, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -6117,30 +8383,55 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
- sResourceTracker->destroyMapping()->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)&descriptorSetLayout);
+ sResourceTracker->destroyMapping()->mapHandles_VkDescriptorSetLayout(
+ (VkDescriptorSetLayout*)&descriptorSetLayout);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkCreateDescriptorPool(
- VkDevice device,
- const VkDescriptorPoolCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDescriptorPool* pDescriptorPool,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateDescriptorPool(VkDevice device,
+ const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorPool* pDescriptorPool, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateDescriptorPool in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateDescriptorPool(device:%p, pCreateInfo:%p, pAllocator:%p, pDescriptorPool:%p)",
+ device, pCreateInfo, pAllocator, pDescriptorPool);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -6149,62 +8440,77 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkDescriptorPoolCreateInfo*)pool->alloc(sizeof(const VkDescriptorPoolCreateInfo));
- deepcopy_VkDescriptorPoolCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDescriptorPoolCreateInfo*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkDescriptorPoolCreateInfo*)pool->alloc(sizeof(const VkDescriptorPoolCreateInfo));
+ deepcopy_VkDescriptorPoolCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkDescriptorPoolCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkDescriptorPoolCreateInfo(sResourceTracker, (VkDescriptorPoolCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkDescriptorPoolCreateInfo(
+ sResourceTracker, (VkDescriptorPoolCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDescriptorPoolCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorPoolCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkDescriptorPoolCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorPoolCreateInfo*)(local_pCreateInfo),
+ countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateDescriptorPool = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateDescriptorPool =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateDescriptorPool);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateDescriptorPool);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateDescriptorPool = OP_vkCreateDescriptorPool;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateDescriptorPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateDescriptorPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateDescriptorPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateDescriptorPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDescriptorPoolCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorPoolCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkDescriptorPoolCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorPoolCreateInfo*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -6215,13 +8521,14 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkDescriptorPool(&cgen_var_3, (VkDescriptorPool*)pDescriptorPool, 1);
+ stream->handleMapping()->mapHandles_u64_VkDescriptorPool(&cgen_var_3,
+ (VkDescriptorPool*)pDescriptorPool, 1);
stream->unsetHandleMapping();
VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0;
stream->read(&vkCreateDescriptorPool_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -6229,14 +8536,35 @@
return vkCreateDescriptorPool_VkResult_return;
}
-void VkEncoder::vkDestroyDescriptorPool(
- VkDevice device,
- VkDescriptorPool descriptorPool,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyDescriptorPool in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyDescriptorPool(device:%p, descriptorPool:%p, pAllocator:%p)",
+ device, descriptorPool, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -6246,15 +8574,15 @@
local_device = device;
local_descriptorPool = descriptorPool;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -6265,19 +8593,28 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyDescriptorPool = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyDescriptorPool =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyDescriptorPool);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyDescriptorPool);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyDescriptorPool = OP_vkDestroyDescriptorPool;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyDescriptorPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyDescriptorPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyDescriptorPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyDescriptorPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -6291,29 +8628,52 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
- sResourceTracker->destroyMapping()->mapHandles_VkDescriptorPool((VkDescriptorPool*)&descriptorPool);
+ sResourceTracker->destroyMapping()->mapHandles_VkDescriptorPool(
+ (VkDescriptorPool*)&descriptorPool);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkResetDescriptorPool(
- VkDevice device,
- VkDescriptorPool descriptorPool,
- VkDescriptorPoolResetFlags flags,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+ VkDescriptorPoolResetFlags flags, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkResetDescriptorPool in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkResetDescriptorPool(device:%p, descriptorPool:%p, flags:%d)", device,
+ descriptorPool, flags);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -6332,14 +8692,23 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkDescriptorPoolResetFlags);
}
- uint32_t packetSize_vkResetDescriptorPool = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkResetDescriptorPool =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkResetDescriptorPool);
uint8_t* streamPtr = stream->reserve(packetSize_vkResetDescriptorPool);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkResetDescriptorPool = OP_vkResetDescriptorPool;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkResetDescriptorPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkResetDescriptorPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkResetDescriptorPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkResetDescriptorPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -6348,13 +8717,14 @@
*&cgen_var_1 = get_host_u64_VkDescriptorPool((*&local_descriptorPool));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- memcpy(*streamPtrPtr, (VkDescriptorPoolResetFlags*)&local_flags, sizeof(VkDescriptorPoolResetFlags));
+ memcpy(*streamPtrPtr, (VkDescriptorPoolResetFlags*)&local_flags,
+ sizeof(VkDescriptorPoolResetFlags));
*streamPtrPtr += sizeof(VkDescriptorPoolResetFlags);
VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0;
stream->read(&vkResetDescriptorPool_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -6362,14 +8732,36 @@
return vkResetDescriptorPool_VkResult_return;
}
-VkResult VkEncoder::vkAllocateDescriptorSets(
- VkDevice device,
- const VkDescriptorSetAllocateInfo* pAllocateInfo,
- VkDescriptorSet* pDescriptorSets,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkAllocateDescriptorSets(VkDevice device,
+ const VkDescriptorSetAllocateInfo* pAllocateInfo,
+ VkDescriptorSet* pDescriptorSets, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkAllocateDescriptorSets in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkAllocateDescriptorSets(device:%p, pAllocateInfo:%p, pDescriptorSets:%p)",
+ device, pAllocateInfo, pDescriptorSets);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -6377,45 +8769,56 @@
VkDescriptorSetAllocateInfo* local_pAllocateInfo;
local_device = device;
local_pAllocateInfo = nullptr;
- if (pAllocateInfo)
- {
- local_pAllocateInfo = (VkDescriptorSetAllocateInfo*)pool->alloc(sizeof(const VkDescriptorSetAllocateInfo));
- deepcopy_VkDescriptorSetAllocateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocateInfo, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo));
+ if (pAllocateInfo) {
+ local_pAllocateInfo =
+ (VkDescriptorSetAllocateInfo*)pool->alloc(sizeof(const VkDescriptorSetAllocateInfo));
+ deepcopy_VkDescriptorSetAllocateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocateInfo,
+ (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo));
}
- if (local_pAllocateInfo)
- {
- transform_tohost_VkDescriptorSetAllocateInfo(sResourceTracker, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo));
+ if (local_pAllocateInfo) {
+ transform_tohost_VkDescriptorSetAllocateInfo(
+ sResourceTracker, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDescriptorSetAllocateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo), countPtr);
- if (pAllocateInfo->descriptorSetCount)
- {
+ count_VkDescriptorSetAllocateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo),
+ countPtr);
+ if (pAllocateInfo->descriptorSetCount) {
*countPtr += pAllocateInfo->descriptorSetCount * 8;
}
}
- uint32_t packetSize_vkAllocateDescriptorSets = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkAllocateDescriptorSets =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkAllocateDescriptorSets);
uint8_t* streamPtr = stream->reserve(packetSize_vkAllocateDescriptorSets);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkAllocateDescriptorSets = OP_vkAllocateDescriptorSets;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkAllocateDescriptorSets, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkAllocateDescriptorSets, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkAllocateDescriptorSets, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkAllocateDescriptorSets, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDescriptorSetAllocateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo), streamPtrPtr);
+ reservedmarshal_VkDescriptorSetAllocateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorSetAllocateInfo*)(local_pAllocateInfo),
+ streamPtrPtr);
/* is handle, possibly out */;
- if (pAllocateInfo->descriptorSetCount)
- {
+ if (pAllocateInfo->descriptorSetCount) {
uint8_t* cgen_var_1_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < pAllocateInfo->descriptorSetCount; ++k)
- {
+ for (uint32_t k = 0; k < pAllocateInfo->descriptorSetCount; ++k) {
uint64_t tmpval = (uint64_t)(pDescriptorSets[k]);
memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -6423,19 +8826,19 @@
}
/* is handle, possibly out */;
stream->setHandleMapping(sResourceTracker->createMapping());
- if (pAllocateInfo->descriptorSetCount)
- {
+ if (pAllocateInfo->descriptorSetCount) {
uint64_t* cgen_var_2;
stream->alloc((void**)&cgen_var_2, pAllocateInfo->descriptorSetCount * 8);
stream->read((uint64_t*)cgen_var_2, pAllocateInfo->descriptorSetCount * 8);
- stream->handleMapping()->mapHandles_u64_VkDescriptorSet(cgen_var_2, (VkDescriptorSet*)pDescriptorSets, pAllocateInfo->descriptorSetCount);
+ stream->handleMapping()->mapHandles_u64_VkDescriptorSet(
+ cgen_var_2, (VkDescriptorSet*)pDescriptorSets, pAllocateInfo->descriptorSetCount);
}
stream->unsetHandleMapping();
VkResult vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
stream->read(&vkAllocateDescriptorSets_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -6443,15 +8846,38 @@
return vkAllocateDescriptorSets_VkResult_return;
}
-VkResult VkEncoder::vkFreeDescriptorSets(
- VkDevice device,
- VkDescriptorPool descriptorPool,
- uint32_t descriptorSetCount,
- const VkDescriptorSet* pDescriptorSets,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkFreeDescriptorSets in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkFreeDescriptorSets(device:%p, descriptorPool:%p, descriptorSetCount:%d, "
+ "pDescriptorSets:%p)",
+ device, descriptorPool, descriptorSetCount, pDescriptorSets);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -6474,22 +8900,29 @@
*countPtr += sizeof(uint32_t);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pDescriptorSets)
- {
- if (((descriptorSetCount)))
- {
+ if (local_pDescriptorSets) {
+ if (((descriptorSetCount))) {
*countPtr += ((descriptorSetCount)) * 8;
}
}
}
- uint32_t packetSize_vkFreeDescriptorSets = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkFreeDescriptorSets =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkFreeDescriptorSets);
uint8_t* streamPtr = stream->reserve(packetSize_vkFreeDescriptorSets);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkFreeDescriptorSets = OP_vkFreeDescriptorSets;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkFreeDescriptorSets, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkFreeDescriptorSets, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkFreeDescriptorSets, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkFreeDescriptorSets, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -6505,13 +8938,10 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pDescriptorSets)
- {
- if (((descriptorSetCount)))
- {
+ if (local_pDescriptorSets) {
+ if (((descriptorSetCount))) {
uint8_t* cgen_var_2_0_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((descriptorSetCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((descriptorSetCount)); ++k) {
uint64_t tmpval = get_host_u64_VkDescriptorSet(local_pDescriptorSets[k]);
memcpy(cgen_var_2_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -6520,13 +8950,13 @@
}
VkResult vkFreeDescriptorSets_VkResult_return = (VkResult)0;
stream->read(&vkFreeDescriptorSets_VkResult_return, sizeof(VkResult));
- if (pDescriptorSets)
- {
- sResourceTracker->destroyMapping()->mapHandles_VkDescriptorSet((VkDescriptorSet*)pDescriptorSets, ((descriptorSetCount)));
+ if (pDescriptorSets) {
+ sResourceTracker->destroyMapping()->mapHandles_VkDescriptorSet(
+ (VkDescriptorSet*)pDescriptorSets, ((descriptorSetCount)));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -6534,16 +8964,40 @@
return vkFreeDescriptorSets_VkResult_return;
}
-void VkEncoder::vkUpdateDescriptorSets(
- VkDevice device,
- uint32_t descriptorWriteCount,
- const VkWriteDescriptorSet* pDescriptorWrites,
- uint32_t descriptorCopyCount,
- const VkCopyDescriptorSet* pDescriptorCopies,
- uint32_t doLock)
-{
+void VkEncoder::vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites,
+ uint32_t descriptorCopyCount,
+ const VkCopyDescriptorSet* pDescriptorCopies,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkUpdateDescriptorSets in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkUpdateDescriptorSets(device:%p, descriptorWriteCount:%d, pDescriptorWrites:%p, "
+ "descriptorCopyCount:%d, pDescriptorCopies:%p)",
+ device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -6555,36 +9009,34 @@
local_device = device;
local_descriptorWriteCount = descriptorWriteCount;
local_pDescriptorWrites = nullptr;
- if (pDescriptorWrites)
- {
- local_pDescriptorWrites = (VkWriteDescriptorSet*)pool->alloc(((descriptorWriteCount)) * sizeof(const VkWriteDescriptorSet));
- for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
- {
- deepcopy_VkWriteDescriptorSet(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDescriptorWrites + i, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
+ if (pDescriptorWrites) {
+ local_pDescriptorWrites = (VkWriteDescriptorSet*)pool->alloc(
+ ((descriptorWriteCount)) * sizeof(const VkWriteDescriptorSet));
+ for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i) {
+ deepcopy_VkWriteDescriptorSet(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDescriptorWrites + i,
+ (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
}
}
local_descriptorCopyCount = descriptorCopyCount;
local_pDescriptorCopies = nullptr;
- if (pDescriptorCopies)
- {
- local_pDescriptorCopies = (VkCopyDescriptorSet*)pool->alloc(((descriptorCopyCount)) * sizeof(const VkCopyDescriptorSet));
- for (uint32_t i = 0; i < (uint32_t)((descriptorCopyCount)); ++i)
- {
- deepcopy_VkCopyDescriptorSet(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDescriptorCopies + i, (VkCopyDescriptorSet*)(local_pDescriptorCopies + i));
+ if (pDescriptorCopies) {
+ local_pDescriptorCopies = (VkCopyDescriptorSet*)pool->alloc(
+ ((descriptorCopyCount)) * sizeof(const VkCopyDescriptorSet));
+ for (uint32_t i = 0; i < (uint32_t)((descriptorCopyCount)); ++i) {
+ deepcopy_VkCopyDescriptorSet(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDescriptorCopies + i,
+ (VkCopyDescriptorSet*)(local_pDescriptorCopies + i));
}
}
- if (local_pDescriptorWrites)
- {
- for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
- {
- transform_tohost_VkWriteDescriptorSet(sResourceTracker, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
+ if (local_pDescriptorWrites) {
+ for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i) {
+ transform_tohost_VkWriteDescriptorSet(
+ sResourceTracker, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
}
}
- if (local_pDescriptorCopies)
- {
- for (uint32_t i = 0; i < (uint32_t)((descriptorCopyCount)); ++i)
- {
- transform_tohost_VkCopyDescriptorSet(sResourceTracker, (VkCopyDescriptorSet*)(local_pDescriptorCopies + i));
+ if (local_pDescriptorCopies) {
+ for (uint32_t i = 0; i < (uint32_t)((descriptorCopyCount)); ++i) {
+ transform_tohost_VkCopyDescriptorSet(
+ sResourceTracker, (VkCopyDescriptorSet*)(local_pDescriptorCopies + i));
}
}
size_t count = 0;
@@ -6593,59 +9045,94 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
- {
- count_VkWriteDescriptorSet(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i) {
+ count_VkWriteDescriptorSet(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkWriteDescriptorSet*)(local_pDescriptorWrites + i),
+ countPtr);
}
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((descriptorCopyCount)); ++i)
- {
- count_VkCopyDescriptorSet(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyDescriptorSet*)(local_pDescriptorCopies + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((descriptorCopyCount)); ++i) {
+ count_VkCopyDescriptorSet(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyDescriptorSet*)(local_pDescriptorCopies + i),
+ countPtr);
}
}
- uint32_t packetSize_vkUpdateDescriptorSets = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkUpdateDescriptorSets =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkUpdateDescriptorSets);
uint8_t* streamPtr = stream->reserve(packetSize_vkUpdateDescriptorSets);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkUpdateDescriptorSets = OP_vkUpdateDescriptorSets;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkUpdateDescriptorSets, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkUpdateDescriptorSets, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkUpdateDescriptorSets, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkUpdateDescriptorSets, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_descriptorWriteCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
- {
- reservedmarshal_VkWriteDescriptorSet(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i) {
+ reservedmarshal_VkWriteDescriptorSet(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkWriteDescriptorSet*)(local_pDescriptorWrites + i),
+ streamPtrPtr);
}
memcpy(*streamPtrPtr, (uint32_t*)&local_descriptorCopyCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((descriptorCopyCount)); ++i)
- {
- reservedmarshal_VkCopyDescriptorSet(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyDescriptorSet*)(local_pDescriptorCopies + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((descriptorCopyCount)); ++i) {
+ reservedmarshal_VkCopyDescriptorSet(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyDescriptorSet*)(local_pDescriptorCopies + i),
+ streamPtrPtr);
}
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkCreateFramebuffer(
- VkDevice device,
- const VkFramebufferCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkFramebuffer* pFramebuffer,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFramebuffer* pFramebuffer, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateFramebuffer in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateFramebuffer(device:%p, pCreateInfo:%p, pAllocator:%p, pFramebuffer:%p)", device,
+ pCreateInfo, pAllocator, pFramebuffer);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -6654,62 +9141,76 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkFramebufferCreateInfo*)pool->alloc(sizeof(const VkFramebufferCreateInfo));
- deepcopy_VkFramebufferCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkFramebufferCreateInfo*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkFramebufferCreateInfo*)pool->alloc(sizeof(const VkFramebufferCreateInfo));
+ deepcopy_VkFramebufferCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkFramebufferCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkFramebufferCreateInfo(sResourceTracker, (VkFramebufferCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkFramebufferCreateInfo(sResourceTracker,
+ (VkFramebufferCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkFramebufferCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFramebufferCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkFramebufferCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkFramebufferCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateFramebuffer = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateFramebuffer =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateFramebuffer);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateFramebuffer);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateFramebuffer = OP_vkCreateFramebuffer;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateFramebuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateFramebuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateFramebuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateFramebuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkFramebufferCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFramebufferCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkFramebufferCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkFramebufferCreateInfo*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -6720,13 +9221,14 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_3, (VkFramebuffer*)pFramebuffer, 1);
+ stream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_3, (VkFramebuffer*)pFramebuffer,
+ 1);
stream->unsetHandleMapping();
VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0;
stream->read(&vkCreateFramebuffer_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -6734,14 +9236,35 @@
return vkCreateFramebuffer_VkResult_return;
}
-void VkEncoder::vkDestroyFramebuffer(
- VkDevice device,
- VkFramebuffer framebuffer,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyFramebuffer in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyFramebuffer(device:%p, framebuffer:%p, pAllocator:%p)", device,
+ framebuffer, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -6751,15 +9274,15 @@
local_device = device;
local_framebuffer = framebuffer;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -6770,19 +9293,28 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyFramebuffer = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyFramebuffer =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyFramebuffer);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyFramebuffer);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyFramebuffer = OP_vkDestroyFramebuffer;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyFramebuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyFramebuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyFramebuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyFramebuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -6796,30 +9328,53 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkFramebuffer((VkFramebuffer*)&framebuffer);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkCreateRenderPass(
- VkDevice device,
- const VkRenderPassCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateRenderPass in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateRenderPass(device:%p, pCreateInfo:%p, pAllocator:%p, pRenderPass:%p)", device,
+ pCreateInfo, pAllocator, pRenderPass);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -6828,62 +9383,76 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkRenderPassCreateInfo*)pool->alloc(sizeof(const VkRenderPassCreateInfo));
- deepcopy_VkRenderPassCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkRenderPassCreateInfo*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkRenderPassCreateInfo*)pool->alloc(sizeof(const VkRenderPassCreateInfo));
+ deepcopy_VkRenderPassCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkRenderPassCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkRenderPassCreateInfo(sResourceTracker, (VkRenderPassCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkRenderPassCreateInfo(sResourceTracker,
+ (VkRenderPassCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkRenderPassCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRenderPassCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkRenderPassCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderPassCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateRenderPass = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateRenderPass =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateRenderPass);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateRenderPass);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateRenderPass = OP_vkCreateRenderPass;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateRenderPass, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateRenderPass, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateRenderPass, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateRenderPass, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkRenderPassCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRenderPassCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkRenderPassCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderPassCreateInfo*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -6894,13 +9463,14 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_3, (VkRenderPass*)pRenderPass, 1);
+ stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_3, (VkRenderPass*)pRenderPass,
+ 1);
stream->unsetHandleMapping();
VkResult vkCreateRenderPass_VkResult_return = (VkResult)0;
stream->read(&vkCreateRenderPass_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -6908,14 +9478,35 @@
return vkCreateRenderPass_VkResult_return;
}
-void VkEncoder::vkDestroyRenderPass(
- VkDevice device,
- VkRenderPass renderPass,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyRenderPass in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyRenderPass(device:%p, renderPass:%p, pAllocator:%p)", device,
+ renderPass, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -6925,15 +9516,15 @@
local_device = device;
local_renderPass = renderPass;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -6944,19 +9535,28 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyRenderPass = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyRenderPass =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyRenderPass);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyRenderPass);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyRenderPass = OP_vkDestroyRenderPass;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyRenderPass, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyRenderPass, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyRenderPass, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyRenderPass, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -6970,29 +9570,51 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkRenderPass((VkRenderPass*)&renderPass);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkGetRenderAreaGranularity(
- VkDevice device,
- VkRenderPass renderPass,
- VkExtent2D* pGranularity,
- uint32_t doLock)
-{
+void VkEncoder::vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
+ VkExtent2D* pGranularity, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetRenderAreaGranularity in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetRenderAreaGranularity(device:%p, renderPass:%p, pGranularity:%p)",
+ device, renderPass, pGranularity);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -7007,16 +9629,26 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkExtent2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pGranularity), countPtr);
+ count_VkExtent2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pGranularity),
+ countPtr);
}
- uint32_t packetSize_vkGetRenderAreaGranularity = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetRenderAreaGranularity =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetRenderAreaGranularity);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetRenderAreaGranularity);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetRenderAreaGranularity = OP_vkGetRenderAreaGranularity;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetRenderAreaGranularity, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetRenderAreaGranularity, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetRenderAreaGranularity, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetRenderAreaGranularity, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -7025,30 +9657,52 @@
*&cgen_var_1 = get_host_u64_VkRenderPass((*&local_renderPass));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkExtent2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pGranularity), streamPtrPtr);
+ reservedmarshal_VkExtent2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pGranularity),
+ streamPtrPtr);
unmarshal_VkExtent2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pGranularity));
- if (pGranularity)
- {
+ if (pGranularity) {
transform_fromhost_VkExtent2D(sResourceTracker, (VkExtent2D*)(pGranularity));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkCreateCommandPool(
- VkDevice device,
- const VkCommandPoolCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkCommandPool* pCommandPool,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCommandPool* pCommandPool, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateCommandPool in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateCommandPool(device:%p, pCreateInfo:%p, pAllocator:%p, pCommandPool:%p)", device,
+ pCreateInfo, pAllocator, pCommandPool);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -7057,62 +9711,76 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkCommandPoolCreateInfo*)pool->alloc(sizeof(const VkCommandPoolCreateInfo));
- deepcopy_VkCommandPoolCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkCommandPoolCreateInfo*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkCommandPoolCreateInfo*)pool->alloc(sizeof(const VkCommandPoolCreateInfo));
+ deepcopy_VkCommandPoolCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkCommandPoolCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkCommandPoolCreateInfo(sResourceTracker, (VkCommandPoolCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkCommandPoolCreateInfo(sResourceTracker,
+ (VkCommandPoolCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCommandPoolCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCommandPoolCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkCommandPoolCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCommandPoolCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateCommandPool = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateCommandPool =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateCommandPool);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateCommandPool);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateCommandPool = OP_vkCreateCommandPool;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateCommandPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateCommandPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateCommandPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateCommandPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkCommandPoolCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCommandPoolCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkCommandPoolCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCommandPoolCreateInfo*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -7123,13 +9791,14 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkCommandPool(&cgen_var_3, (VkCommandPool*)pCommandPool, 1);
+ stream->handleMapping()->mapHandles_u64_VkCommandPool(&cgen_var_3, (VkCommandPool*)pCommandPool,
+ 1);
stream->unsetHandleMapping();
VkResult vkCreateCommandPool_VkResult_return = (VkResult)0;
stream->read(&vkCreateCommandPool_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -7137,14 +9806,35 @@
return vkCreateCommandPool_VkResult_return;
}
-void VkEncoder::vkDestroyCommandPool(
- VkDevice device,
- VkCommandPool commandPool,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyCommandPool in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyCommandPool(device:%p, commandPool:%p, pAllocator:%p)", device,
+ commandPool, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -7154,15 +9844,15 @@
local_device = device;
local_commandPool = commandPool;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -7173,19 +9863,28 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyCommandPool = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyCommandPool =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyCommandPool);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyCommandPool);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyCommandPool = OP_vkDestroyCommandPool;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyCommandPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyCommandPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyCommandPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyCommandPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -7199,29 +9898,51 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkCommandPool((VkCommandPool*)&commandPool);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkResetCommandPool(
- VkDevice device,
- VkCommandPool commandPool,
- VkCommandPoolResetFlags flags,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkResetCommandPool(VkDevice device, VkCommandPool commandPool,
+ VkCommandPoolResetFlags flags, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkResetCommandPool in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkResetCommandPool(device:%p, commandPool:%p, flags:%d)", device,
+ commandPool, flags);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -7240,14 +9961,23 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkCommandPoolResetFlags);
}
- uint32_t packetSize_vkResetCommandPool = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkResetCommandPool =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkResetCommandPool);
uint8_t* streamPtr = stream->reserve(packetSize_vkResetCommandPool);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkResetCommandPool = OP_vkResetCommandPool;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkResetCommandPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkResetCommandPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkResetCommandPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkResetCommandPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -7260,9 +9990,9 @@
*streamPtrPtr += sizeof(VkCommandPoolResetFlags);
VkResult vkResetCommandPool_VkResult_return = (VkResult)0;
stream->read(&vkResetCommandPool_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -7270,14 +10000,36 @@
return vkResetCommandPool_VkResult_return;
}
-VkResult VkEncoder::vkAllocateCommandBuffers(
- VkDevice device,
- const VkCommandBufferAllocateInfo* pAllocateInfo,
- VkCommandBuffer* pCommandBuffers,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkAllocateCommandBuffers(VkDevice device,
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkAllocateCommandBuffers in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkAllocateCommandBuffers(device:%p, pAllocateInfo:%p, pCommandBuffers:%p)",
+ device, pAllocateInfo, pCommandBuffers);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -7285,45 +10037,56 @@
VkCommandBufferAllocateInfo* local_pAllocateInfo;
local_device = device;
local_pAllocateInfo = nullptr;
- if (pAllocateInfo)
- {
- local_pAllocateInfo = (VkCommandBufferAllocateInfo*)pool->alloc(sizeof(const VkCommandBufferAllocateInfo));
- deepcopy_VkCommandBufferAllocateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocateInfo, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo));
+ if (pAllocateInfo) {
+ local_pAllocateInfo =
+ (VkCommandBufferAllocateInfo*)pool->alloc(sizeof(const VkCommandBufferAllocateInfo));
+ deepcopy_VkCommandBufferAllocateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocateInfo,
+ (VkCommandBufferAllocateInfo*)(local_pAllocateInfo));
}
- if (local_pAllocateInfo)
- {
- transform_tohost_VkCommandBufferAllocateInfo(sResourceTracker, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo));
+ if (local_pAllocateInfo) {
+ transform_tohost_VkCommandBufferAllocateInfo(
+ sResourceTracker, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCommandBufferAllocateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo), countPtr);
- if (pAllocateInfo->commandBufferCount)
- {
+ count_VkCommandBufferAllocateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCommandBufferAllocateInfo*)(local_pAllocateInfo),
+ countPtr);
+ if (pAllocateInfo->commandBufferCount) {
*countPtr += pAllocateInfo->commandBufferCount * 8;
}
}
- uint32_t packetSize_vkAllocateCommandBuffers = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkAllocateCommandBuffers =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkAllocateCommandBuffers);
uint8_t* streamPtr = stream->reserve(packetSize_vkAllocateCommandBuffers);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkAllocateCommandBuffers = OP_vkAllocateCommandBuffers;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkAllocateCommandBuffers, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkAllocateCommandBuffers, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkAllocateCommandBuffers, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkAllocateCommandBuffers, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkCommandBufferAllocateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCommandBufferAllocateInfo*)(local_pAllocateInfo), streamPtrPtr);
+ reservedmarshal_VkCommandBufferAllocateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCommandBufferAllocateInfo*)(local_pAllocateInfo),
+ streamPtrPtr);
/* is handle, possibly out */;
- if (pAllocateInfo->commandBufferCount)
- {
+ if (pAllocateInfo->commandBufferCount) {
uint8_t* cgen_var_1_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < pAllocateInfo->commandBufferCount; ++k)
- {
+ for (uint32_t k = 0; k < pAllocateInfo->commandBufferCount; ++k) {
uint64_t tmpval = (uint64_t)(pCommandBuffers[k]);
memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -7331,19 +10094,19 @@
}
/* is handle, possibly out */;
stream->setHandleMapping(sResourceTracker->createMapping());
- if (pAllocateInfo->commandBufferCount)
- {
+ if (pAllocateInfo->commandBufferCount) {
uint64_t* cgen_var_2;
stream->alloc((void**)&cgen_var_2, pAllocateInfo->commandBufferCount * 8);
stream->read((uint64_t*)cgen_var_2, pAllocateInfo->commandBufferCount * 8);
- stream->handleMapping()->mapHandles_u64_VkCommandBuffer(cgen_var_2, (VkCommandBuffer*)pCommandBuffers, pAllocateInfo->commandBufferCount);
+ stream->handleMapping()->mapHandles_u64_VkCommandBuffer(
+ cgen_var_2, (VkCommandBuffer*)pCommandBuffers, pAllocateInfo->commandBufferCount);
}
stream->unsetHandleMapping();
VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
stream->read(&vkAllocateCommandBuffers_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -7351,15 +10114,38 @@
return vkAllocateCommandBuffers_VkResult_return;
}
-void VkEncoder::vkFreeCommandBuffers(
- VkDevice device,
- VkCommandPool commandPool,
- uint32_t commandBufferCount,
- const VkCommandBuffer* pCommandBuffers,
- uint32_t doLock)
-{
+void VkEncoder::vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkFreeCommandBuffers in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkFreeCommandBuffers(device:%p, commandPool:%p, commandBufferCount:%d, "
+ "pCommandBuffers:%p)",
+ device, commandPool, commandBufferCount, pCommandBuffers);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -7382,22 +10168,29 @@
*countPtr += sizeof(uint32_t);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pCommandBuffers)
- {
- if (((commandBufferCount)))
- {
+ if (local_pCommandBuffers) {
+ if (((commandBufferCount))) {
*countPtr += ((commandBufferCount)) * 8;
}
}
}
- uint32_t packetSize_vkFreeCommandBuffers = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkFreeCommandBuffers =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkFreeCommandBuffers);
uint8_t* streamPtr = stream->reserve(packetSize_vkFreeCommandBuffers);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkFreeCommandBuffers = OP_vkFreeCommandBuffers;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkFreeCommandBuffers, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkFreeCommandBuffers, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkFreeCommandBuffers, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkFreeCommandBuffers, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -7413,40 +10206,60 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pCommandBuffers)
- {
- if (((commandBufferCount)))
- {
+ if (local_pCommandBuffers) {
+ if (((commandBufferCount))) {
uint8_t* cgen_var_2_0_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((commandBufferCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((commandBufferCount)); ++k) {
uint64_t tmpval = get_host_u64_VkCommandBuffer(local_pCommandBuffers[k]);
memcpy(cgen_var_2_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
*streamPtrPtr += 8 * ((commandBufferCount));
}
}
- if (pCommandBuffers)
- {
- sResourceTracker->destroyMapping()->mapHandles_VkCommandBuffer((VkCommandBuffer*)pCommandBuffers, ((commandBufferCount)));
+ if (pCommandBuffers) {
+ sResourceTracker->destroyMapping()->mapHandles_VkCommandBuffer(
+ (VkCommandBuffer*)pCommandBuffers, ((commandBufferCount)));
}
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkBeginCommandBuffer(
- VkCommandBuffer commandBuffer,
- const VkCommandBufferBeginInfo* pBeginInfo,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkBeginCommandBuffer in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkBeginCommandBuffer(commandBuffer:%p, pBeginInfo:%p)", commandBuffer,
+ pBeginInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -7454,42 +10267,48 @@
VkCommandBufferBeginInfo* local_pBeginInfo;
local_commandBuffer = commandBuffer;
local_pBeginInfo = nullptr;
- if (pBeginInfo)
- {
- local_pBeginInfo = (VkCommandBufferBeginInfo*)pool->alloc(sizeof(const VkCommandBufferBeginInfo));
- deepcopy_VkCommandBufferBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBeginInfo, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
+ if (pBeginInfo) {
+ local_pBeginInfo =
+ (VkCommandBufferBeginInfo*)pool->alloc(sizeof(const VkCommandBufferBeginInfo));
+ deepcopy_VkCommandBufferBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBeginInfo,
+ (VkCommandBufferBeginInfo*)(local_pBeginInfo));
}
- if (local_pBeginInfo)
- {
- transform_tohost_VkCommandBufferBeginInfo(sResourceTracker, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
+ if (local_pBeginInfo) {
+ transform_tohost_VkCommandBufferBeginInfo(sResourceTracker,
+ (VkCommandBufferBeginInfo*)(local_pBeginInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCommandBufferBeginInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCommandBufferBeginInfo*)(local_pBeginInfo), countPtr);
+ count_VkCommandBufferBeginInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCommandBufferBeginInfo*)(local_pBeginInfo), countPtr);
}
uint32_t packetSize_vkBeginCommandBuffer = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkBeginCommandBuffer);
if (queueSubmitWithCommandsEnabled) packetSize_vkBeginCommandBuffer -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkBeginCommandBuffer);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkBeginCommandBuffer = OP_vkBeginCommandBuffer;
- memcpy(streamPtr, &opcode_vkBeginCommandBuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkBeginCommandBuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkBeginCommandBuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkBeginCommandBuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkCommandBufferBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCommandBufferBeginInfo*)(local_pBeginInfo), streamPtrPtr);
+ reservedmarshal_VkCommandBufferBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCommandBufferBeginInfo*)(local_pBeginInfo),
+ streamPtrPtr);
VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
stream->read(&vkBeginCommandBuffer_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -7497,12 +10316,33 @@
return vkBeginCommandBuffer_VkResult_return;
}
-VkResult VkEncoder::vkEndCommandBuffer(
- VkCommandBuffer commandBuffer,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkEndCommandBuffer(VkCommandBuffer commandBuffer, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkEndCommandBuffer in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkEndCommandBuffer(commandBuffer:%p)", commandBuffer);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -7515,14 +10355,16 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkEndCommandBuffer = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkEndCommandBuffer);
if (queueSubmitWithCommandsEnabled) packetSize_vkEndCommandBuffer -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkEndCommandBuffer);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkEndCommandBuffer = OP_vkEndCommandBuffer;
- memcpy(streamPtr, &opcode_vkEndCommandBuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkEndCommandBuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkEndCommandBuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkEndCommandBuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -7530,9 +10372,9 @@
}
VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
stream->read(&vkEndCommandBuffer_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -7540,13 +10382,34 @@
return vkEndCommandBuffer_VkResult_return;
}
-VkResult VkEncoder::vkResetCommandBuffer(
- VkCommandBuffer commandBuffer,
- VkCommandBufferResetFlags flags,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkResetCommandBuffer(VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkResetCommandBuffer in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkResetCommandBuffer(commandBuffer:%p, flags:%d)", commandBuffer, flags);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -7562,26 +10425,29 @@
*countPtr += sizeof(VkCommandBufferResetFlags);
}
uint32_t packetSize_vkResetCommandBuffer = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkResetCommandBuffer);
if (queueSubmitWithCommandsEnabled) packetSize_vkResetCommandBuffer -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkResetCommandBuffer);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkResetCommandBuffer = OP_vkResetCommandBuffer;
- memcpy(streamPtr, &opcode_vkResetCommandBuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkResetCommandBuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkResetCommandBuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkResetCommandBuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- memcpy(*streamPtrPtr, (VkCommandBufferResetFlags*)&local_flags, sizeof(VkCommandBufferResetFlags));
+ memcpy(*streamPtrPtr, (VkCommandBufferResetFlags*)&local_flags,
+ sizeof(VkCommandBufferResetFlags));
*streamPtrPtr += sizeof(VkCommandBufferResetFlags);
VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
stream->read(&vkResetCommandBuffer_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -7589,14 +10455,35 @@
return vkResetCommandBuffer_VkResult_return;
}
-void VkEncoder::vkCmdBindPipeline(
- VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipeline pipeline,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdBindPipeline(VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBindPipeline in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdBindPipeline(commandBuffer:%p, pipeline:%p)", commandBuffer, pipeline);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -7616,43 +10503,68 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkCmdBindPipeline = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBindPipeline);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBindPipeline -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBindPipeline);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBindPipeline = OP_vkCmdBindPipeline;
- memcpy(streamPtr, &opcode_vkCmdBindPipeline, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBindPipeline, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBindPipeline, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBindPipeline, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- memcpy(*streamPtrPtr, (VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ memcpy(*streamPtrPtr, (VkPipelineBindPoint*)&local_pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
*streamPtrPtr += sizeof(VkPipelineBindPoint);
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPipeline((*&local_pipeline));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetViewport(
- VkCommandBuffer commandBuffer,
- uint32_t firstViewport,
- uint32_t viewportCount,
- const VkViewport* pViewports,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
+ uint32_t viewportCount, const VkViewport* pViewports,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetViewport in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdSetViewport(commandBuffer:%p, firstViewport:%d, viewportCount:%d, pViewports:%p)",
+ commandBuffer, firstViewport, viewportCount, pViewports);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -7664,18 +10576,15 @@
local_firstViewport = firstViewport;
local_viewportCount = viewportCount;
local_pViewports = nullptr;
- if (pViewports)
- {
+ if (pViewports) {
local_pViewports = (VkViewport*)pool->alloc(((viewportCount)) * sizeof(const VkViewport));
- for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
- {
- deepcopy_VkViewport(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pViewports + i, (VkViewport*)(local_pViewports + i));
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+ deepcopy_VkViewport(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pViewports + i,
+ (VkViewport*)(local_pViewports + i));
}
}
- if (local_pViewports)
- {
- for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
- {
+ if (local_pViewports) {
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
transform_tohost_VkViewport(sResourceTracker, (VkViewport*)(local_pViewports + i));
}
}
@@ -7686,20 +10595,22 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
- {
- count_VkViewport(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkViewport*)(local_pViewports + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+ count_VkViewport(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkViewport*)(local_pViewports + i), countPtr);
}
}
uint32_t packetSize_vkCmdSetViewport = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetViewport);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetViewport -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetViewport);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetViewport = OP_vkCmdSetViewport;
- memcpy(streamPtr, &opcode_vkCmdSetViewport, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetViewport, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetViewport, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetViewport, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -7709,28 +10620,49 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_viewportCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
- {
- reservedmarshal_VkViewport(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkViewport*)(local_pViewports + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+ reservedmarshal_VkViewport(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkViewport*)(local_pViewports + i), streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetScissor(
- VkCommandBuffer commandBuffer,
- uint32_t firstScissor,
- uint32_t scissorCount,
- const VkRect2D* pScissors,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
+ uint32_t scissorCount, const VkRect2D* pScissors, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetScissor in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdSetScissor(commandBuffer:%p, firstScissor:%d, scissorCount:%d, pScissors:%p)",
+ commandBuffer, firstScissor, scissorCount, pScissors);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -7742,18 +10674,15 @@
local_firstScissor = firstScissor;
local_scissorCount = scissorCount;
local_pScissors = nullptr;
- if (pScissors)
- {
+ if (pScissors) {
local_pScissors = (VkRect2D*)pool->alloc(((scissorCount)) * sizeof(const VkRect2D));
- for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
- {
- deepcopy_VkRect2D(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pScissors + i, (VkRect2D*)(local_pScissors + i));
+ for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
+ deepcopy_VkRect2D(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pScissors + i,
+ (VkRect2D*)(local_pScissors + i));
}
}
- if (local_pScissors)
- {
- for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
- {
+ if (local_pScissors) {
+ for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
transform_tohost_VkRect2D(sResourceTracker, (VkRect2D*)(local_pScissors + i));
}
}
@@ -7764,20 +10693,22 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
- {
- count_VkRect2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(local_pScissors + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
+ count_VkRect2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRect2D*)(local_pScissors + i), countPtr);
}
}
uint32_t packetSize_vkCmdSetScissor = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetScissor);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetScissor -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetScissor);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetScissor = OP_vkCmdSetScissor;
- memcpy(streamPtr, &opcode_vkCmdSetScissor, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetScissor, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetScissor, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetScissor, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -7787,26 +10718,47 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_scissorCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
- {
- reservedmarshal_VkRect2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(local_pScissors + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
+ reservedmarshal_VkRect2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRect2D*)(local_pScissors + i), streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetLineWidth(
- VkCommandBuffer commandBuffer,
- float lineWidth,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetLineWidth in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetLineWidth(commandBuffer:%p, lineWidth:%f)", commandBuffer,
+ lineWidth);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -7822,14 +10774,16 @@
*countPtr += sizeof(float);
}
uint32_t packetSize_vkCmdSetLineWidth = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetLineWidth);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetLineWidth -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetLineWidth);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetLineWidth = OP_vkCmdSetLineWidth;
- memcpy(streamPtr, &opcode_vkCmdSetLineWidth, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetLineWidth, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetLineWidth, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetLineWidth, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -7837,24 +10791,47 @@
}
memcpy(*streamPtrPtr, (float*)&local_lineWidth, sizeof(float));
*streamPtrPtr += sizeof(float);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetDepthBias(
- VkCommandBuffer commandBuffer,
- float depthBiasConstantFactor,
- float depthBiasClamp,
- float depthBiasSlopeFactor,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
+ float depthBiasClamp, float depthBiasSlopeFactor,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetDepthBias in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdSetDepthBias(commandBuffer:%p, depthBiasConstantFactor:%f, depthBiasClamp:%f, "
+ "depthBiasSlopeFactor:%f)",
+ commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -7876,14 +10853,16 @@
*countPtr += sizeof(float);
}
uint32_t packetSize_vkCmdSetDepthBias = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetDepthBias);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDepthBias -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDepthBias);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetDepthBias = OP_vkCmdSetDepthBias;
- memcpy(streamPtr, &opcode_vkCmdSetDepthBias, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetDepthBias, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetDepthBias, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetDepthBias, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -7895,22 +10874,44 @@
*streamPtrPtr += sizeof(float);
memcpy(*streamPtrPtr, (float*)&local_depthBiasSlopeFactor, sizeof(float));
*streamPtrPtr += sizeof(float);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetBlendConstants(
- VkCommandBuffer commandBuffer,
- const float blendConstants[4],
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4],
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetBlendConstants in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetBlendConstants(commandBuffer:%p, blendConstants:%f)", commandBuffer,
+ blendConstants);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -7926,14 +10927,16 @@
*countPtr += 4 * sizeof(float);
}
uint32_t packetSize_vkCmdSetBlendConstants = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetBlendConstants);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetBlendConstants -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetBlendConstants);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetBlendConstants = OP_vkCmdSetBlendConstants;
- memcpy(streamPtr, &opcode_vkCmdSetBlendConstants, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetBlendConstants, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetBlendConstants, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetBlendConstants, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -7941,23 +10944,44 @@
}
memcpy(*streamPtrPtr, (float*)local_blendConstants, 4 * sizeof(float));
*streamPtrPtr += 4 * sizeof(float);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetDepthBounds(
- VkCommandBuffer commandBuffer,
- float minDepthBounds,
- float maxDepthBounds,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
+ float maxDepthBounds, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetDepthBounds in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetDepthBounds(commandBuffer:%p, minDepthBounds:%f, maxDepthBounds:%f)",
+ commandBuffer, minDepthBounds, maxDepthBounds);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -7976,14 +11000,16 @@
*countPtr += sizeof(float);
}
uint32_t packetSize_vkCmdSetDepthBounds = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetDepthBounds);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDepthBounds -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDepthBounds);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetDepthBounds = OP_vkCmdSetDepthBounds;
- memcpy(streamPtr, &opcode_vkCmdSetDepthBounds, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetDepthBounds, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetDepthBounds, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetDepthBounds, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -7993,23 +11019,45 @@
*streamPtrPtr += sizeof(float);
memcpy(*streamPtrPtr, (float*)&local_maxDepthBounds, sizeof(float));
*streamPtrPtr += sizeof(float);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetStencilCompareMask(
- VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask,
- uint32_t compareMask,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask, uint32_t compareMask,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetStencilCompareMask in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetStencilCompareMask(commandBuffer:%p, faceMask:%d, compareMask:%d)",
+ commandBuffer, faceMask, compareMask);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -8028,14 +11076,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdSetStencilCompareMask = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetStencilCompareMask);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetStencilCompareMask -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetStencilCompareMask);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetStencilCompareMask = OP_vkCmdSetStencilCompareMask;
- memcpy(streamPtr, &opcode_vkCmdSetStencilCompareMask, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetStencilCompareMask, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetStencilCompareMask, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetStencilCompareMask, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -8045,23 +11095,44 @@
*streamPtrPtr += sizeof(VkStencilFaceFlags);
memcpy(*streamPtrPtr, (uint32_t*)&local_compareMask, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetStencilWriteMask(
- VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask,
- uint32_t writeMask,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+ uint32_t writeMask, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetStencilWriteMask in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetStencilWriteMask(commandBuffer:%p, faceMask:%d, writeMask:%d)",
+ commandBuffer, faceMask, writeMask);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -8080,14 +11151,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdSetStencilWriteMask = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetStencilWriteMask);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetStencilWriteMask -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetStencilWriteMask);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetStencilWriteMask = OP_vkCmdSetStencilWriteMask;
- memcpy(streamPtr, &opcode_vkCmdSetStencilWriteMask, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetStencilWriteMask, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetStencilWriteMask, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetStencilWriteMask, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -8097,23 +11170,44 @@
*streamPtrPtr += sizeof(VkStencilFaceFlags);
memcpy(*streamPtrPtr, (uint32_t*)&local_writeMask, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetStencilReference(
- VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask,
- uint32_t reference,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+ uint32_t reference, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetStencilReference in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetStencilReference(commandBuffer:%p, faceMask:%d, reference:%d)",
+ commandBuffer, faceMask, reference);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -8132,14 +11226,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdSetStencilReference = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetStencilReference);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetStencilReference -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetStencilReference);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetStencilReference = OP_vkCmdSetStencilReference;
- memcpy(streamPtr, &opcode_vkCmdSetStencilReference, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetStencilReference, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetStencilReference, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetStencilReference, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -8149,9 +11245,9 @@
*streamPtrPtr += sizeof(VkStencilFaceFlags);
memcpy(*streamPtrPtr, (uint32_t*)&local_reference, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -8159,18 +11255,39 @@
}
void VkEncoder::vkCmdBindDescriptorSets(
- VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipelineLayout layout,
- uint32_t firstSet,
- uint32_t descriptorSetCount,
- const VkDescriptorSet* pDescriptorSets,
- uint32_t dynamicOffsetCount,
- const uint32_t* pDynamicOffsets,
- uint32_t doLock)
-{
+ VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
+ uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets,
+ uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBindDescriptorSets in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdBindDescriptorSets(commandBuffer:%p, layout:%p, firstSet:%d, descriptorSetCount:%d, "
+ "pDescriptorSets:%p, dynamicOffsetCount:%d, pDynamicOffsets:%p)",
+ commandBuffer, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount,
+ pDynamicOffsets);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -8202,28 +11319,30 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
*countPtr += sizeof(uint32_t);
- if (((descriptorSetCount)))
- {
+ if (((descriptorSetCount))) {
*countPtr += ((descriptorSetCount)) * 8;
}
*countPtr += sizeof(uint32_t);
*countPtr += ((dynamicOffsetCount)) * sizeof(uint32_t);
}
uint32_t packetSize_vkCmdBindDescriptorSets = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBindDescriptorSets);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBindDescriptorSets -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBindDescriptorSets);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBindDescriptorSets = OP_vkCmdBindDescriptorSets;
- memcpy(streamPtr, &opcode_vkCmdBindDescriptorSets, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBindDescriptorSets, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBindDescriptorSets, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBindDescriptorSets, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- memcpy(*streamPtrPtr, (VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ memcpy(*streamPtrPtr, (VkPipelineBindPoint*)&local_pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
*streamPtrPtr += sizeof(VkPipelineBindPoint);
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPipelineLayout((*&local_layout));
@@ -8233,11 +11352,9 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_descriptorSetCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (((descriptorSetCount)))
- {
+ if (((descriptorSetCount))) {
uint8_t* cgen_var_1_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((descriptorSetCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((descriptorSetCount)); ++k) {
uint64_t tmpval = get_host_u64_VkDescriptorSet(local_pDescriptorSets[k]);
memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -8245,26 +11362,47 @@
}
memcpy(*streamPtrPtr, (uint32_t*)&local_dynamicOffsetCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- memcpy(*streamPtrPtr, (uint32_t*)local_pDynamicOffsets, ((dynamicOffsetCount)) * sizeof(uint32_t));
+ memcpy(*streamPtrPtr, (uint32_t*)local_pDynamicOffsets,
+ ((dynamicOffsetCount)) * sizeof(uint32_t));
*streamPtrPtr += ((dynamicOffsetCount)) * sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdBindIndexBuffer(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkIndexType indexType,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkIndexType indexType, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBindIndexBuffer in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdBindIndexBuffer(commandBuffer:%p, buffer:%p, offset:%ld)",
+ commandBuffer, buffer, offset);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -8287,14 +11425,16 @@
*countPtr += sizeof(VkIndexType);
}
uint32_t packetSize_vkCmdBindIndexBuffer = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBindIndexBuffer);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBindIndexBuffer -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBindIndexBuffer);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBindIndexBuffer = OP_vkCmdBindIndexBuffer;
- memcpy(streamPtr, &opcode_vkCmdBindIndexBuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBindIndexBuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBindIndexBuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBindIndexBuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -8308,25 +11448,47 @@
*streamPtrPtr += sizeof(VkDeviceSize);
memcpy(*streamPtrPtr, (VkIndexType*)&local_indexType, sizeof(VkIndexType));
*streamPtrPtr += sizeof(VkIndexType);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdBindVertexBuffers(
- VkCommandBuffer commandBuffer,
- uint32_t firstBinding,
- uint32_t bindingCount,
- const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+ uint32_t bindingCount, const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBindVertexBuffers in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdBindVertexBuffers(commandBuffer:%p, firstBinding:%d, bindingCount:%d, pBuffers:%p, "
+ "pOffsets:%p)",
+ commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -8349,21 +11511,22 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
*countPtr += sizeof(uint32_t);
- if (((bindingCount)))
- {
+ if (((bindingCount))) {
*countPtr += ((bindingCount)) * 8;
}
*countPtr += ((bindingCount)) * sizeof(VkDeviceSize);
}
uint32_t packetSize_vkCmdBindVertexBuffers = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBindVertexBuffers);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBindVertexBuffers -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBindVertexBuffers);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBindVertexBuffers = OP_vkCmdBindVertexBuffers;
- memcpy(streamPtr, &opcode_vkCmdBindVertexBuffers, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBindVertexBuffers, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBindVertexBuffers, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBindVertexBuffers, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -8373,11 +11536,9 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_bindingCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (((bindingCount)))
- {
+ if (((bindingCount))) {
uint8_t* cgen_var_0_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((bindingCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((bindingCount)); ++k) {
uint64_t tmpval = get_host_u64_VkBuffer(local_pBuffers[k]);
memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -8385,25 +11546,47 @@
}
memcpy(*streamPtrPtr, (VkDeviceSize*)local_pOffsets, ((bindingCount)) * sizeof(VkDeviceSize));
*streamPtrPtr += ((bindingCount)) * sizeof(VkDeviceSize);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdDraw(
- VkCommandBuffer commandBuffer,
- uint32_t vertexCount,
- uint32_t instanceCount,
- uint32_t firstVertex,
- uint32_t firstInstance,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount,
+ uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDraw in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdDraw(commandBuffer:%p, vertexCount:%d, instanceCount:%d, firstVertex:%d, "
+ "firstInstance:%d)",
+ commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -8428,14 +11611,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDraw = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDraw);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDraw -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDraw);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDraw = OP_vkCmdDraw;
- memcpy(streamPtr, &opcode_vkCmdDraw, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDraw, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDraw, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDraw, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -8449,26 +11634,47 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_firstInstance, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdDrawIndexed(
- VkCommandBuffer commandBuffer,
- uint32_t indexCount,
- uint32_t instanceCount,
- uint32_t firstIndex,
- int32_t vertexOffset,
- uint32_t firstInstance,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
+ uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset,
+ uint32_t firstInstance, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDrawIndexed in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdDrawIndexed(commandBuffer:%p, indexCount:%d, instanceCount:%d, firstIndex:%d, "
+ "vertexOffset:%d, firstInstance:%d)",
+ commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -8496,14 +11702,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDrawIndexed = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDrawIndexed);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawIndexed -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawIndexed);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDrawIndexed = OP_vkCmdDrawIndexed;
- memcpy(streamPtr, &opcode_vkCmdDrawIndexed, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDrawIndexed, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDrawIndexed, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDrawIndexed, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -8519,25 +11727,46 @@
*streamPtrPtr += sizeof(int32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_firstInstance, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdDrawIndirect(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- uint32_t drawCount,
- uint32_t stride,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, uint32_t drawCount, uint32_t stride,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDrawIndirect in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdDrawIndirect(commandBuffer:%p, buffer:%p, offset:%ld, drawCount:%d, stride:%d)",
+ commandBuffer, buffer, offset, drawCount, stride);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -8563,14 +11792,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDrawIndirect = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDrawIndirect);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawIndirect -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawIndirect);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDrawIndirect = OP_vkCmdDrawIndirect;
- memcpy(streamPtr, &opcode_vkCmdDrawIndirect, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDrawIndirect, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDrawIndirect, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDrawIndirect, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -8586,25 +11817,47 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_stride, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdDrawIndexedIndirect(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- uint32_t drawCount,
- uint32_t stride,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, uint32_t drawCount, uint32_t stride,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDrawIndexedIndirect in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdDrawIndexedIndirect(commandBuffer:%p, buffer:%p, offset:%ld, drawCount:%d, "
+ "stride:%d)",
+ commandBuffer, buffer, offset, drawCount, stride);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -8630,14 +11883,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDrawIndexedIndirect = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDrawIndexedIndirect);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawIndexedIndirect -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawIndexedIndirect);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDrawIndexedIndirect = OP_vkCmdDrawIndexedIndirect;
- memcpy(streamPtr, &opcode_vkCmdDrawIndexedIndirect, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDrawIndexedIndirect, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDrawIndexedIndirect, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDrawIndexedIndirect, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -8653,24 +11908,45 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_stride, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdDispatch(
- VkCommandBuffer commandBuffer,
- uint32_t groupCountX,
- uint32_t groupCountY,
- uint32_t groupCountZ,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX,
+ uint32_t groupCountY, uint32_t groupCountZ, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDispatch in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdDispatch(commandBuffer:%p, groupCountX:%d, groupCountY:%d, groupCountZ:%d)",
+ commandBuffer, groupCountX, groupCountY, groupCountZ);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -8692,14 +11968,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDispatch = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDispatch);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDispatch -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDispatch);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDispatch = OP_vkCmdDispatch;
- memcpy(streamPtr, &opcode_vkCmdDispatch, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDispatch, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDispatch, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDispatch, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -8711,23 +11989,44 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_groupCountZ, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdDispatchIndirect(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDispatchIndirect in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdDispatchIndirect(commandBuffer:%p, buffer:%p, offset:%ld)",
+ commandBuffer, buffer, offset);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -8747,14 +12046,16 @@
*countPtr += sizeof(VkDeviceSize);
}
uint32_t packetSize_vkCmdDispatchIndirect = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDispatchIndirect);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDispatchIndirect -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDispatchIndirect);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDispatchIndirect = OP_vkCmdDispatchIndirect;
- memcpy(streamPtr, &opcode_vkCmdDispatchIndirect, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDispatchIndirect, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDispatchIndirect, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDispatchIndirect, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -8766,25 +12067,47 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkDeviceSize*)&local_offset, sizeof(VkDeviceSize));
*streamPtrPtr += sizeof(VkDeviceSize);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdCopyBuffer(
- VkCommandBuffer commandBuffer,
- VkBuffer srcBuffer,
- VkBuffer dstBuffer,
- uint32_t regionCount,
- const VkBufferCopy* pRegions,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
+ VkBuffer dstBuffer, uint32_t regionCount,
+ const VkBufferCopy* pRegions, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdCopyBuffer in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdCopyBuffer(commandBuffer:%p, srcBuffer:%p, dstBuffer:%p, regionCount:%d, "
+ "pRegions:%p)",
+ commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -8798,18 +12121,15 @@
local_dstBuffer = dstBuffer;
local_regionCount = regionCount;
local_pRegions = nullptr;
- if (pRegions)
- {
+ if (pRegions) {
local_pRegions = (VkBufferCopy*)pool->alloc(((regionCount)) * sizeof(const VkBufferCopy));
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- deepcopy_VkBufferCopy(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRegions + i, (VkBufferCopy*)(local_pRegions + i));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ deepcopy_VkBufferCopy(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRegions + i,
+ (VkBufferCopy*)(local_pRegions + i));
}
}
- if (local_pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
+ if (local_pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
transform_tohost_VkBufferCopy(sResourceTracker, (VkBufferCopy*)(local_pRegions + i));
}
}
@@ -8823,20 +12143,22 @@
uint64_t cgen_var_2;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- count_VkBufferCopy(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferCopy*)(local_pRegions + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ count_VkBufferCopy(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferCopy*)(local_pRegions + i), countPtr);
}
}
uint32_t packetSize_vkCmdCopyBuffer = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyBuffer);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyBuffer -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyBuffer);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdCopyBuffer = OP_vkCmdCopyBuffer;
- memcpy(streamPtr, &opcode_vkCmdCopyBuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdCopyBuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdCopyBuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdCopyBuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -8852,31 +12174,52 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_regionCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- reservedmarshal_VkBufferCopy(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferCopy*)(local_pRegions + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ reservedmarshal_VkBufferCopy(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferCopy*)(local_pRegions + i), streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdCopyImage(
- VkCommandBuffer commandBuffer,
- VkImage srcImage,
- VkImageLayout srcImageLayout,
- VkImage dstImage,
- VkImageLayout dstImageLayout,
- uint32_t regionCount,
- const VkImageCopy* pRegions,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+ VkImageLayout srcImageLayout, VkImage dstImage,
+ VkImageLayout dstImageLayout, uint32_t regionCount,
+ const VkImageCopy* pRegions, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdCopyImage in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdCopyImage(commandBuffer:%p, srcImage:%p, srcImageLayout:%d, dstImage:%p, "
+ "dstImageLayout:%d, regionCount:%d, pRegions:%p)",
+ commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -8894,18 +12237,15 @@
local_dstImageLayout = dstImageLayout;
local_regionCount = regionCount;
local_pRegions = nullptr;
- if (pRegions)
- {
+ if (pRegions) {
local_pRegions = (VkImageCopy*)pool->alloc(((regionCount)) * sizeof(const VkImageCopy));
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- deepcopy_VkImageCopy(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRegions + i, (VkImageCopy*)(local_pRegions + i));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ deepcopy_VkImageCopy(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRegions + i,
+ (VkImageCopy*)(local_pRegions + i));
}
}
- if (local_pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
+ if (local_pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
transform_tohost_VkImageCopy(sResourceTracker, (VkImageCopy*)(local_pRegions + i));
}
}
@@ -8921,20 +12261,22 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkImageLayout);
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- count_VkImageCopy(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageCopy*)(local_pRegions + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ count_VkImageCopy(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageCopy*)(local_pRegions + i), countPtr);
}
}
uint32_t packetSize_vkCmdCopyImage = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyImage);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyImage -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyImage);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdCopyImage = OP_vkCmdCopyImage;
- memcpy(streamPtr, &opcode_vkCmdCopyImage, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdCopyImage, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdCopyImage, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdCopyImage, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -8954,32 +12296,52 @@
*streamPtrPtr += sizeof(VkImageLayout);
memcpy(*streamPtrPtr, (uint32_t*)&local_regionCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- reservedmarshal_VkImageCopy(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageCopy*)(local_pRegions + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ reservedmarshal_VkImageCopy(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageCopy*)(local_pRegions + i), streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdBlitImage(
- VkCommandBuffer commandBuffer,
- VkImage srcImage,
- VkImageLayout srcImageLayout,
- VkImage dstImage,
- VkImageLayout dstImageLayout,
- uint32_t regionCount,
- const VkImageBlit* pRegions,
- VkFilter filter,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+ VkImageLayout srcImageLayout, VkImage dstImage,
+ VkImageLayout dstImageLayout, uint32_t regionCount,
+ const VkImageBlit* pRegions, VkFilter filter, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBlitImage in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdBlitImage(commandBuffer:%p, srcImage:%p, srcImageLayout:%d, dstImage:%p, "
+ "dstImageLayout:%d, regionCount:%d, pRegions:%p)",
+ commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -8998,19 +12360,16 @@
local_dstImageLayout = dstImageLayout;
local_regionCount = regionCount;
local_pRegions = nullptr;
- if (pRegions)
- {
+ if (pRegions) {
local_pRegions = (VkImageBlit*)pool->alloc(((regionCount)) * sizeof(const VkImageBlit));
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- deepcopy_VkImageBlit(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRegions + i, (VkImageBlit*)(local_pRegions + i));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ deepcopy_VkImageBlit(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRegions + i,
+ (VkImageBlit*)(local_pRegions + i));
}
}
local_filter = filter;
- if (local_pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
+ if (local_pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
transform_tohost_VkImageBlit(sResourceTracker, (VkImageBlit*)(local_pRegions + i));
}
}
@@ -9026,21 +12385,23 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkImageLayout);
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- count_VkImageBlit(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageBlit*)(local_pRegions + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ count_VkImageBlit(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageBlit*)(local_pRegions + i), countPtr);
}
*countPtr += sizeof(VkFilter);
}
uint32_t packetSize_vkCmdBlitImage = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBlitImage);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBlitImage -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBlitImage);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBlitImage = OP_vkCmdBlitImage;
- memcpy(streamPtr, &opcode_vkCmdBlitImage, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBlitImage, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBlitImage, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBlitImage, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -9060,32 +12421,54 @@
*streamPtrPtr += sizeof(VkImageLayout);
memcpy(*streamPtrPtr, (uint32_t*)&local_regionCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- reservedmarshal_VkImageBlit(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageBlit*)(local_pRegions + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ reservedmarshal_VkImageBlit(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageBlit*)(local_pRegions + i), streamPtrPtr);
}
memcpy(*streamPtrPtr, (VkFilter*)&local_filter, sizeof(VkFilter));
*streamPtrPtr += sizeof(VkFilter);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdCopyBufferToImage(
- VkCommandBuffer commandBuffer,
- VkBuffer srcBuffer,
- VkImage dstImage,
- VkImageLayout dstImageLayout,
- uint32_t regionCount,
- const VkBufferImageCopy* pRegions,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
+ VkImage dstImage, VkImageLayout dstImageLayout,
+ uint32_t regionCount, const VkBufferImageCopy* pRegions,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdCopyBufferToImage in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdCopyBufferToImage(commandBuffer:%p, srcBuffer:%p, dstImage:%p, dstImageLayout:%d, "
+ "regionCount:%d, pRegions:%p)",
+ commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -9101,19 +12484,18 @@
local_dstImageLayout = dstImageLayout;
local_regionCount = regionCount;
local_pRegions = nullptr;
- if (pRegions)
- {
- local_pRegions = (VkBufferImageCopy*)pool->alloc(((regionCount)) * sizeof(const VkBufferImageCopy));
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- deepcopy_VkBufferImageCopy(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRegions + i, (VkBufferImageCopy*)(local_pRegions + i));
+ if (pRegions) {
+ local_pRegions =
+ (VkBufferImageCopy*)pool->alloc(((regionCount)) * sizeof(const VkBufferImageCopy));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ deepcopy_VkBufferImageCopy(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRegions + i,
+ (VkBufferImageCopy*)(local_pRegions + i));
}
}
- if (local_pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- transform_tohost_VkBufferImageCopy(sResourceTracker, (VkBufferImageCopy*)(local_pRegions + i));
+ if (local_pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ transform_tohost_VkBufferImageCopy(sResourceTracker,
+ (VkBufferImageCopy*)(local_pRegions + i));
}
}
size_t count = 0;
@@ -9127,20 +12509,22 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkImageLayout);
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- count_VkBufferImageCopy(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferImageCopy*)(local_pRegions + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ count_VkBufferImageCopy(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferImageCopy*)(local_pRegions + i), countPtr);
}
}
uint32_t packetSize_vkCmdCopyBufferToImage = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyBufferToImage);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyBufferToImage -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyBufferToImage);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdCopyBufferToImage = OP_vkCmdCopyBufferToImage;
- memcpy(streamPtr, &opcode_vkCmdCopyBufferToImage, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdCopyBufferToImage, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdCopyBufferToImage, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdCopyBufferToImage, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -9158,30 +12542,52 @@
*streamPtrPtr += sizeof(VkImageLayout);
memcpy(*streamPtrPtr, (uint32_t*)&local_regionCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- reservedmarshal_VkBufferImageCopy(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferImageCopy*)(local_pRegions + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ reservedmarshal_VkBufferImageCopy(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferImageCopy*)(local_pRegions + i), streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdCopyImageToBuffer(
- VkCommandBuffer commandBuffer,
- VkImage srcImage,
- VkImageLayout srcImageLayout,
- VkBuffer dstBuffer,
- uint32_t regionCount,
- const VkBufferImageCopy* pRegions,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
+ VkImageLayout srcImageLayout, VkBuffer dstBuffer,
+ uint32_t regionCount, const VkBufferImageCopy* pRegions,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdCopyImageToBuffer in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdCopyImageToBuffer(commandBuffer:%p, srcImage:%p, srcImageLayout:%d, dstBuffer:%p, "
+ "regionCount:%d, pRegions:%p)",
+ commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -9197,19 +12603,18 @@
local_dstBuffer = dstBuffer;
local_regionCount = regionCount;
local_pRegions = nullptr;
- if (pRegions)
- {
- local_pRegions = (VkBufferImageCopy*)pool->alloc(((regionCount)) * sizeof(const VkBufferImageCopy));
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- deepcopy_VkBufferImageCopy(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRegions + i, (VkBufferImageCopy*)(local_pRegions + i));
+ if (pRegions) {
+ local_pRegions =
+ (VkBufferImageCopy*)pool->alloc(((regionCount)) * sizeof(const VkBufferImageCopy));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ deepcopy_VkBufferImageCopy(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRegions + i,
+ (VkBufferImageCopy*)(local_pRegions + i));
}
}
- if (local_pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- transform_tohost_VkBufferImageCopy(sResourceTracker, (VkBufferImageCopy*)(local_pRegions + i));
+ if (local_pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ transform_tohost_VkBufferImageCopy(sResourceTracker,
+ (VkBufferImageCopy*)(local_pRegions + i));
}
}
size_t count = 0;
@@ -9223,20 +12628,22 @@
uint64_t cgen_var_2;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- count_VkBufferImageCopy(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferImageCopy*)(local_pRegions + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ count_VkBufferImageCopy(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferImageCopy*)(local_pRegions + i), countPtr);
}
}
uint32_t packetSize_vkCmdCopyImageToBuffer = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyImageToBuffer);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyImageToBuffer -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyImageToBuffer);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdCopyImageToBuffer = OP_vkCmdCopyImageToBuffer;
- memcpy(streamPtr, &opcode_vkCmdCopyImageToBuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdCopyImageToBuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdCopyImageToBuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdCopyImageToBuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -9254,29 +12661,50 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_regionCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- reservedmarshal_VkBufferImageCopy(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferImageCopy*)(local_pRegions + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ reservedmarshal_VkBufferImageCopy(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferImageCopy*)(local_pRegions + i), streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdUpdateBuffer(
- VkCommandBuffer commandBuffer,
- VkBuffer dstBuffer,
- VkDeviceSize dstOffset,
- VkDeviceSize dataSize,
- const void* pData,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
+ VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdUpdateBuffer in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdUpdateBuffer(commandBuffer:%p, dstBuffer:%p, dstOffset:%ld, dataSize:%ld, pData:%p)",
+ commandBuffer, dstBuffer, dstOffset, dataSize, pData);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -9303,14 +12731,16 @@
*countPtr += ((dataSize)) * sizeof(uint8_t);
}
uint32_t packetSize_vkCmdUpdateBuffer = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdUpdateBuffer);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdUpdateBuffer -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdUpdateBuffer);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdUpdateBuffer = OP_vkCmdUpdateBuffer;
- memcpy(streamPtr, &opcode_vkCmdUpdateBuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdUpdateBuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdUpdateBuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdUpdateBuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -9326,25 +12756,46 @@
*streamPtrPtr += sizeof(VkDeviceSize);
memcpy(*streamPtrPtr, (void*)local_pData, ((dataSize)) * sizeof(uint8_t));
*streamPtrPtr += ((dataSize)) * sizeof(uint8_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdFillBuffer(
- VkCommandBuffer commandBuffer,
- VkBuffer dstBuffer,
- VkDeviceSize dstOffset,
- VkDeviceSize size,
- uint32_t data,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
+ VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdFillBuffer in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdFillBuffer(commandBuffer:%p, dstBuffer:%p, dstOffset:%ld, size:%ld, data:%d)",
+ commandBuffer, dstBuffer, dstOffset, size, data);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -9370,14 +12821,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdFillBuffer = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdFillBuffer);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdFillBuffer -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdFillBuffer);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdFillBuffer = OP_vkCmdFillBuffer;
- memcpy(streamPtr, &opcode_vkCmdFillBuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdFillBuffer, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdFillBuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdFillBuffer, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -9393,26 +12846,48 @@
*streamPtrPtr += sizeof(VkDeviceSize);
memcpy(*streamPtrPtr, (uint32_t*)&local_data, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdClearColorImage(
- VkCommandBuffer commandBuffer,
- VkImage image,
- VkImageLayout imageLayout,
- const VkClearColorValue* pColor,
- uint32_t rangeCount,
- const VkImageSubresourceRange* pRanges,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
+ VkImageLayout imageLayout, const VkClearColorValue* pColor,
+ uint32_t rangeCount, const VkImageSubresourceRange* pRanges,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdClearColorImage in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdClearColorImage(commandBuffer:%p, image:%p, imageLayout:%d, pColor:%p, "
+ "rangeCount:%d, pRanges:%p)",
+ commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -9426,30 +12901,28 @@
local_image = image;
local_imageLayout = imageLayout;
local_pColor = nullptr;
- if (pColor)
- {
+ if (pColor) {
local_pColor = (VkClearColorValue*)pool->alloc(sizeof(const VkClearColorValue));
- deepcopy_VkClearColorValue(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pColor, (VkClearColorValue*)(local_pColor));
+ deepcopy_VkClearColorValue(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pColor,
+ (VkClearColorValue*)(local_pColor));
}
local_rangeCount = rangeCount;
local_pRanges = nullptr;
- if (pRanges)
- {
- local_pRanges = (VkImageSubresourceRange*)pool->alloc(((rangeCount)) * sizeof(const VkImageSubresourceRange));
- for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
- {
- deepcopy_VkImageSubresourceRange(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRanges + i, (VkImageSubresourceRange*)(local_pRanges + i));
+ if (pRanges) {
+ local_pRanges = (VkImageSubresourceRange*)pool->alloc(
+ ((rangeCount)) * sizeof(const VkImageSubresourceRange));
+ for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
+ deepcopy_VkImageSubresourceRange(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRanges + i,
+ (VkImageSubresourceRange*)(local_pRanges + i));
}
}
- if (local_pColor)
- {
+ if (local_pColor) {
transform_tohost_VkClearColorValue(sResourceTracker, (VkClearColorValue*)(local_pColor));
}
- if (local_pRanges)
- {
- for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
- {
- transform_tohost_VkImageSubresourceRange(sResourceTracker, (VkImageSubresourceRange*)(local_pRanges + i));
+ if (local_pRanges) {
+ for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
+ transform_tohost_VkImageSubresourceRange(sResourceTracker,
+ (VkImageSubresourceRange*)(local_pRanges + i));
}
}
size_t count = 0;
@@ -9460,22 +12933,25 @@
uint64_t cgen_var_1;
*countPtr += 1 * 8;
*countPtr += sizeof(VkImageLayout);
- count_VkClearColorValue(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkClearColorValue*)(local_pColor), countPtr);
+ count_VkClearColorValue(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkClearColorValue*)(local_pColor), countPtr);
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
- {
- count_VkImageSubresourceRange(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageSubresourceRange*)(local_pRanges + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
+ count_VkImageSubresourceRange(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageSubresourceRange*)(local_pRanges + i), countPtr);
}
}
uint32_t packetSize_vkCmdClearColorImage = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdClearColorImage);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdClearColorImage -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdClearColorImage);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdClearColorImage = OP_vkCmdClearColorImage;
- memcpy(streamPtr, &opcode_vkCmdClearColorImage, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdClearColorImage, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdClearColorImage, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdClearColorImage, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -9487,33 +12963,59 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
*streamPtrPtr += sizeof(VkImageLayout);
- reservedmarshal_VkClearColorValue(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkClearColorValue*)(local_pColor), streamPtrPtr);
+ reservedmarshal_VkClearColorValue(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkClearColorValue*)(local_pColor), streamPtrPtr);
memcpy(*streamPtrPtr, (uint32_t*)&local_rangeCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
- {
- reservedmarshal_VkImageSubresourceRange(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageSubresourceRange*)(local_pRanges + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
+ reservedmarshal_VkImageSubresourceRange(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageSubresourceRange*)(local_pRanges + i),
+ streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdClearDepthStencilImage(
- VkCommandBuffer commandBuffer,
- VkImage image,
- VkImageLayout imageLayout,
- const VkClearDepthStencilValue* pDepthStencil,
- uint32_t rangeCount,
- const VkImageSubresourceRange* pRanges,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearDepthStencilValue* pDepthStencil,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdClearDepthStencilImage in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdClearDepthStencilImage(commandBuffer:%p, image:%p, imageLayout:%d, pDepthStencil:%p, "
+ "rangeCount:%d, pRanges:%p)",
+ commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -9527,30 +13029,30 @@
local_image = image;
local_imageLayout = imageLayout;
local_pDepthStencil = nullptr;
- if (pDepthStencil)
- {
- local_pDepthStencil = (VkClearDepthStencilValue*)pool->alloc(sizeof(const VkClearDepthStencilValue));
- deepcopy_VkClearDepthStencilValue(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDepthStencil, (VkClearDepthStencilValue*)(local_pDepthStencil));
+ if (pDepthStencil) {
+ local_pDepthStencil =
+ (VkClearDepthStencilValue*)pool->alloc(sizeof(const VkClearDepthStencilValue));
+ deepcopy_VkClearDepthStencilValue(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDepthStencil,
+ (VkClearDepthStencilValue*)(local_pDepthStencil));
}
local_rangeCount = rangeCount;
local_pRanges = nullptr;
- if (pRanges)
- {
- local_pRanges = (VkImageSubresourceRange*)pool->alloc(((rangeCount)) * sizeof(const VkImageSubresourceRange));
- for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
- {
- deepcopy_VkImageSubresourceRange(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRanges + i, (VkImageSubresourceRange*)(local_pRanges + i));
+ if (pRanges) {
+ local_pRanges = (VkImageSubresourceRange*)pool->alloc(
+ ((rangeCount)) * sizeof(const VkImageSubresourceRange));
+ for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
+ deepcopy_VkImageSubresourceRange(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRanges + i,
+ (VkImageSubresourceRange*)(local_pRanges + i));
}
}
- if (local_pDepthStencil)
- {
- transform_tohost_VkClearDepthStencilValue(sResourceTracker, (VkClearDepthStencilValue*)(local_pDepthStencil));
+ if (local_pDepthStencil) {
+ transform_tohost_VkClearDepthStencilValue(sResourceTracker,
+ (VkClearDepthStencilValue*)(local_pDepthStencil));
}
- if (local_pRanges)
- {
- for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
- {
- transform_tohost_VkImageSubresourceRange(sResourceTracker, (VkImageSubresourceRange*)(local_pRanges + i));
+ if (local_pRanges) {
+ for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
+ transform_tohost_VkImageSubresourceRange(sResourceTracker,
+ (VkImageSubresourceRange*)(local_pRanges + i));
}
}
size_t count = 0;
@@ -9561,22 +13063,25 @@
uint64_t cgen_var_1;
*countPtr += 1 * 8;
*countPtr += sizeof(VkImageLayout);
- count_VkClearDepthStencilValue(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkClearDepthStencilValue*)(local_pDepthStencil), countPtr);
+ count_VkClearDepthStencilValue(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkClearDepthStencilValue*)(local_pDepthStencil), countPtr);
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
- {
- count_VkImageSubresourceRange(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageSubresourceRange*)(local_pRanges + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
+ count_VkImageSubresourceRange(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageSubresourceRange*)(local_pRanges + i), countPtr);
}
}
uint32_t packetSize_vkCmdClearDepthStencilImage = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdClearDepthStencilImage);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdClearDepthStencilImage -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdClearDepthStencilImage);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdClearDepthStencilImage = OP_vkCmdClearDepthStencilImage;
- memcpy(streamPtr, &opcode_vkCmdClearDepthStencilImage, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdClearDepthStencilImage, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdClearDepthStencilImage, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdClearDepthStencilImage, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -9588,32 +13093,57 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
*streamPtrPtr += sizeof(VkImageLayout);
- reservedmarshal_VkClearDepthStencilValue(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkClearDepthStencilValue*)(local_pDepthStencil), streamPtrPtr);
+ reservedmarshal_VkClearDepthStencilValue(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkClearDepthStencilValue*)(local_pDepthStencil),
+ streamPtrPtr);
memcpy(*streamPtrPtr, (uint32_t*)&local_rangeCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i)
- {
- reservedmarshal_VkImageSubresourceRange(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageSubresourceRange*)(local_pRanges + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
+ reservedmarshal_VkImageSubresourceRange(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageSubresourceRange*)(local_pRanges + i),
+ streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdClearAttachments(
- VkCommandBuffer commandBuffer,
- uint32_t attachmentCount,
- const VkClearAttachment* pAttachments,
- uint32_t rectCount,
- const VkClearRect* pRects,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
+ const VkClearAttachment* pAttachments, uint32_t rectCount,
+ const VkClearRect* pRects, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdClearAttachments in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdClearAttachments(commandBuffer:%p, attachmentCount:%d, pAttachments:%p, "
+ "rectCount:%d, pRects:%p)",
+ commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -9625,35 +13155,31 @@
local_commandBuffer = commandBuffer;
local_attachmentCount = attachmentCount;
local_pAttachments = nullptr;
- if (pAttachments)
- {
- local_pAttachments = (VkClearAttachment*)pool->alloc(((attachmentCount)) * sizeof(const VkClearAttachment));
- for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i)
- {
- deepcopy_VkClearAttachment(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAttachments + i, (VkClearAttachment*)(local_pAttachments + i));
+ if (pAttachments) {
+ local_pAttachments =
+ (VkClearAttachment*)pool->alloc(((attachmentCount)) * sizeof(const VkClearAttachment));
+ for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
+ deepcopy_VkClearAttachment(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAttachments + i,
+ (VkClearAttachment*)(local_pAttachments + i));
}
}
local_rectCount = rectCount;
local_pRects = nullptr;
- if (pRects)
- {
+ if (pRects) {
local_pRects = (VkClearRect*)pool->alloc(((rectCount)) * sizeof(const VkClearRect));
- for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i)
- {
- deepcopy_VkClearRect(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRects + i, (VkClearRect*)(local_pRects + i));
+ for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i) {
+ deepcopy_VkClearRect(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRects + i,
+ (VkClearRect*)(local_pRects + i));
}
}
- if (local_pAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i)
- {
- transform_tohost_VkClearAttachment(sResourceTracker, (VkClearAttachment*)(local_pAttachments + i));
+ if (local_pAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
+ transform_tohost_VkClearAttachment(sResourceTracker,
+ (VkClearAttachment*)(local_pAttachments + i));
}
}
- if (local_pRects)
- {
- for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i)
- {
+ if (local_pRects) {
+ for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i) {
transform_tohost_VkClearRect(sResourceTracker, (VkClearRect*)(local_pRects + i));
}
}
@@ -9663,25 +13189,27 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i)
- {
- count_VkClearAttachment(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkClearAttachment*)(local_pAttachments + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
+ count_VkClearAttachment(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkClearAttachment*)(local_pAttachments + i), countPtr);
}
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i)
- {
- count_VkClearRect(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkClearRect*)(local_pRects + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i) {
+ count_VkClearRect(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkClearRect*)(local_pRects + i), countPtr);
}
}
uint32_t packetSize_vkCmdClearAttachments = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdClearAttachments);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdClearAttachments -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdClearAttachments);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdClearAttachments = OP_vkCmdClearAttachments;
- memcpy(streamPtr, &opcode_vkCmdClearAttachments, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdClearAttachments, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdClearAttachments, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdClearAttachments, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -9689,37 +13217,59 @@
}
memcpy(*streamPtrPtr, (uint32_t*)&local_attachmentCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i)
- {
- reservedmarshal_VkClearAttachment(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkClearAttachment*)(local_pAttachments + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
+ reservedmarshal_VkClearAttachment(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkClearAttachment*)(local_pAttachments + i),
+ streamPtrPtr);
}
memcpy(*streamPtrPtr, (uint32_t*)&local_rectCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i)
- {
- reservedmarshal_VkClearRect(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkClearRect*)(local_pRects + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i) {
+ reservedmarshal_VkClearRect(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkClearRect*)(local_pRects + i), streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdResolveImage(
- VkCommandBuffer commandBuffer,
- VkImage srcImage,
- VkImageLayout srcImageLayout,
- VkImage dstImage,
- VkImageLayout dstImageLayout,
- uint32_t regionCount,
- const VkImageResolve* pRegions,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+ VkImageLayout srcImageLayout, VkImage dstImage,
+ VkImageLayout dstImageLayout, uint32_t regionCount,
+ const VkImageResolve* pRegions, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdResolveImage in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdResolveImage(commandBuffer:%p, srcImage:%p, srcImageLayout:%d, dstImage:%p, "
+ "dstImageLayout:%d, regionCount:%d, pRegions:%p)",
+ commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -9737,19 +13287,18 @@
local_dstImageLayout = dstImageLayout;
local_regionCount = regionCount;
local_pRegions = nullptr;
- if (pRegions)
- {
- local_pRegions = (VkImageResolve*)pool->alloc(((regionCount)) * sizeof(const VkImageResolve));
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- deepcopy_VkImageResolve(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRegions + i, (VkImageResolve*)(local_pRegions + i));
+ if (pRegions) {
+ local_pRegions =
+ (VkImageResolve*)pool->alloc(((regionCount)) * sizeof(const VkImageResolve));
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ deepcopy_VkImageResolve(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRegions + i,
+ (VkImageResolve*)(local_pRegions + i));
}
}
- if (local_pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- transform_tohost_VkImageResolve(sResourceTracker, (VkImageResolve*)(local_pRegions + i));
+ if (local_pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ transform_tohost_VkImageResolve(sResourceTracker,
+ (VkImageResolve*)(local_pRegions + i));
}
}
size_t count = 0;
@@ -9764,20 +13313,22 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkImageLayout);
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- count_VkImageResolve(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageResolve*)(local_pRegions + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ count_VkImageResolve(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageResolve*)(local_pRegions + i), countPtr);
}
}
uint32_t packetSize_vkCmdResolveImage = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdResolveImage);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdResolveImage -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdResolveImage);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdResolveImage = OP_vkCmdResolveImage;
- memcpy(streamPtr, &opcode_vkCmdResolveImage, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdResolveImage, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdResolveImage, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdResolveImage, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -9797,27 +13348,48 @@
*streamPtrPtr += sizeof(VkImageLayout);
memcpy(*streamPtrPtr, (uint32_t*)&local_regionCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i)
- {
- reservedmarshal_VkImageResolve(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageResolve*)(local_pRegions + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
+ reservedmarshal_VkImageResolve(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageResolve*)(local_pRegions + i), streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetEvent(
- VkCommandBuffer commandBuffer,
- VkEvent event,
- VkPipelineStageFlags stageMask,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
+ VkPipelineStageFlags stageMask, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetEvent in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetEvent(commandBuffer:%p, event:%p, stageMask:%d)", commandBuffer,
+ event, stageMask);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -9837,14 +13409,16 @@
*countPtr += sizeof(VkPipelineStageFlags);
}
uint32_t packetSize_vkCmdSetEvent = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetEvent);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetEvent -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetEvent);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetEvent = OP_vkCmdSetEvent;
- memcpy(streamPtr, &opcode_vkCmdSetEvent, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetEvent, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetEvent, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetEvent, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -9856,23 +13430,44 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
*streamPtrPtr += sizeof(VkPipelineStageFlags);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdResetEvent(
- VkCommandBuffer commandBuffer,
- VkEvent event,
- VkPipelineStageFlags stageMask,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
+ VkPipelineStageFlags stageMask, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdResetEvent in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdResetEvent(commandBuffer:%p, event:%p, stageMask:%d)", commandBuffer,
+ event, stageMask);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -9892,14 +13487,16 @@
*countPtr += sizeof(VkPipelineStageFlags);
}
uint32_t packetSize_vkCmdResetEvent = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdResetEvent);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdResetEvent -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdResetEvent);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdResetEvent = OP_vkCmdResetEvent;
- memcpy(streamPtr, &opcode_vkCmdResetEvent, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdResetEvent, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdResetEvent, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdResetEvent, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -9911,31 +13508,55 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags));
*streamPtrPtr += sizeof(VkPipelineStageFlags);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::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,
- uint32_t doLock)
-{
+void VkEncoder::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, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdWaitEvents in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdWaitEvents(commandBuffer:%p, eventCount:%d, pEvents:%p, srcStageMask:%d, "
+ "dstStageMask:%d, memoryBarrierCount:%d, pMemoryBarriers:%p, bufferMemoryBarrierCount:%d, "
+ "pBufferMemoryBarriers:%p, imageMemoryBarrierCount:%d, pImageMemoryBarriers:%p)",
+ commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount,
+ pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount,
+ pImageMemoryBarriers);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -9958,53 +13579,52 @@
local_dstStageMask = dstStageMask;
local_memoryBarrierCount = memoryBarrierCount;
local_pMemoryBarriers = nullptr;
- if (pMemoryBarriers)
- {
- local_pMemoryBarriers = (VkMemoryBarrier*)pool->alloc(((memoryBarrierCount)) * sizeof(const VkMemoryBarrier));
- for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
- {
- deepcopy_VkMemoryBarrier(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMemoryBarriers + i, (VkMemoryBarrier*)(local_pMemoryBarriers + i));
+ if (pMemoryBarriers) {
+ local_pMemoryBarriers =
+ (VkMemoryBarrier*)pool->alloc(((memoryBarrierCount)) * sizeof(const VkMemoryBarrier));
+ for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
+ deepcopy_VkMemoryBarrier(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMemoryBarriers + i,
+ (VkMemoryBarrier*)(local_pMemoryBarriers + i));
}
}
local_bufferMemoryBarrierCount = bufferMemoryBarrierCount;
local_pBufferMemoryBarriers = nullptr;
- if (pBufferMemoryBarriers)
- {
- local_pBufferMemoryBarriers = (VkBufferMemoryBarrier*)pool->alloc(((bufferMemoryBarrierCount)) * sizeof(const VkBufferMemoryBarrier));
- for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
- {
- deepcopy_VkBufferMemoryBarrier(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBufferMemoryBarriers + i, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
+ if (pBufferMemoryBarriers) {
+ local_pBufferMemoryBarriers = (VkBufferMemoryBarrier*)pool->alloc(
+ ((bufferMemoryBarrierCount)) * sizeof(const VkBufferMemoryBarrier));
+ for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
+ deepcopy_VkBufferMemoryBarrier(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBufferMemoryBarriers + i,
+ (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
}
}
local_imageMemoryBarrierCount = imageMemoryBarrierCount;
local_pImageMemoryBarriers = nullptr;
- if (pImageMemoryBarriers)
- {
- local_pImageMemoryBarriers = (VkImageMemoryBarrier*)pool->alloc(((imageMemoryBarrierCount)) * sizeof(const VkImageMemoryBarrier));
- for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
- {
- deepcopy_VkImageMemoryBarrier(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImageMemoryBarriers + i, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
+ if (pImageMemoryBarriers) {
+ local_pImageMemoryBarriers = (VkImageMemoryBarrier*)pool->alloc(
+ ((imageMemoryBarrierCount)) * sizeof(const VkImageMemoryBarrier));
+ for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
+ deepcopy_VkImageMemoryBarrier(pool, VK_STRUCTURE_TYPE_MAX_ENUM,
+ pImageMemoryBarriers + i,
+ (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
}
}
- if (local_pMemoryBarriers)
- {
- for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
- {
- transform_tohost_VkMemoryBarrier(sResourceTracker, (VkMemoryBarrier*)(local_pMemoryBarriers + i));
+ if (local_pMemoryBarriers) {
+ for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
+ transform_tohost_VkMemoryBarrier(sResourceTracker,
+ (VkMemoryBarrier*)(local_pMemoryBarriers + i));
}
}
- if (local_pBufferMemoryBarriers)
- {
- for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
- {
- transform_tohost_VkBufferMemoryBarrier(sResourceTracker, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
+ if (local_pBufferMemoryBarriers) {
+ for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
+ transform_tohost_VkBufferMemoryBarrier(
+ sResourceTracker, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
}
}
- if (local_pImageMemoryBarriers)
- {
- for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
- {
- transform_tohost_VkImageMemoryBarrier(sResourceTracker, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
+ if (local_pImageMemoryBarriers) {
+ for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
+ transform_tohost_VkImageMemoryBarrier(
+ sResourceTracker, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
}
}
size_t count = 0;
@@ -10013,37 +13633,40 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- if (((eventCount)))
- {
+ if (((eventCount))) {
*countPtr += ((eventCount)) * 8;
}
*countPtr += sizeof(VkPipelineStageFlags);
*countPtr += sizeof(VkPipelineStageFlags);
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
- {
- count_VkMemoryBarrier(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryBarrier*)(local_pMemoryBarriers + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
+ count_VkMemoryBarrier(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryBarrier*)(local_pMemoryBarriers + i), countPtr);
}
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
- {
- count_VkBufferMemoryBarrier(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
+ count_VkBufferMemoryBarrier(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i),
+ countPtr);
}
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
- {
- count_VkImageMemoryBarrier(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
+ count_VkImageMemoryBarrier(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i),
+ countPtr);
}
}
uint32_t packetSize_vkCmdWaitEvents = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdWaitEvents);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdWaitEvents -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdWaitEvents);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdWaitEvents = OP_vkCmdWaitEvents;
- memcpy(streamPtr, &opcode_vkCmdWaitEvents, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdWaitEvents, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdWaitEvents, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdWaitEvents, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -10051,11 +13674,9 @@
}
memcpy(*streamPtrPtr, (uint32_t*)&local_eventCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (((eventCount)))
- {
+ if (((eventCount))) {
uint8_t* cgen_var_0_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((eventCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((eventCount)); ++k) {
uint64_t tmpval = get_host_u64_VkEvent(local_pEvents[k]);
memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -10067,25 +13688,28 @@
*streamPtrPtr += sizeof(VkPipelineStageFlags);
memcpy(*streamPtrPtr, (uint32_t*)&local_memoryBarrierCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
- {
- reservedmarshal_VkMemoryBarrier(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryBarrier*)(local_pMemoryBarriers + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
+ reservedmarshal_VkMemoryBarrier(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryBarrier*)(local_pMemoryBarriers + i),
+ streamPtrPtr);
}
memcpy(*streamPtrPtr, (uint32_t*)&local_bufferMemoryBarrierCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
- {
- reservedmarshal_VkBufferMemoryBarrier(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
+ reservedmarshal_VkBufferMemoryBarrier(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i), streamPtrPtr);
}
memcpy(*streamPtrPtr, (uint32_t*)&local_imageMemoryBarrierCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
- {
- reservedmarshal_VkImageMemoryBarrier(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
+ reservedmarshal_VkImageMemoryBarrier(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i), streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -10093,20 +13717,45 @@
}
void VkEncoder::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,
- uint32_t doLock)
-{
+ 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,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdPipelineBarrier in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdPipelineBarrier(commandBuffer:%p, srcStageMask:%d, dstStageMask:%d, "
+ "dependencyFlags:%d, memoryBarrierCount:%d, pMemoryBarriers:%p, "
+ "bufferMemoryBarrierCount:%d, pBufferMemoryBarriers:%p, imageMemoryBarrierCount:%d, "
+ "pImageMemoryBarriers:%p)",
+ commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount,
+ pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount,
+ pImageMemoryBarriers);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -10126,53 +13775,52 @@
local_dependencyFlags = dependencyFlags;
local_memoryBarrierCount = memoryBarrierCount;
local_pMemoryBarriers = nullptr;
- if (pMemoryBarriers)
- {
- local_pMemoryBarriers = (VkMemoryBarrier*)pool->alloc(((memoryBarrierCount)) * sizeof(const VkMemoryBarrier));
- for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
- {
- deepcopy_VkMemoryBarrier(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMemoryBarriers + i, (VkMemoryBarrier*)(local_pMemoryBarriers + i));
+ if (pMemoryBarriers) {
+ local_pMemoryBarriers =
+ (VkMemoryBarrier*)pool->alloc(((memoryBarrierCount)) * sizeof(const VkMemoryBarrier));
+ for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
+ deepcopy_VkMemoryBarrier(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMemoryBarriers + i,
+ (VkMemoryBarrier*)(local_pMemoryBarriers + i));
}
}
local_bufferMemoryBarrierCount = bufferMemoryBarrierCount;
local_pBufferMemoryBarriers = nullptr;
- if (pBufferMemoryBarriers)
- {
- local_pBufferMemoryBarriers = (VkBufferMemoryBarrier*)pool->alloc(((bufferMemoryBarrierCount)) * sizeof(const VkBufferMemoryBarrier));
- for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
- {
- deepcopy_VkBufferMemoryBarrier(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBufferMemoryBarriers + i, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
+ if (pBufferMemoryBarriers) {
+ local_pBufferMemoryBarriers = (VkBufferMemoryBarrier*)pool->alloc(
+ ((bufferMemoryBarrierCount)) * sizeof(const VkBufferMemoryBarrier));
+ for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
+ deepcopy_VkBufferMemoryBarrier(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBufferMemoryBarriers + i,
+ (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
}
}
local_imageMemoryBarrierCount = imageMemoryBarrierCount;
local_pImageMemoryBarriers = nullptr;
- if (pImageMemoryBarriers)
- {
- local_pImageMemoryBarriers = (VkImageMemoryBarrier*)pool->alloc(((imageMemoryBarrierCount)) * sizeof(const VkImageMemoryBarrier));
- for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
- {
- deepcopy_VkImageMemoryBarrier(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImageMemoryBarriers + i, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
+ if (pImageMemoryBarriers) {
+ local_pImageMemoryBarriers = (VkImageMemoryBarrier*)pool->alloc(
+ ((imageMemoryBarrierCount)) * sizeof(const VkImageMemoryBarrier));
+ for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
+ deepcopy_VkImageMemoryBarrier(pool, VK_STRUCTURE_TYPE_MAX_ENUM,
+ pImageMemoryBarriers + i,
+ (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
}
}
- if (local_pMemoryBarriers)
- {
- for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
- {
- transform_tohost_VkMemoryBarrier(sResourceTracker, (VkMemoryBarrier*)(local_pMemoryBarriers + i));
+ if (local_pMemoryBarriers) {
+ for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
+ transform_tohost_VkMemoryBarrier(sResourceTracker,
+ (VkMemoryBarrier*)(local_pMemoryBarriers + i));
}
}
- if (local_pBufferMemoryBarriers)
- {
- for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
- {
- transform_tohost_VkBufferMemoryBarrier(sResourceTracker, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
+ if (local_pBufferMemoryBarriers) {
+ for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
+ transform_tohost_VkBufferMemoryBarrier(
+ sResourceTracker, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i));
}
}
- if (local_pImageMemoryBarriers)
- {
- for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
- {
- transform_tohost_VkImageMemoryBarrier(sResourceTracker, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
+ if (local_pImageMemoryBarriers) {
+ for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
+ transform_tohost_VkImageMemoryBarrier(
+ sResourceTracker, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i));
}
}
size_t count = 0;
@@ -10184,30 +13832,34 @@
*countPtr += sizeof(VkPipelineStageFlags);
*countPtr += sizeof(VkDependencyFlags);
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
- {
- count_VkMemoryBarrier(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryBarrier*)(local_pMemoryBarriers + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
+ count_VkMemoryBarrier(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryBarrier*)(local_pMemoryBarriers + i), countPtr);
}
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
- {
- count_VkBufferMemoryBarrier(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
+ count_VkBufferMemoryBarrier(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i),
+ countPtr);
}
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
- {
- count_VkImageMemoryBarrier(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
+ count_VkImageMemoryBarrier(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i),
+ countPtr);
}
}
uint32_t packetSize_vkCmdPipelineBarrier = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdPipelineBarrier);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdPipelineBarrier -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdPipelineBarrier);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdPipelineBarrier = OP_vkCmdPipelineBarrier;
- memcpy(streamPtr, &opcode_vkCmdPipelineBarrier, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdPipelineBarrier, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdPipelineBarrier, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdPipelineBarrier, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -10221,40 +13873,63 @@
*streamPtrPtr += sizeof(VkDependencyFlags);
memcpy(*streamPtrPtr, (uint32_t*)&local_memoryBarrierCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i)
- {
- reservedmarshal_VkMemoryBarrier(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryBarrier*)(local_pMemoryBarriers + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
+ reservedmarshal_VkMemoryBarrier(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryBarrier*)(local_pMemoryBarriers + i),
+ streamPtrPtr);
}
memcpy(*streamPtrPtr, (uint32_t*)&local_bufferMemoryBarrierCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i)
- {
- reservedmarshal_VkBufferMemoryBarrier(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
+ reservedmarshal_VkBufferMemoryBarrier(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferMemoryBarrier*)(local_pBufferMemoryBarriers + i), streamPtrPtr);
}
memcpy(*streamPtrPtr, (uint32_t*)&local_imageMemoryBarrierCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i)
- {
- reservedmarshal_VkImageMemoryBarrier(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
+ reservedmarshal_VkImageMemoryBarrier(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i), streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdBeginQuery(
- VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t query,
- VkQueryControlFlags flags,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t query, VkQueryControlFlags flags, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBeginQuery in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdBeginQuery(commandBuffer:%p, queryPool:%p, query:%d, flags:%d)",
+ commandBuffer, queryPool, query, flags);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -10277,14 +13952,16 @@
*countPtr += sizeof(VkQueryControlFlags);
}
uint32_t packetSize_vkCmdBeginQuery = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBeginQuery);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginQuery -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBeginQuery);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBeginQuery = OP_vkCmdBeginQuery;
- memcpy(streamPtr, &opcode_vkCmdBeginQuery, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBeginQuery, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBeginQuery, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBeginQuery, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -10298,23 +13975,44 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (VkQueryControlFlags*)&local_flags, sizeof(VkQueryControlFlags));
*streamPtrPtr += sizeof(VkQueryControlFlags);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdEndQuery(
- VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t query,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdEndQuery in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdEndQuery(commandBuffer:%p, queryPool:%p, query:%d)", commandBuffer,
+ queryPool, query);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -10334,14 +14032,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdEndQuery = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdEndQuery);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEndQuery -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdEndQuery);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdEndQuery = OP_vkCmdEndQuery;
- memcpy(streamPtr, &opcode_vkCmdEndQuery, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdEndQuery, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdEndQuery, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdEndQuery, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -10353,24 +14053,45 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_query, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdResetQueryPool(
- VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t queryCount,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t firstQuery, uint32_t queryCount, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdResetQueryPool in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdResetQueryPool(commandBuffer:%p, queryPool:%p, firstQuery:%d, queryCount:%d)",
+ commandBuffer, queryPool, firstQuery, queryCount);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -10393,14 +14114,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdResetQueryPool = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdResetQueryPool);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdResetQueryPool -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdResetQueryPool);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdResetQueryPool = OP_vkCmdResetQueryPool;
- memcpy(streamPtr, &opcode_vkCmdResetQueryPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdResetQueryPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdResetQueryPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdResetQueryPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -10414,24 +14137,45 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_queryCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdWriteTimestamp(
- VkCommandBuffer commandBuffer,
- VkPipelineStageFlagBits pipelineStage,
- VkQueryPool queryPool,
- uint32_t query,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdWriteTimestamp(VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool,
+ uint32_t query, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdWriteTimestamp in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdWriteTimestamp(commandBuffer:%p, queryPool:%p, query:%d)",
+ commandBuffer, queryPool, query);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -10454,20 +14198,23 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdWriteTimestamp = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdWriteTimestamp);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdWriteTimestamp -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdWriteTimestamp);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdWriteTimestamp = OP_vkCmdWriteTimestamp;
- memcpy(streamPtr, &opcode_vkCmdWriteTimestamp, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdWriteTimestamp, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdWriteTimestamp, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdWriteTimestamp, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- memcpy(*streamPtrPtr, (VkPipelineStageFlagBits*)&local_pipelineStage, sizeof(VkPipelineStageFlagBits));
+ memcpy(*streamPtrPtr, (VkPipelineStageFlagBits*)&local_pipelineStage,
+ sizeof(VkPipelineStageFlagBits));
*streamPtrPtr += sizeof(VkPipelineStageFlagBits);
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkQueryPool((*&local_queryPool));
@@ -10475,28 +14222,49 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_query, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdCopyQueryPoolResults(
- VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t queryCount,
- VkBuffer dstBuffer,
- VkDeviceSize dstOffset,
- VkDeviceSize stride,
- VkQueryResultFlags flags,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t firstQuery, uint32_t queryCount,
+ VkBuffer dstBuffer, VkDeviceSize dstOffset,
+ VkDeviceSize stride, VkQueryResultFlags flags,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdCopyQueryPoolResults in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdCopyQueryPoolResults(commandBuffer:%p, queryPool:%p, firstQuery:%d, queryCount:%d, "
+ "dstBuffer:%p, dstOffset:%ld, stride:%ld, flags:%d)",
+ commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -10532,14 +14300,16 @@
*countPtr += sizeof(VkQueryResultFlags);
}
uint32_t packetSize_vkCmdCopyQueryPoolResults = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyQueryPoolResults);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyQueryPoolResults -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyQueryPoolResults);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdCopyQueryPoolResults = OP_vkCmdCopyQueryPoolResults;
- memcpy(streamPtr, &opcode_vkCmdCopyQueryPoolResults, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdCopyQueryPoolResults, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdCopyQueryPoolResults, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdCopyQueryPoolResults, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -10563,26 +14333,47 @@
*streamPtrPtr += sizeof(VkDeviceSize);
memcpy(*streamPtrPtr, (VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags));
*streamPtrPtr += sizeof(VkQueryResultFlags);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdPushConstants(
- VkCommandBuffer commandBuffer,
- VkPipelineLayout layout,
- VkShaderStageFlags stageFlags,
- uint32_t offset,
- uint32_t size,
- const void* pValues,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
+ const void* pValues, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdPushConstants in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdPushConstants(commandBuffer:%p, layout:%p, stageFlags:%d, offset:%d, size:%d, "
+ "pValues:%p)",
+ commandBuffer, layout, stageFlags, offset, size, pValues);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -10612,14 +14403,16 @@
*countPtr += ((size)) * sizeof(uint8_t);
}
uint32_t packetSize_vkCmdPushConstants = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdPushConstants);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdPushConstants -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdPushConstants);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdPushConstants = OP_vkCmdPushConstants;
- memcpy(streamPtr, &opcode_vkCmdPushConstants, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdPushConstants, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdPushConstants, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdPushConstants, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -10637,23 +14430,45 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (void*)local_pValues, ((size)) * sizeof(uint8_t));
*streamPtrPtr += ((size)) * sizeof(uint8_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdBeginRenderPass(
- VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo* pRenderPassBegin,
- VkSubpassContents contents,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ VkSubpassContents contents, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBeginRenderPass in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdBeginRenderPass(commandBuffer:%p, pRenderPassBegin:%p)", commandBuffer,
+ pRenderPassBegin);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -10662,57 +14477,84 @@
VkSubpassContents local_contents;
local_commandBuffer = commandBuffer;
local_pRenderPassBegin = nullptr;
- if (pRenderPassBegin)
- {
- local_pRenderPassBegin = (VkRenderPassBeginInfo*)pool->alloc(sizeof(const VkRenderPassBeginInfo));
- deepcopy_VkRenderPassBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRenderPassBegin, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+ if (pRenderPassBegin) {
+ local_pRenderPassBegin =
+ (VkRenderPassBeginInfo*)pool->alloc(sizeof(const VkRenderPassBeginInfo));
+ deepcopy_VkRenderPassBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRenderPassBegin,
+ (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
}
local_contents = contents;
- if (local_pRenderPassBegin)
- {
- transform_tohost_VkRenderPassBeginInfo(sResourceTracker, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+ if (local_pRenderPassBegin) {
+ transform_tohost_VkRenderPassBeginInfo(sResourceTracker,
+ (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkRenderPassBeginInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRenderPassBeginInfo*)(local_pRenderPassBegin), countPtr);
+ count_VkRenderPassBeginInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderPassBeginInfo*)(local_pRenderPassBegin), countPtr);
*countPtr += sizeof(VkSubpassContents);
}
uint32_t packetSize_vkCmdBeginRenderPass = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBeginRenderPass);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginRenderPass -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBeginRenderPass);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBeginRenderPass = OP_vkCmdBeginRenderPass;
- memcpy(streamPtr, &opcode_vkCmdBeginRenderPass, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBeginRenderPass, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBeginRenderPass, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBeginRenderPass, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkRenderPassBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRenderPassBeginInfo*)(local_pRenderPassBegin), streamPtrPtr);
+ reservedmarshal_VkRenderPassBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderPassBeginInfo*)(local_pRenderPassBegin),
+ streamPtrPtr);
memcpy(*streamPtrPtr, (VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
*streamPtrPtr += sizeof(VkSubpassContents);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdNextSubpass(
- VkCommandBuffer commandBuffer,
- VkSubpassContents contents,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdNextSubpass in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdNextSubpass(commandBuffer:%p)", commandBuffer);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -10728,14 +14570,16 @@
*countPtr += sizeof(VkSubpassContents);
}
uint32_t packetSize_vkCmdNextSubpass = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdNextSubpass);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdNextSubpass -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdNextSubpass);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdNextSubpass = OP_vkCmdNextSubpass;
- memcpy(streamPtr, &opcode_vkCmdNextSubpass, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdNextSubpass, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdNextSubpass, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdNextSubpass, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -10743,21 +14587,42 @@
}
memcpy(*streamPtrPtr, (VkSubpassContents*)&local_contents, sizeof(VkSubpassContents));
*streamPtrPtr += sizeof(VkSubpassContents);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdEndRenderPass(
- VkCommandBuffer commandBuffer,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdEndRenderPass(VkCommandBuffer commandBuffer, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdEndRenderPass in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdEndRenderPass(commandBuffer:%p)", commandBuffer);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -10770,36 +14635,60 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkCmdEndRenderPass = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdEndRenderPass);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEndRenderPass -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdEndRenderPass);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdEndRenderPass = OP_vkCmdEndRenderPass;
- memcpy(streamPtr, &opcode_vkCmdEndRenderPass, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdEndRenderPass, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdEndRenderPass, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdEndRenderPass, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdExecuteCommands(
- VkCommandBuffer commandBuffer,
- uint32_t commandBufferCount,
- const VkCommandBuffer* pCommandBuffers,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdExecuteCommands in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdExecuteCommands(commandBuffer:%p, commandBufferCount:%d, pCommandBuffers:%p)",
+ commandBuffer, commandBufferCount, pCommandBuffers);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -10816,20 +14705,21 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- if (((commandBufferCount)))
- {
+ if (((commandBufferCount))) {
*countPtr += ((commandBufferCount)) * 8;
}
}
uint32_t packetSize_vkCmdExecuteCommands = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdExecuteCommands);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdExecuteCommands -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdExecuteCommands);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdExecuteCommands = OP_vkCmdExecuteCommands;
- memcpy(streamPtr, &opcode_vkCmdExecuteCommands, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdExecuteCommands, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdExecuteCommands, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdExecuteCommands, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -10837,19 +14727,17 @@
}
memcpy(*streamPtrPtr, (uint32_t*)&local_commandBufferCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (((commandBufferCount)))
- {
+ if (((commandBufferCount))) {
uint8_t* cgen_var_0_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((commandBufferCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((commandBufferCount)); ++k) {
uint64_t tmpval = get_host_u64_VkCommandBuffer(local_pCommandBuffers[k]);
memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
*streamPtrPtr += 8 * ((commandBufferCount));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -10858,36 +14746,64 @@
#endif
#ifdef VK_VERSION_1_1
-VkResult VkEncoder::vkEnumerateInstanceVersion(
- uint32_t* pApiVersion,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkEnumerateInstanceVersion(uint32_t* pApiVersion, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkEnumerateInstanceVersion in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkEnumerateInstanceVersion(pApiVersion:%p)", pApiVersion);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
size_t count = 0;
size_t* countPtr = &count;
- {
- *countPtr += sizeof(uint32_t);
- }
- uint32_t packetSize_vkEnumerateInstanceVersion = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ { *countPtr += sizeof(uint32_t); }
+ uint32_t packetSize_vkEnumerateInstanceVersion =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkEnumerateInstanceVersion);
uint8_t* streamPtr = stream->reserve(packetSize_vkEnumerateInstanceVersion);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkEnumerateInstanceVersion = OP_vkEnumerateInstanceVersion;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkEnumerateInstanceVersion, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkEnumerateInstanceVersion, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkEnumerateInstanceVersion, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkEnumerateInstanceVersion, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
memcpy(*streamPtrPtr, (uint32_t*)pApiVersion, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
stream->read((uint32_t*)pApiVersion, sizeof(uint32_t));
VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
stream->read(&vkEnumerateInstanceVersion_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -10895,14 +14811,35 @@
return vkEnumerateInstanceVersion_VkResult_return;
}
-VkResult VkEncoder::vkBindBufferMemory2(
- VkDevice device,
- uint32_t bindInfoCount,
- const VkBindBufferMemoryInfo* pBindInfos,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkBindBufferMemory2 in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkBindBufferMemory2(device:%p, bindInfoCount:%d, pBindInfos:%p)", device,
+ bindInfoCount, pBindInfos);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -10912,19 +14849,18 @@
local_device = device;
local_bindInfoCount = bindInfoCount;
local_pBindInfos = nullptr;
- if (pBindInfos)
- {
- local_pBindInfos = (VkBindBufferMemoryInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindBufferMemoryInfo));
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- deepcopy_VkBindBufferMemoryInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfos + i, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
+ if (pBindInfos) {
+ local_pBindInfos = (VkBindBufferMemoryInfo*)pool->alloc(
+ ((bindInfoCount)) * sizeof(const VkBindBufferMemoryInfo));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ deepcopy_VkBindBufferMemoryInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfos + i,
+ (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
}
}
- if (local_pBindInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- transform_tohost_VkBindBufferMemoryInfo(sResourceTracker, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
+ if (local_pBindInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ transform_tohost_VkBindBufferMemoryInfo(
+ sResourceTracker, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
}
}
size_t count = 0;
@@ -10933,34 +14869,44 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- count_VkBindBufferMemoryInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindBufferMemoryInfo*)(local_pBindInfos + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ count_VkBindBufferMemoryInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBindBufferMemoryInfo*)(local_pBindInfos + i), countPtr);
}
}
- uint32_t packetSize_vkBindBufferMemory2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkBindBufferMemory2 =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkBindBufferMemory2);
uint8_t* streamPtr = stream->reserve(packetSize_vkBindBufferMemory2);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkBindBufferMemory2 = OP_vkBindBufferMemory2;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkBindBufferMemory2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkBindBufferMemory2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkBindBufferMemory2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkBindBufferMemory2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- reservedmarshal_VkBindBufferMemoryInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindBufferMemoryInfo*)(local_pBindInfos + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ reservedmarshal_VkBindBufferMemoryInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBindBufferMemoryInfo*)(local_pBindInfos + i),
+ streamPtrPtr);
}
VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
stream->read(&vkBindBufferMemory2_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -10968,14 +14914,35 @@
return vkBindBufferMemory2_VkResult_return;
}
-VkResult VkEncoder::vkBindImageMemory2(
- VkDevice device,
- uint32_t bindInfoCount,
- const VkBindImageMemoryInfo* pBindInfos,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkBindImageMemory2 in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkBindImageMemory2(device:%p, bindInfoCount:%d, pBindInfos:%p)", device,
+ bindInfoCount, pBindInfos);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -10985,19 +14952,18 @@
local_device = device;
local_bindInfoCount = bindInfoCount;
local_pBindInfos = nullptr;
- if (pBindInfos)
- {
- local_pBindInfos = (VkBindImageMemoryInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindImageMemoryInfo));
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- deepcopy_VkBindImageMemoryInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfos + i, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
+ if (pBindInfos) {
+ local_pBindInfos = (VkBindImageMemoryInfo*)pool->alloc(((bindInfoCount)) *
+ sizeof(const VkBindImageMemoryInfo));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ deepcopy_VkBindImageMemoryInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfos + i,
+ (VkBindImageMemoryInfo*)(local_pBindInfos + i));
}
}
- if (local_pBindInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- transform_tohost_VkBindImageMemoryInfo(sResourceTracker, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
+ if (local_pBindInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ transform_tohost_VkBindImageMemoryInfo(sResourceTracker,
+ (VkBindImageMemoryInfo*)(local_pBindInfos + i));
}
}
size_t count = 0;
@@ -11006,34 +14972,44 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- count_VkBindImageMemoryInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindImageMemoryInfo*)(local_pBindInfos + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ count_VkBindImageMemoryInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBindImageMemoryInfo*)(local_pBindInfos + i), countPtr);
}
}
- uint32_t packetSize_vkBindImageMemory2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkBindImageMemory2 =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkBindImageMemory2);
uint8_t* streamPtr = stream->reserve(packetSize_vkBindImageMemory2);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkBindImageMemory2 = OP_vkBindImageMemory2;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkBindImageMemory2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkBindImageMemory2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkBindImageMemory2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkBindImageMemory2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- reservedmarshal_VkBindImageMemoryInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindImageMemoryInfo*)(local_pBindInfos + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ reservedmarshal_VkBindImageMemoryInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBindImageMemoryInfo*)(local_pBindInfos + i),
+ streamPtrPtr);
}
VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
stream->read(&vkBindImageMemory2_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -11041,16 +15017,40 @@
return vkBindImageMemory2_VkResult_return;
}
-void VkEncoder::vkGetDeviceGroupPeerMemoryFeatures(
- VkDevice device,
- uint32_t heapIndex,
- uint32_t localDeviceIndex,
- uint32_t remoteDeviceIndex,
- VkPeerMemoryFeatureFlags* pPeerMemoryFeatures,
- uint32_t doLock)
-{
+void VkEncoder::vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetDeviceGroupPeerMemoryFeatures in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetDeviceGroupPeerMemoryFeatures(device:%p, heapIndex:%d, localDeviceIndex:%d, "
+ "remoteDeviceIndex:%d, pPeerMemoryFeatures:%p)",
+ device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -11072,14 +15072,24 @@
*countPtr += sizeof(uint32_t);
*countPtr += sizeof(VkPeerMemoryFeatureFlags);
}
- uint32_t packetSize_vkGetDeviceGroupPeerMemoryFeatures = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDeviceGroupPeerMemoryFeatures =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDeviceGroupPeerMemoryFeatures);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceGroupPeerMemoryFeatures);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDeviceGroupPeerMemoryFeatures = OP_vkGetDeviceGroupPeerMemoryFeatures;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDeviceGroupPeerMemoryFeatures, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDeviceGroupPeerMemoryFeatures, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDeviceGroupPeerMemoryFeatures, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDeviceGroupPeerMemoryFeatures, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -11090,25 +15100,48 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- memcpy(*streamPtrPtr, (VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
+ memcpy(*streamPtrPtr, (VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures,
+ sizeof(VkPeerMemoryFeatureFlags));
*streamPtrPtr += sizeof(VkPeerMemoryFeatureFlags);
stream->read((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetDeviceMask(
- VkCommandBuffer commandBuffer,
- uint32_t deviceMask,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetDeviceMask in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetDeviceMask(commandBuffer:%p, deviceMask:%d)", commandBuffer,
+ deviceMask);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -11124,14 +15157,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdSetDeviceMask = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetDeviceMask);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDeviceMask -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDeviceMask);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetDeviceMask = OP_vkCmdSetDeviceMask;
- memcpy(streamPtr, &opcode_vkCmdSetDeviceMask, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetDeviceMask, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetDeviceMask, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetDeviceMask, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -11139,27 +15174,47 @@
}
memcpy(*streamPtrPtr, (uint32_t*)&local_deviceMask, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdDispatchBase(
- VkCommandBuffer commandBuffer,
- uint32_t baseGroupX,
- uint32_t baseGroupY,
- uint32_t baseGroupZ,
- uint32_t groupCountX,
- uint32_t groupCountY,
- uint32_t groupCountZ,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX,
+ uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX,
+ uint32_t groupCountY, uint32_t groupCountZ, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDispatchBase in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdDispatchBase(commandBuffer:%p, baseGroupX:%d, baseGroupY:%d, baseGroupZ:%d, "
+ "groupCountX:%d, groupCountY:%d, groupCountZ:%d)",
+ commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -11190,14 +15245,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDispatchBase = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDispatchBase);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDispatchBase -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDispatchBase);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDispatchBase = OP_vkCmdDispatchBase;
- memcpy(streamPtr, &opcode_vkCmdDispatchBase, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDispatchBase, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDispatchBase, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDispatchBase, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -11215,9 +15272,9 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_groupCountZ, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -11225,13 +15282,37 @@
}
VkResult VkEncoder::vkEnumeratePhysicalDeviceGroups(
- VkInstance instance,
- uint32_t* pPhysicalDeviceGroupCount,
- VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties,
- uint32_t doLock)
-{
+ VkInstance instance, uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkEnumeratePhysicalDeviceGroups in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkEnumeratePhysicalDeviceGroups(instance:%p, pPhysicalDeviceGroupCount:%p, "
+ "pPhysicalDeviceGroupProperties:%p)",
+ instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -11244,31 +15325,40 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pPhysicalDeviceGroupCount)
- {
+ if (pPhysicalDeviceGroupCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pPhysicalDeviceGroupProperties)
- {
- if (pPhysicalDeviceGroupCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
- {
- count_VkPhysicalDeviceGroupProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i), countPtr);
+ if (pPhysicalDeviceGroupProperties) {
+ if (pPhysicalDeviceGroupCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i) {
+ count_VkPhysicalDeviceGroupProperties(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i),
+ countPtr);
}
}
}
}
- uint32_t packetSize_vkEnumeratePhysicalDeviceGroups = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkEnumeratePhysicalDeviceGroups =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkEnumeratePhysicalDeviceGroups);
uint8_t* streamPtr = stream->reserve(packetSize_vkEnumeratePhysicalDeviceGroups);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkEnumeratePhysicalDeviceGroups = OP_vkEnumeratePhysicalDeviceGroups;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkEnumeratePhysicalDeviceGroups, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkEnumeratePhysicalDeviceGroups, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkEnumeratePhysicalDeviceGroups, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkEnumeratePhysicalDeviceGroups, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -11278,8 +15368,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPhysicalDeviceGroupCount)
- {
+ if (pPhysicalDeviceGroupCount) {
memcpy(*streamPtrPtr, (uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -11288,56 +15377,55 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPhysicalDeviceGroupProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
- {
- reservedmarshal_VkPhysicalDeviceGroupProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i), streamPtrPtr);
+ if (pPhysicalDeviceGroupProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i) {
+ reservedmarshal_VkPhysicalDeviceGroupProperties(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i),
+ streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pPhysicalDeviceGroupCount;
check_pPhysicalDeviceGroupCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pPhysicalDeviceGroupCount)
- {
- if (!(check_pPhysicalDeviceGroupCount))
- {
- fprintf(stderr, "fatal: pPhysicalDeviceGroupCount inconsistent between guest and host\n");
+ if (pPhysicalDeviceGroupCount) {
+ if (!(check_pPhysicalDeviceGroupCount)) {
+ fprintf(stderr,
+ "fatal: pPhysicalDeviceGroupCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
VkPhysicalDeviceGroupProperties* check_pPhysicalDeviceGroupProperties;
- check_pPhysicalDeviceGroupProperties = (VkPhysicalDeviceGroupProperties*)(uintptr_t)stream->getBe64();
- if (pPhysicalDeviceGroupProperties)
- {
- if (!(check_pPhysicalDeviceGroupProperties))
- {
- fprintf(stderr, "fatal: pPhysicalDeviceGroupProperties inconsistent between guest and host\n");
+ check_pPhysicalDeviceGroupProperties =
+ (VkPhysicalDeviceGroupProperties*)(uintptr_t)stream->getBe64();
+ if (pPhysicalDeviceGroupProperties) {
+ if (!(check_pPhysicalDeviceGroupProperties)) {
+ fprintf(stderr,
+ "fatal: pPhysicalDeviceGroupProperties inconsistent between guest and host\n");
}
- if (pPhysicalDeviceGroupCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
- {
- unmarshal_VkPhysicalDeviceGroupProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
+ if (pPhysicalDeviceGroupCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i) {
+ unmarshal_VkPhysicalDeviceGroupProperties(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
}
}
}
- if (pPhysicalDeviceGroupCount)
- {
- if (pPhysicalDeviceGroupProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
- {
- transform_fromhost_VkPhysicalDeviceGroupProperties(sResourceTracker, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
+ if (pPhysicalDeviceGroupCount) {
+ if (pPhysicalDeviceGroupProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i) {
+ transform_fromhost_VkPhysicalDeviceGroupProperties(
+ sResourceTracker,
+ (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
}
}
}
VkResult vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
stream->read(&vkEnumeratePhysicalDeviceGroups_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -11345,14 +15433,37 @@
return vkEnumeratePhysicalDeviceGroups_VkResult_return;
}
-void VkEncoder::vkGetImageMemoryRequirements2(
- VkDevice device,
- const VkImageMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements,
- uint32_t doLock)
-{
+void VkEncoder::vkGetImageMemoryRequirements2(VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetImageMemoryRequirements2 in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetImageMemoryRequirements2(device:%p, pInfo:%p, pMemoryRequirements:%p)",
+ device, pInfo, pMemoryRequirements);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -11360,59 +15471,101 @@
VkImageMemoryRequirementsInfo2* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkImageMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkImageMemoryRequirementsInfo2));
- deepcopy_VkImageMemoryRequirementsInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkImageMemoryRequirementsInfo2*)pool->alloc(
+ sizeof(const VkImageMemoryRequirementsInfo2));
+ deepcopy_VkImageMemoryRequirementsInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkImageMemoryRequirementsInfo2*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkImageMemoryRequirementsInfo2(sResourceTracker, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkImageMemoryRequirementsInfo2(
+ sResourceTracker, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImageMemoryRequirementsInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageMemoryRequirementsInfo2*)(local_pInfo), countPtr);
- count_VkMemoryRequirements2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements), countPtr);
+ count_VkImageMemoryRequirementsInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageMemoryRequirementsInfo2*)(local_pInfo),
+ countPtr);
+ count_VkMemoryRequirements2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements), countPtr);
}
- uint32_t packetSize_vkGetImageMemoryRequirements2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetImageMemoryRequirements2 =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetImageMemoryRequirements2);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageMemoryRequirements2);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetImageMemoryRequirements2 = OP_vkGetImageMemoryRequirements2;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetImageMemoryRequirements2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetImageMemoryRequirements2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetImageMemoryRequirements2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetImageMemoryRequirements2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageMemoryRequirementsInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageMemoryRequirementsInfo2*)(local_pInfo), streamPtrPtr);
- reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements), streamPtrPtr);
- unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements));
- if (pMemoryRequirements)
- {
- transform_fromhost_VkMemoryRequirements2(sResourceTracker, (VkMemoryRequirements2*)(pMemoryRequirements));
+ reservedmarshal_VkImageMemoryRequirementsInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageMemoryRequirementsInfo2*)(local_pInfo),
+ streamPtrPtr);
+ reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements),
+ streamPtrPtr);
+ unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements));
+ if (pMemoryRequirements) {
+ transform_fromhost_VkMemoryRequirements2(sResourceTracker,
+ (VkMemoryRequirements2*)(pMemoryRequirements));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkGetBufferMemoryRequirements2(
- VkDevice device,
- const VkBufferMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements,
- uint32_t doLock)
-{
+void VkEncoder::vkGetBufferMemoryRequirements2(VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetBufferMemoryRequirements2 in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetBufferMemoryRequirements2(device:%p, pInfo:%p, pMemoryRequirements:%p)",
+ device, pInfo, pMemoryRequirements);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -11420,45 +15573,64 @@
VkBufferMemoryRequirementsInfo2* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkBufferMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkBufferMemoryRequirementsInfo2));
- deepcopy_VkBufferMemoryRequirementsInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkBufferMemoryRequirementsInfo2*)pool->alloc(
+ sizeof(const VkBufferMemoryRequirementsInfo2));
+ deepcopy_VkBufferMemoryRequirementsInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkBufferMemoryRequirementsInfo2(sResourceTracker, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkBufferMemoryRequirementsInfo2(
+ sResourceTracker, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferMemoryRequirementsInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferMemoryRequirementsInfo2*)(local_pInfo), countPtr);
- count_VkMemoryRequirements2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements), countPtr);
+ count_VkBufferMemoryRequirementsInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferMemoryRequirementsInfo2*)(local_pInfo),
+ countPtr);
+ count_VkMemoryRequirements2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements), countPtr);
}
- uint32_t packetSize_vkGetBufferMemoryRequirements2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetBufferMemoryRequirements2 =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetBufferMemoryRequirements2);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferMemoryRequirements2);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetBufferMemoryRequirements2 = OP_vkGetBufferMemoryRequirements2;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetBufferMemoryRequirements2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetBufferMemoryRequirements2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetBufferMemoryRequirements2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetBufferMemoryRequirements2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferMemoryRequirementsInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferMemoryRequirementsInfo2*)(local_pInfo), streamPtrPtr);
- reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements), streamPtrPtr);
- unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements));
- if (pMemoryRequirements)
- {
- transform_fromhost_VkMemoryRequirements2(sResourceTracker, (VkMemoryRequirements2*)(pMemoryRequirements));
+ reservedmarshal_VkBufferMemoryRequirementsInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferMemoryRequirementsInfo2*)(local_pInfo),
+ streamPtrPtr);
+ reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements),
+ streamPtrPtr);
+ unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements));
+ if (pMemoryRequirements) {
+ transform_fromhost_VkMemoryRequirements2(sResourceTracker,
+ (VkMemoryRequirements2*)(pMemoryRequirements));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -11466,14 +15638,38 @@
}
void VkEncoder::vkGetImageSparseMemoryRequirements2(
- VkDevice device,
- const VkImageSparseMemoryRequirementsInfo2* pInfo,
+ VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements,
- uint32_t doLock)
-{
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetImageSparseMemoryRequirements2 in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetImageSparseMemoryRequirements2(device:%p, pInfo:%p, "
+ "pSparseMemoryRequirementCount:%p, pSparseMemoryRequirements:%p)",
+ device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -11481,60 +15677,74 @@
VkImageSparseMemoryRequirementsInfo2* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkImageSparseMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkImageSparseMemoryRequirementsInfo2));
- deepcopy_VkImageSparseMemoryRequirementsInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkImageSparseMemoryRequirementsInfo2*)pool->alloc(
+ sizeof(const VkImageSparseMemoryRequirementsInfo2));
+ deepcopy_VkImageSparseMemoryRequirementsInfo2(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkImageSparseMemoryRequirementsInfo2(sResourceTracker, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkImageSparseMemoryRequirementsInfo2(
+ sResourceTracker, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImageSparseMemoryRequirementsInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo), countPtr);
+ count_VkImageSparseMemoryRequirementsInfo2(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (pSparseMemoryRequirementCount)
- {
+ if (pSparseMemoryRequirementCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pSparseMemoryRequirements)
- {
- if (pSparseMemoryRequirementCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
- {
- count_VkSparseImageMemoryRequirements2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), countPtr);
+ if (pSparseMemoryRequirements) {
+ if (pSparseMemoryRequirementCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
+ count_VkSparseImageMemoryRequirements2(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i),
+ countPtr);
}
}
}
}
- uint32_t packetSize_vkGetImageSparseMemoryRequirements2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetImageSparseMemoryRequirements2 =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetImageSparseMemoryRequirements2);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageSparseMemoryRequirements2);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetImageSparseMemoryRequirements2 = OP_vkGetImageSparseMemoryRequirements2;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetImageSparseMemoryRequirements2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetImageSparseMemoryRequirements2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetImageSparseMemoryRequirements2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetImageSparseMemoryRequirements2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageSparseMemoryRequirementsInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkImageSparseMemoryRequirementsInfo2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pSparseMemoryRequirementCount)
- {
+ if (pSparseMemoryRequirementCount) {
memcpy(*streamPtrPtr, (uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -11543,67 +15753,88 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pSparseMemoryRequirements)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
- {
- reservedmarshal_VkSparseImageMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), streamPtrPtr);
+ if (pSparseMemoryRequirements) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
+ reservedmarshal_VkSparseImageMemoryRequirements2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pSparseMemoryRequirementCount;
check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pSparseMemoryRequirementCount)
- {
- if (!(check_pSparseMemoryRequirementCount))
- {
- fprintf(stderr, "fatal: pSparseMemoryRequirementCount inconsistent between guest and host\n");
+ if (pSparseMemoryRequirementCount) {
+ if (!(check_pSparseMemoryRequirementCount)) {
+ fprintf(stderr,
+ "fatal: pSparseMemoryRequirementCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
VkSparseImageMemoryRequirements2* check_pSparseMemoryRequirements;
- check_pSparseMemoryRequirements = (VkSparseImageMemoryRequirements2*)(uintptr_t)stream->getBe64();
- if (pSparseMemoryRequirements)
- {
- if (!(check_pSparseMemoryRequirements))
- {
- fprintf(stderr, "fatal: pSparseMemoryRequirements inconsistent between guest and host\n");
+ check_pSparseMemoryRequirements =
+ (VkSparseImageMemoryRequirements2*)(uintptr_t)stream->getBe64();
+ if (pSparseMemoryRequirements) {
+ if (!(check_pSparseMemoryRequirements)) {
+ fprintf(stderr,
+ "fatal: pSparseMemoryRequirements inconsistent between guest and host\n");
}
- if (pSparseMemoryRequirementCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
- {
- unmarshal_VkSparseImageMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+ if (pSparseMemoryRequirementCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
+ unmarshal_VkSparseImageMemoryRequirements2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
}
}
}
- if (pSparseMemoryRequirementCount)
- {
- if (pSparseMemoryRequirements)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
- {
- transform_fromhost_VkSparseImageMemoryRequirements2(sResourceTracker, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+ if (pSparseMemoryRequirementCount) {
+ if (pSparseMemoryRequirements) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
+ transform_fromhost_VkSparseImageMemoryRequirements2(
+ sResourceTracker,
+ (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
}
}
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkGetPhysicalDeviceFeatures2(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures2* pFeatures,
- uint32_t doLock)
-{
+void VkEncoder::vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetPhysicalDeviceFeatures2 in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetPhysicalDeviceFeatures2(physicalDevice:%p, pFeatures:%p)",
+ physicalDevice, pFeatures);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -11614,43 +15845,79 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceFeatures2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFeatures2*)(pFeatures), countPtr);
+ count_VkPhysicalDeviceFeatures2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceFeatures2*)(pFeatures), countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceFeatures2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceFeatures2 =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceFeatures2);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceFeatures2);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceFeatures2 = OP_vkGetPhysicalDeviceFeatures2;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceFeatures2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceFeatures2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceFeatures2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceFeatures2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceFeatures2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFeatures2*)(pFeatures), streamPtrPtr);
- unmarshal_VkPhysicalDeviceFeatures2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFeatures2*)(pFeatures));
- if (pFeatures)
- {
- transform_fromhost_VkPhysicalDeviceFeatures2(sResourceTracker, (VkPhysicalDeviceFeatures2*)(pFeatures));
+ reservedmarshal_VkPhysicalDeviceFeatures2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFeatures2*)(pFeatures), streamPtrPtr);
+ unmarshal_VkPhysicalDeviceFeatures2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceFeatures2*)(pFeatures));
+ if (pFeatures) {
+ transform_fromhost_VkPhysicalDeviceFeatures2(sResourceTracker,
+ (VkPhysicalDeviceFeatures2*)(pFeatures));
}
sResourceTracker->on_vkGetPhysicalDeviceFeatures2(this, physicalDevice, pFeatures);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkGetPhysicalDeviceProperties2(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties2* pProperties,
- uint32_t doLock)
-{
+void VkEncoder::vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetPhysicalDeviceProperties2 in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetPhysicalDeviceProperties2(physicalDevice:%p, pProperties:%p)",
+ physicalDevice, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -11661,44 +15928,82 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceProperties2*)(pProperties), countPtr);
+ count_VkPhysicalDeviceProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceProperties2*)(pProperties), countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceProperties2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceProperties2 =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceProperties2);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceProperties2);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceProperties2 = OP_vkGetPhysicalDeviceProperties2;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceProperties2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceProperties2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceProperties2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceProperties2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceProperties2*)(pProperties), streamPtrPtr);
- unmarshal_VkPhysicalDeviceProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceProperties2*)(pProperties));
- if (pProperties)
- {
- transform_fromhost_VkPhysicalDeviceProperties2(sResourceTracker, (VkPhysicalDeviceProperties2*)(pProperties));
+ reservedmarshal_VkPhysicalDeviceProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceProperties2*)(pProperties),
+ streamPtrPtr);
+ unmarshal_VkPhysicalDeviceProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceProperties2*)(pProperties));
+ if (pProperties) {
+ transform_fromhost_VkPhysicalDeviceProperties2(sResourceTracker,
+ (VkPhysicalDeviceProperties2*)(pProperties));
}
sResourceTracker->on_vkGetPhysicalDeviceProperties2(this, physicalDevice, pProperties);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkGetPhysicalDeviceFormatProperties2(
- VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties2* pFormatProperties,
- uint32_t doLock)
-{
+void VkEncoder::vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2* pFormatProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetPhysicalDeviceFormatProperties2 in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceFormatProperties2(physicalDevice:%p, format:%d, pFormatProperties:%p)",
+ physicalDevice, format, pFormatProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -11712,31 +16017,44 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(VkFormat);
- count_VkFormatProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFormatProperties2*)(pFormatProperties), countPtr);
+ count_VkFormatProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkFormatProperties2*)(pFormatProperties), countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceFormatProperties2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceFormatProperties2 =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceFormatProperties2);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceFormatProperties2);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceFormatProperties2 = OP_vkGetPhysicalDeviceFormatProperties2;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceFormatProperties2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceFormatProperties2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceFormatProperties2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceFormatProperties2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkFormat*)&local_format, sizeof(VkFormat));
*streamPtrPtr += sizeof(VkFormat);
- reservedmarshal_VkFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFormatProperties2*)(pFormatProperties), streamPtrPtr);
- unmarshal_VkFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFormatProperties2*)(pFormatProperties));
- if (pFormatProperties)
- {
- transform_fromhost_VkFormatProperties2(sResourceTracker, (VkFormatProperties2*)(pFormatProperties));
+ reservedmarshal_VkFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkFormatProperties2*)(pFormatProperties), streamPtrPtr);
+ unmarshal_VkFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkFormatProperties2*)(pFormatProperties));
+ if (pFormatProperties) {
+ transform_fromhost_VkFormatProperties2(sResourceTracker,
+ (VkFormatProperties2*)(pFormatProperties));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -11744,13 +16062,38 @@
}
VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties2(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
- VkImageFormatProperties2* pImageFormatProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+ VkImageFormatProperties2* pImageFormatProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceImageFormatProperties2 in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceImageFormatProperties2(physicalDevice:%p, pImageFormatInfo:%p, "
+ "pImageFormatProperties:%p)",
+ physicalDevice, pImageFormatInfo, pImageFormatProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -11758,47 +16101,69 @@
VkPhysicalDeviceImageFormatInfo2* local_pImageFormatInfo;
local_physicalDevice = physicalDevice;
local_pImageFormatInfo = nullptr;
- if (pImageFormatInfo)
- {
- local_pImageFormatInfo = (VkPhysicalDeviceImageFormatInfo2*)pool->alloc(sizeof(const VkPhysicalDeviceImageFormatInfo2));
- deepcopy_VkPhysicalDeviceImageFormatInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImageFormatInfo, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
+ if (pImageFormatInfo) {
+ local_pImageFormatInfo = (VkPhysicalDeviceImageFormatInfo2*)pool->alloc(
+ sizeof(const VkPhysicalDeviceImageFormatInfo2));
+ deepcopy_VkPhysicalDeviceImageFormatInfo2(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImageFormatInfo,
+ (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
}
- if (local_pImageFormatInfo)
- {
- transform_tohost_VkPhysicalDeviceImageFormatInfo2(sResourceTracker, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
+ if (local_pImageFormatInfo) {
+ transform_tohost_VkPhysicalDeviceImageFormatInfo2(
+ sResourceTracker, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceImageFormatInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo), countPtr);
- count_VkImageFormatProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageFormatProperties2*)(pImageFormatProperties), countPtr);
+ count_VkPhysicalDeviceImageFormatInfo2(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo), countPtr);
+ count_VkImageFormatProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageFormatProperties2*)(pImageFormatProperties),
+ countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceImageFormatProperties2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceImageFormatProperties2 =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceImageFormatProperties2);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceImageFormatProperties2);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceImageFormatProperties2 = OP_vkGetPhysicalDeviceImageFormatProperties2;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceImageFormatProperties2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceImageFormatProperties2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceImageFormatProperties2 =
+ OP_vkGetPhysicalDeviceImageFormatProperties2;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceImageFormatProperties2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceImageFormatProperties2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceImageFormatInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo), streamPtrPtr);
- reservedmarshal_VkImageFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageFormatProperties2*)(pImageFormatProperties), streamPtrPtr);
- unmarshal_VkImageFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageFormatProperties2*)(pImageFormatProperties));
- if (pImageFormatProperties)
- {
- transform_fromhost_VkImageFormatProperties2(sResourceTracker, (VkImageFormatProperties2*)(pImageFormatProperties));
+ reservedmarshal_VkPhysicalDeviceImageFormatInfo2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo), streamPtrPtr);
+ reservedmarshal_VkImageFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageFormatProperties2*)(pImageFormatProperties),
+ streamPtrPtr);
+ unmarshal_VkImageFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageFormatProperties2*)(pImageFormatProperties));
+ if (pImageFormatProperties) {
+ transform_fromhost_VkImageFormatProperties2(
+ sResourceTracker, (VkImageFormatProperties2*)(pImageFormatProperties));
}
VkResult vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDeviceImageFormatProperties2_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -11807,13 +16172,38 @@
}
void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2(
- VkPhysicalDevice physicalDevice,
- uint32_t* pQueueFamilyPropertyCount,
- VkQueueFamilyProperties2* pQueueFamilyProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2* pQueueFamilyProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceQueueFamilyProperties2 in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice:%p, "
+ "pQueueFamilyPropertyCount:%p, pQueueFamilyProperties:%p)",
+ physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -11826,31 +16216,40 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pQueueFamilyPropertyCount)
- {
+ if (pQueueFamilyPropertyCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pQueueFamilyProperties)
- {
- if (pQueueFamilyPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
- {
- count_VkQueueFamilyProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i), countPtr);
+ if (pQueueFamilyProperties) {
+ if (pQueueFamilyPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
+ count_VkQueueFamilyProperties2(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPhysicalDeviceQueueFamilyProperties2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceQueueFamilyProperties2 =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceQueueFamilyProperties2);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceQueueFamilyProperties2);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceQueueFamilyProperties2 = OP_vkGetPhysicalDeviceQueueFamilyProperties2;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceQueueFamilyProperties2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceQueueFamilyProperties2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceQueueFamilyProperties2 =
+ OP_vkGetPhysicalDeviceQueueFamilyProperties2;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceQueueFamilyProperties2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceQueueFamilyProperties2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -11860,8 +16259,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pQueueFamilyPropertyCount)
- {
+ if (pQueueFamilyPropertyCount) {
memcpy(*streamPtrPtr, (uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -11870,54 +16268,49 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pQueueFamilyProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
- {
- reservedmarshal_VkQueueFamilyProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i), streamPtrPtr);
+ if (pQueueFamilyProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
+ reservedmarshal_VkQueueFamilyProperties2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pQueueFamilyPropertyCount;
check_pQueueFamilyPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pQueueFamilyPropertyCount)
- {
- if (!(check_pQueueFamilyPropertyCount))
- {
- fprintf(stderr, "fatal: pQueueFamilyPropertyCount inconsistent between guest and host\n");
+ if (pQueueFamilyPropertyCount) {
+ if (!(check_pQueueFamilyPropertyCount)) {
+ fprintf(stderr,
+ "fatal: pQueueFamilyPropertyCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
VkQueueFamilyProperties2* check_pQueueFamilyProperties;
check_pQueueFamilyProperties = (VkQueueFamilyProperties2*)(uintptr_t)stream->getBe64();
- if (pQueueFamilyProperties)
- {
- if (!(check_pQueueFamilyProperties))
- {
+ if (pQueueFamilyProperties) {
+ if (!(check_pQueueFamilyProperties)) {
fprintf(stderr, "fatal: pQueueFamilyProperties inconsistent between guest and host\n");
}
- if (pQueueFamilyPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
- {
- unmarshal_VkQueueFamilyProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
+ if (pQueueFamilyPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
+ unmarshal_VkQueueFamilyProperties2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
}
}
}
- if (pQueueFamilyPropertyCount)
- {
- if (pQueueFamilyProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
- {
- transform_fromhost_VkQueueFamilyProperties2(sResourceTracker, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
+ if (pQueueFamilyPropertyCount) {
+ if (pQueueFamilyProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
+ transform_fromhost_VkQueueFamilyProperties2(
+ sResourceTracker, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
}
}
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -11925,12 +16318,36 @@
}
void VkEncoder::vkGetPhysicalDeviceMemoryProperties2(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceMemoryProperties2* pMemoryProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetPhysicalDeviceMemoryProperties2 in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceMemoryProperties2(physicalDevice:%p, pMemoryProperties:%p)",
+ physicalDevice, pMemoryProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -11941,30 +16358,47 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceMemoryProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties), countPtr);
+ count_VkPhysicalDeviceMemoryProperties2(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties), countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties2 =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceMemoryProperties2);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceMemoryProperties2);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceMemoryProperties2 = OP_vkGetPhysicalDeviceMemoryProperties2;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceMemoryProperties2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceMemoryProperties2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceMemoryProperties2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceMemoryProperties2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceMemoryProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties), streamPtrPtr);
- unmarshal_VkPhysicalDeviceMemoryProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
- if (pMemoryProperties)
- {
- transform_fromhost_VkPhysicalDeviceMemoryProperties2(sResourceTracker, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
+ reservedmarshal_VkPhysicalDeviceMemoryProperties2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties),
+ streamPtrPtr);
+ unmarshal_VkPhysicalDeviceMemoryProperties2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
+ if (pMemoryProperties) {
+ transform_fromhost_VkPhysicalDeviceMemoryProperties2(
+ sResourceTracker, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
}
- sResourceTracker->on_vkGetPhysicalDeviceMemoryProperties2(this, physicalDevice, pMemoryProperties);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ sResourceTracker->on_vkGetPhysicalDeviceMemoryProperties2(this, physicalDevice,
+ pMemoryProperties);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -11972,14 +16406,38 @@
}
void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
- uint32_t* pPropertyCount,
- VkSparseImageFormatProperties2* pProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+ uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceSparseImageFormatProperties2 in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice:%p, pFormatInfo:%p, "
+ "pPropertyCount:%p, pProperties:%p)",
+ physicalDevice, pFormatInfo, pPropertyCount, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -11987,60 +16445,76 @@
VkPhysicalDeviceSparseImageFormatInfo2* local_pFormatInfo;
local_physicalDevice = physicalDevice;
local_pFormatInfo = nullptr;
- if (pFormatInfo)
- {
- local_pFormatInfo = (VkPhysicalDeviceSparseImageFormatInfo2*)pool->alloc(sizeof(const VkPhysicalDeviceSparseImageFormatInfo2));
- deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pFormatInfo, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
+ if (pFormatInfo) {
+ local_pFormatInfo = (VkPhysicalDeviceSparseImageFormatInfo2*)pool->alloc(
+ sizeof(const VkPhysicalDeviceSparseImageFormatInfo2));
+ deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pFormatInfo,
+ (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
}
- if (local_pFormatInfo)
- {
- transform_tohost_VkPhysicalDeviceSparseImageFormatInfo2(sResourceTracker, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
+ if (local_pFormatInfo) {
+ transform_tohost_VkPhysicalDeviceSparseImageFormatInfo2(
+ sResourceTracker, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceSparseImageFormatInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo), countPtr);
+ count_VkPhysicalDeviceSparseImageFormatInfo2(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pProperties)
- {
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- count_VkSparseImageFormatProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageFormatProperties2*)(pProperties + i), countPtr);
+ if (pProperties) {
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ count_VkSparseImageFormatProperties2(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageFormatProperties2*)(pProperties + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2);
+ uint32_t packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2 =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2);
+ uint8_t* streamPtr =
+ stream->reserve(packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceSparseImageFormatProperties2 = OP_vkGetPhysicalDeviceSparseImageFormatProperties2;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSparseImageFormatProperties2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceSparseImageFormatProperties2 =
+ OP_vkGetPhysicalDeviceSparseImageFormatProperties2;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSparseImageFormatProperties2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2,
+ sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceSparseImageFormatInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo), streamPtrPtr);
+ reservedmarshal_VkPhysicalDeviceSparseImageFormatInfo2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)pPropertyCount;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
memcpy(*streamPtrPtr, (uint32_t*)pPropertyCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -12049,20 +16523,18 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- reservedmarshal_VkSparseImageFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageFormatProperties2*)(pProperties + i), streamPtrPtr);
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ reservedmarshal_VkSparseImageFormatProperties2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageFormatProperties2*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pPropertyCount)
- {
- if (!(check_pPropertyCount))
- {
+ if (pPropertyCount) {
+ if (!(check_pPropertyCount)) {
fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
@@ -12070,47 +16542,64 @@
// WARNING PTR CHECK
VkSparseImageFormatProperties2* check_pProperties;
check_pProperties = (VkSparseImageFormatProperties2*)(uintptr_t)stream->getBe64();
- if (pProperties)
- {
- if (!(check_pProperties))
- {
+ if (pProperties) {
+ if (!(check_pProperties)) {
fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
}
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- unmarshal_VkSparseImageFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageFormatProperties2*)(pProperties + i));
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ unmarshal_VkSparseImageFormatProperties2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageFormatProperties2*)(pProperties + i));
}
}
}
- if (pPropertyCount)
- {
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- transform_fromhost_VkSparseImageFormatProperties2(sResourceTracker, (VkSparseImageFormatProperties2*)(pProperties + i));
+ if (pPropertyCount) {
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ transform_fromhost_VkSparseImageFormatProperties2(
+ sResourceTracker, (VkSparseImageFormatProperties2*)(pProperties + i));
}
}
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkTrimCommandPool(
- VkDevice device,
- VkCommandPool commandPool,
- VkCommandPoolTrimFlags flags,
- uint32_t doLock)
-{
+void VkEncoder::vkTrimCommandPool(VkDevice device, VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkTrimCommandPool in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkTrimCommandPool(device:%p, commandPool:%p, flags:%d)", device, commandPool,
+ flags);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -12129,14 +16618,23 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkCommandPoolTrimFlags);
}
- uint32_t packetSize_vkTrimCommandPool = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkTrimCommandPool =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkTrimCommandPool);
uint8_t* streamPtr = stream->reserve(packetSize_vkTrimCommandPool);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkTrimCommandPool = OP_vkTrimCommandPool;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkTrimCommandPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkTrimCommandPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkTrimCommandPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkTrimCommandPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -12148,23 +16646,44 @@
memcpy(*streamPtrPtr, (VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
*streamPtrPtr += sizeof(VkCommandPoolTrimFlags);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkGetDeviceQueue2(
- VkDevice device,
- const VkDeviceQueueInfo2* pQueueInfo,
- VkQueue* pQueue,
- uint32_t doLock)
-{
+void VkEncoder::vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo,
+ VkQueue* pQueue, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetDeviceQueue2 in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetDeviceQueue2(device:%p, pQueueInfo:%p, pQueue:%p)", device, pQueueInfo,
+ pQueue);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -12172,37 +16691,48 @@
VkDeviceQueueInfo2* local_pQueueInfo;
local_device = device;
local_pQueueInfo = nullptr;
- if (pQueueInfo)
- {
+ if (pQueueInfo) {
local_pQueueInfo = (VkDeviceQueueInfo2*)pool->alloc(sizeof(const VkDeviceQueueInfo2));
- deepcopy_VkDeviceQueueInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pQueueInfo, (VkDeviceQueueInfo2*)(local_pQueueInfo));
+ deepcopy_VkDeviceQueueInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pQueueInfo,
+ (VkDeviceQueueInfo2*)(local_pQueueInfo));
}
- if (local_pQueueInfo)
- {
- transform_tohost_VkDeviceQueueInfo2(sResourceTracker, (VkDeviceQueueInfo2*)(local_pQueueInfo));
+ if (local_pQueueInfo) {
+ transform_tohost_VkDeviceQueueInfo2(sResourceTracker,
+ (VkDeviceQueueInfo2*)(local_pQueueInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDeviceQueueInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceQueueInfo2*)(local_pQueueInfo), countPtr);
+ count_VkDeviceQueueInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDeviceQueueInfo2*)(local_pQueueInfo), countPtr);
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkGetDeviceQueue2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDeviceQueue2 =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetDeviceQueue2);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceQueue2);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDeviceQueue2 = OP_vkGetDeviceQueue2;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDeviceQueue2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDeviceQueue2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDeviceQueue2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDeviceQueue2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDeviceQueueInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceQueueInfo2*)(local_pQueueInfo), streamPtrPtr);
+ reservedmarshal_VkDeviceQueueInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDeviceQueueInfo2*)(local_pQueueInfo), streamPtrPtr);
/* is handle, possibly out */;
uint64_t cgen_var_1;
*&cgen_var_1 = (uint64_t)((*pQueue));
@@ -12213,9 +16743,9 @@
stream->read((uint64_t*)&cgen_var_2, 8);
stream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_2, (VkQueue*)pQueue, 1);
sResourceTracker->on_vkGetDeviceQueue2(this, device, pQueueInfo, pQueue);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -12223,14 +16753,38 @@
}
VkResult VkEncoder::vkCreateSamplerYcbcrConversion(
- VkDevice device,
- const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSamplerYcbcrConversion* pYcbcrConversion,
- uint32_t doLock)
-{
+ VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateSamplerYcbcrConversion in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateSamplerYcbcrConversion(device:%p, pCreateInfo:%p, pAllocator:%p, "
+ "pYcbcrConversion:%p)",
+ device, pCreateInfo, pAllocator, pYcbcrConversion);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -12239,62 +16793,79 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkSamplerYcbcrConversionCreateInfo*)pool->alloc(sizeof(const VkSamplerYcbcrConversionCreateInfo));
- deepcopy_VkSamplerYcbcrConversionCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkSamplerYcbcrConversionCreateInfo*)pool->alloc(
+ sizeof(const VkSamplerYcbcrConversionCreateInfo));
+ deepcopy_VkSamplerYcbcrConversionCreateInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkSamplerYcbcrConversionCreateInfo(sResourceTracker, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkSamplerYcbcrConversionCreateInfo(
+ sResourceTracker, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSamplerYcbcrConversionCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkSamplerYcbcrConversionCreateInfo(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateSamplerYcbcrConversion = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateSamplerYcbcrConversion =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCreateSamplerYcbcrConversion);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateSamplerYcbcrConversion);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateSamplerYcbcrConversion = OP_vkCreateSamplerYcbcrConversion;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateSamplerYcbcrConversion, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateSamplerYcbcrConversion, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateSamplerYcbcrConversion, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateSamplerYcbcrConversion, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSamplerYcbcrConversionCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkSamplerYcbcrConversionCreateInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -12305,13 +16876,14 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_3, (VkSamplerYcbcrConversion*)pYcbcrConversion, 1);
+ stream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(
+ &cgen_var_3, (VkSamplerYcbcrConversion*)pYcbcrConversion, 1);
stream->unsetHandleMapping();
VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
stream->read(&vkCreateSamplerYcbcrConversion_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -12319,14 +16891,38 @@
return vkCreateSamplerYcbcrConversion_VkResult_return;
}
-void VkEncoder::vkDestroySamplerYcbcrConversion(
- VkDevice device,
- VkSamplerYcbcrConversion ycbcrConversion,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroySamplerYcbcrConversion(VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroySamplerYcbcrConversion in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkDestroySamplerYcbcrConversion(device:%p, ycbcrConversion:%p, pAllocator:%p)", device,
+ ycbcrConversion, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -12336,15 +16932,15 @@
local_device = device;
local_ycbcrConversion = ycbcrConversion;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -12355,19 +16951,29 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroySamplerYcbcrConversion = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroySamplerYcbcrConversion =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkDestroySamplerYcbcrConversion);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroySamplerYcbcrConversion);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroySamplerYcbcrConversion = OP_vkDestroySamplerYcbcrConversion;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroySamplerYcbcrConversion, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroySamplerYcbcrConversion, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroySamplerYcbcrConversion, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroySamplerYcbcrConversion, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -12381,15 +16987,17 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
- sResourceTracker->destroyMapping()->mapHandles_VkSamplerYcbcrConversion((VkSamplerYcbcrConversion*)&ycbcrConversion);
+ sResourceTracker->destroyMapping()->mapHandles_VkSamplerYcbcrConversion(
+ (VkSamplerYcbcrConversion*)&ycbcrConversion);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -12397,14 +17005,38 @@
}
VkResult VkEncoder::vkCreateDescriptorUpdateTemplate(
- VkDevice device,
- const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate,
- uint32_t doLock)
-{
+ VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateDescriptorUpdateTemplate in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateDescriptorUpdateTemplate(device:%p, pCreateInfo:%p, pAllocator:%p, "
+ "pDescriptorUpdateTemplate:%p)",
+ device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -12413,62 +17045,79 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkDescriptorUpdateTemplateCreateInfo*)pool->alloc(sizeof(const VkDescriptorUpdateTemplateCreateInfo));
- deepcopy_VkDescriptorUpdateTemplateCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkDescriptorUpdateTemplateCreateInfo*)pool->alloc(
+ sizeof(const VkDescriptorUpdateTemplateCreateInfo));
+ deepcopy_VkDescriptorUpdateTemplateCreateInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkDescriptorUpdateTemplateCreateInfo(sResourceTracker, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkDescriptorUpdateTemplateCreateInfo(
+ sResourceTracker, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDescriptorUpdateTemplateCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkDescriptorUpdateTemplateCreateInfo(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateDescriptorUpdateTemplate = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateDescriptorUpdateTemplate =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCreateDescriptorUpdateTemplate);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateDescriptorUpdateTemplate);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateDescriptorUpdateTemplate = OP_vkCreateDescriptorUpdateTemplate;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateDescriptorUpdateTemplate, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateDescriptorUpdateTemplate, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateDescriptorUpdateTemplate, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateDescriptorUpdateTemplate, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDescriptorUpdateTemplateCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkDescriptorUpdateTemplateCreateInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -12479,14 +17128,17 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(&cgen_var_3, (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1);
+ stream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(
+ &cgen_var_3, (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1);
stream->unsetHandleMapping();
VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
stream->read(&vkCreateDescriptorUpdateTemplate_VkResult_return, sizeof(VkResult));
- sResourceTracker->on_vkCreateDescriptorUpdateTemplate(this, vkCreateDescriptorUpdateTemplate_VkResult_return, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ sResourceTracker->on_vkCreateDescriptorUpdateTemplate(
+ this, vkCreateDescriptorUpdateTemplate_VkResult_return, device, pCreateInfo, pAllocator,
+ pDescriptorUpdateTemplate);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -12495,13 +17147,36 @@
}
void VkEncoder::vkDestroyDescriptorUpdateTemplate(
- VkDevice device,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+ VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyDescriptorUpdateTemplate in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkDestroyDescriptorUpdateTemplate(device:%p, descriptorUpdateTemplate:%p, pAllocator:%p)",
+ device, descriptorUpdateTemplate, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -12511,15 +17186,15 @@
local_device = device;
local_descriptorUpdateTemplate = descriptorUpdateTemplate;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -12530,19 +17205,29 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyDescriptorUpdateTemplate = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyDescriptorUpdateTemplate =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkDestroyDescriptorUpdateTemplate);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyDescriptorUpdateTemplate);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyDescriptorUpdateTemplate = OP_vkDestroyDescriptorUpdateTemplate;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyDescriptorUpdateTemplate, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyDescriptorUpdateTemplate, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyDescriptorUpdateTemplate, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyDescriptorUpdateTemplate, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -12556,15 +17241,17 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
- sResourceTracker->destroyMapping()->mapHandles_VkDescriptorUpdateTemplate((VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate);
+ sResourceTracker->destroyMapping()->mapHandles_VkDescriptorUpdateTemplate(
+ (VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -12572,14 +17259,37 @@
}
void VkEncoder::vkUpdateDescriptorSetWithTemplate(
- VkDevice device,
- VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const void* pData,
- uint32_t doLock)
-{
+ VkDevice device, VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkUpdateDescriptorSetWithTemplate in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkUpdateDescriptorSetWithTemplate(device:%p, descriptorSet:%p, "
+ "descriptorUpdateTemplate:%p, pData:%p)",
+ device, descriptorSet, descriptorUpdateTemplate, pData);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -12603,19 +17313,28 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pData)
- {
+ if (local_pData) {
*countPtr += sizeof(uint8_t);
}
}
- uint32_t packetSize_vkUpdateDescriptorSetWithTemplate = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkUpdateDescriptorSetWithTemplate =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkUpdateDescriptorSetWithTemplate);
uint8_t* streamPtr = stream->reserve(packetSize_vkUpdateDescriptorSetWithTemplate);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkUpdateDescriptorSetWithTemplate = OP_vkUpdateDescriptorSetWithTemplate;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkUpdateDescriptorSetWithTemplate, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkUpdateDescriptorSetWithTemplate, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkUpdateDescriptorSetWithTemplate, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkUpdateDescriptorSetWithTemplate, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -12633,15 +17352,14 @@
memcpy((*streamPtrPtr), &cgen_var_3, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pData)
- {
+ if (local_pData) {
memcpy(*streamPtrPtr, (void*)local_pData, sizeof(uint8_t));
*streamPtrPtr += sizeof(uint8_t);
}
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -12649,13 +17367,38 @@
}
void VkEncoder::vkGetPhysicalDeviceExternalBufferProperties(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
- VkExternalBufferProperties* pExternalBufferProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+ VkExternalBufferProperties* pExternalBufferProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceExternalBufferProperties in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceExternalBufferProperties(physicalDevice:%p, pExternalBufferInfo:%p, "
+ "pExternalBufferProperties:%p)",
+ physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -12663,47 +17406,71 @@
VkPhysicalDeviceExternalBufferInfo* local_pExternalBufferInfo;
local_physicalDevice = physicalDevice;
local_pExternalBufferInfo = nullptr;
- if (pExternalBufferInfo)
- {
- local_pExternalBufferInfo = (VkPhysicalDeviceExternalBufferInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalBufferInfo));
- deepcopy_VkPhysicalDeviceExternalBufferInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExternalBufferInfo, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
+ if (pExternalBufferInfo) {
+ local_pExternalBufferInfo = (VkPhysicalDeviceExternalBufferInfo*)pool->alloc(
+ sizeof(const VkPhysicalDeviceExternalBufferInfo));
+ deepcopy_VkPhysicalDeviceExternalBufferInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExternalBufferInfo,
+ (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
}
- if (local_pExternalBufferInfo)
- {
- sResourceTracker->transformImpl_VkPhysicalDeviceExternalBufferInfo_tohost(local_pExternalBufferInfo, 1);
- transform_tohost_VkPhysicalDeviceExternalBufferInfo(sResourceTracker, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
+ if (local_pExternalBufferInfo) {
+ sResourceTracker->transformImpl_VkPhysicalDeviceExternalBufferInfo_tohost(
+ local_pExternalBufferInfo, 1);
+ transform_tohost_VkPhysicalDeviceExternalBufferInfo(
+ sResourceTracker, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceExternalBufferInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo), countPtr);
- count_VkExternalBufferProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalBufferProperties*)(pExternalBufferProperties), countPtr);
+ count_VkPhysicalDeviceExternalBufferInfo(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo), countPtr);
+ count_VkExternalBufferProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExternalBufferProperties*)(pExternalBufferProperties),
+ countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceExternalBufferProperties = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceExternalBufferProperties =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceExternalBufferProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceExternalBufferProperties);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceExternalBufferProperties = OP_vkGetPhysicalDeviceExternalBufferProperties;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceExternalBufferProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceExternalBufferProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceExternalBufferProperties =
+ OP_vkGetPhysicalDeviceExternalBufferProperties;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceExternalBufferProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceExternalBufferProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceExternalBufferInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo), streamPtrPtr);
- reservedmarshal_VkExternalBufferProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalBufferProperties*)(pExternalBufferProperties), streamPtrPtr);
- unmarshal_VkExternalBufferProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalBufferProperties*)(pExternalBufferProperties));
- if (pExternalBufferProperties)
- {
- sResourceTracker->transformImpl_VkExternalBufferProperties_fromhost(pExternalBufferProperties, 1);
- transform_fromhost_VkExternalBufferProperties(sResourceTracker, (VkExternalBufferProperties*)(pExternalBufferProperties));
+ reservedmarshal_VkPhysicalDeviceExternalBufferInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo), streamPtrPtr);
+ reservedmarshal_VkExternalBufferProperties(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExternalBufferProperties*)(pExternalBufferProperties), streamPtrPtr);
+ unmarshal_VkExternalBufferProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExternalBufferProperties*)(pExternalBufferProperties));
+ if (pExternalBufferProperties) {
+ sResourceTracker->transformImpl_VkExternalBufferProperties_fromhost(
+ pExternalBufferProperties, 1);
+ transform_fromhost_VkExternalBufferProperties(
+ sResourceTracker, (VkExternalBufferProperties*)(pExternalBufferProperties));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -12711,13 +17478,38 @@
}
void VkEncoder::vkGetPhysicalDeviceExternalFenceProperties(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
- VkExternalFenceProperties* pExternalFenceProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+ VkExternalFenceProperties* pExternalFenceProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceExternalFenceProperties in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceExternalFenceProperties(physicalDevice:%p, pExternalFenceInfo:%p, "
+ "pExternalFenceProperties:%p)",
+ physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -12725,45 +17517,67 @@
VkPhysicalDeviceExternalFenceInfo* local_pExternalFenceInfo;
local_physicalDevice = physicalDevice;
local_pExternalFenceInfo = nullptr;
- if (pExternalFenceInfo)
- {
- local_pExternalFenceInfo = (VkPhysicalDeviceExternalFenceInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalFenceInfo));
- deepcopy_VkPhysicalDeviceExternalFenceInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExternalFenceInfo, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
+ if (pExternalFenceInfo) {
+ local_pExternalFenceInfo = (VkPhysicalDeviceExternalFenceInfo*)pool->alloc(
+ sizeof(const VkPhysicalDeviceExternalFenceInfo));
+ deepcopy_VkPhysicalDeviceExternalFenceInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExternalFenceInfo,
+ (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
}
- if (local_pExternalFenceInfo)
- {
- transform_tohost_VkPhysicalDeviceExternalFenceInfo(sResourceTracker, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
+ if (local_pExternalFenceInfo) {
+ transform_tohost_VkPhysicalDeviceExternalFenceInfo(
+ sResourceTracker, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceExternalFenceInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo), countPtr);
- count_VkExternalFenceProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalFenceProperties*)(pExternalFenceProperties), countPtr);
+ count_VkPhysicalDeviceExternalFenceInfo(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo), countPtr);
+ count_VkExternalFenceProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExternalFenceProperties*)(pExternalFenceProperties),
+ countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceExternalFenceProperties = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceExternalFenceProperties =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceExternalFenceProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceExternalFenceProperties);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceExternalFenceProperties = OP_vkGetPhysicalDeviceExternalFenceProperties;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceExternalFenceProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceExternalFenceProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceExternalFenceProperties =
+ OP_vkGetPhysicalDeviceExternalFenceProperties;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceExternalFenceProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceExternalFenceProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceExternalFenceInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo), streamPtrPtr);
- reservedmarshal_VkExternalFenceProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalFenceProperties*)(pExternalFenceProperties), streamPtrPtr);
- unmarshal_VkExternalFenceProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalFenceProperties*)(pExternalFenceProperties));
- if (pExternalFenceProperties)
- {
- transform_fromhost_VkExternalFenceProperties(sResourceTracker, (VkExternalFenceProperties*)(pExternalFenceProperties));
+ reservedmarshal_VkPhysicalDeviceExternalFenceInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo), streamPtrPtr);
+ reservedmarshal_VkExternalFenceProperties(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalFenceProperties*)(pExternalFenceProperties),
+ streamPtrPtr);
+ unmarshal_VkExternalFenceProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExternalFenceProperties*)(pExternalFenceProperties));
+ if (pExternalFenceProperties) {
+ transform_fromhost_VkExternalFenceProperties(
+ sResourceTracker, (VkExternalFenceProperties*)(pExternalFenceProperties));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -12773,11 +17587,37 @@
void VkEncoder::vkGetPhysicalDeviceExternalSemaphoreProperties(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
- VkExternalSemaphoreProperties* pExternalSemaphoreProperties,
- uint32_t doLock)
-{
+ VkExternalSemaphoreProperties* pExternalSemaphoreProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceExternalSemaphoreProperties in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice:%p, "
+ "pExternalSemaphoreInfo:%p, pExternalSemaphoreProperties:%p)",
+ physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -12785,60 +17625,108 @@
VkPhysicalDeviceExternalSemaphoreInfo* local_pExternalSemaphoreInfo;
local_physicalDevice = physicalDevice;
local_pExternalSemaphoreInfo = nullptr;
- if (pExternalSemaphoreInfo)
- {
- local_pExternalSemaphoreInfo = (VkPhysicalDeviceExternalSemaphoreInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalSemaphoreInfo));
- deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExternalSemaphoreInfo, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
+ if (pExternalSemaphoreInfo) {
+ local_pExternalSemaphoreInfo = (VkPhysicalDeviceExternalSemaphoreInfo*)pool->alloc(
+ sizeof(const VkPhysicalDeviceExternalSemaphoreInfo));
+ deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExternalSemaphoreInfo,
+ (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
}
- if (local_pExternalSemaphoreInfo)
- {
- transform_tohost_VkPhysicalDeviceExternalSemaphoreInfo(sResourceTracker, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
+ if (local_pExternalSemaphoreInfo) {
+ transform_tohost_VkPhysicalDeviceExternalSemaphoreInfo(
+ sResourceTracker,
+ (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceExternalSemaphoreInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo), countPtr);
- count_VkExternalSemaphoreProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties), countPtr);
+ count_VkPhysicalDeviceExternalSemaphoreInfo(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo), countPtr);
+ count_VkExternalSemaphoreProperties(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties), countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceExternalSemaphoreProperties = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceExternalSemaphoreProperties =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceExternalSemaphoreProperties);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceExternalSemaphoreProperties);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceExternalSemaphoreProperties = OP_vkGetPhysicalDeviceExternalSemaphoreProperties;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceExternalSemaphoreProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceExternalSemaphoreProperties, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceExternalSemaphoreProperties =
+ OP_vkGetPhysicalDeviceExternalSemaphoreProperties;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceExternalSemaphoreProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceExternalSemaphoreProperties, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceExternalSemaphoreInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo), streamPtrPtr);
- reservedmarshal_VkExternalSemaphoreProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties), streamPtrPtr);
- unmarshal_VkExternalSemaphoreProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
- if (pExternalSemaphoreProperties)
- {
- transform_fromhost_VkExternalSemaphoreProperties(sResourceTracker, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
+ reservedmarshal_VkPhysicalDeviceExternalSemaphoreInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo), streamPtrPtr);
+ reservedmarshal_VkExternalSemaphoreProperties(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties), streamPtrPtr);
+ unmarshal_VkExternalSemaphoreProperties(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
+ if (pExternalSemaphoreProperties) {
+ transform_fromhost_VkExternalSemaphoreProperties(
+ sResourceTracker, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
}
- sResourceTracker->on_vkGetPhysicalDeviceExternalSemaphoreProperties(this, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ sResourceTracker->on_vkGetPhysicalDeviceExternalSemaphoreProperties(
+ this, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkGetDescriptorSetLayoutSupport(
- VkDevice device,
- const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- VkDescriptorSetLayoutSupport* pSupport,
- uint32_t doLock)
-{
+void VkEncoder::vkGetDescriptorSetLayoutSupport(VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetDescriptorSetLayoutSupport in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetDescriptorSetLayoutSupport(device:%p, pCreateInfo:%p, pSupport:%p)",
+ device, pCreateInfo, pSupport);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -12846,45 +17734,65 @@
VkDescriptorSetLayoutCreateInfo* local_pCreateInfo;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkDescriptorSetLayoutCreateInfo*)pool->alloc(sizeof(const VkDescriptorSetLayoutCreateInfo));
- deepcopy_VkDescriptorSetLayoutCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkDescriptorSetLayoutCreateInfo*)pool->alloc(
+ sizeof(const VkDescriptorSetLayoutCreateInfo));
+ deepcopy_VkDescriptorSetLayoutCreateInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
}
- if (local_pCreateInfo)
- {
- transform_tohost_VkDescriptorSetLayoutCreateInfo(sResourceTracker, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkDescriptorSetLayoutCreateInfo(
+ sResourceTracker, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDescriptorSetLayoutCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo), countPtr);
- count_VkDescriptorSetLayoutSupport(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorSetLayoutSupport*)(pSupport), countPtr);
+ count_VkDescriptorSetLayoutCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo),
+ countPtr);
+ count_VkDescriptorSetLayoutSupport(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorSetLayoutSupport*)(pSupport), countPtr);
}
- uint32_t packetSize_vkGetDescriptorSetLayoutSupport = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDescriptorSetLayoutSupport =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDescriptorSetLayoutSupport);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDescriptorSetLayoutSupport);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDescriptorSetLayoutSupport = OP_vkGetDescriptorSetLayoutSupport;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDescriptorSetLayoutSupport, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDescriptorSetLayoutSupport, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDescriptorSetLayoutSupport, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDescriptorSetLayoutSupport, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDescriptorSetLayoutCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo), streamPtrPtr);
- reservedmarshal_VkDescriptorSetLayoutSupport(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorSetLayoutSupport*)(pSupport), streamPtrPtr);
- unmarshal_VkDescriptorSetLayoutSupport(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorSetLayoutSupport*)(pSupport));
- if (pSupport)
- {
- transform_fromhost_VkDescriptorSetLayoutSupport(sResourceTracker, (VkDescriptorSetLayoutSupport*)(pSupport));
+ reservedmarshal_VkDescriptorSetLayoutCreateInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo),
+ streamPtrPtr);
+ reservedmarshal_VkDescriptorSetLayoutSupport(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorSetLayoutSupport*)(pSupport),
+ streamPtrPtr);
+ unmarshal_VkDescriptorSetLayoutSupport(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorSetLayoutSupport*)(pSupport));
+ if (pSupport) {
+ transform_fromhost_VkDescriptorSetLayoutSupport(sResourceTracker,
+ (VkDescriptorSetLayoutSupport*)(pSupport));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -12893,18 +17801,39 @@
#endif
#ifdef VK_VERSION_1_2
-void VkEncoder::vkCmdDrawIndirectCount(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+ uint32_t stride, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDrawIndirectCount in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdDrawIndirectCount(commandBuffer:%p, buffer:%p, offset:%ld, countBuffer:%p, "
+ "countBufferOffset:%ld, maxDrawCount:%d, stride:%d)",
+ commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -12937,14 +17866,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDrawIndirectCount = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDrawIndirectCount);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawIndirectCount -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawIndirectCount);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDrawIndirectCount = OP_vkCmdDrawIndirectCount;
- memcpy(streamPtr, &opcode_vkCmdDrawIndirectCount, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDrawIndirectCount, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDrawIndirectCount, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDrawIndirectCount, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -12966,27 +17897,48 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_stride, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdDrawIndexedIndirectCount(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+ uint32_t stride, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDrawIndexedIndirectCount in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdDrawIndexedIndirectCount(commandBuffer:%p, buffer:%p, offset:%ld, countBuffer:%p, "
+ "countBufferOffset:%ld, maxDrawCount:%d, stride:%d)",
+ commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -13019,14 +17971,17 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDrawIndexedIndirectCount = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdDrawIndexedIndirectCount);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawIndexedIndirectCount -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawIndexedIndirectCount);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDrawIndexedIndirectCount = OP_vkCmdDrawIndexedIndirectCount;
- memcpy(streamPtr, &opcode_vkCmdDrawIndexedIndirectCount, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDrawIndexedIndirectCount, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDrawIndexedIndirectCount, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDrawIndexedIndirectCount, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -13048,24 +18003,46 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_stride, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkCreateRenderPass2(
- VkDevice device,
- const VkRenderPassCreateInfo2* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateRenderPass2 in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateRenderPass2(device:%p, pCreateInfo:%p, pAllocator:%p, pRenderPass:%p)", device,
+ pCreateInfo, pAllocator, pRenderPass);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -13074,62 +18051,76 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkRenderPassCreateInfo2*)pool->alloc(sizeof(const VkRenderPassCreateInfo2));
- deepcopy_VkRenderPassCreateInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkRenderPassCreateInfo2*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkRenderPassCreateInfo2*)pool->alloc(sizeof(const VkRenderPassCreateInfo2));
+ deepcopy_VkRenderPassCreateInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkRenderPassCreateInfo2*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkRenderPassCreateInfo2(sResourceTracker, (VkRenderPassCreateInfo2*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkRenderPassCreateInfo2(sResourceTracker,
+ (VkRenderPassCreateInfo2*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkRenderPassCreateInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRenderPassCreateInfo2*)(local_pCreateInfo), countPtr);
+ count_VkRenderPassCreateInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderPassCreateInfo2*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateRenderPass2 = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateRenderPass2 =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateRenderPass2);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateRenderPass2);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateRenderPass2 = OP_vkCreateRenderPass2;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateRenderPass2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateRenderPass2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateRenderPass2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateRenderPass2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkRenderPassCreateInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRenderPassCreateInfo2*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkRenderPassCreateInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderPassCreateInfo2*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -13137,14 +18128,17 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
+ stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_3, (VkRenderPass*)pRenderPass, 1);
+ stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_3, (VkRenderPass*)pRenderPass,
+ 1);
+ stream->unsetHandleMapping();
VkResult vkCreateRenderPass2_VkResult_return = (VkResult)0;
stream->read(&vkCreateRenderPass2_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -13152,14 +18146,38 @@
return vkCreateRenderPass2_VkResult_return;
}
-void VkEncoder::vkCmdBeginRenderPass2(
- VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo* pRenderPassBegin,
- const VkSubpassBeginInfo* pSubpassBeginInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ const VkSubpassBeginInfo* pSubpassBeginInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBeginRenderPass2 in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdBeginRenderPass2(commandBuffer:%p, pRenderPassBegin:%p, pSubpassBeginInfo:%p)",
+ commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -13168,66 +18186,99 @@
VkSubpassBeginInfo* local_pSubpassBeginInfo;
local_commandBuffer = commandBuffer;
local_pRenderPassBegin = nullptr;
- if (pRenderPassBegin)
- {
- local_pRenderPassBegin = (VkRenderPassBeginInfo*)pool->alloc(sizeof(const VkRenderPassBeginInfo));
- deepcopy_VkRenderPassBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRenderPassBegin, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+ if (pRenderPassBegin) {
+ local_pRenderPassBegin =
+ (VkRenderPassBeginInfo*)pool->alloc(sizeof(const VkRenderPassBeginInfo));
+ deepcopy_VkRenderPassBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRenderPassBegin,
+ (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
}
local_pSubpassBeginInfo = nullptr;
- if (pSubpassBeginInfo)
- {
- local_pSubpassBeginInfo = (VkSubpassBeginInfo*)pool->alloc(sizeof(const VkSubpassBeginInfo));
- deepcopy_VkSubpassBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassBeginInfo, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
+ if (pSubpassBeginInfo) {
+ local_pSubpassBeginInfo =
+ (VkSubpassBeginInfo*)pool->alloc(sizeof(const VkSubpassBeginInfo));
+ deepcopy_VkSubpassBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassBeginInfo,
+ (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
}
- if (local_pRenderPassBegin)
- {
- transform_tohost_VkRenderPassBeginInfo(sResourceTracker, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+ if (local_pRenderPassBegin) {
+ transform_tohost_VkRenderPassBeginInfo(sResourceTracker,
+ (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
}
- if (local_pSubpassBeginInfo)
- {
- transform_tohost_VkSubpassBeginInfo(sResourceTracker, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
+ if (local_pSubpassBeginInfo) {
+ transform_tohost_VkSubpassBeginInfo(sResourceTracker,
+ (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkRenderPassBeginInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRenderPassBeginInfo*)(local_pRenderPassBegin), countPtr);
- count_VkSubpassBeginInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo), countPtr);
+ count_VkRenderPassBeginInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderPassBeginInfo*)(local_pRenderPassBegin), countPtr);
+ count_VkSubpassBeginInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubpassBeginInfo*)(local_pSubpassBeginInfo), countPtr);
}
uint32_t packetSize_vkCmdBeginRenderPass2 = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBeginRenderPass2);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginRenderPass2 -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBeginRenderPass2);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBeginRenderPass2 = OP_vkCmdBeginRenderPass2;
- memcpy(streamPtr, &opcode_vkCmdBeginRenderPass2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBeginRenderPass2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBeginRenderPass2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBeginRenderPass2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkRenderPassBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRenderPassBeginInfo*)(local_pRenderPassBegin), streamPtrPtr);
- reservedmarshal_VkSubpassBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkRenderPassBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderPassBeginInfo*)(local_pRenderPassBegin),
+ streamPtrPtr);
+ reservedmarshal_VkSubpassBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubpassBeginInfo*)(local_pSubpassBeginInfo),
+ streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdNextSubpass2(
- VkCommandBuffer commandBuffer,
- const VkSubpassBeginInfo* pSubpassBeginInfo,
- const VkSubpassEndInfo* pSubpassEndInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdNextSubpass2(VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfo* pSubpassBeginInfo,
+ const VkSubpassEndInfo* pSubpassEndInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdNextSubpass2 in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdNextSubpass2(commandBuffer:%p, pSubpassBeginInfo:%p, pSubpassEndInfo:%p)",
+ commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -13236,65 +18287,95 @@
VkSubpassEndInfo* local_pSubpassEndInfo;
local_commandBuffer = commandBuffer;
local_pSubpassBeginInfo = nullptr;
- if (pSubpassBeginInfo)
- {
- local_pSubpassBeginInfo = (VkSubpassBeginInfo*)pool->alloc(sizeof(const VkSubpassBeginInfo));
- deepcopy_VkSubpassBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassBeginInfo, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
+ if (pSubpassBeginInfo) {
+ local_pSubpassBeginInfo =
+ (VkSubpassBeginInfo*)pool->alloc(sizeof(const VkSubpassBeginInfo));
+ deepcopy_VkSubpassBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassBeginInfo,
+ (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
}
local_pSubpassEndInfo = nullptr;
- if (pSubpassEndInfo)
- {
+ if (pSubpassEndInfo) {
local_pSubpassEndInfo = (VkSubpassEndInfo*)pool->alloc(sizeof(const VkSubpassEndInfo));
- deepcopy_VkSubpassEndInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassEndInfo, (VkSubpassEndInfo*)(local_pSubpassEndInfo));
+ deepcopy_VkSubpassEndInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassEndInfo,
+ (VkSubpassEndInfo*)(local_pSubpassEndInfo));
}
- if (local_pSubpassBeginInfo)
- {
- transform_tohost_VkSubpassBeginInfo(sResourceTracker, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
+ if (local_pSubpassBeginInfo) {
+ transform_tohost_VkSubpassBeginInfo(sResourceTracker,
+ (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
}
- if (local_pSubpassEndInfo)
- {
- transform_tohost_VkSubpassEndInfo(sResourceTracker, (VkSubpassEndInfo*)(local_pSubpassEndInfo));
+ if (local_pSubpassEndInfo) {
+ transform_tohost_VkSubpassEndInfo(sResourceTracker,
+ (VkSubpassEndInfo*)(local_pSubpassEndInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSubpassBeginInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo), countPtr);
- count_VkSubpassEndInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassEndInfo*)(local_pSubpassEndInfo), countPtr);
+ count_VkSubpassBeginInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubpassBeginInfo*)(local_pSubpassBeginInfo), countPtr);
+ count_VkSubpassEndInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubpassEndInfo*)(local_pSubpassEndInfo), countPtr);
}
uint32_t packetSize_vkCmdNextSubpass2 = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdNextSubpass2);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdNextSubpass2 -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdNextSubpass2);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdNextSubpass2 = OP_vkCmdNextSubpass2;
- memcpy(streamPtr, &opcode_vkCmdNextSubpass2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdNextSubpass2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdNextSubpass2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdNextSubpass2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkSubpassBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo), streamPtrPtr);
- reservedmarshal_VkSubpassEndInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassEndInfo*)(local_pSubpassEndInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkSubpassBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubpassBeginInfo*)(local_pSubpassBeginInfo),
+ streamPtrPtr);
+ reservedmarshal_VkSubpassEndInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubpassEndInfo*)(local_pSubpassEndInfo), streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdEndRenderPass2(
- VkCommandBuffer commandBuffer,
- const VkSubpassEndInfo* pSubpassEndInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdEndRenderPass2(VkCommandBuffer commandBuffer,
+ const VkSubpassEndInfo* pSubpassEndInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdEndRenderPass2 in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdEndRenderPass2(commandBuffer:%p, pSubpassEndInfo:%p)", commandBuffer,
+ pSubpassEndInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -13302,55 +18383,79 @@
VkSubpassEndInfo* local_pSubpassEndInfo;
local_commandBuffer = commandBuffer;
local_pSubpassEndInfo = nullptr;
- if (pSubpassEndInfo)
- {
+ if (pSubpassEndInfo) {
local_pSubpassEndInfo = (VkSubpassEndInfo*)pool->alloc(sizeof(const VkSubpassEndInfo));
- deepcopy_VkSubpassEndInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassEndInfo, (VkSubpassEndInfo*)(local_pSubpassEndInfo));
+ deepcopy_VkSubpassEndInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassEndInfo,
+ (VkSubpassEndInfo*)(local_pSubpassEndInfo));
}
- if (local_pSubpassEndInfo)
- {
- transform_tohost_VkSubpassEndInfo(sResourceTracker, (VkSubpassEndInfo*)(local_pSubpassEndInfo));
+ if (local_pSubpassEndInfo) {
+ transform_tohost_VkSubpassEndInfo(sResourceTracker,
+ (VkSubpassEndInfo*)(local_pSubpassEndInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSubpassEndInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassEndInfo*)(local_pSubpassEndInfo), countPtr);
+ count_VkSubpassEndInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubpassEndInfo*)(local_pSubpassEndInfo), countPtr);
}
uint32_t packetSize_vkCmdEndRenderPass2 = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdEndRenderPass2);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEndRenderPass2 -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdEndRenderPass2);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdEndRenderPass2 = OP_vkCmdEndRenderPass2;
- memcpy(streamPtr, &opcode_vkCmdEndRenderPass2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdEndRenderPass2, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdEndRenderPass2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdEndRenderPass2, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkSubpassEndInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassEndInfo*)(local_pSubpassEndInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkSubpassEndInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubpassEndInfo*)(local_pSubpassEndInfo), streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkResetQueryPool(
- VkDevice device,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t queryCount,
- uint32_t doLock)
-{
+void VkEncoder::vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
+ uint32_t queryCount, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkResetQueryPool in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkResetQueryPool(device:%p, queryPool:%p, firstQuery:%d, queryCount:%d)",
+ device, queryPool, firstQuery, queryCount);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -13373,13 +18478,21 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkResetQueryPool = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkResetQueryPool);
uint8_t* streamPtr = stream->reserve(packetSize_vkResetQueryPool);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkResetQueryPool = OP_vkResetQueryPool;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkResetQueryPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkResetQueryPool, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkResetQueryPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkResetQueryPool, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -13393,23 +18506,44 @@
memcpy(*streamPtrPtr, (uint32_t*)&local_queryCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkGetSemaphoreCounterValue(
- VkDevice device,
- VkSemaphore semaphore,
- uint64_t* pValue,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore,
+ uint64_t* pValue, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetSemaphoreCounterValue in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetSemaphoreCounterValue(device:%p, semaphore:%p, pValue:%p)", device,
+ semaphore, pValue);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -13426,14 +18560,23 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint64_t);
}
- uint32_t packetSize_vkGetSemaphoreCounterValue = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetSemaphoreCounterValue =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetSemaphoreCounterValue);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetSemaphoreCounterValue);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetSemaphoreCounterValue = OP_vkGetSemaphoreCounterValue;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetSemaphoreCounterValue, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetSemaphoreCounterValue, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetSemaphoreCounterValue, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetSemaphoreCounterValue, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -13447,9 +18590,9 @@
stream->read((uint64_t*)pValue, sizeof(uint64_t));
VkResult vkGetSemaphoreCounterValue_VkResult_return = (VkResult)0;
stream->read(&vkGetSemaphoreCounterValue_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -13457,14 +18600,35 @@
return vkGetSemaphoreCounterValue_VkResult_return;
}
-VkResult VkEncoder::vkWaitSemaphores(
- VkDevice device,
- const VkSemaphoreWaitInfo* pWaitInfo,
- uint64_t timeout,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo,
+ uint64_t timeout, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkWaitSemaphores in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkWaitSemaphores(device:%p, pWaitInfo:%p, timeout:%ld)", device, pWaitInfo,
+ timeout);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -13473,44 +18637,54 @@
uint64_t local_timeout;
local_device = device;
local_pWaitInfo = nullptr;
- if (pWaitInfo)
- {
+ if (pWaitInfo) {
local_pWaitInfo = (VkSemaphoreWaitInfo*)pool->alloc(sizeof(const VkSemaphoreWaitInfo));
- deepcopy_VkSemaphoreWaitInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pWaitInfo, (VkSemaphoreWaitInfo*)(local_pWaitInfo));
+ deepcopy_VkSemaphoreWaitInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pWaitInfo,
+ (VkSemaphoreWaitInfo*)(local_pWaitInfo));
}
local_timeout = timeout;
- if (local_pWaitInfo)
- {
- transform_tohost_VkSemaphoreWaitInfo(sResourceTracker, (VkSemaphoreWaitInfo*)(local_pWaitInfo));
+ if (local_pWaitInfo) {
+ transform_tohost_VkSemaphoreWaitInfo(sResourceTracker,
+ (VkSemaphoreWaitInfo*)(local_pWaitInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSemaphoreWaitInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSemaphoreWaitInfo*)(local_pWaitInfo), countPtr);
+ count_VkSemaphoreWaitInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSemaphoreWaitInfo*)(local_pWaitInfo), countPtr);
*countPtr += sizeof(uint64_t);
}
uint32_t packetSize_vkWaitSemaphores = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkWaitSemaphores);
uint8_t* streamPtr = stream->reserve(packetSize_vkWaitSemaphores);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkWaitSemaphores = OP_vkWaitSemaphores;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkWaitSemaphores, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkWaitSemaphores, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkWaitSemaphores, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkWaitSemaphores, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSemaphoreWaitInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSemaphoreWaitInfo*)(local_pWaitInfo), streamPtrPtr);
+ reservedmarshal_VkSemaphoreWaitInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSemaphoreWaitInfo*)(local_pWaitInfo), streamPtrPtr);
memcpy(*streamPtrPtr, (uint64_t*)&local_timeout, sizeof(uint64_t));
*streamPtrPtr += sizeof(uint64_t);
VkResult vkWaitSemaphores_VkResult_return = (VkResult)0;
stream->read(&vkWaitSemaphores_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -13518,13 +18692,34 @@
return vkWaitSemaphores_VkResult_return;
}
-VkResult VkEncoder::vkSignalSemaphore(
- VkDevice device,
- const VkSemaphoreSignalInfo* pSignalInfo,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkSignalSemaphore in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkSignalSemaphore(device:%p, pSignalInfo:%p)", device, pSignalInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -13532,40 +18727,53 @@
VkSemaphoreSignalInfo* local_pSignalInfo;
local_device = device;
local_pSignalInfo = nullptr;
- if (pSignalInfo)
- {
- local_pSignalInfo = (VkSemaphoreSignalInfo*)pool->alloc(sizeof(const VkSemaphoreSignalInfo));
- deepcopy_VkSemaphoreSignalInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSignalInfo, (VkSemaphoreSignalInfo*)(local_pSignalInfo));
+ if (pSignalInfo) {
+ local_pSignalInfo =
+ (VkSemaphoreSignalInfo*)pool->alloc(sizeof(const VkSemaphoreSignalInfo));
+ deepcopy_VkSemaphoreSignalInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSignalInfo,
+ (VkSemaphoreSignalInfo*)(local_pSignalInfo));
}
- if (local_pSignalInfo)
- {
- transform_tohost_VkSemaphoreSignalInfo(sResourceTracker, (VkSemaphoreSignalInfo*)(local_pSignalInfo));
+ if (local_pSignalInfo) {
+ transform_tohost_VkSemaphoreSignalInfo(sResourceTracker,
+ (VkSemaphoreSignalInfo*)(local_pSignalInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSemaphoreSignalInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSemaphoreSignalInfo*)(local_pSignalInfo), countPtr);
+ count_VkSemaphoreSignalInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSemaphoreSignalInfo*)(local_pSignalInfo), countPtr);
}
- uint32_t packetSize_vkSignalSemaphore = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkSignalSemaphore =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkSignalSemaphore);
uint8_t* streamPtr = stream->reserve(packetSize_vkSignalSemaphore);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkSignalSemaphore = OP_vkSignalSemaphore;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkSignalSemaphore, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkSignalSemaphore, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkSignalSemaphore, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkSignalSemaphore, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSemaphoreSignalInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSemaphoreSignalInfo*)(local_pSignalInfo), streamPtrPtr);
+ reservedmarshal_VkSemaphoreSignalInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSemaphoreSignalInfo*)(local_pSignalInfo),
+ streamPtrPtr);
VkResult vkSignalSemaphore_VkResult_return = (VkResult)0;
stream->read(&vkSignalSemaphore_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -13573,13 +18781,35 @@
return vkSignalSemaphore_VkResult_return;
}
-VkDeviceAddress VkEncoder::vkGetBufferDeviceAddress(
- VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo,
- uint32_t doLock)
-{
+VkDeviceAddress VkEncoder::vkGetBufferDeviceAddress(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetBufferDeviceAddress in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetBufferDeviceAddress(device:%p, pInfo:%p)", device, pInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -13587,40 +18817,53 @@
VkBufferDeviceAddressInfo* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkBufferDeviceAddressInfo*)pool->alloc(sizeof(const VkBufferDeviceAddressInfo));
- deepcopy_VkBufferDeviceAddressInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkBufferDeviceAddressInfo*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo =
+ (VkBufferDeviceAddressInfo*)pool->alloc(sizeof(const VkBufferDeviceAddressInfo));
+ deepcopy_VkBufferDeviceAddressInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkBufferDeviceAddressInfo*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkBufferDeviceAddressInfo(sResourceTracker, (VkBufferDeviceAddressInfo*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkBufferDeviceAddressInfo(sResourceTracker,
+ (VkBufferDeviceAddressInfo*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferDeviceAddressInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferDeviceAddressInfo*)(local_pInfo), countPtr);
+ count_VkBufferDeviceAddressInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferDeviceAddressInfo*)(local_pInfo), countPtr);
}
- uint32_t packetSize_vkGetBufferDeviceAddress = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetBufferDeviceAddress =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetBufferDeviceAddress);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferDeviceAddress);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetBufferDeviceAddress = OP_vkGetBufferDeviceAddress;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetBufferDeviceAddress, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetBufferDeviceAddress, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetBufferDeviceAddress, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetBufferDeviceAddress, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferDeviceAddressInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferDeviceAddressInfo*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkBufferDeviceAddressInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferDeviceAddressInfo*)(local_pInfo),
+ streamPtrPtr);
VkDeviceAddress vkGetBufferDeviceAddress_VkDeviceAddress_return = (VkDeviceAddress)0;
stream->read(&vkGetBufferDeviceAddress_VkDeviceAddress_return, sizeof(VkDeviceAddress));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -13628,13 +18871,35 @@
return vkGetBufferDeviceAddress_VkDeviceAddress_return;
}
-uint64_t VkEncoder::vkGetBufferOpaqueCaptureAddress(
- VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo,
- uint32_t doLock)
-{
+uint64_t VkEncoder::vkGetBufferOpaqueCaptureAddress(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetBufferOpaqueCaptureAddress in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetBufferOpaqueCaptureAddress(device:%p, pInfo:%p)", device, pInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -13642,40 +18907,54 @@
VkBufferDeviceAddressInfo* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkBufferDeviceAddressInfo*)pool->alloc(sizeof(const VkBufferDeviceAddressInfo));
- deepcopy_VkBufferDeviceAddressInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkBufferDeviceAddressInfo*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo =
+ (VkBufferDeviceAddressInfo*)pool->alloc(sizeof(const VkBufferDeviceAddressInfo));
+ deepcopy_VkBufferDeviceAddressInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkBufferDeviceAddressInfo*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkBufferDeviceAddressInfo(sResourceTracker, (VkBufferDeviceAddressInfo*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkBufferDeviceAddressInfo(sResourceTracker,
+ (VkBufferDeviceAddressInfo*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferDeviceAddressInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferDeviceAddressInfo*)(local_pInfo), countPtr);
+ count_VkBufferDeviceAddressInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferDeviceAddressInfo*)(local_pInfo), countPtr);
}
- uint32_t packetSize_vkGetBufferOpaqueCaptureAddress = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetBufferOpaqueCaptureAddress =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetBufferOpaqueCaptureAddress);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferOpaqueCaptureAddress);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetBufferOpaqueCaptureAddress = OP_vkGetBufferOpaqueCaptureAddress;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetBufferOpaqueCaptureAddress, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetBufferOpaqueCaptureAddress, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetBufferOpaqueCaptureAddress, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetBufferOpaqueCaptureAddress, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferDeviceAddressInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferDeviceAddressInfo*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkBufferDeviceAddressInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferDeviceAddressInfo*)(local_pInfo),
+ streamPtrPtr);
uint64_t vkGetBufferOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
stream->read(&vkGetBufferOpaqueCaptureAddress_uint64_t_return, sizeof(uint64_t));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -13684,12 +18963,34 @@
}
uint64_t VkEncoder::vkGetDeviceMemoryOpaqueCaptureAddress(
- VkDevice device,
- const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo,
- uint32_t doLock)
-{
+ VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetDeviceMemoryOpaqueCaptureAddress in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetDeviceMemoryOpaqueCaptureAddress(device:%p, pInfo:%p)", device, pInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -13697,40 +18998,57 @@
VkDeviceMemoryOpaqueCaptureAddressInfo* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkDeviceMemoryOpaqueCaptureAddressInfo*)pool->alloc(sizeof(const VkDeviceMemoryOpaqueCaptureAddressInfo));
- deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkDeviceMemoryOpaqueCaptureAddressInfo*)pool->alloc(
+ sizeof(const VkDeviceMemoryOpaqueCaptureAddressInfo));
+ deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkDeviceMemoryOpaqueCaptureAddressInfo(sResourceTracker, (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkDeviceMemoryOpaqueCaptureAddressInfo(
+ sResourceTracker, (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDeviceMemoryOpaqueCaptureAddressInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo), countPtr);
+ count_VkDeviceMemoryOpaqueCaptureAddressInfo(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo), countPtr);
}
- uint32_t packetSize_vkGetDeviceMemoryOpaqueCaptureAddress = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDeviceMemoryOpaqueCaptureAddress =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDeviceMemoryOpaqueCaptureAddress);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceMemoryOpaqueCaptureAddress);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetDeviceMemoryOpaqueCaptureAddress = OP_vkGetDeviceMemoryOpaqueCaptureAddress;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDeviceMemoryOpaqueCaptureAddress, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDeviceMemoryOpaqueCaptureAddress, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetDeviceMemoryOpaqueCaptureAddress =
+ OP_vkGetDeviceMemoryOpaqueCaptureAddress;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDeviceMemoryOpaqueCaptureAddress, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDeviceMemoryOpaqueCaptureAddress, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo),
+ streamPtrPtr);
uint64_t vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
stream->read(&vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return, sizeof(uint64_t));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -13740,14 +19058,35 @@
#endif
#ifdef VK_KHR_surface
-void VkEncoder::vkDestroySurfaceKHR(
- VkInstance instance,
- VkSurfaceKHR surface,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroySurfaceKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroySurfaceKHR(instance:%p, surface:%p, pAllocator:%p)", instance,
+ surface, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -13757,15 +19096,15 @@
local_instance = instance;
local_surface = surface;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -13776,19 +19115,28 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroySurfaceKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroySurfaceKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroySurfaceKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroySurfaceKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroySurfaceKHR = OP_vkDestroySurfaceKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroySurfaceKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroySurfaceKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroySurfaceKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroySurfaceKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -13802,30 +19150,55 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkSurfaceKHR((VkSurfaceKHR*)&surface);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkGetPhysicalDeviceSurfaceSupportKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- VkSurfaceKHR surface,
- VkBool32* pSupported,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ VkSurfaceKHR surface, VkBool32* pSupported,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetPhysicalDeviceSurfaceSupportKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice:%p, queueFamilyIndex:%d, surface:%p, "
+ "pSupported:%p)",
+ physicalDevice, queueFamilyIndex, surface, pSupported);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -13845,14 +19218,24 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkBool32);
}
- uint32_t packetSize_vkGetPhysicalDeviceSurfaceSupportKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceSurfaceSupportKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceSurfaceSupportKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceSurfaceSupportKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceSurfaceSupportKHR = OP_vkGetPhysicalDeviceSurfaceSupportKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSurfaceSupportKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSurfaceSupportKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSurfaceSupportKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSurfaceSupportKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -13868,9 +19251,9 @@
stream->read((VkBool32*)pSupported, sizeof(VkBool32));
VkResult vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -13879,13 +19262,38 @@
}
VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
- VkPhysicalDevice physicalDevice,
- VkSurfaceKHR surface,
- VkSurfaceCapabilitiesKHR* pSurfaceCapabilities,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+ VkSurfaceCapabilitiesKHR* pSurfaceCapabilities, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceSurfaceCapabilitiesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice:%p, surface:%p, "
+ "pSurfaceCapabilities:%p)",
+ physicalDevice, surface, pSurfaceCapabilities);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -13900,16 +19308,28 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkSurfaceCapabilitiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities), countPtr);
+ count_VkSurfaceCapabilitiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities), countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceSurfaceCapabilitiesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = OP_vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceSurfaceCapabilitiesKHR =
+ OP_vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -13918,17 +19338,20 @@
*&cgen_var_1 = get_host_u64_VkSurfaceKHR((*&local_surface));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSurfaceCapabilitiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities), streamPtrPtr);
- unmarshal_VkSurfaceCapabilitiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities));
- if (pSurfaceCapabilities)
- {
- transform_fromhost_VkSurfaceCapabilitiesKHR(sResourceTracker, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities));
+ reservedmarshal_VkSurfaceCapabilitiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities),
+ streamPtrPtr);
+ unmarshal_VkSurfaceCapabilitiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities));
+ if (pSurfaceCapabilities) {
+ transform_fromhost_VkSurfaceCapabilitiesKHR(
+ sResourceTracker, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities));
}
VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -13936,15 +19359,40 @@
return vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return;
}
-VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormatsKHR(
- VkPhysicalDevice physicalDevice,
- VkSurfaceKHR surface,
- uint32_t* pSurfaceFormatCount,
- VkSurfaceFormatKHR* pSurfaceFormats,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormatKHR* pSurfaceFormats,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetPhysicalDeviceSurfaceFormatsKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice:%p, surface:%p, "
+ "pSurfaceFormatCount:%p, pSurfaceFormats:%p)",
+ physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -13961,31 +19409,38 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pSurfaceFormatCount)
- {
+ if (pSurfaceFormatCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pSurfaceFormats)
- {
- if (pSurfaceFormatCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
- {
- count_VkSurfaceFormatKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceFormatKHR*)(pSurfaceFormats + i), countPtr);
+ if (pSurfaceFormats) {
+ if (pSurfaceFormatCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i) {
+ count_VkSurfaceFormatKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSurfaceFormatKHR*)(pSurfaceFormats + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPhysicalDeviceSurfaceFormatsKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceSurfaceFormatsKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceSurfaceFormatsKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceSurfaceFormatsKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceSurfaceFormatsKHR = OP_vkGetPhysicalDeviceSurfaceFormatsKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSurfaceFormatsKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSurfaceFormatsKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSurfaceFormatsKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSurfaceFormatsKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -13999,8 +19454,7 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pSurfaceFormatCount)
- {
+ if (pSurfaceFormatCount) {
memcpy(*streamPtrPtr, (uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -14009,20 +19463,18 @@
memcpy((*streamPtrPtr), &cgen_var_3, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pSurfaceFormats)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
- {
- reservedmarshal_VkSurfaceFormatKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceFormatKHR*)(pSurfaceFormats + i), streamPtrPtr);
+ if (pSurfaceFormats) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i) {
+ reservedmarshal_VkSurfaceFormatKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSurfaceFormatKHR*)(pSurfaceFormats + i),
+ streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pSurfaceFormatCount;
check_pSurfaceFormatCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pSurfaceFormatCount)
- {
- if (!(check_pSurfaceFormatCount))
- {
+ if (pSurfaceFormatCount) {
+ if (!(check_pSurfaceFormatCount)) {
fprintf(stderr, "fatal: pSurfaceFormatCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
@@ -14030,35 +19482,30 @@
// WARNING PTR CHECK
VkSurfaceFormatKHR* check_pSurfaceFormats;
check_pSurfaceFormats = (VkSurfaceFormatKHR*)(uintptr_t)stream->getBe64();
- if (pSurfaceFormats)
- {
- if (!(check_pSurfaceFormats))
- {
+ if (pSurfaceFormats) {
+ if (!(check_pSurfaceFormats)) {
fprintf(stderr, "fatal: pSurfaceFormats inconsistent between guest and host\n");
}
- if (pSurfaceFormatCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
- {
- unmarshal_VkSurfaceFormatKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceFormatKHR*)(pSurfaceFormats + i));
+ if (pSurfaceFormatCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i) {
+ unmarshal_VkSurfaceFormatKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSurfaceFormatKHR*)(pSurfaceFormats + i));
}
}
}
- if (pSurfaceFormatCount)
- {
- if (pSurfaceFormats)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
- {
- transform_fromhost_VkSurfaceFormatKHR(sResourceTracker, (VkSurfaceFormatKHR*)(pSurfaceFormats + i));
+ if (pSurfaceFormatCount) {
+ if (pSurfaceFormats) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i) {
+ transform_fromhost_VkSurfaceFormatKHR(sResourceTracker,
+ (VkSurfaceFormatKHR*)(pSurfaceFormats + i));
}
}
}
VkResult vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -14066,15 +19513,41 @@
return vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return;
}
-VkResult VkEncoder::vkGetPhysicalDeviceSurfacePresentModesKHR(
- VkPhysicalDevice physicalDevice,
- VkSurfaceKHR surface,
- uint32_t* pPresentModeCount,
- VkPresentModeKHR* pPresentModes,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pPresentModeCount,
+ VkPresentModeKHR* pPresentModes,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceSurfacePresentModesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice:%p, surface:%p, "
+ "pPresentModeCount:%p, pPresentModes:%p)",
+ physicalDevice, surface, pPresentModeCount, pPresentModes);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -14091,28 +19564,36 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pPresentModeCount)
- {
+ if (pPresentModeCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pPresentModes)
- {
- if (pPresentModeCount)
- {
+ if (pPresentModes) {
+ if (pPresentModeCount) {
*countPtr += (*(pPresentModeCount)) * sizeof(VkPresentModeKHR);
}
}
}
- uint32_t packetSize_vkGetPhysicalDeviceSurfacePresentModesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceSurfacePresentModesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceSurfacePresentModesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceSurfacePresentModesKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceSurfacePresentModesKHR = OP_vkGetPhysicalDeviceSurfacePresentModesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSurfacePresentModesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSurfacePresentModesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceSurfacePresentModesKHR =
+ OP_vkGetPhysicalDeviceSurfacePresentModesKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSurfacePresentModesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSurfacePresentModesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -14126,8 +19607,7 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPresentModeCount)
- {
+ if (pPresentModeCount) {
memcpy(*streamPtrPtr, (uint32_t*)pPresentModeCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -14136,18 +19616,16 @@
memcpy((*streamPtrPtr), &cgen_var_3, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPresentModes)
- {
- memcpy(*streamPtrPtr, (VkPresentModeKHR*)pPresentModes, (*(pPresentModeCount)) * sizeof(VkPresentModeKHR));
+ if (pPresentModes) {
+ memcpy(*streamPtrPtr, (VkPresentModeKHR*)pPresentModes,
+ (*(pPresentModeCount)) * sizeof(VkPresentModeKHR));
*streamPtrPtr += (*(pPresentModeCount)) * sizeof(VkPresentModeKHR);
}
// WARNING PTR CHECK
uint32_t* check_pPresentModeCount;
check_pPresentModeCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pPresentModeCount)
- {
- if (!(check_pPresentModeCount))
- {
+ if (pPresentModeCount) {
+ if (!(check_pPresentModeCount)) {
fprintf(stderr, "fatal: pPresentModeCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pPresentModeCount, sizeof(uint32_t));
@@ -14155,19 +19633,18 @@
// WARNING PTR CHECK
VkPresentModeKHR* check_pPresentModes;
check_pPresentModes = (VkPresentModeKHR*)(uintptr_t)stream->getBe64();
- if (pPresentModes)
- {
- if (!(check_pPresentModes))
- {
+ if (pPresentModes) {
+ if (!(check_pPresentModes)) {
fprintf(stderr, "fatal: pPresentModes inconsistent between guest and host\n");
}
- stream->read((VkPresentModeKHR*)pPresentModes, (*(pPresentModeCount)) * sizeof(VkPresentModeKHR));
+ stream->read((VkPresentModeKHR*)pPresentModes,
+ (*(pPresentModeCount)) * sizeof(VkPresentModeKHR));
}
VkResult vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -14177,15 +19654,38 @@
#endif
#ifdef VK_KHR_swapchain
-VkResult VkEncoder::vkCreateSwapchainKHR(
- VkDevice device,
- const VkSwapchainCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSwapchainKHR* pSwapchain,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateSwapchainKHR(VkDevice device,
+ const VkSwapchainCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchain, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateSwapchainKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateSwapchainKHR(device:%p, pCreateInfo:%p, pAllocator:%p, pSwapchain:%p)", device,
+ pCreateInfo, pAllocator, pSwapchain);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -14194,62 +19694,76 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkSwapchainCreateInfoKHR*)pool->alloc(sizeof(const VkSwapchainCreateInfoKHR));
- deepcopy_VkSwapchainCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkSwapchainCreateInfoKHR*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkSwapchainCreateInfoKHR*)pool->alloc(sizeof(const VkSwapchainCreateInfoKHR));
+ deepcopy_VkSwapchainCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkSwapchainCreateInfoKHR*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkSwapchainCreateInfoKHR(sResourceTracker, (VkSwapchainCreateInfoKHR*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkSwapchainCreateInfoKHR(sResourceTracker,
+ (VkSwapchainCreateInfoKHR*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSwapchainCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSwapchainCreateInfoKHR*)(local_pCreateInfo), countPtr);
+ count_VkSwapchainCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSwapchainCreateInfoKHR*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateSwapchainKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateSwapchainKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateSwapchainKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateSwapchainKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateSwapchainKHR = OP_vkCreateSwapchainKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateSwapchainKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateSwapchainKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateSwapchainKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateSwapchainKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSwapchainCreateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSwapchainCreateInfoKHR*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkSwapchainCreateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSwapchainCreateInfoKHR*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -14260,13 +19774,14 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_3, (VkSwapchainKHR*)pSwapchain, 1);
+ stream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_3, (VkSwapchainKHR*)pSwapchain,
+ 1);
stream->unsetHandleMapping();
VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateSwapchainKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -14274,14 +19789,35 @@
return vkCreateSwapchainKHR_VkResult_return;
}
-void VkEncoder::vkDestroySwapchainKHR(
- VkDevice device,
- VkSwapchainKHR swapchain,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroySwapchainKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroySwapchainKHR(device:%p, swapchain:%p, pAllocator:%p)", device,
+ swapchain, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -14291,15 +19827,15 @@
local_device = device;
local_swapchain = swapchain;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -14310,19 +19846,28 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroySwapchainKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroySwapchainKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroySwapchainKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroySwapchainKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroySwapchainKHR = OP_vkDestroySwapchainKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroySwapchainKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroySwapchainKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroySwapchainKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroySwapchainKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -14336,30 +19881,54 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
sResourceTracker->destroyMapping()->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&swapchain);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkGetSwapchainImagesKHR(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint32_t* pSwapchainImageCount,
- VkImage* pSwapchainImages,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain,
+ uint32_t* pSwapchainImageCount,
+ VkImage* pSwapchainImages, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetSwapchainImagesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetSwapchainImagesKHR(device:%p, swapchain:%p, pSwapchainImageCount:%p, "
+ "pSwapchainImages:%p)",
+ device, swapchain, pSwapchainImageCount, pSwapchainImages);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -14376,28 +19945,34 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pSwapchainImageCount)
- {
+ if (pSwapchainImageCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pSwapchainImages)
- {
- if ((*(pSwapchainImageCount)))
- {
+ if (pSwapchainImages) {
+ if ((*(pSwapchainImageCount))) {
*countPtr += (*(pSwapchainImageCount)) * 8;
}
}
}
- uint32_t packetSize_vkGetSwapchainImagesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetSwapchainImagesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetSwapchainImagesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetSwapchainImagesKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetSwapchainImagesKHR = OP_vkGetSwapchainImagesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetSwapchainImagesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetSwapchainImagesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetSwapchainImagesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetSwapchainImagesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -14411,8 +19986,7 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pSwapchainImageCount)
- {
+ if (pSwapchainImageCount) {
memcpy(*streamPtrPtr, (uint32_t*)pSwapchainImageCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -14422,15 +19996,11 @@
memcpy((*streamPtrPtr), &cgen_var_3, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pSwapchainImages)
- {
- if ((*(pSwapchainImageCount)))
- {
+ if (pSwapchainImages) {
+ if ((*(pSwapchainImageCount))) {
uint8_t* cgen_var_3_0_ptr = (uint8_t*)(*streamPtrPtr);
- if (pSwapchainImageCount)
- {
- for (uint32_t k = 0; k < (*(pSwapchainImageCount)); ++k)
- {
+ if (pSwapchainImageCount) {
+ for (uint32_t k = 0; k < (*(pSwapchainImageCount)); ++k) {
uint64_t tmpval = (uint64_t)(pSwapchainImages[k]);
memcpy(cgen_var_3_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -14442,10 +20012,8 @@
// WARNING PTR CHECK
uint32_t* check_pSwapchainImageCount;
check_pSwapchainImageCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pSwapchainImageCount)
- {
- if (!(check_pSwapchainImageCount))
- {
+ if (pSwapchainImageCount) {
+ if (!(check_pSwapchainImageCount)) {
fprintf(stderr, "fatal: pSwapchainImageCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pSwapchainImageCount, sizeof(uint32_t));
@@ -14453,25 +20021,23 @@
// WARNING PTR CHECK
VkImage* check_pSwapchainImages;
check_pSwapchainImages = (VkImage*)(uintptr_t)stream->getBe64();
- if (pSwapchainImages)
- {
- if (!(check_pSwapchainImages))
- {
+ if (pSwapchainImages) {
+ if (!(check_pSwapchainImages)) {
fprintf(stderr, "fatal: pSwapchainImages inconsistent between guest and host\n");
}
- if ((*(pSwapchainImageCount)))
- {
+ if ((*(pSwapchainImageCount))) {
uint64_t* cgen_var_5_0;
stream->alloc((void**)&cgen_var_5_0, (*(pSwapchainImageCount)) * 8);
stream->read((uint64_t*)cgen_var_5_0, (*(pSwapchainImageCount)) * 8);
- stream->handleMapping()->mapHandles_u64_VkImage(cgen_var_5_0, (VkImage*)pSwapchainImages, (*(pSwapchainImageCount)));
+ stream->handleMapping()->mapHandles_u64_VkImage(
+ cgen_var_5_0, (VkImage*)pSwapchainImages, (*(pSwapchainImageCount)));
}
}
VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetSwapchainImagesKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -14479,17 +20045,38 @@
return vkGetSwapchainImagesKHR_VkResult_return;
}
-VkResult VkEncoder::vkAcquireNextImageKHR(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint64_t timeout,
- VkSemaphore semaphore,
- VkFence fence,
- uint32_t* pImageIndex,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain,
+ uint64_t timeout, VkSemaphore semaphore, VkFence fence,
+ uint32_t* pImageIndex, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkAcquireNextImageKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkAcquireNextImageKHR(device:%p, swapchain:%p, timeout:%ld, semaphore:%p, fence:%p, "
+ "pImageIndex:%p)",
+ device, swapchain, timeout, semaphore, fence, pImageIndex);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -14517,14 +20104,23 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
}
- uint32_t packetSize_vkAcquireNextImageKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkAcquireNextImageKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkAcquireNextImageKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkAcquireNextImageKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkAcquireNextImageKHR = OP_vkAcquireNextImageKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkAcquireNextImageKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkAcquireNextImageKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkAcquireNextImageKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkAcquireNextImageKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -14548,9 +20144,9 @@
stream->read((uint32_t*)pImageIndex, sizeof(uint32_t));
VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
stream->read(&vkAcquireNextImageKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -14558,13 +20154,34 @@
return vkAcquireNextImageKHR_VkResult_return;
}
-VkResult VkEncoder::vkQueuePresentKHR(
- VkQueue queue,
- const VkPresentInfoKHR* pPresentInfo,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkQueuePresentKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkQueuePresentKHR(queue:%p, pPresentInfo:%p)", queue, pPresentInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -14572,40 +20189,51 @@
VkPresentInfoKHR* local_pPresentInfo;
local_queue = queue;
local_pPresentInfo = nullptr;
- if (pPresentInfo)
- {
+ if (pPresentInfo) {
local_pPresentInfo = (VkPresentInfoKHR*)pool->alloc(sizeof(const VkPresentInfoKHR));
- deepcopy_VkPresentInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pPresentInfo, (VkPresentInfoKHR*)(local_pPresentInfo));
+ deepcopy_VkPresentInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pPresentInfo,
+ (VkPresentInfoKHR*)(local_pPresentInfo));
}
- if (local_pPresentInfo)
- {
- transform_tohost_VkPresentInfoKHR(sResourceTracker, (VkPresentInfoKHR*)(local_pPresentInfo));
+ if (local_pPresentInfo) {
+ transform_tohost_VkPresentInfoKHR(sResourceTracker,
+ (VkPresentInfoKHR*)(local_pPresentInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPresentInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPresentInfoKHR*)(local_pPresentInfo), countPtr);
+ count_VkPresentInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPresentInfoKHR*)(local_pPresentInfo), countPtr);
}
- uint32_t packetSize_vkQueuePresentKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkQueuePresentKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkQueuePresentKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueuePresentKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueuePresentKHR = OP_vkQueuePresentKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkQueuePresentKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkQueuePresentKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkQueuePresentKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkQueuePresentKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPresentInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPresentInfoKHR*)(local_pPresentInfo), streamPtrPtr);
+ reservedmarshal_VkPresentInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPresentInfoKHR*)(local_pPresentInfo), streamPtrPtr);
VkResult vkQueuePresentKHR_VkResult_return = (VkResult)0;
stream->read(&vkQueuePresentKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -14614,12 +20242,37 @@
}
VkResult VkEncoder::vkGetDeviceGroupPresentCapabilitiesKHR(
- VkDevice device,
- VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities,
- uint32_t doLock)
-{
+ VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetDeviceGroupPresentCapabilitiesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetDeviceGroupPresentCapabilitiesKHR(device:%p, pDeviceGroupPresentCapabilities:%p)",
+ device, pDeviceGroupPresentCapabilities);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -14630,31 +20283,49 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDeviceGroupPresentCapabilitiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities), countPtr);
+ count_VkDeviceGroupPresentCapabilitiesKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities), countPtr);
}
- uint32_t packetSize_vkGetDeviceGroupPresentCapabilitiesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDeviceGroupPresentCapabilitiesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDeviceGroupPresentCapabilitiesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceGroupPresentCapabilitiesKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetDeviceGroupPresentCapabilitiesKHR = OP_vkGetDeviceGroupPresentCapabilitiesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDeviceGroupPresentCapabilitiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDeviceGroupPresentCapabilitiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetDeviceGroupPresentCapabilitiesKHR =
+ OP_vkGetDeviceGroupPresentCapabilitiesKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDeviceGroupPresentCapabilitiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDeviceGroupPresentCapabilitiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDeviceGroupPresentCapabilitiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities), streamPtrPtr);
- unmarshal_VkDeviceGroupPresentCapabilitiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
- if (pDeviceGroupPresentCapabilities)
- {
- transform_fromhost_VkDeviceGroupPresentCapabilitiesKHR(sResourceTracker, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
+ reservedmarshal_VkDeviceGroupPresentCapabilitiesKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities), streamPtrPtr);
+ unmarshal_VkDeviceGroupPresentCapabilitiesKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
+ if (pDeviceGroupPresentCapabilities) {
+ transform_fromhost_VkDeviceGroupPresentCapabilitiesKHR(
+ sResourceTracker,
+ (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities));
}
VkResult vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -14662,14 +20333,37 @@
return vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return;
}
-VkResult VkEncoder::vkGetDeviceGroupSurfacePresentModesKHR(
- VkDevice device,
- VkSurfaceKHR surface,
- VkDeviceGroupPresentModeFlagsKHR* pModes,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface,
+ VkDeviceGroupPresentModeFlagsKHR* pModes,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetDeviceGroupSurfacePresentModesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetDeviceGroupSurfacePresentModesKHR(device:%p, surface:%p, pModes:%p)",
+ device, surface, pModes);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -14686,19 +20380,29 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pModes)
- {
+ if (pModes) {
*countPtr += sizeof(VkDeviceGroupPresentModeFlagsKHR);
}
}
- uint32_t packetSize_vkGetDeviceGroupSurfacePresentModesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDeviceGroupSurfacePresentModesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDeviceGroupSurfacePresentModesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceGroupSurfacePresentModesKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetDeviceGroupSurfacePresentModesKHR = OP_vkGetDeviceGroupSurfacePresentModesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDeviceGroupSurfacePresentModesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDeviceGroupSurfacePresentModesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetDeviceGroupSurfacePresentModesKHR =
+ OP_vkGetDeviceGroupSurfacePresentModesKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDeviceGroupSurfacePresentModesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDeviceGroupSurfacePresentModesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -14712,27 +20416,26 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pModes)
- {
- memcpy(*streamPtrPtr, (VkDeviceGroupPresentModeFlagsKHR*)pModes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+ if (pModes) {
+ memcpy(*streamPtrPtr, (VkDeviceGroupPresentModeFlagsKHR*)pModes,
+ sizeof(VkDeviceGroupPresentModeFlagsKHR));
*streamPtrPtr += sizeof(VkDeviceGroupPresentModeFlagsKHR);
}
// WARNING PTR CHECK
VkDeviceGroupPresentModeFlagsKHR* check_pModes;
check_pModes = (VkDeviceGroupPresentModeFlagsKHR*)(uintptr_t)stream->getBe64();
- if (pModes)
- {
- if (!(check_pModes))
- {
+ if (pModes) {
+ if (!(check_pModes)) {
fprintf(stderr, "fatal: pModes inconsistent between guest and host\n");
}
- stream->read((VkDeviceGroupPresentModeFlagsKHR*)pModes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+ stream->read((VkDeviceGroupPresentModeFlagsKHR*)pModes,
+ sizeof(VkDeviceGroupPresentModeFlagsKHR));
}
VkResult vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -14740,15 +20443,40 @@
return vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return;
}
-VkResult VkEncoder::vkGetPhysicalDevicePresentRectanglesKHR(
- VkPhysicalDevice physicalDevice,
- VkSurfaceKHR surface,
- uint32_t* pRectCount,
- VkRect2D* pRects,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pRectCount, VkRect2D* pRects,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDevicePresentRectanglesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice:%p, surface:%p, pRectCount:%p, "
+ "pRects:%p)",
+ physicalDevice, surface, pRectCount, pRects);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -14765,31 +20493,39 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pRectCount)
- {
+ if (pRectCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pRects)
- {
- if (pRectCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i)
- {
- count_VkRect2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(pRects + i), countPtr);
+ if (pRects) {
+ if (pRectCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i) {
+ count_VkRect2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRect2D*)(pRects + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPhysicalDevicePresentRectanglesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDevicePresentRectanglesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDevicePresentRectanglesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDevicePresentRectanglesKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDevicePresentRectanglesKHR = OP_vkGetPhysicalDevicePresentRectanglesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDevicePresentRectanglesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDevicePresentRectanglesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDevicePresentRectanglesKHR =
+ OP_vkGetPhysicalDevicePresentRectanglesKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDevicePresentRectanglesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDevicePresentRectanglesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -14803,8 +20539,7 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pRectCount)
- {
+ if (pRectCount) {
memcpy(*streamPtrPtr, (uint32_t*)pRectCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -14813,20 +20548,17 @@
memcpy((*streamPtrPtr), &cgen_var_3, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pRects)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i)
- {
- reservedmarshal_VkRect2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(pRects + i), streamPtrPtr);
+ if (pRects) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i) {
+ reservedmarshal_VkRect2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(pRects + i),
+ streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pRectCount;
check_pRectCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pRectCount)
- {
- if (!(check_pRectCount))
- {
+ if (pRectCount) {
+ if (!(check_pRectCount)) {
fprintf(stderr, "fatal: pRectCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pRectCount, sizeof(uint32_t));
@@ -14834,35 +20566,28 @@
// WARNING PTR CHECK
VkRect2D* check_pRects;
check_pRects = (VkRect2D*)(uintptr_t)stream->getBe64();
- if (pRects)
- {
- if (!(check_pRects))
- {
+ if (pRects) {
+ if (!(check_pRects)) {
fprintf(stderr, "fatal: pRects inconsistent between guest and host\n");
}
- if (pRectCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i)
- {
+ if (pRectCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i) {
unmarshal_VkRect2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(pRects + i));
}
}
}
- if (pRectCount)
- {
- if (pRects)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i)
- {
+ if (pRectCount) {
+ if (pRects) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pRectCount)); ++i) {
transform_fromhost_VkRect2D(sResourceTracker, (VkRect2D*)(pRects + i));
}
}
}
VkResult vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -14870,14 +20595,36 @@
return vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return;
}
-VkResult VkEncoder::vkAcquireNextImage2KHR(
- VkDevice device,
- const VkAcquireNextImageInfoKHR* pAcquireInfo,
- uint32_t* pImageIndex,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkAcquireNextImage2KHR(VkDevice device,
+ const VkAcquireNextImageInfoKHR* pAcquireInfo,
+ uint32_t* pImageIndex, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkAcquireNextImage2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkAcquireNextImage2KHR(device:%p, pAcquireInfo:%p, pImageIndex:%p)", device,
+ pAcquireInfo, pImageIndex);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -14885,44 +20632,57 @@
VkAcquireNextImageInfoKHR* local_pAcquireInfo;
local_device = device;
local_pAcquireInfo = nullptr;
- if (pAcquireInfo)
- {
- local_pAcquireInfo = (VkAcquireNextImageInfoKHR*)pool->alloc(sizeof(const VkAcquireNextImageInfoKHR));
- deepcopy_VkAcquireNextImageInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAcquireInfo, (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo));
+ if (pAcquireInfo) {
+ local_pAcquireInfo =
+ (VkAcquireNextImageInfoKHR*)pool->alloc(sizeof(const VkAcquireNextImageInfoKHR));
+ deepcopy_VkAcquireNextImageInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAcquireInfo,
+ (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo));
}
- if (local_pAcquireInfo)
- {
- transform_tohost_VkAcquireNextImageInfoKHR(sResourceTracker, (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo));
+ if (local_pAcquireInfo) {
+ transform_tohost_VkAcquireNextImageInfoKHR(
+ sResourceTracker, (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkAcquireNextImageInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo), countPtr);
+ count_VkAcquireNextImageInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo), countPtr);
*countPtr += sizeof(uint32_t);
}
- uint32_t packetSize_vkAcquireNextImage2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkAcquireNextImage2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkAcquireNextImage2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkAcquireNextImage2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkAcquireNextImage2KHR = OP_vkAcquireNextImage2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkAcquireNextImage2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkAcquireNextImage2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkAcquireNextImage2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkAcquireNextImage2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkAcquireNextImageInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo), streamPtrPtr);
+ reservedmarshal_VkAcquireNextImageInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo),
+ streamPtrPtr);
memcpy(*streamPtrPtr, (uint32_t*)pImageIndex, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
stream->read((uint32_t*)pImageIndex, sizeof(uint32_t));
VkResult vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
stream->read(&vkAcquireNextImage2KHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -14932,14 +20692,40 @@
#endif
#ifdef VK_KHR_display
-VkResult VkEncoder::vkGetPhysicalDeviceDisplayPropertiesKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkDisplayPropertiesKHR* pProperties,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPropertiesKHR* pProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceDisplayPropertiesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice:%p, pPropertyCount:%p, "
+ "pProperties:%p)",
+ physicalDevice, pPropertyCount, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -14952,31 +20738,40 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pProperties)
- {
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- count_VkDisplayPropertiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPropertiesKHR*)(pProperties + i), countPtr);
+ if (pProperties) {
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ count_VkDisplayPropertiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayPropertiesKHR*)(pProperties + i),
+ countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPhysicalDeviceDisplayPropertiesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceDisplayPropertiesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceDisplayPropertiesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceDisplayPropertiesKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceDisplayPropertiesKHR = OP_vkGetPhysicalDeviceDisplayPropertiesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceDisplayPropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceDisplayPropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceDisplayPropertiesKHR =
+ OP_vkGetPhysicalDeviceDisplayPropertiesKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceDisplayPropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceDisplayPropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -14986,8 +20781,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
memcpy(*streamPtrPtr, (uint32_t*)pPropertyCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -14996,20 +20790,18 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- reservedmarshal_VkDisplayPropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPropertiesKHR*)(pProperties + i), streamPtrPtr);
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ reservedmarshal_VkDisplayPropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayPropertiesKHR*)(pProperties + i),
+ streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pPropertyCount)
- {
- if (!(check_pPropertyCount))
- {
+ if (pPropertyCount) {
+ if (!(check_pPropertyCount)) {
fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
@@ -15017,35 +20809,30 @@
// WARNING PTR CHECK
VkDisplayPropertiesKHR* check_pProperties;
check_pProperties = (VkDisplayPropertiesKHR*)(uintptr_t)stream->getBe64();
- if (pProperties)
- {
- if (!(check_pProperties))
- {
+ if (pProperties) {
+ if (!(check_pProperties)) {
fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
}
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- unmarshal_VkDisplayPropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPropertiesKHR*)(pProperties + i));
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ unmarshal_VkDisplayPropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayPropertiesKHR*)(pProperties + i));
}
}
}
- if (pPropertyCount)
- {
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- transform_fromhost_VkDisplayPropertiesKHR(sResourceTracker, (VkDisplayPropertiesKHR*)(pProperties + i));
+ if (pPropertyCount) {
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ transform_fromhost_VkDisplayPropertiesKHR(
+ sResourceTracker, (VkDisplayPropertiesKHR*)(pProperties + i));
}
}
}
VkResult vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -15054,13 +20841,38 @@
}
VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkDisplayPlanePropertiesKHR* pProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount,
+ VkDisplayPlanePropertiesKHR* pProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceDisplayPlanePropertiesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice:%p, pPropertyCount:%p, "
+ "pProperties:%p)",
+ physicalDevice, pPropertyCount, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -15073,31 +20885,40 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pProperties)
- {
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- count_VkDisplayPlanePropertiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlanePropertiesKHR*)(pProperties + i), countPtr);
+ if (pProperties) {
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ count_VkDisplayPlanePropertiesKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayPlanePropertiesKHR*)(pProperties + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceDisplayPlanePropertiesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceDisplayPlanePropertiesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceDisplayPlanePropertiesKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = OP_vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceDisplayPlanePropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceDisplayPlanePropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceDisplayPlanePropertiesKHR =
+ OP_vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceDisplayPlanePropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceDisplayPlanePropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -15107,8 +20928,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
memcpy(*streamPtrPtr, (uint32_t*)pPropertyCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -15117,20 +20937,18 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- reservedmarshal_VkDisplayPlanePropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlanePropertiesKHR*)(pProperties + i), streamPtrPtr);
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ reservedmarshal_VkDisplayPlanePropertiesKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlanePropertiesKHR*)(pProperties + i),
+ streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pPropertyCount)
- {
- if (!(check_pPropertyCount))
- {
+ if (pPropertyCount) {
+ if (!(check_pPropertyCount)) {
fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
@@ -15138,35 +20956,31 @@
// WARNING PTR CHECK
VkDisplayPlanePropertiesKHR* check_pProperties;
check_pProperties = (VkDisplayPlanePropertiesKHR*)(uintptr_t)stream->getBe64();
- if (pProperties)
- {
- if (!(check_pProperties))
- {
+ if (pProperties) {
+ if (!(check_pProperties)) {
fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
}
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- unmarshal_VkDisplayPlanePropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlanePropertiesKHR*)(pProperties + i));
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ unmarshal_VkDisplayPlanePropertiesKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayPlanePropertiesKHR*)(pProperties + i));
}
}
}
- if (pPropertyCount)
- {
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- transform_fromhost_VkDisplayPlanePropertiesKHR(sResourceTracker, (VkDisplayPlanePropertiesKHR*)(pProperties + i));
+ if (pPropertyCount) {
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ transform_fromhost_VkDisplayPlanePropertiesKHR(
+ sResourceTracker, (VkDisplayPlanePropertiesKHR*)(pProperties + i));
}
}
}
VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -15174,15 +20988,41 @@
return vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return;
}
-VkResult VkEncoder::vkGetDisplayPlaneSupportedDisplaysKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t planeIndex,
- uint32_t* pDisplayCount,
- VkDisplayKHR* pDisplays,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice,
+ uint32_t planeIndex,
+ uint32_t* pDisplayCount,
+ VkDisplayKHR* pDisplays,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetDisplayPlaneSupportedDisplaysKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice:%p, planeIndex:%d, pDisplayCount:%p, "
+ "pDisplays:%p)",
+ physicalDevice, planeIndex, pDisplayCount, pDisplays);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -15198,28 +21038,36 @@
*countPtr += sizeof(uint32_t);
// WARNING PTR CHECK
*countPtr += 8;
- if (pDisplayCount)
- {
+ if (pDisplayCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pDisplays)
- {
- if ((*(pDisplayCount)))
- {
+ if (pDisplays) {
+ if ((*(pDisplayCount))) {
*countPtr += (*(pDisplayCount)) * 8;
}
}
}
- uint32_t packetSize_vkGetDisplayPlaneSupportedDisplaysKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDisplayPlaneSupportedDisplaysKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDisplayPlaneSupportedDisplaysKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDisplayPlaneSupportedDisplaysKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetDisplayPlaneSupportedDisplaysKHR = OP_vkGetDisplayPlaneSupportedDisplaysKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDisplayPlaneSupportedDisplaysKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDisplayPlaneSupportedDisplaysKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetDisplayPlaneSupportedDisplaysKHR =
+ OP_vkGetDisplayPlaneSupportedDisplaysKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDisplayPlaneSupportedDisplaysKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDisplayPlaneSupportedDisplaysKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -15231,8 +21079,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pDisplayCount)
- {
+ if (pDisplayCount) {
memcpy(*streamPtrPtr, (uint32_t*)pDisplayCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -15242,15 +21089,11 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pDisplays)
- {
- if ((*(pDisplayCount)))
- {
+ if (pDisplays) {
+ if ((*(pDisplayCount))) {
uint8_t* cgen_var_2_0_ptr = (uint8_t*)(*streamPtrPtr);
- if (pDisplayCount)
- {
- for (uint32_t k = 0; k < (*(pDisplayCount)); ++k)
- {
+ if (pDisplayCount) {
+ for (uint32_t k = 0; k < (*(pDisplayCount)); ++k) {
uint64_t tmpval = (uint64_t)(pDisplays[k]);
memcpy(cgen_var_2_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -15262,10 +21105,8 @@
// WARNING PTR CHECK
uint32_t* check_pDisplayCount;
check_pDisplayCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pDisplayCount)
- {
- if (!(check_pDisplayCount))
- {
+ if (pDisplayCount) {
+ if (!(check_pDisplayCount)) {
fprintf(stderr, "fatal: pDisplayCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pDisplayCount, sizeof(uint32_t));
@@ -15273,25 +21114,23 @@
// WARNING PTR CHECK
VkDisplayKHR* check_pDisplays;
check_pDisplays = (VkDisplayKHR*)(uintptr_t)stream->getBe64();
- if (pDisplays)
- {
- if (!(check_pDisplays))
- {
+ if (pDisplays) {
+ if (!(check_pDisplays)) {
fprintf(stderr, "fatal: pDisplays inconsistent between guest and host\n");
}
- if ((*(pDisplayCount)))
- {
+ if ((*(pDisplayCount))) {
uint64_t* cgen_var_4_0;
stream->alloc((void**)&cgen_var_4_0, (*(pDisplayCount)) * 8);
stream->read((uint64_t*)cgen_var_4_0, (*(pDisplayCount)) * 8);
- stream->handleMapping()->mapHandles_u64_VkDisplayKHR(cgen_var_4_0, (VkDisplayKHR*)pDisplays, (*(pDisplayCount)));
+ stream->handleMapping()->mapHandles_u64_VkDisplayKHR(
+ cgen_var_4_0, (VkDisplayKHR*)pDisplays, (*(pDisplayCount)));
}
}
VkResult vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -15299,15 +21138,39 @@
return vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return;
}
-VkResult VkEncoder::vkGetDisplayModePropertiesKHR(
- VkPhysicalDevice physicalDevice,
- VkDisplayKHR display,
- uint32_t* pPropertyCount,
- VkDisplayModePropertiesKHR* pProperties,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display, uint32_t* pPropertyCount,
+ VkDisplayModePropertiesKHR* pProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetDisplayModePropertiesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetDisplayModePropertiesKHR(physicalDevice:%p, display:%p, pPropertyCount:%p, "
+ "pProperties:%p)",
+ physicalDevice, display, pPropertyCount, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -15324,31 +21187,39 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pProperties)
- {
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- count_VkDisplayModePropertiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayModePropertiesKHR*)(pProperties + i), countPtr);
+ if (pProperties) {
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ count_VkDisplayModePropertiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayModePropertiesKHR*)(pProperties + i),
+ countPtr);
}
}
}
}
- uint32_t packetSize_vkGetDisplayModePropertiesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDisplayModePropertiesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDisplayModePropertiesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDisplayModePropertiesKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDisplayModePropertiesKHR = OP_vkGetDisplayModePropertiesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDisplayModePropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDisplayModePropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDisplayModePropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDisplayModePropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -15362,8 +21233,7 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
memcpy(*streamPtrPtr, (uint32_t*)pPropertyCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -15372,20 +21242,18 @@
memcpy((*streamPtrPtr), &cgen_var_3, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- reservedmarshal_VkDisplayModePropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayModePropertiesKHR*)(pProperties + i), streamPtrPtr);
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ reservedmarshal_VkDisplayModePropertiesKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayModePropertiesKHR*)(pProperties + i),
+ streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pPropertyCount)
- {
- if (!(check_pPropertyCount))
- {
+ if (pPropertyCount) {
+ if (!(check_pPropertyCount)) {
fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
@@ -15393,35 +21261,31 @@
// WARNING PTR CHECK
VkDisplayModePropertiesKHR* check_pProperties;
check_pProperties = (VkDisplayModePropertiesKHR*)(uintptr_t)stream->getBe64();
- if (pProperties)
- {
- if (!(check_pProperties))
- {
+ if (pProperties) {
+ if (!(check_pProperties)) {
fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
}
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- unmarshal_VkDisplayModePropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayModePropertiesKHR*)(pProperties + i));
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ unmarshal_VkDisplayModePropertiesKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayModePropertiesKHR*)(pProperties + i));
}
}
}
- if (pPropertyCount)
- {
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- transform_fromhost_VkDisplayModePropertiesKHR(sResourceTracker, (VkDisplayModePropertiesKHR*)(pProperties + i));
+ if (pPropertyCount) {
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ transform_fromhost_VkDisplayModePropertiesKHR(
+ sResourceTracker, (VkDisplayModePropertiesKHR*)(pProperties + i));
}
}
}
VkResult vkGetDisplayModePropertiesKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetDisplayModePropertiesKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -15429,16 +21293,39 @@
return vkGetDisplayModePropertiesKHR_VkResult_return;
}
-VkResult VkEncoder::vkCreateDisplayModeKHR(
- VkPhysicalDevice physicalDevice,
- VkDisplayKHR display,
- const VkDisplayModeCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDisplayModeKHR* pMode,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+ const VkDisplayModeCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDisplayModeKHR* pMode, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateDisplayModeKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateDisplayModeKHR(physicalDevice:%p, display:%p, pCreateInfo:%p, pAllocator:%p, "
+ "pMode:%p)",
+ physicalDevice, display, pCreateInfo, pAllocator, pMode);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -15449,25 +21336,26 @@
local_physicalDevice = physicalDevice;
local_display = display;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkDisplayModeCreateInfoKHR*)pool->alloc(sizeof(const VkDisplayModeCreateInfoKHR));
- deepcopy_VkDisplayModeCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDisplayModeCreateInfoKHR*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkDisplayModeCreateInfoKHR*)pool->alloc(sizeof(const VkDisplayModeCreateInfoKHR));
+ deepcopy_VkDisplayModeCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkDisplayModeCreateInfoKHR*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkDisplayModeCreateInfoKHR(sResourceTracker, (VkDisplayModeCreateInfoKHR*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkDisplayModeCreateInfoKHR(
+ sResourceTracker, (VkDisplayModeCreateInfoKHR*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -15476,24 +21364,35 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkDisplayModeCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayModeCreateInfoKHR*)(local_pCreateInfo), countPtr);
+ count_VkDisplayModeCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayModeCreateInfoKHR*)(local_pCreateInfo),
+ countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_2;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateDisplayModeKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateDisplayModeKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateDisplayModeKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateDisplayModeKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateDisplayModeKHR = OP_vkCreateDisplayModeKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateDisplayModeKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateDisplayModeKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateDisplayModeKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateDisplayModeKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -15502,15 +21401,18 @@
*&cgen_var_1 = get_host_u64_VkDisplayKHR((*&local_display));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDisplayModeCreateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayModeCreateInfoKHR*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkDisplayModeCreateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayModeCreateInfoKHR*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_2 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_3;
@@ -15521,13 +21423,14 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_4;
stream->read((uint64_t*)&cgen_var_4, 8);
- stream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_4, (VkDisplayModeKHR*)pMode, 1);
+ stream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_4, (VkDisplayModeKHR*)pMode,
+ 1);
stream->unsetHandleMapping();
VkResult vkCreateDisplayModeKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateDisplayModeKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -15535,15 +21438,39 @@
return vkCreateDisplayModeKHR_VkResult_return;
}
-VkResult VkEncoder::vkGetDisplayPlaneCapabilitiesKHR(
- VkPhysicalDevice physicalDevice,
- VkDisplayModeKHR mode,
- uint32_t planeIndex,
- VkDisplayPlaneCapabilitiesKHR* pCapabilities,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice,
+ VkDisplayModeKHR mode, uint32_t planeIndex,
+ VkDisplayPlaneCapabilitiesKHR* pCapabilities,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetDisplayPlaneCapabilitiesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetDisplayPlaneCapabilitiesKHR(physicalDevice:%p, mode:%p, planeIndex:%d, "
+ "pCapabilities:%p)",
+ physicalDevice, mode, planeIndex, pCapabilities);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -15561,16 +21488,28 @@
uint64_t cgen_var_1;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- count_VkDisplayPlaneCapabilitiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities), countPtr);
+ count_VkDisplayPlaneCapabilitiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities),
+ countPtr);
}
- uint32_t packetSize_vkGetDisplayPlaneCapabilitiesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDisplayPlaneCapabilitiesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDisplayPlaneCapabilitiesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDisplayPlaneCapabilitiesKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDisplayPlaneCapabilitiesKHR = OP_vkGetDisplayPlaneCapabilitiesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDisplayPlaneCapabilitiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDisplayPlaneCapabilitiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDisplayPlaneCapabilitiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDisplayPlaneCapabilitiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -15581,17 +21520,20 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_planeIndex, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- reservedmarshal_VkDisplayPlaneCapabilitiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities), streamPtrPtr);
- unmarshal_VkDisplayPlaneCapabilitiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities));
- if (pCapabilities)
- {
- transform_fromhost_VkDisplayPlaneCapabilitiesKHR(sResourceTracker, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities));
+ reservedmarshal_VkDisplayPlaneCapabilitiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities),
+ streamPtrPtr);
+ unmarshal_VkDisplayPlaneCapabilitiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities));
+ if (pCapabilities) {
+ transform_fromhost_VkDisplayPlaneCapabilitiesKHR(
+ sResourceTracker, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities));
}
VkResult vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetDisplayPlaneCapabilitiesKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -15599,15 +21541,38 @@
return vkGetDisplayPlaneCapabilitiesKHR_VkResult_return;
}
-VkResult VkEncoder::vkCreateDisplayPlaneSurfaceKHR(
- VkInstance instance,
- const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateDisplayPlaneSurfaceKHR(VkInstance instance,
+ const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateDisplayPlaneSurfaceKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateDisplayPlaneSurfaceKHR(instance:%p, pCreateInfo:%p, pAllocator:%p, pSurface:%p)",
+ instance, pCreateInfo, pAllocator, pSurface);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -15616,62 +21581,78 @@
VkAllocationCallbacks* local_pAllocator;
local_instance = instance;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkDisplaySurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkDisplaySurfaceCreateInfoKHR));
- deepcopy_VkDisplaySurfaceCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDisplaySurfaceCreateInfoKHR*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkDisplaySurfaceCreateInfoKHR*)pool->alloc(
+ sizeof(const VkDisplaySurfaceCreateInfoKHR));
+ deepcopy_VkDisplaySurfaceCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkDisplaySurfaceCreateInfoKHR*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkDisplaySurfaceCreateInfoKHR(sResourceTracker, (VkDisplaySurfaceCreateInfoKHR*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkDisplaySurfaceCreateInfoKHR(
+ sResourceTracker, (VkDisplaySurfaceCreateInfoKHR*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDisplaySurfaceCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplaySurfaceCreateInfoKHR*)(local_pCreateInfo), countPtr);
+ count_VkDisplaySurfaceCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplaySurfaceCreateInfoKHR*)(local_pCreateInfo),
+ countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateDisplayPlaneSurfaceKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateDisplayPlaneSurfaceKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCreateDisplayPlaneSurfaceKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateDisplayPlaneSurfaceKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateDisplayPlaneSurfaceKHR = OP_vkCreateDisplayPlaneSurfaceKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateDisplayPlaneSurfaceKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateDisplayPlaneSurfaceKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateDisplayPlaneSurfaceKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateDisplayPlaneSurfaceKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDisplaySurfaceCreateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplaySurfaceCreateInfoKHR*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkDisplaySurfaceCreateInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplaySurfaceCreateInfoKHR*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -15684,9 +21665,9 @@
stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_3, (VkSurfaceKHR*)pSurface, 1);
VkResult vkCreateDisplayPlaneSurfaceKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateDisplayPlaneSurfaceKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -15696,16 +21677,39 @@
#endif
#ifdef VK_KHR_display_swapchain
-VkResult VkEncoder::vkCreateSharedSwapchainsKHR(
- VkDevice device,
- uint32_t swapchainCount,
- const VkSwapchainCreateInfoKHR* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkSwapchainKHR* pSwapchains,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
+ const VkSwapchainCreateInfoKHR* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchains, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateSharedSwapchainsKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateSharedSwapchainsKHR(device:%p, swapchainCount:%d, pCreateInfos:%p, pAllocator:%p, "
+ "pSwapchains:%p)",
+ device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -15716,31 +21720,30 @@
local_device = device;
local_swapchainCount = swapchainCount;
local_pCreateInfos = nullptr;
- if (pCreateInfos)
- {
- local_pCreateInfos = (VkSwapchainCreateInfoKHR*)pool->alloc(((swapchainCount)) * sizeof(const VkSwapchainCreateInfoKHR));
- for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
- {
- deepcopy_VkSwapchainCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfos + i, (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i));
+ if (pCreateInfos) {
+ local_pCreateInfos = (VkSwapchainCreateInfoKHR*)pool->alloc(
+ ((swapchainCount)) * sizeof(const VkSwapchainCreateInfoKHR));
+ for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i) {
+ deepcopy_VkSwapchainCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfos + i,
+ (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i));
}
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
- {
- transform_tohost_VkSwapchainCreateInfoKHR(sResourceTracker, (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i));
+ if (local_pCreateInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i) {
+ transform_tohost_VkSwapchainCreateInfoKHR(
+ sResourceTracker, (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i));
}
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -15748,72 +21751,81 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
- {
- count_VkSwapchainCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i) {
+ count_VkSwapchainCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i),
+ countPtr);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
- if (((swapchainCount)))
- {
+ if (((swapchainCount))) {
*countPtr += ((swapchainCount)) * 8;
}
}
- uint32_t packetSize_vkCreateSharedSwapchainsKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateSharedSwapchainsKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateSharedSwapchainsKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateSharedSwapchainsKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateSharedSwapchainsKHR = OP_vkCreateSharedSwapchainsKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateSharedSwapchainsKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateSharedSwapchainsKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateSharedSwapchainsKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateSharedSwapchainsKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_swapchainCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
- {
- reservedmarshal_VkSwapchainCreateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i) {
+ reservedmarshal_VkSwapchainCreateInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSwapchainCreateInfoKHR*)(local_pCreateInfos + i),
+ streamPtrPtr);
}
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
- if (((swapchainCount)))
- {
+ if (((swapchainCount))) {
uint8_t* cgen_var_2_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((swapchainCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((swapchainCount)); ++k) {
uint64_t tmpval = (uint64_t)(pSwapchains[k]);
memcpy(cgen_var_2_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
*streamPtrPtr += 8 * ((swapchainCount));
}
/* is handle, possibly out */;
- if (((swapchainCount)))
- {
+ if (((swapchainCount))) {
uint64_t* cgen_var_3;
stream->alloc((void**)&cgen_var_3, ((swapchainCount)) * 8);
stream->read((uint64_t*)cgen_var_3, ((swapchainCount)) * 8);
- stream->handleMapping()->mapHandles_u64_VkSwapchainKHR(cgen_var_3, (VkSwapchainKHR*)pSwapchains, ((swapchainCount)));
+ stream->handleMapping()->mapHandles_u64_VkSwapchainKHR(
+ cgen_var_3, (VkSwapchainKHR*)pSwapchains, ((swapchainCount)));
}
VkResult vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateSharedSwapchainsKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -15823,15 +21835,38 @@
#endif
#ifdef VK_KHR_xlib_surface
-VkResult VkEncoder::vkCreateXlibSurfaceKHR(
- VkInstance instance,
- const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateXlibSurfaceKHR(VkInstance instance,
+ const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateXlibSurfaceKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateXlibSurfaceKHR(instance:%p, pCreateInfo:%p, pAllocator:%p, pSurface:%p)", instance,
+ pCreateInfo, pAllocator, pSurface);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -15840,62 +21875,77 @@
VkAllocationCallbacks* local_pAllocator;
local_instance = instance;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkXlibSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkXlibSurfaceCreateInfoKHR));
- deepcopy_VkXlibSurfaceCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkXlibSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkXlibSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkXlibSurfaceCreateInfoKHR));
+ deepcopy_VkXlibSurfaceCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkXlibSurfaceCreateInfoKHR*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkXlibSurfaceCreateInfoKHR(sResourceTracker, (VkXlibSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkXlibSurfaceCreateInfoKHR(
+ sResourceTracker, (VkXlibSurfaceCreateInfoKHR*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkXlibSurfaceCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkXlibSurfaceCreateInfoKHR*)(local_pCreateInfo), countPtr);
+ count_VkXlibSurfaceCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkXlibSurfaceCreateInfoKHR*)(local_pCreateInfo),
+ countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateXlibSurfaceKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateXlibSurfaceKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateXlibSurfaceKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateXlibSurfaceKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateXlibSurfaceKHR = OP_vkCreateXlibSurfaceKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateXlibSurfaceKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateXlibSurfaceKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateXlibSurfaceKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateXlibSurfaceKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkXlibSurfaceCreateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkXlibSurfaceCreateInfoKHR*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkXlibSurfaceCreateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkXlibSurfaceCreateInfoKHR*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -15908,9 +21958,9 @@
stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_3, (VkSurfaceKHR*)pSurface, 1);
VkResult vkCreateXlibSurfaceKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateXlibSurfaceKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -15918,15 +21968,40 @@
return vkCreateXlibSurfaceKHR_VkResult_return;
}
-VkBool32 VkEncoder::vkGetPhysicalDeviceXlibPresentationSupportKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- Display* dpy,
- VisualID visualID,
- uint32_t doLock)
-{
+VkBool32 VkEncoder::vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ Display* dpy, VisualID visualID,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceXlibPresentationSupportKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice:%p, queueFamilyIndex:%d, "
+ "dpy:%p)",
+ physicalDevice, queueFamilyIndex, dpy);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -15945,14 +22020,25 @@
*countPtr += sizeof(Display);
*countPtr += sizeof(VisualID);
}
- uint32_t packetSize_vkGetPhysicalDeviceXlibPresentationSupportKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceXlibPresentationSupportKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceXlibPresentationSupportKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceXlibPresentationSupportKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceXlibPresentationSupportKHR = OP_vkGetPhysicalDeviceXlibPresentationSupportKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceXlibPresentationSupportKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceXlibPresentationSupportKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceXlibPresentationSupportKHR =
+ OP_vkGetPhysicalDeviceXlibPresentationSupportKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceXlibPresentationSupportKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceXlibPresentationSupportKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -15966,9 +22052,9 @@
stream->read((Display*)dpy, sizeof(Display));
VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = (VkBool32)0;
stream->read(&vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -15978,15 +22064,38 @@
#endif
#ifdef VK_KHR_xcb_surface
-VkResult VkEncoder::vkCreateXcbSurfaceKHR(
- VkInstance instance,
- const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateXcbSurfaceKHR(VkInstance instance,
+ const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateXcbSurfaceKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateXcbSurfaceKHR(instance:%p, pCreateInfo:%p, pAllocator:%p, pSurface:%p)", instance,
+ pCreateInfo, pAllocator, pSurface);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -15995,62 +22104,76 @@
VkAllocationCallbacks* local_pAllocator;
local_instance = instance;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkXcbSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkXcbSurfaceCreateInfoKHR));
- deepcopy_VkXcbSurfaceCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkXcbSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkXcbSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkXcbSurfaceCreateInfoKHR));
+ deepcopy_VkXcbSurfaceCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkXcbSurfaceCreateInfoKHR*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkXcbSurfaceCreateInfoKHR(sResourceTracker, (VkXcbSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkXcbSurfaceCreateInfoKHR(sResourceTracker,
+ (VkXcbSurfaceCreateInfoKHR*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkXcbSurfaceCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkXcbSurfaceCreateInfoKHR*)(local_pCreateInfo), countPtr);
+ count_VkXcbSurfaceCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkXcbSurfaceCreateInfoKHR*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateXcbSurfaceKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateXcbSurfaceKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateXcbSurfaceKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateXcbSurfaceKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateXcbSurfaceKHR = OP_vkCreateXcbSurfaceKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateXcbSurfaceKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateXcbSurfaceKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateXcbSurfaceKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateXcbSurfaceKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkXcbSurfaceCreateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkXcbSurfaceCreateInfoKHR*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkXcbSurfaceCreateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkXcbSurfaceCreateInfoKHR*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -16063,9 +22186,9 @@
stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_3, (VkSurfaceKHR*)pSurface, 1);
VkResult vkCreateXcbSurfaceKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateXcbSurfaceKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -16073,15 +22196,41 @@
return vkCreateXcbSurfaceKHR_VkResult_return;
}
-VkBool32 VkEncoder::vkGetPhysicalDeviceXcbPresentationSupportKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- xcb_connection_t* connection,
- xcb_visualid_t visual_id,
- uint32_t doLock)
-{
+VkBool32 VkEncoder::vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ xcb_connection_t* connection,
+ xcb_visualid_t visual_id,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceXcbPresentationSupportKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice:%p, queueFamilyIndex:%d, "
+ "connection:%p)",
+ physicalDevice, queueFamilyIndex, connection);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -16100,14 +22249,25 @@
*countPtr += sizeof(xcb_connection_t);
*countPtr += sizeof(xcb_visualid_t);
}
- uint32_t packetSize_vkGetPhysicalDeviceXcbPresentationSupportKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceXcbPresentationSupportKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceXcbPresentationSupportKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceXcbPresentationSupportKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceXcbPresentationSupportKHR = OP_vkGetPhysicalDeviceXcbPresentationSupportKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceXcbPresentationSupportKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceXcbPresentationSupportKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceXcbPresentationSupportKHR =
+ OP_vkGetPhysicalDeviceXcbPresentationSupportKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceXcbPresentationSupportKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceXcbPresentationSupportKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -16121,9 +22281,9 @@
stream->read((xcb_connection_t*)connection, sizeof(xcb_connection_t));
VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = (VkBool32)0;
stream->read(&vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -16133,15 +22293,38 @@
#endif
#ifdef VK_KHR_wayland_surface
-VkResult VkEncoder::vkCreateWaylandSurfaceKHR(
- VkInstance instance,
- const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateWaylandSurfaceKHR(VkInstance instance,
+ const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateWaylandSurfaceKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateWaylandSurfaceKHR(instance:%p, pCreateInfo:%p, pAllocator:%p, pSurface:%p)",
+ instance, pCreateInfo, pAllocator, pSurface);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -16150,62 +22333,77 @@
VkAllocationCallbacks* local_pAllocator;
local_instance = instance;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkWaylandSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkWaylandSurfaceCreateInfoKHR));
- deepcopy_VkWaylandSurfaceCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkWaylandSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkWaylandSurfaceCreateInfoKHR*)pool->alloc(
+ sizeof(const VkWaylandSurfaceCreateInfoKHR));
+ deepcopy_VkWaylandSurfaceCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkWaylandSurfaceCreateInfoKHR*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkWaylandSurfaceCreateInfoKHR(sResourceTracker, (VkWaylandSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkWaylandSurfaceCreateInfoKHR(
+ sResourceTracker, (VkWaylandSurfaceCreateInfoKHR*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkWaylandSurfaceCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkWaylandSurfaceCreateInfoKHR*)(local_pCreateInfo), countPtr);
+ count_VkWaylandSurfaceCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkWaylandSurfaceCreateInfoKHR*)(local_pCreateInfo),
+ countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateWaylandSurfaceKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateWaylandSurfaceKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateWaylandSurfaceKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateWaylandSurfaceKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateWaylandSurfaceKHR = OP_vkCreateWaylandSurfaceKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateWaylandSurfaceKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateWaylandSurfaceKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateWaylandSurfaceKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateWaylandSurfaceKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkWaylandSurfaceCreateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkWaylandSurfaceCreateInfoKHR*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkWaylandSurfaceCreateInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkWaylandSurfaceCreateInfoKHR*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -16218,9 +22416,9 @@
stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_3, (VkSurfaceKHR*)pSurface, 1);
VkResult vkCreateWaylandSurfaceKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateWaylandSurfaceKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -16229,13 +22427,38 @@
}
VkBool32 VkEncoder::vkGetPhysicalDeviceWaylandPresentationSupportKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- wl_display* display,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, wl_display* display,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceWaylandPresentationSupportKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice:%p, queueFamilyIndex:%d, "
+ "display:%p)",
+ physicalDevice, queueFamilyIndex, display);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -16251,14 +22474,27 @@
*countPtr += sizeof(uint32_t);
*countPtr += sizeof(wl_display);
}
- uint32_t packetSize_vkGetPhysicalDeviceWaylandPresentationSupportKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceWaylandPresentationSupportKHR);
+ uint32_t packetSize_vkGetPhysicalDeviceWaylandPresentationSupportKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceWaylandPresentationSupportKHR);
+ uint8_t* streamPtr =
+ stream->reserve(packetSize_vkGetPhysicalDeviceWaylandPresentationSupportKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceWaylandPresentationSupportKHR = OP_vkGetPhysicalDeviceWaylandPresentationSupportKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceWaylandPresentationSupportKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceWaylandPresentationSupportKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceWaylandPresentationSupportKHR =
+ OP_vkGetPhysicalDeviceWaylandPresentationSupportKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceWaylandPresentationSupportKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceWaylandPresentationSupportKHR,
+ sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -16269,10 +22505,11 @@
*streamPtrPtr += sizeof(wl_display);
stream->read((wl_display*)display, sizeof(wl_display));
VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return = (VkBool32)0;
- stream->read(&vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ stream->read(&vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return,
+ sizeof(VkBool32));
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -16282,15 +22519,38 @@
#endif
#ifdef VK_KHR_android_surface
-VkResult VkEncoder::vkCreateAndroidSurfaceKHR(
- VkInstance instance,
- const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateAndroidSurfaceKHR(VkInstance instance,
+ const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateAndroidSurfaceKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateAndroidSurfaceKHR(instance:%p, pCreateInfo:%p, pAllocator:%p, pSurface:%p)",
+ instance, pCreateInfo, pAllocator, pSurface);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -16299,62 +22559,77 @@
VkAllocationCallbacks* local_pAllocator;
local_instance = instance;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkAndroidSurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkAndroidSurfaceCreateInfoKHR));
- deepcopy_VkAndroidSurfaceCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkAndroidSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkAndroidSurfaceCreateInfoKHR*)pool->alloc(
+ sizeof(const VkAndroidSurfaceCreateInfoKHR));
+ deepcopy_VkAndroidSurfaceCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkAndroidSurfaceCreateInfoKHR*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkAndroidSurfaceCreateInfoKHR(sResourceTracker, (VkAndroidSurfaceCreateInfoKHR*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkAndroidSurfaceCreateInfoKHR(
+ sResourceTracker, (VkAndroidSurfaceCreateInfoKHR*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkAndroidSurfaceCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAndroidSurfaceCreateInfoKHR*)(local_pCreateInfo), countPtr);
+ count_VkAndroidSurfaceCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAndroidSurfaceCreateInfoKHR*)(local_pCreateInfo),
+ countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateAndroidSurfaceKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateAndroidSurfaceKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateAndroidSurfaceKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateAndroidSurfaceKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateAndroidSurfaceKHR = OP_vkCreateAndroidSurfaceKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateAndroidSurfaceKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateAndroidSurfaceKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateAndroidSurfaceKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateAndroidSurfaceKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkAndroidSurfaceCreateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAndroidSurfaceCreateInfoKHR*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkAndroidSurfaceCreateInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAndroidSurfaceCreateInfoKHR*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -16367,9 +22642,9 @@
stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_3, (VkSurfaceKHR*)pSurface, 1);
VkResult vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateAndroidSurfaceKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -16379,15 +22654,38 @@
#endif
#ifdef VK_KHR_win32_surface
-VkResult VkEncoder::vkCreateWin32SurfaceKHR(
- VkInstance instance,
- const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateWin32SurfaceKHR(VkInstance instance,
+ const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateWin32SurfaceKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateWin32SurfaceKHR(instance:%p, pCreateInfo:%p, pAllocator:%p, pSurface:%p)",
+ instance, pCreateInfo, pAllocator, pSurface);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -16396,62 +22694,77 @@
VkAllocationCallbacks* local_pAllocator;
local_instance = instance;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkWin32SurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkWin32SurfaceCreateInfoKHR));
- deepcopy_VkWin32SurfaceCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkWin32SurfaceCreateInfoKHR*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkWin32SurfaceCreateInfoKHR*)pool->alloc(sizeof(const VkWin32SurfaceCreateInfoKHR));
+ deepcopy_VkWin32SurfaceCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkWin32SurfaceCreateInfoKHR*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkWin32SurfaceCreateInfoKHR(sResourceTracker, (VkWin32SurfaceCreateInfoKHR*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkWin32SurfaceCreateInfoKHR(
+ sResourceTracker, (VkWin32SurfaceCreateInfoKHR*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkWin32SurfaceCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkWin32SurfaceCreateInfoKHR*)(local_pCreateInfo), countPtr);
+ count_VkWin32SurfaceCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkWin32SurfaceCreateInfoKHR*)(local_pCreateInfo),
+ countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateWin32SurfaceKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateWin32SurfaceKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateWin32SurfaceKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateWin32SurfaceKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateWin32SurfaceKHR = OP_vkCreateWin32SurfaceKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateWin32SurfaceKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateWin32SurfaceKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateWin32SurfaceKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateWin32SurfaceKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkWin32SurfaceCreateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkWin32SurfaceCreateInfoKHR*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkWin32SurfaceCreateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkWin32SurfaceCreateInfoKHR*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -16464,9 +22777,9 @@
stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_3, (VkSurfaceKHR*)pSurface, 1);
VkResult vkCreateWin32SurfaceKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateWin32SurfaceKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -16474,13 +22787,38 @@
return vkCreateWin32SurfaceKHR_VkResult_return;
}
-VkBool32 VkEncoder::vkGetPhysicalDeviceWin32PresentationSupportKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- uint32_t doLock)
-{
+VkBool32 VkEncoder::vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceWin32PresentationSupportKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice:%p, queueFamilyIndex:%d)",
+ physicalDevice, queueFamilyIndex);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -16495,14 +22833,25 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
}
- uint32_t packetSize_vkGetPhysicalDeviceWin32PresentationSupportKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceWin32PresentationSupportKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceWin32PresentationSupportKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceWin32PresentationSupportKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceWin32PresentationSupportKHR = OP_vkGetPhysicalDeviceWin32PresentationSupportKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceWin32PresentationSupportKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceWin32PresentationSupportKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceWin32PresentationSupportKHR =
+ OP_vkGetPhysicalDeviceWin32PresentationSupportKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceWin32PresentationSupportKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceWin32PresentationSupportKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -16511,9 +22860,9 @@
*streamPtrPtr += sizeof(uint32_t);
VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = (VkBool32)0;
stream->read(&vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return, sizeof(VkBool32));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -16525,14 +22874,40 @@
#ifdef VK_KHR_sampler_mirror_clamp_to_edge
#endif
#ifdef VK_KHR_video_queue
-VkResult VkEncoder::vkGetPhysicalDeviceVideoCapabilitiesKHR(
- VkPhysicalDevice physicalDevice,
- const VkVideoProfileKHR* pVideoProfile,
- VkVideoCapabilitiesKHR* pCapabilities,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice,
+ const VkVideoProfileKHR* pVideoProfile,
+ VkVideoCapabilitiesKHR* pCapabilities,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceVideoCapabilitiesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice:%p, pVideoProfile:%p, "
+ "pCapabilities:%p)",
+ physicalDevice, pVideoProfile, pCapabilities);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -16540,47 +22915,63 @@
VkVideoProfileKHR* local_pVideoProfile;
local_physicalDevice = physicalDevice;
local_pVideoProfile = nullptr;
- if (pVideoProfile)
- {
+ if (pVideoProfile) {
local_pVideoProfile = (VkVideoProfileKHR*)pool->alloc(sizeof(const VkVideoProfileKHR));
- deepcopy_VkVideoProfileKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pVideoProfile, (VkVideoProfileKHR*)(local_pVideoProfile));
+ deepcopy_VkVideoProfileKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pVideoProfile,
+ (VkVideoProfileKHR*)(local_pVideoProfile));
}
- if (local_pVideoProfile)
- {
- transform_tohost_VkVideoProfileKHR(sResourceTracker, (VkVideoProfileKHR*)(local_pVideoProfile));
+ if (local_pVideoProfile) {
+ transform_tohost_VkVideoProfileKHR(sResourceTracker,
+ (VkVideoProfileKHR*)(local_pVideoProfile));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkVideoProfileKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoProfileKHR*)(local_pVideoProfile), countPtr);
- count_VkVideoCapabilitiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoCapabilitiesKHR*)(pCapabilities), countPtr);
+ count_VkVideoProfileKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoProfileKHR*)(local_pVideoProfile), countPtr);
+ count_VkVideoCapabilitiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoCapabilitiesKHR*)(pCapabilities), countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceVideoCapabilitiesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceVideoCapabilitiesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceVideoCapabilitiesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceVideoCapabilitiesKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceVideoCapabilitiesKHR = OP_vkGetPhysicalDeviceVideoCapabilitiesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceVideoCapabilitiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceVideoCapabilitiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceVideoCapabilitiesKHR =
+ OP_vkGetPhysicalDeviceVideoCapabilitiesKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceVideoCapabilitiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceVideoCapabilitiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkVideoProfileKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoProfileKHR*)(local_pVideoProfile), streamPtrPtr);
- reservedmarshal_VkVideoCapabilitiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoCapabilitiesKHR*)(pCapabilities), streamPtrPtr);
- unmarshal_VkVideoCapabilitiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoCapabilitiesKHR*)(pCapabilities));
- if (pCapabilities)
- {
- transform_fromhost_VkVideoCapabilitiesKHR(sResourceTracker, (VkVideoCapabilitiesKHR*)(pCapabilities));
+ reservedmarshal_VkVideoProfileKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoProfileKHR*)(local_pVideoProfile), streamPtrPtr);
+ reservedmarshal_VkVideoCapabilitiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoCapabilitiesKHR*)(pCapabilities), streamPtrPtr);
+ unmarshal_VkVideoCapabilitiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoCapabilitiesKHR*)(pCapabilities));
+ if (pCapabilities) {
+ transform_fromhost_VkVideoCapabilitiesKHR(sResourceTracker,
+ (VkVideoCapabilitiesKHR*)(pCapabilities));
}
VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDeviceVideoCapabilitiesKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -16589,14 +22980,39 @@
}
VkResult VkEncoder::vkGetPhysicalDeviceVideoFormatPropertiesKHR(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo,
- uint32_t* pVideoFormatPropertyCount,
- VkVideoFormatPropertiesKHR* pVideoFormatProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo,
+ uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceVideoFormatPropertiesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice:%p, pVideoFormatInfo:%p, "
+ "pVideoFormatPropertyCount:%p, pVideoFormatProperties:%p)",
+ physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -16604,60 +23020,74 @@
VkPhysicalDeviceVideoFormatInfoKHR* local_pVideoFormatInfo;
local_physicalDevice = physicalDevice;
local_pVideoFormatInfo = nullptr;
- if (pVideoFormatInfo)
- {
- local_pVideoFormatInfo = (VkPhysicalDeviceVideoFormatInfoKHR*)pool->alloc(sizeof(const VkPhysicalDeviceVideoFormatInfoKHR));
- deepcopy_VkPhysicalDeviceVideoFormatInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pVideoFormatInfo, (VkPhysicalDeviceVideoFormatInfoKHR*)(local_pVideoFormatInfo));
+ if (pVideoFormatInfo) {
+ local_pVideoFormatInfo = (VkPhysicalDeviceVideoFormatInfoKHR*)pool->alloc(
+ sizeof(const VkPhysicalDeviceVideoFormatInfoKHR));
+ deepcopy_VkPhysicalDeviceVideoFormatInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pVideoFormatInfo,
+ (VkPhysicalDeviceVideoFormatInfoKHR*)(local_pVideoFormatInfo));
}
- if (local_pVideoFormatInfo)
- {
- transform_tohost_VkPhysicalDeviceVideoFormatInfoKHR(sResourceTracker, (VkPhysicalDeviceVideoFormatInfoKHR*)(local_pVideoFormatInfo));
+ if (local_pVideoFormatInfo) {
+ transform_tohost_VkPhysicalDeviceVideoFormatInfoKHR(
+ sResourceTracker, (VkPhysicalDeviceVideoFormatInfoKHR*)(local_pVideoFormatInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceVideoFormatInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceVideoFormatInfoKHR*)(local_pVideoFormatInfo), countPtr);
+ count_VkPhysicalDeviceVideoFormatInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceVideoFormatInfoKHR*)(local_pVideoFormatInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (pVideoFormatPropertyCount)
- {
+ if (pVideoFormatPropertyCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pVideoFormatProperties)
- {
- if (pVideoFormatPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pVideoFormatPropertyCount)); ++i)
- {
- count_VkVideoFormatPropertiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoFormatPropertiesKHR*)(pVideoFormatProperties + i), countPtr);
+ if (pVideoFormatProperties) {
+ if (pVideoFormatPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pVideoFormatPropertyCount)); ++i) {
+ count_VkVideoFormatPropertiesKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoFormatPropertiesKHR*)(pVideoFormatProperties + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPhysicalDeviceVideoFormatPropertiesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceVideoFormatPropertiesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceVideoFormatPropertiesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceVideoFormatPropertiesKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceVideoFormatPropertiesKHR = OP_vkGetPhysicalDeviceVideoFormatPropertiesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceVideoFormatPropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceVideoFormatPropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceVideoFormatPropertiesKHR =
+ OP_vkGetPhysicalDeviceVideoFormatPropertiesKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceVideoFormatPropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceVideoFormatPropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceVideoFormatInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceVideoFormatInfoKHR*)(local_pVideoFormatInfo), streamPtrPtr);
+ reservedmarshal_VkPhysicalDeviceVideoFormatInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceVideoFormatInfoKHR*)(local_pVideoFormatInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)pVideoFormatPropertyCount;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pVideoFormatPropertyCount)
- {
+ if (pVideoFormatPropertyCount) {
memcpy(*streamPtrPtr, (uint32_t*)pVideoFormatPropertyCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -16666,56 +23096,51 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pVideoFormatProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pVideoFormatPropertyCount)); ++i)
- {
- reservedmarshal_VkVideoFormatPropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoFormatPropertiesKHR*)(pVideoFormatProperties + i), streamPtrPtr);
+ if (pVideoFormatProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pVideoFormatPropertyCount)); ++i) {
+ reservedmarshal_VkVideoFormatPropertiesKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoFormatPropertiesKHR*)(pVideoFormatProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pVideoFormatPropertyCount;
check_pVideoFormatPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pVideoFormatPropertyCount)
- {
- if (!(check_pVideoFormatPropertyCount))
- {
- fprintf(stderr, "fatal: pVideoFormatPropertyCount inconsistent between guest and host\n");
+ if (pVideoFormatPropertyCount) {
+ if (!(check_pVideoFormatPropertyCount)) {
+ fprintf(stderr,
+ "fatal: pVideoFormatPropertyCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pVideoFormatPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
VkVideoFormatPropertiesKHR* check_pVideoFormatProperties;
check_pVideoFormatProperties = (VkVideoFormatPropertiesKHR*)(uintptr_t)stream->getBe64();
- if (pVideoFormatProperties)
- {
- if (!(check_pVideoFormatProperties))
- {
+ if (pVideoFormatProperties) {
+ if (!(check_pVideoFormatProperties)) {
fprintf(stderr, "fatal: pVideoFormatProperties inconsistent between guest and host\n");
}
- if (pVideoFormatPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pVideoFormatPropertyCount)); ++i)
- {
- unmarshal_VkVideoFormatPropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoFormatPropertiesKHR*)(pVideoFormatProperties + i));
+ if (pVideoFormatPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pVideoFormatPropertyCount)); ++i) {
+ unmarshal_VkVideoFormatPropertiesKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoFormatPropertiesKHR*)(pVideoFormatProperties + i));
}
}
}
- if (pVideoFormatPropertyCount)
- {
- if (pVideoFormatProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pVideoFormatPropertyCount)); ++i)
- {
- transform_fromhost_VkVideoFormatPropertiesKHR(sResourceTracker, (VkVideoFormatPropertiesKHR*)(pVideoFormatProperties + i));
+ if (pVideoFormatPropertyCount) {
+ if (pVideoFormatProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pVideoFormatPropertyCount)); ++i) {
+ transform_fromhost_VkVideoFormatPropertiesKHR(
+ sResourceTracker, (VkVideoFormatPropertiesKHR*)(pVideoFormatProperties + i));
}
}
}
VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDeviceVideoFormatPropertiesKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -16723,15 +23148,38 @@
return vkGetPhysicalDeviceVideoFormatPropertiesKHR_VkResult_return;
}
-VkResult VkEncoder::vkCreateVideoSessionKHR(
- VkDevice device,
- const VkVideoSessionCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkVideoSessionKHR* pVideoSession,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateVideoSessionKHR(VkDevice device,
+ const VkVideoSessionCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkVideoSessionKHR* pVideoSession, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateVideoSessionKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateVideoSessionKHR(device:%p, pCreateInfo:%p, pAllocator:%p, pVideoSession:%p)",
+ device, pCreateInfo, pAllocator, pVideoSession);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -16740,61 +23188,76 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkVideoSessionCreateInfoKHR*)pool->alloc(sizeof(const VkVideoSessionCreateInfoKHR));
- deepcopy_VkVideoSessionCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkVideoSessionCreateInfoKHR*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkVideoSessionCreateInfoKHR*)pool->alloc(sizeof(const VkVideoSessionCreateInfoKHR));
+ deepcopy_VkVideoSessionCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkVideoSessionCreateInfoKHR*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkVideoSessionCreateInfoKHR(sResourceTracker, (VkVideoSessionCreateInfoKHR*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkVideoSessionCreateInfoKHR(
+ sResourceTracker, (VkVideoSessionCreateInfoKHR*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkVideoSessionCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoSessionCreateInfoKHR*)(local_pCreateInfo), countPtr);
+ count_VkVideoSessionCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoSessionCreateInfoKHR*)(local_pCreateInfo),
+ countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
*countPtr += 8;
}
- uint32_t packetSize_vkCreateVideoSessionKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateVideoSessionKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateVideoSessionKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateVideoSessionKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateVideoSessionKHR = OP_vkCreateVideoSessionKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateVideoSessionKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateVideoSessionKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateVideoSessionKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateVideoSessionKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkVideoSessionCreateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoSessionCreateInfoKHR*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkVideoSessionCreateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoSessionCreateInfoKHR*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
uint64_t cgen_var_2 = (uint64_t)(*pVideoSession);
memcpy((*streamPtrPtr), &cgen_var_2, 8);
@@ -16803,9 +23266,9 @@
(*pVideoSession) = (VkVideoSessionKHR)stream->getBe64();
VkResult vkCreateVideoSessionKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateVideoSessionKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -16813,14 +23276,34 @@
return vkCreateVideoSessionKHR_VkResult_return;
}
-void VkEncoder::vkDestroyVideoSessionKHR(
- VkDevice device,
- VkVideoSessionKHR videoSession,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyVideoSessionKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyVideoSessionKHR(device:%p, pAllocator:%p)", device, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -16830,15 +23313,15 @@
local_device = device;
local_videoSession = videoSession;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -16848,19 +23331,28 @@
*countPtr += 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyVideoSessionKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyVideoSessionKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyVideoSessionKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyVideoSessionKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyVideoSessionKHR = OP_vkDestroyVideoSessionKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyVideoSessionKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyVideoSessionKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyVideoSessionKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyVideoSessionKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -16874,14 +23366,15 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -16889,14 +23382,38 @@
}
VkResult VkEncoder::vkGetVideoSessionMemoryRequirementsKHR(
- VkDevice device,
- VkVideoSessionKHR videoSession,
- uint32_t* pVideoSessionMemoryRequirementsCount,
- VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements,
- uint32_t doLock)
-{
+ VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pVideoSessionMemoryRequirementsCount,
+ VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetVideoSessionMemoryRequirementsKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetVideoSessionMemoryRequirementsKHR(device:%p, "
+ "pVideoSessionMemoryRequirementsCount:%p, pVideoSessionMemoryRequirements:%p)",
+ device, pVideoSessionMemoryRequirementsCount, pVideoSessionMemoryRequirements);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -16912,31 +23429,41 @@
*countPtr += 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pVideoSessionMemoryRequirementsCount)
- {
+ if (pVideoSessionMemoryRequirementsCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pVideoSessionMemoryRequirements)
- {
- if (pVideoSessionMemoryRequirementsCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pVideoSessionMemoryRequirementsCount)); ++i)
- {
- count_VkVideoGetMemoryPropertiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoGetMemoryPropertiesKHR*)(pVideoSessionMemoryRequirements + i), countPtr);
+ if (pVideoSessionMemoryRequirements) {
+ if (pVideoSessionMemoryRequirementsCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pVideoSessionMemoryRequirementsCount)); ++i) {
+ count_VkVideoGetMemoryPropertiesKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoGetMemoryPropertiesKHR*)(pVideoSessionMemoryRequirements + i),
+ countPtr);
}
}
}
}
- uint32_t packetSize_vkGetVideoSessionMemoryRequirementsKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetVideoSessionMemoryRequirementsKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetVideoSessionMemoryRequirementsKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetVideoSessionMemoryRequirementsKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetVideoSessionMemoryRequirementsKHR = OP_vkGetVideoSessionMemoryRequirementsKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetVideoSessionMemoryRequirementsKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetVideoSessionMemoryRequirementsKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetVideoSessionMemoryRequirementsKHR =
+ OP_vkGetVideoSessionMemoryRequirementsKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetVideoSessionMemoryRequirementsKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetVideoSessionMemoryRequirementsKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -16950,8 +23477,7 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pVideoSessionMemoryRequirementsCount)
- {
+ if (pVideoSessionMemoryRequirementsCount) {
memcpy(*streamPtrPtr, (uint32_t*)pVideoSessionMemoryRequirementsCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -16960,56 +23486,56 @@
memcpy((*streamPtrPtr), &cgen_var_3, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pVideoSessionMemoryRequirements)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pVideoSessionMemoryRequirementsCount)); ++i)
- {
- reservedmarshal_VkVideoGetMemoryPropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoGetMemoryPropertiesKHR*)(pVideoSessionMemoryRequirements + i), streamPtrPtr);
+ if (pVideoSessionMemoryRequirements) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pVideoSessionMemoryRequirementsCount)); ++i) {
+ reservedmarshal_VkVideoGetMemoryPropertiesKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoGetMemoryPropertiesKHR*)(pVideoSessionMemoryRequirements + i),
+ streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pVideoSessionMemoryRequirementsCount;
check_pVideoSessionMemoryRequirementsCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pVideoSessionMemoryRequirementsCount)
- {
- if (!(check_pVideoSessionMemoryRequirementsCount))
- {
- fprintf(stderr, "fatal: pVideoSessionMemoryRequirementsCount inconsistent between guest and host\n");
+ if (pVideoSessionMemoryRequirementsCount) {
+ if (!(check_pVideoSessionMemoryRequirementsCount)) {
+ fprintf(stderr,
+ "fatal: pVideoSessionMemoryRequirementsCount inconsistent between guest and "
+ "host\n");
}
stream->read((uint32_t*)pVideoSessionMemoryRequirementsCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
VkVideoGetMemoryPropertiesKHR* check_pVideoSessionMemoryRequirements;
- check_pVideoSessionMemoryRequirements = (VkVideoGetMemoryPropertiesKHR*)(uintptr_t)stream->getBe64();
- if (pVideoSessionMemoryRequirements)
- {
- if (!(check_pVideoSessionMemoryRequirements))
- {
- fprintf(stderr, "fatal: pVideoSessionMemoryRequirements inconsistent between guest and host\n");
+ check_pVideoSessionMemoryRequirements =
+ (VkVideoGetMemoryPropertiesKHR*)(uintptr_t)stream->getBe64();
+ if (pVideoSessionMemoryRequirements) {
+ if (!(check_pVideoSessionMemoryRequirements)) {
+ fprintf(stderr,
+ "fatal: pVideoSessionMemoryRequirements inconsistent between guest and host\n");
}
- if (pVideoSessionMemoryRequirementsCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pVideoSessionMemoryRequirementsCount)); ++i)
- {
- unmarshal_VkVideoGetMemoryPropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoGetMemoryPropertiesKHR*)(pVideoSessionMemoryRequirements + i));
+ if (pVideoSessionMemoryRequirementsCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pVideoSessionMemoryRequirementsCount)); ++i) {
+ unmarshal_VkVideoGetMemoryPropertiesKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoGetMemoryPropertiesKHR*)(pVideoSessionMemoryRequirements + i));
}
}
}
- if (pVideoSessionMemoryRequirementsCount)
- {
- if (pVideoSessionMemoryRequirements)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pVideoSessionMemoryRequirementsCount)); ++i)
- {
- transform_fromhost_VkVideoGetMemoryPropertiesKHR(sResourceTracker, (VkVideoGetMemoryPropertiesKHR*)(pVideoSessionMemoryRequirements + i));
+ if (pVideoSessionMemoryRequirementsCount) {
+ if (pVideoSessionMemoryRequirements) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pVideoSessionMemoryRequirementsCount)); ++i) {
+ transform_fromhost_VkVideoGetMemoryPropertiesKHR(
+ sResourceTracker,
+ (VkVideoGetMemoryPropertiesKHR*)(pVideoSessionMemoryRequirements + i));
}
}
}
VkResult vkGetVideoSessionMemoryRequirementsKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetVideoSessionMemoryRequirementsKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -17018,14 +23544,37 @@
}
VkResult VkEncoder::vkBindVideoSessionMemoryKHR(
- VkDevice device,
- VkVideoSessionKHR videoSession,
- uint32_t videoSessionBindMemoryCount,
- const VkVideoBindMemoryKHR* pVideoSessionBindMemories,
- uint32_t doLock)
-{
+ VkDevice device, VkVideoSessionKHR videoSession, uint32_t videoSessionBindMemoryCount,
+ const VkVideoBindMemoryKHR* pVideoSessionBindMemories, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkBindVideoSessionMemoryKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkBindVideoSessionMemoryKHR(device:%p, videoSessionBindMemoryCount:%d, "
+ "pVideoSessionBindMemories:%p)",
+ device, videoSessionBindMemoryCount, pVideoSessionBindMemories);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -17037,19 +23586,19 @@
local_videoSession = videoSession;
local_videoSessionBindMemoryCount = videoSessionBindMemoryCount;
local_pVideoSessionBindMemories = nullptr;
- if (pVideoSessionBindMemories)
- {
- local_pVideoSessionBindMemories = (VkVideoBindMemoryKHR*)pool->alloc(((videoSessionBindMemoryCount)) * sizeof(const VkVideoBindMemoryKHR));
- for (uint32_t i = 0; i < (uint32_t)((videoSessionBindMemoryCount)); ++i)
- {
- deepcopy_VkVideoBindMemoryKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pVideoSessionBindMemories + i, (VkVideoBindMemoryKHR*)(local_pVideoSessionBindMemories + i));
+ if (pVideoSessionBindMemories) {
+ local_pVideoSessionBindMemories = (VkVideoBindMemoryKHR*)pool->alloc(
+ ((videoSessionBindMemoryCount)) * sizeof(const VkVideoBindMemoryKHR));
+ for (uint32_t i = 0; i < (uint32_t)((videoSessionBindMemoryCount)); ++i) {
+ deepcopy_VkVideoBindMemoryKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pVideoSessionBindMemories + i,
+ (VkVideoBindMemoryKHR*)(local_pVideoSessionBindMemories + i));
}
}
- if (local_pVideoSessionBindMemories)
- {
- for (uint32_t i = 0; i < (uint32_t)((videoSessionBindMemoryCount)); ++i)
- {
- transform_tohost_VkVideoBindMemoryKHR(sResourceTracker, (VkVideoBindMemoryKHR*)(local_pVideoSessionBindMemories + i));
+ if (local_pVideoSessionBindMemories) {
+ for (uint32_t i = 0; i < (uint32_t)((videoSessionBindMemoryCount)); ++i) {
+ transform_tohost_VkVideoBindMemoryKHR(
+ sResourceTracker, (VkVideoBindMemoryKHR*)(local_pVideoSessionBindMemories + i));
}
}
size_t count = 0;
@@ -17059,19 +23608,29 @@
*countPtr += 1 * 8;
*countPtr += 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((videoSessionBindMemoryCount)); ++i)
- {
- count_VkVideoBindMemoryKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoBindMemoryKHR*)(local_pVideoSessionBindMemories + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((videoSessionBindMemoryCount)); ++i) {
+ count_VkVideoBindMemoryKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoBindMemoryKHR*)(local_pVideoSessionBindMemories + i),
+ countPtr);
}
}
- uint32_t packetSize_vkBindVideoSessionMemoryKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkBindVideoSessionMemoryKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkBindVideoSessionMemoryKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkBindVideoSessionMemoryKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkBindVideoSessionMemoryKHR = OP_vkBindVideoSessionMemoryKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkBindVideoSessionMemoryKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkBindVideoSessionMemoryKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkBindVideoSessionMemoryKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkBindVideoSessionMemoryKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -17082,15 +23641,16 @@
*streamPtrPtr += 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_videoSessionBindMemoryCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((videoSessionBindMemoryCount)); ++i)
- {
- reservedmarshal_VkVideoBindMemoryKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoBindMemoryKHR*)(local_pVideoSessionBindMemories + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((videoSessionBindMemoryCount)); ++i) {
+ reservedmarshal_VkVideoBindMemoryKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoBindMemoryKHR*)(local_pVideoSessionBindMemories + i), streamPtrPtr);
}
VkResult vkBindVideoSessionMemoryKHR_VkResult_return = (VkResult)0;
stream->read(&vkBindVideoSessionMemoryKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -17099,14 +23659,38 @@
}
VkResult VkEncoder::vkCreateVideoSessionParametersKHR(
- VkDevice device,
- const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkVideoSessionParametersKHR* pVideoSessionParameters,
- uint32_t doLock)
-{
+ VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateVideoSessionParametersKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateVideoSessionParametersKHR(device:%p, pCreateInfo:%p, pAllocator:%p, "
+ "pVideoSessionParameters:%p)",
+ device, pCreateInfo, pAllocator, pVideoSessionParameters);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -17115,61 +23699,78 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkVideoSessionParametersCreateInfoKHR*)pool->alloc(sizeof(const VkVideoSessionParametersCreateInfoKHR));
- deepcopy_VkVideoSessionParametersCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkVideoSessionParametersCreateInfoKHR*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkVideoSessionParametersCreateInfoKHR*)pool->alloc(
+ sizeof(const VkVideoSessionParametersCreateInfoKHR));
+ deepcopy_VkVideoSessionParametersCreateInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkVideoSessionParametersCreateInfoKHR*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkVideoSessionParametersCreateInfoKHR(sResourceTracker, (VkVideoSessionParametersCreateInfoKHR*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkVideoSessionParametersCreateInfoKHR(
+ sResourceTracker, (VkVideoSessionParametersCreateInfoKHR*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkVideoSessionParametersCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoSessionParametersCreateInfoKHR*)(local_pCreateInfo), countPtr);
+ count_VkVideoSessionParametersCreateInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoSessionParametersCreateInfoKHR*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
*countPtr += 8;
}
- uint32_t packetSize_vkCreateVideoSessionParametersKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateVideoSessionParametersKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCreateVideoSessionParametersKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateVideoSessionParametersKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateVideoSessionParametersKHR = OP_vkCreateVideoSessionParametersKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateVideoSessionParametersKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateVideoSessionParametersKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateVideoSessionParametersKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateVideoSessionParametersKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkVideoSessionParametersCreateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoSessionParametersCreateInfoKHR*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkVideoSessionParametersCreateInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoSessionParametersCreateInfoKHR*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
uint64_t cgen_var_2 = (uint64_t)(*pVideoSessionParameters);
memcpy((*streamPtrPtr), &cgen_var_2, 8);
@@ -17178,9 +23779,9 @@
(*pVideoSessionParameters) = (VkVideoSessionParametersKHR)stream->getBe64();
VkResult vkCreateVideoSessionParametersKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateVideoSessionParametersKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -17189,13 +23790,35 @@
}
VkResult VkEncoder::vkUpdateVideoSessionParametersKHR(
- VkDevice device,
- VkVideoSessionParametersKHR videoSessionParameters,
- const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo,
- uint32_t doLock)
-{
+ VkDevice device, VkVideoSessionParametersKHR videoSessionParameters,
+ const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkUpdateVideoSessionParametersKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkUpdateVideoSessionParametersKHR(device:%p, pUpdateInfo:%p)", device,
+ pUpdateInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -17205,14 +23828,16 @@
local_device = device;
local_videoSessionParameters = videoSessionParameters;
local_pUpdateInfo = nullptr;
- if (pUpdateInfo)
- {
- local_pUpdateInfo = (VkVideoSessionParametersUpdateInfoKHR*)pool->alloc(sizeof(const VkVideoSessionParametersUpdateInfoKHR));
- deepcopy_VkVideoSessionParametersUpdateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pUpdateInfo, (VkVideoSessionParametersUpdateInfoKHR*)(local_pUpdateInfo));
+ if (pUpdateInfo) {
+ local_pUpdateInfo = (VkVideoSessionParametersUpdateInfoKHR*)pool->alloc(
+ sizeof(const VkVideoSessionParametersUpdateInfoKHR));
+ deepcopy_VkVideoSessionParametersUpdateInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pUpdateInfo,
+ (VkVideoSessionParametersUpdateInfoKHR*)(local_pUpdateInfo));
}
- if (local_pUpdateInfo)
- {
- transform_tohost_VkVideoSessionParametersUpdateInfoKHR(sResourceTracker, (VkVideoSessionParametersUpdateInfoKHR*)(local_pUpdateInfo));
+ if (local_pUpdateInfo) {
+ transform_tohost_VkVideoSessionParametersUpdateInfoKHR(
+ sResourceTracker, (VkVideoSessionParametersUpdateInfoKHR*)(local_pUpdateInfo));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -17220,16 +23845,28 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += 8;
- count_VkVideoSessionParametersUpdateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoSessionParametersUpdateInfoKHR*)(local_pUpdateInfo), countPtr);
+ count_VkVideoSessionParametersUpdateInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoSessionParametersUpdateInfoKHR*)(local_pUpdateInfo), countPtr);
}
- uint32_t packetSize_vkUpdateVideoSessionParametersKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkUpdateVideoSessionParametersKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkUpdateVideoSessionParametersKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkUpdateVideoSessionParametersKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkUpdateVideoSessionParametersKHR = OP_vkUpdateVideoSessionParametersKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkUpdateVideoSessionParametersKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkUpdateVideoSessionParametersKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkUpdateVideoSessionParametersKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkUpdateVideoSessionParametersKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -17238,12 +23875,14 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- reservedmarshal_VkVideoSessionParametersUpdateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoSessionParametersUpdateInfoKHR*)(local_pUpdateInfo), streamPtrPtr);
+ reservedmarshal_VkVideoSessionParametersUpdateInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoSessionParametersUpdateInfoKHR*)(local_pUpdateInfo), streamPtrPtr);
VkResult vkUpdateVideoSessionParametersKHR_VkResult_return = (VkResult)0;
stream->read(&vkUpdateVideoSessionParametersKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -17252,13 +23891,35 @@
}
void VkEncoder::vkDestroyVideoSessionParametersKHR(
- VkDevice device,
- VkVideoSessionParametersKHR videoSessionParameters,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+ VkDevice device, VkVideoSessionParametersKHR videoSessionParameters,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyVideoSessionParametersKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyVideoSessionParametersKHR(device:%p, pAllocator:%p)", device,
+ pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -17268,15 +23929,15 @@
local_device = device;
local_videoSessionParameters = videoSessionParameters;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -17286,19 +23947,29 @@
*countPtr += 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyVideoSessionParametersKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyVideoSessionParametersKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkDestroyVideoSessionParametersKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyVideoSessionParametersKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyVideoSessionParametersKHR = OP_vkDestroyVideoSessionParametersKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyVideoSessionParametersKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyVideoSessionParametersKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyVideoSessionParametersKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyVideoSessionParametersKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -17312,27 +23983,51 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdBeginVideoCodingKHR(
- VkCommandBuffer commandBuffer,
- const VkVideoBeginCodingInfoKHR* pBeginInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer,
+ const VkVideoBeginCodingInfoKHR* pBeginInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBeginVideoCodingKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdBeginVideoCodingKHR(commandBuffer:%p, pBeginInfo:%p)", commandBuffer,
+ pBeginInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -17340,53 +24035,82 @@
VkVideoBeginCodingInfoKHR* local_pBeginInfo;
local_commandBuffer = commandBuffer;
local_pBeginInfo = nullptr;
- if (pBeginInfo)
- {
- local_pBeginInfo = (VkVideoBeginCodingInfoKHR*)pool->alloc(sizeof(const VkVideoBeginCodingInfoKHR));
- deepcopy_VkVideoBeginCodingInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBeginInfo, (VkVideoBeginCodingInfoKHR*)(local_pBeginInfo));
+ if (pBeginInfo) {
+ local_pBeginInfo =
+ (VkVideoBeginCodingInfoKHR*)pool->alloc(sizeof(const VkVideoBeginCodingInfoKHR));
+ deepcopy_VkVideoBeginCodingInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBeginInfo,
+ (VkVideoBeginCodingInfoKHR*)(local_pBeginInfo));
}
- if (local_pBeginInfo)
- {
- transform_tohost_VkVideoBeginCodingInfoKHR(sResourceTracker, (VkVideoBeginCodingInfoKHR*)(local_pBeginInfo));
+ if (local_pBeginInfo) {
+ transform_tohost_VkVideoBeginCodingInfoKHR(sResourceTracker,
+ (VkVideoBeginCodingInfoKHR*)(local_pBeginInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkVideoBeginCodingInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoBeginCodingInfoKHR*)(local_pBeginInfo), countPtr);
+ count_VkVideoBeginCodingInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoBeginCodingInfoKHR*)(local_pBeginInfo), countPtr);
}
uint32_t packetSize_vkCmdBeginVideoCodingKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBeginVideoCodingKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginVideoCodingKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBeginVideoCodingKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBeginVideoCodingKHR = OP_vkCmdBeginVideoCodingKHR;
- memcpy(streamPtr, &opcode_vkCmdBeginVideoCodingKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBeginVideoCodingKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBeginVideoCodingKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBeginVideoCodingKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkVideoBeginCodingInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoBeginCodingInfoKHR*)(local_pBeginInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkVideoBeginCodingInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoBeginCodingInfoKHR*)(local_pBeginInfo),
+ streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdEndVideoCodingKHR(
- VkCommandBuffer commandBuffer,
- const VkVideoEndCodingInfoKHR* pEndCodingInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer,
+ const VkVideoEndCodingInfoKHR* pEndCodingInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdEndVideoCodingKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdEndVideoCodingKHR(commandBuffer:%p, pEndCodingInfo:%p)", commandBuffer,
+ pEndCodingInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -17394,53 +24118,82 @@
VkVideoEndCodingInfoKHR* local_pEndCodingInfo;
local_commandBuffer = commandBuffer;
local_pEndCodingInfo = nullptr;
- if (pEndCodingInfo)
- {
- local_pEndCodingInfo = (VkVideoEndCodingInfoKHR*)pool->alloc(sizeof(const VkVideoEndCodingInfoKHR));
- deepcopy_VkVideoEndCodingInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pEndCodingInfo, (VkVideoEndCodingInfoKHR*)(local_pEndCodingInfo));
+ if (pEndCodingInfo) {
+ local_pEndCodingInfo =
+ (VkVideoEndCodingInfoKHR*)pool->alloc(sizeof(const VkVideoEndCodingInfoKHR));
+ deepcopy_VkVideoEndCodingInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pEndCodingInfo,
+ (VkVideoEndCodingInfoKHR*)(local_pEndCodingInfo));
}
- if (local_pEndCodingInfo)
- {
- transform_tohost_VkVideoEndCodingInfoKHR(sResourceTracker, (VkVideoEndCodingInfoKHR*)(local_pEndCodingInfo));
+ if (local_pEndCodingInfo) {
+ transform_tohost_VkVideoEndCodingInfoKHR(sResourceTracker,
+ (VkVideoEndCodingInfoKHR*)(local_pEndCodingInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkVideoEndCodingInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoEndCodingInfoKHR*)(local_pEndCodingInfo), countPtr);
+ count_VkVideoEndCodingInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoEndCodingInfoKHR*)(local_pEndCodingInfo), countPtr);
}
uint32_t packetSize_vkCmdEndVideoCodingKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdEndVideoCodingKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEndVideoCodingKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdEndVideoCodingKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdEndVideoCodingKHR = OP_vkCmdEndVideoCodingKHR;
- memcpy(streamPtr, &opcode_vkCmdEndVideoCodingKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdEndVideoCodingKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdEndVideoCodingKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdEndVideoCodingKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkVideoEndCodingInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoEndCodingInfoKHR*)(local_pEndCodingInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkVideoEndCodingInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoEndCodingInfoKHR*)(local_pEndCodingInfo),
+ streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdControlVideoCodingKHR(
- VkCommandBuffer commandBuffer,
- const VkVideoCodingControlInfoKHR* pCodingControlInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer,
+ const VkVideoCodingControlInfoKHR* pCodingControlInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdControlVideoCodingKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdControlVideoCodingKHR(commandBuffer:%p, pCodingControlInfo:%p)",
+ commandBuffer, pCodingControlInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -17448,40 +24201,48 @@
VkVideoCodingControlInfoKHR* local_pCodingControlInfo;
local_commandBuffer = commandBuffer;
local_pCodingControlInfo = nullptr;
- if (pCodingControlInfo)
- {
- local_pCodingControlInfo = (VkVideoCodingControlInfoKHR*)pool->alloc(sizeof(const VkVideoCodingControlInfoKHR));
- deepcopy_VkVideoCodingControlInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCodingControlInfo, (VkVideoCodingControlInfoKHR*)(local_pCodingControlInfo));
+ if (pCodingControlInfo) {
+ local_pCodingControlInfo =
+ (VkVideoCodingControlInfoKHR*)pool->alloc(sizeof(const VkVideoCodingControlInfoKHR));
+ deepcopy_VkVideoCodingControlInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCodingControlInfo,
+ (VkVideoCodingControlInfoKHR*)(local_pCodingControlInfo));
}
- if (local_pCodingControlInfo)
- {
- transform_tohost_VkVideoCodingControlInfoKHR(sResourceTracker, (VkVideoCodingControlInfoKHR*)(local_pCodingControlInfo));
+ if (local_pCodingControlInfo) {
+ transform_tohost_VkVideoCodingControlInfoKHR(
+ sResourceTracker, (VkVideoCodingControlInfoKHR*)(local_pCodingControlInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkVideoCodingControlInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoCodingControlInfoKHR*)(local_pCodingControlInfo), countPtr);
+ count_VkVideoCodingControlInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoCodingControlInfoKHR*)(local_pCodingControlInfo),
+ countPtr);
}
uint32_t packetSize_vkCmdControlVideoCodingKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdControlVideoCodingKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdControlVideoCodingKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdControlVideoCodingKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdControlVideoCodingKHR = OP_vkCmdControlVideoCodingKHR;
- memcpy(streamPtr, &opcode_vkCmdControlVideoCodingKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdControlVideoCodingKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdControlVideoCodingKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdControlVideoCodingKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkVideoCodingControlInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoCodingControlInfoKHR*)(local_pCodingControlInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkVideoCodingControlInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoCodingControlInfoKHR*)(local_pCodingControlInfo), streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -17490,13 +24251,35 @@
#endif
#ifdef VK_KHR_video_decode_queue
-void VkEncoder::vkCmdDecodeVideoKHR(
- VkCommandBuffer commandBuffer,
- const VkVideoDecodeInfoKHR* pFrameInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer,
+ const VkVideoDecodeInfoKHR* pFrameInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDecodeVideoKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdDecodeVideoKHR(commandBuffer:%p, pFrameInfo:%p)", commandBuffer,
+ pFrameInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -17504,40 +24287,44 @@
VkVideoDecodeInfoKHR* local_pFrameInfo;
local_commandBuffer = commandBuffer;
local_pFrameInfo = nullptr;
- if (pFrameInfo)
- {
+ if (pFrameInfo) {
local_pFrameInfo = (VkVideoDecodeInfoKHR*)pool->alloc(sizeof(const VkVideoDecodeInfoKHR));
- deepcopy_VkVideoDecodeInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pFrameInfo, (VkVideoDecodeInfoKHR*)(local_pFrameInfo));
+ deepcopy_VkVideoDecodeInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pFrameInfo,
+ (VkVideoDecodeInfoKHR*)(local_pFrameInfo));
}
- if (local_pFrameInfo)
- {
- transform_tohost_VkVideoDecodeInfoKHR(sResourceTracker, (VkVideoDecodeInfoKHR*)(local_pFrameInfo));
+ if (local_pFrameInfo) {
+ transform_tohost_VkVideoDecodeInfoKHR(sResourceTracker,
+ (VkVideoDecodeInfoKHR*)(local_pFrameInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkVideoDecodeInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoDecodeInfoKHR*)(local_pFrameInfo), countPtr);
+ count_VkVideoDecodeInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoDecodeInfoKHR*)(local_pFrameInfo), countPtr);
}
uint32_t packetSize_vkCmdDecodeVideoKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDecodeVideoKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDecodeVideoKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDecodeVideoKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDecodeVideoKHR = OP_vkCmdDecodeVideoKHR;
- memcpy(streamPtr, &opcode_vkCmdDecodeVideoKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDecodeVideoKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDecodeVideoKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDecodeVideoKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkVideoDecodeInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoDecodeInfoKHR*)(local_pFrameInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkVideoDecodeInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoDecodeInfoKHR*)(local_pFrameInfo), streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -17546,13 +24333,35 @@
#endif
#ifdef VK_KHR_dynamic_rendering
-void VkEncoder::vkCmdBeginRenderingKHR(
- VkCommandBuffer commandBuffer,
- const VkRenderingInfoKHR* pRenderingInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer,
+ const VkRenderingInfoKHR* pRenderingInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBeginRenderingKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdBeginRenderingKHR(commandBuffer:%p, pRenderingInfo:%p)", commandBuffer,
+ pRenderingInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -17560,52 +24369,77 @@
VkRenderingInfoKHR* local_pRenderingInfo;
local_commandBuffer = commandBuffer;
local_pRenderingInfo = nullptr;
- if (pRenderingInfo)
- {
+ if (pRenderingInfo) {
local_pRenderingInfo = (VkRenderingInfoKHR*)pool->alloc(sizeof(const VkRenderingInfoKHR));
- deepcopy_VkRenderingInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRenderingInfo, (VkRenderingInfoKHR*)(local_pRenderingInfo));
+ deepcopy_VkRenderingInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRenderingInfo,
+ (VkRenderingInfoKHR*)(local_pRenderingInfo));
}
- if (local_pRenderingInfo)
- {
- transform_tohost_VkRenderingInfoKHR(sResourceTracker, (VkRenderingInfoKHR*)(local_pRenderingInfo));
+ if (local_pRenderingInfo) {
+ transform_tohost_VkRenderingInfoKHR(sResourceTracker,
+ (VkRenderingInfoKHR*)(local_pRenderingInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkRenderingInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRenderingInfoKHR*)(local_pRenderingInfo), countPtr);
+ count_VkRenderingInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderingInfoKHR*)(local_pRenderingInfo), countPtr);
}
uint32_t packetSize_vkCmdBeginRenderingKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBeginRenderingKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginRenderingKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBeginRenderingKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBeginRenderingKHR = OP_vkCmdBeginRenderingKHR;
- memcpy(streamPtr, &opcode_vkCmdBeginRenderingKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBeginRenderingKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBeginRenderingKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBeginRenderingKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkRenderingInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRenderingInfoKHR*)(local_pRenderingInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkRenderingInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderingInfoKHR*)(local_pRenderingInfo), streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdEndRenderingKHR(
- VkCommandBuffer commandBuffer,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdEndRenderingKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdEndRenderingKHR(commandBuffer:%p)", commandBuffer);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -17618,22 +24452,24 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkCmdEndRenderingKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdEndRenderingKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEndRenderingKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdEndRenderingKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdEndRenderingKHR = OP_vkCmdEndRenderingKHR;
- memcpy(streamPtr, &opcode_vkCmdEndRenderingKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdEndRenderingKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdEndRenderingKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdEndRenderingKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -17644,13 +24480,36 @@
#ifdef VK_KHR_multiview
#endif
#ifdef VK_KHR_get_physical_device_properties2
-void VkEncoder::vkGetPhysicalDeviceFeatures2KHR(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures2* pFeatures,
- uint32_t doLock)
-{
+void VkEncoder::vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetPhysicalDeviceFeatures2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetPhysicalDeviceFeatures2KHR(physicalDevice:%p, pFeatures:%p)",
+ physicalDevice, pFeatures);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -17661,43 +24520,79 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceFeatures2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFeatures2*)(pFeatures), countPtr);
+ count_VkPhysicalDeviceFeatures2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceFeatures2*)(pFeatures), countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceFeatures2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceFeatures2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceFeatures2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceFeatures2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceFeatures2KHR = OP_vkGetPhysicalDeviceFeatures2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceFeatures2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceFeatures2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceFeatures2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceFeatures2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceFeatures2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFeatures2*)(pFeatures), streamPtrPtr);
- unmarshal_VkPhysicalDeviceFeatures2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFeatures2*)(pFeatures));
- if (pFeatures)
- {
- transform_fromhost_VkPhysicalDeviceFeatures2(sResourceTracker, (VkPhysicalDeviceFeatures2*)(pFeatures));
+ reservedmarshal_VkPhysicalDeviceFeatures2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFeatures2*)(pFeatures), streamPtrPtr);
+ unmarshal_VkPhysicalDeviceFeatures2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceFeatures2*)(pFeatures));
+ if (pFeatures) {
+ transform_fromhost_VkPhysicalDeviceFeatures2(sResourceTracker,
+ (VkPhysicalDeviceFeatures2*)(pFeatures));
}
sResourceTracker->on_vkGetPhysicalDeviceFeatures2KHR(this, physicalDevice, pFeatures);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkGetPhysicalDeviceProperties2KHR(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties2* pProperties,
- uint32_t doLock)
-{
+void VkEncoder::vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetPhysicalDeviceProperties2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetPhysicalDeviceProperties2KHR(physicalDevice:%p, pProperties:%p)",
+ physicalDevice, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -17708,44 +24603,84 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceProperties2*)(pProperties), countPtr);
+ count_VkPhysicalDeviceProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceProperties2*)(pProperties), countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceProperties2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceProperties2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceProperties2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceProperties2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceProperties2KHR = OP_vkGetPhysicalDeviceProperties2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceProperties2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceProperties2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceProperties2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceProperties2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceProperties2*)(pProperties), streamPtrPtr);
- unmarshal_VkPhysicalDeviceProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceProperties2*)(pProperties));
- if (pProperties)
- {
- transform_fromhost_VkPhysicalDeviceProperties2(sResourceTracker, (VkPhysicalDeviceProperties2*)(pProperties));
+ reservedmarshal_VkPhysicalDeviceProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceProperties2*)(pProperties),
+ streamPtrPtr);
+ unmarshal_VkPhysicalDeviceProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceProperties2*)(pProperties));
+ if (pProperties) {
+ transform_fromhost_VkPhysicalDeviceProperties2(sResourceTracker,
+ (VkPhysicalDeviceProperties2*)(pProperties));
}
sResourceTracker->on_vkGetPhysicalDeviceProperties2KHR(this, physicalDevice, pProperties);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkGetPhysicalDeviceFormatProperties2KHR(
- VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties2* pFormatProperties,
- uint32_t doLock)
-{
+void VkEncoder::vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2* pFormatProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceFormatProperties2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice:%p, format:%d, "
+ "pFormatProperties:%p)",
+ physicalDevice, format, pFormatProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -17759,31 +24694,45 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(VkFormat);
- count_VkFormatProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFormatProperties2*)(pFormatProperties), countPtr);
+ count_VkFormatProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkFormatProperties2*)(pFormatProperties), countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceFormatProperties2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceFormatProperties2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceFormatProperties2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceFormatProperties2KHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceFormatProperties2KHR = OP_vkGetPhysicalDeviceFormatProperties2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceFormatProperties2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceFormatProperties2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceFormatProperties2KHR =
+ OP_vkGetPhysicalDeviceFormatProperties2KHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceFormatProperties2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceFormatProperties2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkFormat*)&local_format, sizeof(VkFormat));
*streamPtrPtr += sizeof(VkFormat);
- reservedmarshal_VkFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFormatProperties2*)(pFormatProperties), streamPtrPtr);
- unmarshal_VkFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFormatProperties2*)(pFormatProperties));
- if (pFormatProperties)
- {
- transform_fromhost_VkFormatProperties2(sResourceTracker, (VkFormatProperties2*)(pFormatProperties));
+ reservedmarshal_VkFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkFormatProperties2*)(pFormatProperties), streamPtrPtr);
+ unmarshal_VkFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkFormatProperties2*)(pFormatProperties));
+ if (pFormatProperties) {
+ transform_fromhost_VkFormatProperties2(sResourceTracker,
+ (VkFormatProperties2*)(pFormatProperties));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -17791,13 +24740,38 @@
}
VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties2KHR(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
- VkImageFormatProperties2* pImageFormatProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+ VkImageFormatProperties2* pImageFormatProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceImageFormatProperties2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice:%p, pImageFormatInfo:%p, "
+ "pImageFormatProperties:%p)",
+ physicalDevice, pImageFormatInfo, pImageFormatProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -17805,47 +24779,69 @@
VkPhysicalDeviceImageFormatInfo2* local_pImageFormatInfo;
local_physicalDevice = physicalDevice;
local_pImageFormatInfo = nullptr;
- if (pImageFormatInfo)
- {
- local_pImageFormatInfo = (VkPhysicalDeviceImageFormatInfo2*)pool->alloc(sizeof(const VkPhysicalDeviceImageFormatInfo2));
- deepcopy_VkPhysicalDeviceImageFormatInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImageFormatInfo, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
+ if (pImageFormatInfo) {
+ local_pImageFormatInfo = (VkPhysicalDeviceImageFormatInfo2*)pool->alloc(
+ sizeof(const VkPhysicalDeviceImageFormatInfo2));
+ deepcopy_VkPhysicalDeviceImageFormatInfo2(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImageFormatInfo,
+ (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
}
- if (local_pImageFormatInfo)
- {
- transform_tohost_VkPhysicalDeviceImageFormatInfo2(sResourceTracker, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
+ if (local_pImageFormatInfo) {
+ transform_tohost_VkPhysicalDeviceImageFormatInfo2(
+ sResourceTracker, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceImageFormatInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo), countPtr);
- count_VkImageFormatProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageFormatProperties2*)(pImageFormatProperties), countPtr);
+ count_VkPhysicalDeviceImageFormatInfo2(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo), countPtr);
+ count_VkImageFormatProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageFormatProperties2*)(pImageFormatProperties),
+ countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceImageFormatProperties2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceImageFormatProperties2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceImageFormatProperties2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceImageFormatProperties2KHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceImageFormatProperties2KHR = OP_vkGetPhysicalDeviceImageFormatProperties2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceImageFormatProperties2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceImageFormatProperties2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceImageFormatProperties2KHR =
+ OP_vkGetPhysicalDeviceImageFormatProperties2KHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceImageFormatProperties2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceImageFormatProperties2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceImageFormatInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo), streamPtrPtr);
- reservedmarshal_VkImageFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageFormatProperties2*)(pImageFormatProperties), streamPtrPtr);
- unmarshal_VkImageFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageFormatProperties2*)(pImageFormatProperties));
- if (pImageFormatProperties)
- {
- transform_fromhost_VkImageFormatProperties2(sResourceTracker, (VkImageFormatProperties2*)(pImageFormatProperties));
+ reservedmarshal_VkPhysicalDeviceImageFormatInfo2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo), streamPtrPtr);
+ reservedmarshal_VkImageFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageFormatProperties2*)(pImageFormatProperties),
+ streamPtrPtr);
+ unmarshal_VkImageFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageFormatProperties2*)(pImageFormatProperties));
+ if (pImageFormatProperties) {
+ transform_fromhost_VkImageFormatProperties2(
+ sResourceTracker, (VkImageFormatProperties2*)(pImageFormatProperties));
}
VkResult vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -17854,13 +24850,38 @@
}
void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2KHR(
- VkPhysicalDevice physicalDevice,
- uint32_t* pQueueFamilyPropertyCount,
- VkQueueFamilyProperties2* pQueueFamilyProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2* pQueueFamilyProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceQueueFamilyProperties2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice:%p, "
+ "pQueueFamilyPropertyCount:%p, pQueueFamilyProperties:%p)",
+ physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -17873,31 +24894,40 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pQueueFamilyPropertyCount)
- {
+ if (pQueueFamilyPropertyCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pQueueFamilyProperties)
- {
- if (pQueueFamilyPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
- {
- count_VkQueueFamilyProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i), countPtr);
+ if (pQueueFamilyProperties) {
+ if (pQueueFamilyPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
+ count_VkQueueFamilyProperties2(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPhysicalDeviceQueueFamilyProperties2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceQueueFamilyProperties2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceQueueFamilyProperties2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceQueueFamilyProperties2KHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceQueueFamilyProperties2KHR = OP_vkGetPhysicalDeviceQueueFamilyProperties2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceQueueFamilyProperties2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceQueueFamilyProperties2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceQueueFamilyProperties2KHR =
+ OP_vkGetPhysicalDeviceQueueFamilyProperties2KHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceQueueFamilyProperties2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceQueueFamilyProperties2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -17907,8 +24937,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pQueueFamilyPropertyCount)
- {
+ if (pQueueFamilyPropertyCount) {
memcpy(*streamPtrPtr, (uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -17917,54 +24946,49 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pQueueFamilyProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
- {
- reservedmarshal_VkQueueFamilyProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i), streamPtrPtr);
+ if (pQueueFamilyProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
+ reservedmarshal_VkQueueFamilyProperties2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pQueueFamilyPropertyCount;
check_pQueueFamilyPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pQueueFamilyPropertyCount)
- {
- if (!(check_pQueueFamilyPropertyCount))
- {
- fprintf(stderr, "fatal: pQueueFamilyPropertyCount inconsistent between guest and host\n");
+ if (pQueueFamilyPropertyCount) {
+ if (!(check_pQueueFamilyPropertyCount)) {
+ fprintf(stderr,
+ "fatal: pQueueFamilyPropertyCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pQueueFamilyPropertyCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
VkQueueFamilyProperties2* check_pQueueFamilyProperties;
check_pQueueFamilyProperties = (VkQueueFamilyProperties2*)(uintptr_t)stream->getBe64();
- if (pQueueFamilyProperties)
- {
- if (!(check_pQueueFamilyProperties))
- {
+ if (pQueueFamilyProperties) {
+ if (!(check_pQueueFamilyProperties)) {
fprintf(stderr, "fatal: pQueueFamilyProperties inconsistent between guest and host\n");
}
- if (pQueueFamilyPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
- {
- unmarshal_VkQueueFamilyProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
+ if (pQueueFamilyPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
+ unmarshal_VkQueueFamilyProperties2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
}
}
}
- if (pQueueFamilyPropertyCount)
- {
- if (pQueueFamilyProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i)
- {
- transform_fromhost_VkQueueFamilyProperties2(sResourceTracker, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
+ if (pQueueFamilyPropertyCount) {
+ if (pQueueFamilyProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pQueueFamilyPropertyCount)); ++i) {
+ transform_fromhost_VkQueueFamilyProperties2(
+ sResourceTracker, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i));
}
}
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -17972,12 +24996,37 @@
}
void VkEncoder::vkGetPhysicalDeviceMemoryProperties2KHR(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceMemoryProperties2* pMemoryProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceMemoryProperties2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice:%p, pMemoryProperties:%p)",
+ physicalDevice, pMemoryProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -17988,30 +25037,48 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceMemoryProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties), countPtr);
+ count_VkPhysicalDeviceMemoryProperties2(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties), countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceMemoryProperties2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceMemoryProperties2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceMemoryProperties2KHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceMemoryProperties2KHR = OP_vkGetPhysicalDeviceMemoryProperties2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceMemoryProperties2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceMemoryProperties2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceMemoryProperties2KHR =
+ OP_vkGetPhysicalDeviceMemoryProperties2KHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceMemoryProperties2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceMemoryProperties2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceMemoryProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties), streamPtrPtr);
- unmarshal_VkPhysicalDeviceMemoryProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
- if (pMemoryProperties)
- {
- transform_fromhost_VkPhysicalDeviceMemoryProperties2(sResourceTracker, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
+ reservedmarshal_VkPhysicalDeviceMemoryProperties2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties),
+ streamPtrPtr);
+ unmarshal_VkPhysicalDeviceMemoryProperties2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
+ if (pMemoryProperties) {
+ transform_fromhost_VkPhysicalDeviceMemoryProperties2(
+ sResourceTracker, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties));
}
- sResourceTracker->on_vkGetPhysicalDeviceMemoryProperties2KHR(this, physicalDevice, pMemoryProperties);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ sResourceTracker->on_vkGetPhysicalDeviceMemoryProperties2KHR(this, physicalDevice,
+ pMemoryProperties);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -18019,14 +25086,38 @@
}
void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
- uint32_t* pPropertyCount,
- VkSparseImageFormatProperties2* pProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+ uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceSparseImageFormatProperties2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice:%p, pFormatInfo:%p, "
+ "pPropertyCount:%p, pProperties:%p)",
+ physicalDevice, pFormatInfo, pPropertyCount, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -18034,60 +25125,76 @@
VkPhysicalDeviceSparseImageFormatInfo2* local_pFormatInfo;
local_physicalDevice = physicalDevice;
local_pFormatInfo = nullptr;
- if (pFormatInfo)
- {
- local_pFormatInfo = (VkPhysicalDeviceSparseImageFormatInfo2*)pool->alloc(sizeof(const VkPhysicalDeviceSparseImageFormatInfo2));
- deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pFormatInfo, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
+ if (pFormatInfo) {
+ local_pFormatInfo = (VkPhysicalDeviceSparseImageFormatInfo2*)pool->alloc(
+ sizeof(const VkPhysicalDeviceSparseImageFormatInfo2));
+ deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pFormatInfo,
+ (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
}
- if (local_pFormatInfo)
- {
- transform_tohost_VkPhysicalDeviceSparseImageFormatInfo2(sResourceTracker, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
+ if (local_pFormatInfo) {
+ transform_tohost_VkPhysicalDeviceSparseImageFormatInfo2(
+ sResourceTracker, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceSparseImageFormatInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo), countPtr);
+ count_VkPhysicalDeviceSparseImageFormatInfo2(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pProperties)
- {
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- count_VkSparseImageFormatProperties2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageFormatProperties2*)(pProperties + i), countPtr);
+ if (pProperties) {
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ count_VkSparseImageFormatProperties2(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageFormatProperties2*)(pProperties + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2KHR);
+ uint32_t packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2KHR);
+ uint8_t* streamPtr =
+ stream->reserve(packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2KHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = OP_vkGetPhysicalDeviceSparseImageFormatProperties2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSparseImageFormatProperties2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceSparseImageFormatProperties2KHR =
+ OP_vkGetPhysicalDeviceSparseImageFormatProperties2KHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSparseImageFormatProperties2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,
+ sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceSparseImageFormatInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo), streamPtrPtr);
+ reservedmarshal_VkPhysicalDeviceSparseImageFormatInfo2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceSparseImageFormatInfo2*)(local_pFormatInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)pPropertyCount;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
memcpy(*streamPtrPtr, (uint32_t*)pPropertyCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -18096,20 +25203,18 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- reservedmarshal_VkSparseImageFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageFormatProperties2*)(pProperties + i), streamPtrPtr);
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ reservedmarshal_VkSparseImageFormatProperties2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageFormatProperties2*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pPropertyCount)
- {
- if (!(check_pPropertyCount))
- {
+ if (pPropertyCount) {
+ if (!(check_pPropertyCount)) {
fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
@@ -18117,33 +25222,29 @@
// WARNING PTR CHECK
VkSparseImageFormatProperties2* check_pProperties;
check_pProperties = (VkSparseImageFormatProperties2*)(uintptr_t)stream->getBe64();
- if (pProperties)
- {
- if (!(check_pProperties))
- {
+ if (pProperties) {
+ if (!(check_pProperties)) {
fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
}
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- unmarshal_VkSparseImageFormatProperties2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageFormatProperties2*)(pProperties + i));
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ unmarshal_VkSparseImageFormatProperties2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageFormatProperties2*)(pProperties + i));
}
}
}
- if (pPropertyCount)
- {
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- transform_fromhost_VkSparseImageFormatProperties2(sResourceTracker, (VkSparseImageFormatProperties2*)(pProperties + i));
+ if (pPropertyCount) {
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ transform_fromhost_VkSparseImageFormatProperties2(
+ sResourceTracker, (VkSparseImageFormatProperties2*)(pProperties + i));
}
}
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -18152,16 +25253,41 @@
#endif
#ifdef VK_KHR_device_group
-void VkEncoder::vkGetDeviceGroupPeerMemoryFeaturesKHR(
- VkDevice device,
- uint32_t heapIndex,
- uint32_t localDeviceIndex,
- uint32_t remoteDeviceIndex,
- VkPeerMemoryFeatureFlags* pPeerMemoryFeatures,
- uint32_t doLock)
-{
+void VkEncoder::vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetDeviceGroupPeerMemoryFeaturesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetDeviceGroupPeerMemoryFeaturesKHR(device:%p, heapIndex:%d, localDeviceIndex:%d, "
+ "remoteDeviceIndex:%d, pPeerMemoryFeatures:%p)",
+ device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -18183,14 +25309,25 @@
*countPtr += sizeof(uint32_t);
*countPtr += sizeof(VkPeerMemoryFeatureFlags);
}
- uint32_t packetSize_vkGetDeviceGroupPeerMemoryFeaturesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDeviceGroupPeerMemoryFeaturesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDeviceGroupPeerMemoryFeaturesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceGroupPeerMemoryFeaturesKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetDeviceGroupPeerMemoryFeaturesKHR = OP_vkGetDeviceGroupPeerMemoryFeaturesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDeviceGroupPeerMemoryFeaturesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDeviceGroupPeerMemoryFeaturesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetDeviceGroupPeerMemoryFeaturesKHR =
+ OP_vkGetDeviceGroupPeerMemoryFeaturesKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDeviceGroupPeerMemoryFeaturesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDeviceGroupPeerMemoryFeaturesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -18201,25 +25338,48 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- memcpy(*streamPtrPtr, (VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
+ memcpy(*streamPtrPtr, (VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures,
+ sizeof(VkPeerMemoryFeatureFlags));
*streamPtrPtr += sizeof(VkPeerMemoryFeatureFlags);
stream->read((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetDeviceMaskKHR(
- VkCommandBuffer commandBuffer,
- uint32_t deviceMask,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetDeviceMaskKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetDeviceMaskKHR(commandBuffer:%p, deviceMask:%d)", commandBuffer,
+ deviceMask);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -18235,14 +25395,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdSetDeviceMaskKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetDeviceMaskKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDeviceMaskKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDeviceMaskKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetDeviceMaskKHR = OP_vkCmdSetDeviceMaskKHR;
- memcpy(streamPtr, &opcode_vkCmdSetDeviceMaskKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetDeviceMaskKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetDeviceMaskKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetDeviceMaskKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -18250,27 +25412,47 @@
}
memcpy(*streamPtrPtr, (uint32_t*)&local_deviceMask, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdDispatchBaseKHR(
- VkCommandBuffer commandBuffer,
- uint32_t baseGroupX,
- uint32_t baseGroupY,
- uint32_t baseGroupZ,
- uint32_t groupCountX,
- uint32_t groupCountY,
- uint32_t groupCountZ,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX,
+ uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX,
+ uint32_t groupCountY, uint32_t groupCountZ, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDispatchBaseKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdDispatchBaseKHR(commandBuffer:%p, baseGroupX:%d, baseGroupY:%d, baseGroupZ:%d, "
+ "groupCountX:%d, groupCountY:%d, groupCountZ:%d)",
+ commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -18301,14 +25483,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDispatchBaseKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDispatchBaseKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDispatchBaseKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDispatchBaseKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDispatchBaseKHR = OP_vkCmdDispatchBaseKHR;
- memcpy(streamPtr, &opcode_vkCmdDispatchBaseKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDispatchBaseKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDispatchBaseKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDispatchBaseKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -18326,9 +25510,9 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_groupCountZ, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -18339,14 +25523,35 @@
#ifdef VK_KHR_shader_draw_parameters
#endif
#ifdef VK_KHR_maintenance1
-void VkEncoder::vkTrimCommandPoolKHR(
- VkDevice device,
- VkCommandPool commandPool,
- VkCommandPoolTrimFlags flags,
- uint32_t doLock)
-{
+void VkEncoder::vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkTrimCommandPoolKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkTrimCommandPoolKHR(device:%p, commandPool:%p, flags:%d)", device,
+ commandPool, flags);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -18365,14 +25570,23 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkCommandPoolTrimFlags);
}
- uint32_t packetSize_vkTrimCommandPoolKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkTrimCommandPoolKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkTrimCommandPoolKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkTrimCommandPoolKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkTrimCommandPoolKHR = OP_vkTrimCommandPoolKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkTrimCommandPoolKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkTrimCommandPoolKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkTrimCommandPoolKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkTrimCommandPoolKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -18384,9 +25598,9 @@
memcpy(*streamPtrPtr, (VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags));
*streamPtrPtr += sizeof(VkCommandPoolTrimFlags);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -18396,13 +25610,37 @@
#endif
#ifdef VK_KHR_device_group_creation
VkResult VkEncoder::vkEnumeratePhysicalDeviceGroupsKHR(
- VkInstance instance,
- uint32_t* pPhysicalDeviceGroupCount,
- VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties,
- uint32_t doLock)
-{
+ VkInstance instance, uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkEnumeratePhysicalDeviceGroupsKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkEnumeratePhysicalDeviceGroupsKHR(instance:%p, pPhysicalDeviceGroupCount:%p, "
+ "pPhysicalDeviceGroupProperties:%p)",
+ instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -18415,31 +25653,40 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pPhysicalDeviceGroupCount)
- {
+ if (pPhysicalDeviceGroupCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pPhysicalDeviceGroupProperties)
- {
- if (pPhysicalDeviceGroupCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
- {
- count_VkPhysicalDeviceGroupProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i), countPtr);
+ if (pPhysicalDeviceGroupProperties) {
+ if (pPhysicalDeviceGroupCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i) {
+ count_VkPhysicalDeviceGroupProperties(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i),
+ countPtr);
}
}
}
}
- uint32_t packetSize_vkEnumeratePhysicalDeviceGroupsKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkEnumeratePhysicalDeviceGroupsKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkEnumeratePhysicalDeviceGroupsKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkEnumeratePhysicalDeviceGroupsKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkEnumeratePhysicalDeviceGroupsKHR = OP_vkEnumeratePhysicalDeviceGroupsKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkEnumeratePhysicalDeviceGroupsKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkEnumeratePhysicalDeviceGroupsKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkEnumeratePhysicalDeviceGroupsKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkEnumeratePhysicalDeviceGroupsKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -18449,8 +25696,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPhysicalDeviceGroupCount)
- {
+ if (pPhysicalDeviceGroupCount) {
memcpy(*streamPtrPtr, (uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -18459,56 +25705,55 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPhysicalDeviceGroupProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
- {
- reservedmarshal_VkPhysicalDeviceGroupProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i), streamPtrPtr);
+ if (pPhysicalDeviceGroupProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i) {
+ reservedmarshal_VkPhysicalDeviceGroupProperties(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i),
+ streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pPhysicalDeviceGroupCount;
check_pPhysicalDeviceGroupCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pPhysicalDeviceGroupCount)
- {
- if (!(check_pPhysicalDeviceGroupCount))
- {
- fprintf(stderr, "fatal: pPhysicalDeviceGroupCount inconsistent between guest and host\n");
+ if (pPhysicalDeviceGroupCount) {
+ if (!(check_pPhysicalDeviceGroupCount)) {
+ fprintf(stderr,
+ "fatal: pPhysicalDeviceGroupCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pPhysicalDeviceGroupCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
VkPhysicalDeviceGroupProperties* check_pPhysicalDeviceGroupProperties;
- check_pPhysicalDeviceGroupProperties = (VkPhysicalDeviceGroupProperties*)(uintptr_t)stream->getBe64();
- if (pPhysicalDeviceGroupProperties)
- {
- if (!(check_pPhysicalDeviceGroupProperties))
- {
- fprintf(stderr, "fatal: pPhysicalDeviceGroupProperties inconsistent between guest and host\n");
+ check_pPhysicalDeviceGroupProperties =
+ (VkPhysicalDeviceGroupProperties*)(uintptr_t)stream->getBe64();
+ if (pPhysicalDeviceGroupProperties) {
+ if (!(check_pPhysicalDeviceGroupProperties)) {
+ fprintf(stderr,
+ "fatal: pPhysicalDeviceGroupProperties inconsistent between guest and host\n");
}
- if (pPhysicalDeviceGroupCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
- {
- unmarshal_VkPhysicalDeviceGroupProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
+ if (pPhysicalDeviceGroupCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i) {
+ unmarshal_VkPhysicalDeviceGroupProperties(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
}
}
}
- if (pPhysicalDeviceGroupCount)
- {
- if (pPhysicalDeviceGroupProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i)
- {
- transform_fromhost_VkPhysicalDeviceGroupProperties(sResourceTracker, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
+ if (pPhysicalDeviceGroupCount) {
+ if (pPhysicalDeviceGroupProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPhysicalDeviceGroupCount)); ++i) {
+ transform_fromhost_VkPhysicalDeviceGroupProperties(
+ sResourceTracker,
+ (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i));
}
}
}
VkResult vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return = (VkResult)0;
stream->read(&vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -18519,13 +25764,38 @@
#endif
#ifdef VK_KHR_external_memory_capabilities
void VkEncoder::vkGetPhysicalDeviceExternalBufferPropertiesKHR(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
- VkExternalBufferProperties* pExternalBufferProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+ VkExternalBufferProperties* pExternalBufferProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceExternalBufferPropertiesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice:%p, pExternalBufferInfo:%p, "
+ "pExternalBufferProperties:%p)",
+ physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -18533,47 +25803,71 @@
VkPhysicalDeviceExternalBufferInfo* local_pExternalBufferInfo;
local_physicalDevice = physicalDevice;
local_pExternalBufferInfo = nullptr;
- if (pExternalBufferInfo)
- {
- local_pExternalBufferInfo = (VkPhysicalDeviceExternalBufferInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalBufferInfo));
- deepcopy_VkPhysicalDeviceExternalBufferInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExternalBufferInfo, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
+ if (pExternalBufferInfo) {
+ local_pExternalBufferInfo = (VkPhysicalDeviceExternalBufferInfo*)pool->alloc(
+ sizeof(const VkPhysicalDeviceExternalBufferInfo));
+ deepcopy_VkPhysicalDeviceExternalBufferInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExternalBufferInfo,
+ (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
}
- if (local_pExternalBufferInfo)
- {
- sResourceTracker->transformImpl_VkPhysicalDeviceExternalBufferInfo_tohost(local_pExternalBufferInfo, 1);
- transform_tohost_VkPhysicalDeviceExternalBufferInfo(sResourceTracker, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
+ if (local_pExternalBufferInfo) {
+ sResourceTracker->transformImpl_VkPhysicalDeviceExternalBufferInfo_tohost(
+ local_pExternalBufferInfo, 1);
+ transform_tohost_VkPhysicalDeviceExternalBufferInfo(
+ sResourceTracker, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceExternalBufferInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo), countPtr);
- count_VkExternalBufferProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalBufferProperties*)(pExternalBufferProperties), countPtr);
+ count_VkPhysicalDeviceExternalBufferInfo(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo), countPtr);
+ count_VkExternalBufferProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExternalBufferProperties*)(pExternalBufferProperties),
+ countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceExternalBufferPropertiesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceExternalBufferPropertiesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceExternalBufferPropertiesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceExternalBufferPropertiesKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceExternalBufferPropertiesKHR = OP_vkGetPhysicalDeviceExternalBufferPropertiesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceExternalBufferPropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceExternalBufferPropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceExternalBufferPropertiesKHR =
+ OP_vkGetPhysicalDeviceExternalBufferPropertiesKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceExternalBufferPropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceExternalBufferPropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceExternalBufferInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo), streamPtrPtr);
- reservedmarshal_VkExternalBufferProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalBufferProperties*)(pExternalBufferProperties), streamPtrPtr);
- unmarshal_VkExternalBufferProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalBufferProperties*)(pExternalBufferProperties));
- if (pExternalBufferProperties)
- {
- sResourceTracker->transformImpl_VkExternalBufferProperties_fromhost(pExternalBufferProperties, 1);
- transform_fromhost_VkExternalBufferProperties(sResourceTracker, (VkExternalBufferProperties*)(pExternalBufferProperties));
+ reservedmarshal_VkPhysicalDeviceExternalBufferInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo), streamPtrPtr);
+ reservedmarshal_VkExternalBufferProperties(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExternalBufferProperties*)(pExternalBufferProperties), streamPtrPtr);
+ unmarshal_VkExternalBufferProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExternalBufferProperties*)(pExternalBufferProperties));
+ if (pExternalBufferProperties) {
+ sResourceTracker->transformImpl_VkExternalBufferProperties_fromhost(
+ pExternalBufferProperties, 1);
+ transform_fromhost_VkExternalBufferProperties(
+ sResourceTracker, (VkExternalBufferProperties*)(pExternalBufferProperties));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -18585,13 +25879,35 @@
#endif
#ifdef VK_KHR_external_memory_win32
VkResult VkEncoder::vkGetMemoryWin32HandleKHR(
- VkDevice device,
- const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
- HANDLE* pHandle,
- uint32_t doLock)
-{
+ VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetMemoryWin32HandleKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetMemoryWin32HandleKHR(device:%p, pGetWin32HandleInfo:%p, pHandle:%p)",
+ device, pGetWin32HandleInfo, pHandle);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -18599,44 +25915,59 @@
VkMemoryGetWin32HandleInfoKHR* local_pGetWin32HandleInfo;
local_device = device;
local_pGetWin32HandleInfo = nullptr;
- if (pGetWin32HandleInfo)
- {
- local_pGetWin32HandleInfo = (VkMemoryGetWin32HandleInfoKHR*)pool->alloc(sizeof(const VkMemoryGetWin32HandleInfoKHR));
- deepcopy_VkMemoryGetWin32HandleInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetWin32HandleInfo, (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+ if (pGetWin32HandleInfo) {
+ local_pGetWin32HandleInfo = (VkMemoryGetWin32HandleInfoKHR*)pool->alloc(
+ sizeof(const VkMemoryGetWin32HandleInfoKHR));
+ deepcopy_VkMemoryGetWin32HandleInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetWin32HandleInfo,
+ (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
}
- if (local_pGetWin32HandleInfo)
- {
- transform_tohost_VkMemoryGetWin32HandleInfoKHR(sResourceTracker, (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+ if (local_pGetWin32HandleInfo) {
+ transform_tohost_VkMemoryGetWin32HandleInfoKHR(
+ sResourceTracker, (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkMemoryGetWin32HandleInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo), countPtr);
+ count_VkMemoryGetWin32HandleInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo), countPtr);
*countPtr += sizeof(HANDLE);
}
- uint32_t packetSize_vkGetMemoryWin32HandleKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetMemoryWin32HandleKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetMemoryWin32HandleKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetMemoryWin32HandleKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetMemoryWin32HandleKHR = OP_vkGetMemoryWin32HandleKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetMemoryWin32HandleKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetMemoryWin32HandleKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetMemoryWin32HandleKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetMemoryWin32HandleKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkMemoryGetWin32HandleInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo), streamPtrPtr);
+ reservedmarshal_VkMemoryGetWin32HandleInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo), streamPtrPtr);
memcpy(*streamPtrPtr, (HANDLE*)pHandle, sizeof(HANDLE));
*streamPtrPtr += sizeof(HANDLE);
stream->read((HANDLE*)pHandle, sizeof(HANDLE));
VkResult vkGetMemoryWin32HandleKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetMemoryWin32HandleKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -18645,14 +25976,36 @@
}
VkResult VkEncoder::vkGetMemoryWin32HandlePropertiesKHR(
- VkDevice device,
- VkExternalMemoryHandleTypeFlagBits handleType,
- HANDLE handle,
- VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties,
- uint32_t doLock)
-{
+ VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle,
+ VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetMemoryWin32HandlePropertiesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetMemoryWin32HandlePropertiesKHR(device:%p, pMemoryWin32HandleProperties:%p)", device,
+ pMemoryWin32HandleProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -18669,35 +26022,52 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkExternalMemoryHandleTypeFlagBits);
*countPtr += sizeof(HANDLE);
- count_VkMemoryWin32HandlePropertiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties), countPtr);
+ count_VkMemoryWin32HandlePropertiesKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties), countPtr);
}
- uint32_t packetSize_vkGetMemoryWin32HandlePropertiesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetMemoryWin32HandlePropertiesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetMemoryWin32HandlePropertiesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetMemoryWin32HandlePropertiesKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetMemoryWin32HandlePropertiesKHR = OP_vkGetMemoryWin32HandlePropertiesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetMemoryWin32HandlePropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetMemoryWin32HandlePropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetMemoryWin32HandlePropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetMemoryWin32HandlePropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- memcpy(*streamPtrPtr, (VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ memcpy(*streamPtrPtr, (VkExternalMemoryHandleTypeFlagBits*)&local_handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
*streamPtrPtr += sizeof(VkExternalMemoryHandleTypeFlagBits);
memcpy(*streamPtrPtr, (HANDLE*)&local_handle, sizeof(HANDLE));
*streamPtrPtr += sizeof(HANDLE);
- reservedmarshal_VkMemoryWin32HandlePropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties), streamPtrPtr);
- unmarshal_VkMemoryWin32HandlePropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties));
- if (pMemoryWin32HandleProperties)
- {
- transform_fromhost_VkMemoryWin32HandlePropertiesKHR(sResourceTracker, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties));
+ reservedmarshal_VkMemoryWin32HandlePropertiesKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties), streamPtrPtr);
+ unmarshal_VkMemoryWin32HandlePropertiesKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties));
+ if (pMemoryWin32HandleProperties) {
+ transform_fromhost_VkMemoryWin32HandlePropertiesKHR(
+ sResourceTracker, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties));
}
VkResult vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetMemoryWin32HandlePropertiesKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -18707,14 +26077,35 @@
#endif
#ifdef VK_KHR_external_memory_fd
-VkResult VkEncoder::vkGetMemoryFdKHR(
- VkDevice device,
- const VkMemoryGetFdInfoKHR* pGetFdInfo,
- int* pFd,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo,
+ int* pFd, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetMemoryFdKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetMemoryFdKHR(device:%p, pGetFdInfo:%p, pFd:%p)", device, pGetFdInfo,
+ pFd);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -18722,44 +26113,54 @@
VkMemoryGetFdInfoKHR* local_pGetFdInfo;
local_device = device;
local_pGetFdInfo = nullptr;
- if (pGetFdInfo)
- {
+ if (pGetFdInfo) {
local_pGetFdInfo = (VkMemoryGetFdInfoKHR*)pool->alloc(sizeof(const VkMemoryGetFdInfoKHR));
- deepcopy_VkMemoryGetFdInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetFdInfo, (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo));
+ deepcopy_VkMemoryGetFdInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetFdInfo,
+ (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo));
}
- if (local_pGetFdInfo)
- {
- transform_tohost_VkMemoryGetFdInfoKHR(sResourceTracker, (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo));
+ if (local_pGetFdInfo) {
+ transform_tohost_VkMemoryGetFdInfoKHR(sResourceTracker,
+ (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkMemoryGetFdInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo), countPtr);
+ count_VkMemoryGetFdInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo), countPtr);
*countPtr += sizeof(int);
}
uint32_t packetSize_vkGetMemoryFdKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetMemoryFdKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetMemoryFdKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetMemoryFdKHR = OP_vkGetMemoryFdKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetMemoryFdKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetMemoryFdKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetMemoryFdKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetMemoryFdKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkMemoryGetFdInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo), streamPtrPtr);
+ reservedmarshal_VkMemoryGetFdInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo), streamPtrPtr);
memcpy(*streamPtrPtr, (int*)pFd, sizeof(int));
*streamPtrPtr += sizeof(int);
stream->read((int*)pFd, sizeof(int));
VkResult vkGetMemoryFdKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetMemoryFdKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -18767,15 +26168,37 @@
return vkGetMemoryFdKHR_VkResult_return;
}
-VkResult VkEncoder::vkGetMemoryFdPropertiesKHR(
- VkDevice device,
- VkExternalMemoryHandleTypeFlagBits handleType,
- int fd,
- VkMemoryFdPropertiesKHR* pMemoryFdProperties,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetMemoryFdPropertiesKHR(VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetMemoryFdPropertiesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetMemoryFdPropertiesKHR(device:%p, fd:%d, pMemoryFdProperties:%p)",
+ device, fd, pMemoryFdProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -18792,35 +26215,49 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkExternalMemoryHandleTypeFlagBits);
*countPtr += sizeof(int);
- count_VkMemoryFdPropertiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties), countPtr);
+ count_VkMemoryFdPropertiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties), countPtr);
}
- uint32_t packetSize_vkGetMemoryFdPropertiesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetMemoryFdPropertiesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetMemoryFdPropertiesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetMemoryFdPropertiesKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetMemoryFdPropertiesKHR = OP_vkGetMemoryFdPropertiesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetMemoryFdPropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetMemoryFdPropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetMemoryFdPropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetMemoryFdPropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- memcpy(*streamPtrPtr, (VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ memcpy(*streamPtrPtr, (VkExternalMemoryHandleTypeFlagBits*)&local_handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
*streamPtrPtr += sizeof(VkExternalMemoryHandleTypeFlagBits);
memcpy(*streamPtrPtr, (int*)&local_fd, sizeof(int));
*streamPtrPtr += sizeof(int);
- reservedmarshal_VkMemoryFdPropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties), streamPtrPtr);
- unmarshal_VkMemoryFdPropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties));
- if (pMemoryFdProperties)
- {
- transform_fromhost_VkMemoryFdPropertiesKHR(sResourceTracker, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties));
+ reservedmarshal_VkMemoryFdPropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties),
+ streamPtrPtr);
+ unmarshal_VkMemoryFdPropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties));
+ if (pMemoryFdProperties) {
+ transform_fromhost_VkMemoryFdPropertiesKHR(sResourceTracker,
+ (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties));
}
VkResult vkGetMemoryFdPropertiesKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetMemoryFdPropertiesKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -18835,11 +26272,37 @@
void VkEncoder::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
- VkExternalSemaphoreProperties* pExternalSemaphoreProperties,
- uint32_t doLock)
-{
+ VkExternalSemaphoreProperties* pExternalSemaphoreProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice:%p, "
+ "pExternalSemaphoreInfo:%p, pExternalSemaphoreProperties:%p)",
+ physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -18847,46 +26310,73 @@
VkPhysicalDeviceExternalSemaphoreInfo* local_pExternalSemaphoreInfo;
local_physicalDevice = physicalDevice;
local_pExternalSemaphoreInfo = nullptr;
- if (pExternalSemaphoreInfo)
- {
- local_pExternalSemaphoreInfo = (VkPhysicalDeviceExternalSemaphoreInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalSemaphoreInfo));
- deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExternalSemaphoreInfo, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
+ if (pExternalSemaphoreInfo) {
+ local_pExternalSemaphoreInfo = (VkPhysicalDeviceExternalSemaphoreInfo*)pool->alloc(
+ sizeof(const VkPhysicalDeviceExternalSemaphoreInfo));
+ deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExternalSemaphoreInfo,
+ (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
}
- if (local_pExternalSemaphoreInfo)
- {
- transform_tohost_VkPhysicalDeviceExternalSemaphoreInfo(sResourceTracker, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
+ if (local_pExternalSemaphoreInfo) {
+ transform_tohost_VkPhysicalDeviceExternalSemaphoreInfo(
+ sResourceTracker,
+ (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceExternalSemaphoreInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo), countPtr);
- count_VkExternalSemaphoreProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties), countPtr);
+ count_VkPhysicalDeviceExternalSemaphoreInfo(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo), countPtr);
+ count_VkExternalSemaphoreProperties(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties), countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR);
+ uint32_t packetSize_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR);
+ uint8_t* streamPtr =
+ stream->reserve(packetSize_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = OP_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR =
+ OP_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,
+ sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceExternalSemaphoreInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo), streamPtrPtr);
- reservedmarshal_VkExternalSemaphoreProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties), streamPtrPtr);
- unmarshal_VkExternalSemaphoreProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
- if (pExternalSemaphoreProperties)
- {
- transform_fromhost_VkExternalSemaphoreProperties(sResourceTracker, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
+ reservedmarshal_VkPhysicalDeviceExternalSemaphoreInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo), streamPtrPtr);
+ reservedmarshal_VkExternalSemaphoreProperties(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties), streamPtrPtr);
+ unmarshal_VkExternalSemaphoreProperties(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
+ if (pExternalSemaphoreProperties) {
+ transform_fromhost_VkExternalSemaphoreProperties(
+ sResourceTracker, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties));
}
- sResourceTracker->on_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(this, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ sResourceTracker->on_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+ this, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -18898,12 +26388,36 @@
#endif
#ifdef VK_KHR_external_semaphore_win32
VkResult VkEncoder::vkImportSemaphoreWin32HandleKHR(
- VkDevice device,
- const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo,
- uint32_t doLock)
-{
+ VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkImportSemaphoreWin32HandleKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkImportSemaphoreWin32HandleKHR(device:%p, pImportSemaphoreWin32HandleInfo:%p)", device,
+ pImportSemaphoreWin32HandleInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -18911,40 +26425,59 @@
VkImportSemaphoreWin32HandleInfoKHR* local_pImportSemaphoreWin32HandleInfo;
local_device = device;
local_pImportSemaphoreWin32HandleInfo = nullptr;
- if (pImportSemaphoreWin32HandleInfo)
- {
- local_pImportSemaphoreWin32HandleInfo = (VkImportSemaphoreWin32HandleInfoKHR*)pool->alloc(sizeof(const VkImportSemaphoreWin32HandleInfoKHR));
- deepcopy_VkImportSemaphoreWin32HandleInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImportSemaphoreWin32HandleInfo, (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo));
+ if (pImportSemaphoreWin32HandleInfo) {
+ local_pImportSemaphoreWin32HandleInfo = (VkImportSemaphoreWin32HandleInfoKHR*)pool->alloc(
+ sizeof(const VkImportSemaphoreWin32HandleInfoKHR));
+ deepcopy_VkImportSemaphoreWin32HandleInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImportSemaphoreWin32HandleInfo,
+ (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo));
}
- if (local_pImportSemaphoreWin32HandleInfo)
- {
- transform_tohost_VkImportSemaphoreWin32HandleInfoKHR(sResourceTracker, (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo));
+ if (local_pImportSemaphoreWin32HandleInfo) {
+ transform_tohost_VkImportSemaphoreWin32HandleInfoKHR(
+ sResourceTracker,
+ (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImportSemaphoreWin32HandleInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo), countPtr);
+ count_VkImportSemaphoreWin32HandleInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo),
+ countPtr);
}
- uint32_t packetSize_vkImportSemaphoreWin32HandleKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkImportSemaphoreWin32HandleKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkImportSemaphoreWin32HandleKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkImportSemaphoreWin32HandleKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkImportSemaphoreWin32HandleKHR = OP_vkImportSemaphoreWin32HandleKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkImportSemaphoreWin32HandleKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkImportSemaphoreWin32HandleKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkImportSemaphoreWin32HandleKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkImportSemaphoreWin32HandleKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImportSemaphoreWin32HandleInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo), streamPtrPtr);
+ reservedmarshal_VkImportSemaphoreWin32HandleInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo),
+ streamPtrPtr);
VkResult vkImportSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
stream->read(&vkImportSemaphoreWin32HandleKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -18953,13 +26486,35 @@
}
VkResult VkEncoder::vkGetSemaphoreWin32HandleKHR(
- VkDevice device,
- const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
- HANDLE* pHandle,
- uint32_t doLock)
-{
+ VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetSemaphoreWin32HandleKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetSemaphoreWin32HandleKHR(device:%p, pGetWin32HandleInfo:%p, pHandle:%p)",
+ device, pGetWin32HandleInfo, pHandle);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -18967,44 +26522,60 @@
VkSemaphoreGetWin32HandleInfoKHR* local_pGetWin32HandleInfo;
local_device = device;
local_pGetWin32HandleInfo = nullptr;
- if (pGetWin32HandleInfo)
- {
- local_pGetWin32HandleInfo = (VkSemaphoreGetWin32HandleInfoKHR*)pool->alloc(sizeof(const VkSemaphoreGetWin32HandleInfoKHR));
- deepcopy_VkSemaphoreGetWin32HandleInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetWin32HandleInfo, (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+ if (pGetWin32HandleInfo) {
+ local_pGetWin32HandleInfo = (VkSemaphoreGetWin32HandleInfoKHR*)pool->alloc(
+ sizeof(const VkSemaphoreGetWin32HandleInfoKHR));
+ deepcopy_VkSemaphoreGetWin32HandleInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetWin32HandleInfo,
+ (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
}
- if (local_pGetWin32HandleInfo)
- {
- transform_tohost_VkSemaphoreGetWin32HandleInfoKHR(sResourceTracker, (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+ if (local_pGetWin32HandleInfo) {
+ transform_tohost_VkSemaphoreGetWin32HandleInfoKHR(
+ sResourceTracker, (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSemaphoreGetWin32HandleInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo), countPtr);
+ count_VkSemaphoreGetWin32HandleInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo), countPtr);
*countPtr += sizeof(HANDLE);
}
- uint32_t packetSize_vkGetSemaphoreWin32HandleKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetSemaphoreWin32HandleKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetSemaphoreWin32HandleKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetSemaphoreWin32HandleKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetSemaphoreWin32HandleKHR = OP_vkGetSemaphoreWin32HandleKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetSemaphoreWin32HandleKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetSemaphoreWin32HandleKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetSemaphoreWin32HandleKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetSemaphoreWin32HandleKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSemaphoreGetWin32HandleInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo), streamPtrPtr);
+ reservedmarshal_VkSemaphoreGetWin32HandleInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo), streamPtrPtr);
memcpy(*streamPtrPtr, (HANDLE*)pHandle, sizeof(HANDLE));
*streamPtrPtr += sizeof(HANDLE);
stream->read((HANDLE*)pHandle, sizeof(HANDLE));
VkResult vkGetSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetSemaphoreWin32HandleKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -19014,13 +26585,36 @@
#endif
#ifdef VK_KHR_external_semaphore_fd
-VkResult VkEncoder::vkImportSemaphoreFdKHR(
- VkDevice device,
- const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkImportSemaphoreFdKHR(VkDevice device,
+ const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkImportSemaphoreFdKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkImportSemaphoreFdKHR(device:%p, pImportSemaphoreFdInfo:%p)", device,
+ pImportSemaphoreFdInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -19028,40 +26622,55 @@
VkImportSemaphoreFdInfoKHR* local_pImportSemaphoreFdInfo;
local_device = device;
local_pImportSemaphoreFdInfo = nullptr;
- if (pImportSemaphoreFdInfo)
- {
- local_pImportSemaphoreFdInfo = (VkImportSemaphoreFdInfoKHR*)pool->alloc(sizeof(const VkImportSemaphoreFdInfoKHR));
- deepcopy_VkImportSemaphoreFdInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImportSemaphoreFdInfo, (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo));
+ if (pImportSemaphoreFdInfo) {
+ local_pImportSemaphoreFdInfo =
+ (VkImportSemaphoreFdInfoKHR*)pool->alloc(sizeof(const VkImportSemaphoreFdInfoKHR));
+ deepcopy_VkImportSemaphoreFdInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImportSemaphoreFdInfo,
+ (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo));
}
- if (local_pImportSemaphoreFdInfo)
- {
- transform_tohost_VkImportSemaphoreFdInfoKHR(sResourceTracker, (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo));
+ if (local_pImportSemaphoreFdInfo) {
+ transform_tohost_VkImportSemaphoreFdInfoKHR(
+ sResourceTracker, (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImportSemaphoreFdInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo), countPtr);
+ count_VkImportSemaphoreFdInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo), countPtr);
}
- uint32_t packetSize_vkImportSemaphoreFdKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkImportSemaphoreFdKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkImportSemaphoreFdKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkImportSemaphoreFdKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkImportSemaphoreFdKHR = OP_vkImportSemaphoreFdKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkImportSemaphoreFdKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkImportSemaphoreFdKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkImportSemaphoreFdKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkImportSemaphoreFdKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImportSemaphoreFdInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo), streamPtrPtr);
+ reservedmarshal_VkImportSemaphoreFdInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo), streamPtrPtr);
VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
stream->read(&vkImportSemaphoreFdKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -19069,14 +26678,35 @@
return vkImportSemaphoreFdKHR_VkResult_return;
}
-VkResult VkEncoder::vkGetSemaphoreFdKHR(
- VkDevice device,
- const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
- int* pFd,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+ int* pFd, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetSemaphoreFdKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetSemaphoreFdKHR(device:%p, pGetFdInfo:%p, pFd:%p)", device, pGetFdInfo,
+ pFd);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -19084,44 +26714,57 @@
VkSemaphoreGetFdInfoKHR* local_pGetFdInfo;
local_device = device;
local_pGetFdInfo = nullptr;
- if (pGetFdInfo)
- {
- local_pGetFdInfo = (VkSemaphoreGetFdInfoKHR*)pool->alloc(sizeof(const VkSemaphoreGetFdInfoKHR));
- deepcopy_VkSemaphoreGetFdInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetFdInfo, (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo));
+ if (pGetFdInfo) {
+ local_pGetFdInfo =
+ (VkSemaphoreGetFdInfoKHR*)pool->alloc(sizeof(const VkSemaphoreGetFdInfoKHR));
+ deepcopy_VkSemaphoreGetFdInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetFdInfo,
+ (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo));
}
- if (local_pGetFdInfo)
- {
- transform_tohost_VkSemaphoreGetFdInfoKHR(sResourceTracker, (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo));
+ if (local_pGetFdInfo) {
+ transform_tohost_VkSemaphoreGetFdInfoKHR(sResourceTracker,
+ (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSemaphoreGetFdInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo), countPtr);
+ count_VkSemaphoreGetFdInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo), countPtr);
*countPtr += sizeof(int);
}
- uint32_t packetSize_vkGetSemaphoreFdKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetSemaphoreFdKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetSemaphoreFdKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetSemaphoreFdKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetSemaphoreFdKHR = OP_vkGetSemaphoreFdKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetSemaphoreFdKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetSemaphoreFdKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetSemaphoreFdKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetSemaphoreFdKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSemaphoreGetFdInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo), streamPtrPtr);
+ reservedmarshal_VkSemaphoreGetFdInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo),
+ streamPtrPtr);
memcpy(*streamPtrPtr, (int*)pFd, sizeof(int));
*streamPtrPtr += sizeof(int);
stream->read((int*)pFd, sizeof(int));
VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetSemaphoreFdKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -19131,17 +26774,41 @@
#endif
#ifdef VK_KHR_push_descriptor
-void VkEncoder::vkCmdPushDescriptorSetKHR(
- VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipelineLayout layout,
- uint32_t set,
- uint32_t descriptorWriteCount,
- const VkWriteDescriptorSet* pDescriptorWrites,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout, uint32_t set,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdPushDescriptorSetKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdPushDescriptorSetKHR(commandBuffer:%p, layout:%p, set:%d, descriptorWriteCount:%d, "
+ "pDescriptorWrites:%p)",
+ commandBuffer, layout, set, descriptorWriteCount, pDescriptorWrites);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -19157,19 +26824,18 @@
local_set = set;
local_descriptorWriteCount = descriptorWriteCount;
local_pDescriptorWrites = nullptr;
- if (pDescriptorWrites)
- {
- local_pDescriptorWrites = (VkWriteDescriptorSet*)pool->alloc(((descriptorWriteCount)) * sizeof(const VkWriteDescriptorSet));
- for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
- {
- deepcopy_VkWriteDescriptorSet(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDescriptorWrites + i, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
+ if (pDescriptorWrites) {
+ local_pDescriptorWrites = (VkWriteDescriptorSet*)pool->alloc(
+ ((descriptorWriteCount)) * sizeof(const VkWriteDescriptorSet));
+ for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i) {
+ deepcopy_VkWriteDescriptorSet(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDescriptorWrites + i,
+ (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
}
}
- if (local_pDescriptorWrites)
- {
- for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
- {
- transform_tohost_VkWriteDescriptorSet(sResourceTracker, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
+ if (local_pDescriptorWrites) {
+ for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i) {
+ transform_tohost_VkWriteDescriptorSet(
+ sResourceTracker, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i));
}
}
size_t count = 0;
@@ -19182,26 +26848,30 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
- {
- count_VkWriteDescriptorSet(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i) {
+ count_VkWriteDescriptorSet(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkWriteDescriptorSet*)(local_pDescriptorWrites + i),
+ countPtr);
}
}
uint32_t packetSize_vkCmdPushDescriptorSetKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdPushDescriptorSetKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdPushDescriptorSetKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdPushDescriptorSetKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdPushDescriptorSetKHR = OP_vkCmdPushDescriptorSetKHR;
- memcpy(streamPtr, &opcode_vkCmdPushDescriptorSetKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdPushDescriptorSetKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdPushDescriptorSetKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdPushDescriptorSetKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- memcpy(*streamPtrPtr, (VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ memcpy(*streamPtrPtr, (VkPipelineBindPoint*)&local_pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
*streamPtrPtr += sizeof(VkPipelineBindPoint);
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPipelineLayout((*&local_layout));
@@ -19211,13 +26881,14 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_descriptorWriteCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i)
- {
- reservedmarshal_VkWriteDescriptorSet(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((descriptorWriteCount)); ++i) {
+ reservedmarshal_VkWriteDescriptorSet(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkWriteDescriptorSet*)(local_pDescriptorWrites + i),
+ streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -19225,15 +26896,38 @@
}
void VkEncoder::vkCmdPushDescriptorSetWithTemplateKHR(
- VkCommandBuffer commandBuffer,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- VkPipelineLayout layout,
- uint32_t set,
- const void* pData,
- uint32_t doLock)
-{
+ VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ VkPipelineLayout layout, uint32_t set, const void* pData, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkCmdPushDescriptorSetWithTemplateKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer:%p, descriptorUpdateTemplate:%p, "
+ "layout:%p, set:%d, pData:%p)",
+ commandBuffer, descriptorUpdateTemplate, layout, set, pData);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -19260,20 +26954,23 @@
*countPtr += sizeof(uint32_t);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pData)
- {
+ if (local_pData) {
*countPtr += sizeof(uint8_t);
}
}
uint32_t packetSize_vkCmdPushDescriptorSetWithTemplateKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdPushDescriptorSetWithTemplateKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdPushDescriptorSetWithTemplateKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdPushDescriptorSetWithTemplateKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkCmdPushDescriptorSetWithTemplateKHR = OP_vkCmdPushDescriptorSetWithTemplateKHR;
- memcpy(streamPtr, &opcode_vkCmdPushDescriptorSetWithTemplateKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdPushDescriptorSetWithTemplateKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ uint32_t opcode_vkCmdPushDescriptorSetWithTemplateKHR =
+ OP_vkCmdPushDescriptorSetWithTemplateKHR;
+ memcpy(streamPtr, &opcode_vkCmdPushDescriptorSetWithTemplateKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdPushDescriptorSetWithTemplateKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -19294,14 +26991,13 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pData)
- {
+ if (local_pData) {
memcpy(*streamPtrPtr, (void*)local_pData, sizeof(uint8_t));
*streamPtrPtr += sizeof(uint8_t);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -19317,14 +27013,38 @@
#endif
#ifdef VK_KHR_descriptor_update_template
VkResult VkEncoder::vkCreateDescriptorUpdateTemplateKHR(
- VkDevice device,
- const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate,
- uint32_t doLock)
-{
+ VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateDescriptorUpdateTemplateKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateDescriptorUpdateTemplateKHR(device:%p, pCreateInfo:%p, pAllocator:%p, "
+ "pDescriptorUpdateTemplate:%p)",
+ device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -19333,62 +27053,79 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkDescriptorUpdateTemplateCreateInfo*)pool->alloc(sizeof(const VkDescriptorUpdateTemplateCreateInfo));
- deepcopy_VkDescriptorUpdateTemplateCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkDescriptorUpdateTemplateCreateInfo*)pool->alloc(
+ sizeof(const VkDescriptorUpdateTemplateCreateInfo));
+ deepcopy_VkDescriptorUpdateTemplateCreateInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkDescriptorUpdateTemplateCreateInfo(sResourceTracker, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkDescriptorUpdateTemplateCreateInfo(
+ sResourceTracker, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDescriptorUpdateTemplateCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkDescriptorUpdateTemplateCreateInfo(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateDescriptorUpdateTemplateKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateDescriptorUpdateTemplateKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCreateDescriptorUpdateTemplateKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateDescriptorUpdateTemplateKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateDescriptorUpdateTemplateKHR = OP_vkCreateDescriptorUpdateTemplateKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateDescriptorUpdateTemplateKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateDescriptorUpdateTemplateKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateDescriptorUpdateTemplateKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateDescriptorUpdateTemplateKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDescriptorUpdateTemplateCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkDescriptorUpdateTemplateCreateInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorUpdateTemplateCreateInfo*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -19399,14 +27136,17 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(&cgen_var_3, (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1);
+ stream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(
+ &cgen_var_3, (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1);
stream->unsetHandleMapping();
VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateDescriptorUpdateTemplateKHR_VkResult_return, sizeof(VkResult));
- sResourceTracker->on_vkCreateDescriptorUpdateTemplateKHR(this, vkCreateDescriptorUpdateTemplateKHR_VkResult_return, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ sResourceTracker->on_vkCreateDescriptorUpdateTemplateKHR(
+ this, vkCreateDescriptorUpdateTemplateKHR_VkResult_return, device, pCreateInfo, pAllocator,
+ pDescriptorUpdateTemplate);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -19415,13 +27155,37 @@
}
void VkEncoder::vkDestroyDescriptorUpdateTemplateKHR(
- VkDevice device,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+ VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyDescriptorUpdateTemplateKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkDestroyDescriptorUpdateTemplateKHR(device:%p, descriptorUpdateTemplate:%p, "
+ "pAllocator:%p)",
+ device, descriptorUpdateTemplate, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -19431,15 +27195,15 @@
local_device = device;
local_descriptorUpdateTemplate = descriptorUpdateTemplate;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -19450,19 +27214,29 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyDescriptorUpdateTemplateKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyDescriptorUpdateTemplateKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkDestroyDescriptorUpdateTemplateKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyDescriptorUpdateTemplateKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyDescriptorUpdateTemplateKHR = OP_vkDestroyDescriptorUpdateTemplateKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyDescriptorUpdateTemplateKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyDescriptorUpdateTemplateKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyDescriptorUpdateTemplateKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyDescriptorUpdateTemplateKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -19476,15 +27250,17 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
- sResourceTracker->destroyMapping()->mapHandles_VkDescriptorUpdateTemplate((VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate);
+ sResourceTracker->destroyMapping()->mapHandles_VkDescriptorUpdateTemplate(
+ (VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -19492,14 +27268,37 @@
}
void VkEncoder::vkUpdateDescriptorSetWithTemplateKHR(
- VkDevice device,
- VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const void* pData,
- uint32_t doLock)
-{
+ VkDevice device, VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkUpdateDescriptorSetWithTemplateKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkUpdateDescriptorSetWithTemplateKHR(device:%p, descriptorSet:%p, "
+ "descriptorUpdateTemplate:%p, pData:%p)",
+ device, descriptorSet, descriptorUpdateTemplate, pData);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -19523,19 +27322,28 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pData)
- {
+ if (local_pData) {
*countPtr += sizeof(uint8_t);
}
}
- uint32_t packetSize_vkUpdateDescriptorSetWithTemplateKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkUpdateDescriptorSetWithTemplateKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkUpdateDescriptorSetWithTemplateKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkUpdateDescriptorSetWithTemplateKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkUpdateDescriptorSetWithTemplateKHR = OP_vkUpdateDescriptorSetWithTemplateKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkUpdateDescriptorSetWithTemplateKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkUpdateDescriptorSetWithTemplateKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkUpdateDescriptorSetWithTemplateKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkUpdateDescriptorSetWithTemplateKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -19553,15 +27361,14 @@
memcpy((*streamPtrPtr), &cgen_var_3, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pData)
- {
+ if (local_pData) {
memcpy(*streamPtrPtr, (void*)local_pData, sizeof(uint8_t));
*streamPtrPtr += sizeof(uint8_t);
}
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -19572,15 +27379,38 @@
#ifdef VK_KHR_imageless_framebuffer
#endif
#ifdef VK_KHR_create_renderpass2
-VkResult VkEncoder::vkCreateRenderPass2KHR(
- VkDevice device,
- const VkRenderPassCreateInfo2* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateRenderPass2KHR(VkDevice device,
+ const VkRenderPassCreateInfo2* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateRenderPass2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateRenderPass2KHR(device:%p, pCreateInfo:%p, pAllocator:%p, pRenderPass:%p)", device,
+ pCreateInfo, pAllocator, pRenderPass);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -19589,62 +27419,76 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkRenderPassCreateInfo2*)pool->alloc(sizeof(const VkRenderPassCreateInfo2));
- deepcopy_VkRenderPassCreateInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkRenderPassCreateInfo2*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkRenderPassCreateInfo2*)pool->alloc(sizeof(const VkRenderPassCreateInfo2));
+ deepcopy_VkRenderPassCreateInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkRenderPassCreateInfo2*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkRenderPassCreateInfo2(sResourceTracker, (VkRenderPassCreateInfo2*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkRenderPassCreateInfo2(sResourceTracker,
+ (VkRenderPassCreateInfo2*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkRenderPassCreateInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRenderPassCreateInfo2*)(local_pCreateInfo), countPtr);
+ count_VkRenderPassCreateInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderPassCreateInfo2*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateRenderPass2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateRenderPass2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateRenderPass2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateRenderPass2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateRenderPass2KHR = OP_vkCreateRenderPass2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateRenderPass2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateRenderPass2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateRenderPass2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateRenderPass2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkRenderPassCreateInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRenderPassCreateInfo2*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkRenderPassCreateInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderPassCreateInfo2*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -19652,14 +27496,17 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
+ stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_3, (VkRenderPass*)pRenderPass, 1);
+ stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_3, (VkRenderPass*)pRenderPass,
+ 1);
+ stream->unsetHandleMapping();
VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateRenderPass2KHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -19667,14 +27514,38 @@
return vkCreateRenderPass2KHR_VkResult_return;
}
-void VkEncoder::vkCmdBeginRenderPass2KHR(
- VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo* pRenderPassBegin,
- const VkSubpassBeginInfo* pSubpassBeginInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ const VkSubpassBeginInfo* pSubpassBeginInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBeginRenderPass2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdBeginRenderPass2KHR(commandBuffer:%p, pRenderPassBegin:%p, pSubpassBeginInfo:%p)",
+ commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -19683,66 +27554,99 @@
VkSubpassBeginInfo* local_pSubpassBeginInfo;
local_commandBuffer = commandBuffer;
local_pRenderPassBegin = nullptr;
- if (pRenderPassBegin)
- {
- local_pRenderPassBegin = (VkRenderPassBeginInfo*)pool->alloc(sizeof(const VkRenderPassBeginInfo));
- deepcopy_VkRenderPassBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRenderPassBegin, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+ if (pRenderPassBegin) {
+ local_pRenderPassBegin =
+ (VkRenderPassBeginInfo*)pool->alloc(sizeof(const VkRenderPassBeginInfo));
+ deepcopy_VkRenderPassBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRenderPassBegin,
+ (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
}
local_pSubpassBeginInfo = nullptr;
- if (pSubpassBeginInfo)
- {
- local_pSubpassBeginInfo = (VkSubpassBeginInfo*)pool->alloc(sizeof(const VkSubpassBeginInfo));
- deepcopy_VkSubpassBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassBeginInfo, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
+ if (pSubpassBeginInfo) {
+ local_pSubpassBeginInfo =
+ (VkSubpassBeginInfo*)pool->alloc(sizeof(const VkSubpassBeginInfo));
+ deepcopy_VkSubpassBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassBeginInfo,
+ (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
}
- if (local_pRenderPassBegin)
- {
- transform_tohost_VkRenderPassBeginInfo(sResourceTracker, (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
+ if (local_pRenderPassBegin) {
+ transform_tohost_VkRenderPassBeginInfo(sResourceTracker,
+ (VkRenderPassBeginInfo*)(local_pRenderPassBegin));
}
- if (local_pSubpassBeginInfo)
- {
- transform_tohost_VkSubpassBeginInfo(sResourceTracker, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
+ if (local_pSubpassBeginInfo) {
+ transform_tohost_VkSubpassBeginInfo(sResourceTracker,
+ (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkRenderPassBeginInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRenderPassBeginInfo*)(local_pRenderPassBegin), countPtr);
- count_VkSubpassBeginInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo), countPtr);
+ count_VkRenderPassBeginInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderPassBeginInfo*)(local_pRenderPassBegin), countPtr);
+ count_VkSubpassBeginInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubpassBeginInfo*)(local_pSubpassBeginInfo), countPtr);
}
uint32_t packetSize_vkCmdBeginRenderPass2KHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBeginRenderPass2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginRenderPass2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBeginRenderPass2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBeginRenderPass2KHR = OP_vkCmdBeginRenderPass2KHR;
- memcpy(streamPtr, &opcode_vkCmdBeginRenderPass2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBeginRenderPass2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBeginRenderPass2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBeginRenderPass2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkRenderPassBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRenderPassBeginInfo*)(local_pRenderPassBegin), streamPtrPtr);
- reservedmarshal_VkSubpassBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkRenderPassBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRenderPassBeginInfo*)(local_pRenderPassBegin),
+ streamPtrPtr);
+ reservedmarshal_VkSubpassBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubpassBeginInfo*)(local_pSubpassBeginInfo),
+ streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdNextSubpass2KHR(
- VkCommandBuffer commandBuffer,
- const VkSubpassBeginInfo* pSubpassBeginInfo,
- const VkSubpassEndInfo* pSubpassEndInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfo* pSubpassBeginInfo,
+ const VkSubpassEndInfo* pSubpassEndInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdNextSubpass2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdNextSubpass2KHR(commandBuffer:%p, pSubpassBeginInfo:%p, pSubpassEndInfo:%p)",
+ commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -19751,65 +27655,95 @@
VkSubpassEndInfo* local_pSubpassEndInfo;
local_commandBuffer = commandBuffer;
local_pSubpassBeginInfo = nullptr;
- if (pSubpassBeginInfo)
- {
- local_pSubpassBeginInfo = (VkSubpassBeginInfo*)pool->alloc(sizeof(const VkSubpassBeginInfo));
- deepcopy_VkSubpassBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassBeginInfo, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
+ if (pSubpassBeginInfo) {
+ local_pSubpassBeginInfo =
+ (VkSubpassBeginInfo*)pool->alloc(sizeof(const VkSubpassBeginInfo));
+ deepcopy_VkSubpassBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassBeginInfo,
+ (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
}
local_pSubpassEndInfo = nullptr;
- if (pSubpassEndInfo)
- {
+ if (pSubpassEndInfo) {
local_pSubpassEndInfo = (VkSubpassEndInfo*)pool->alloc(sizeof(const VkSubpassEndInfo));
- deepcopy_VkSubpassEndInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassEndInfo, (VkSubpassEndInfo*)(local_pSubpassEndInfo));
+ deepcopy_VkSubpassEndInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassEndInfo,
+ (VkSubpassEndInfo*)(local_pSubpassEndInfo));
}
- if (local_pSubpassBeginInfo)
- {
- transform_tohost_VkSubpassBeginInfo(sResourceTracker, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
+ if (local_pSubpassBeginInfo) {
+ transform_tohost_VkSubpassBeginInfo(sResourceTracker,
+ (VkSubpassBeginInfo*)(local_pSubpassBeginInfo));
}
- if (local_pSubpassEndInfo)
- {
- transform_tohost_VkSubpassEndInfo(sResourceTracker, (VkSubpassEndInfo*)(local_pSubpassEndInfo));
+ if (local_pSubpassEndInfo) {
+ transform_tohost_VkSubpassEndInfo(sResourceTracker,
+ (VkSubpassEndInfo*)(local_pSubpassEndInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSubpassBeginInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo), countPtr);
- count_VkSubpassEndInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassEndInfo*)(local_pSubpassEndInfo), countPtr);
+ count_VkSubpassBeginInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubpassBeginInfo*)(local_pSubpassBeginInfo), countPtr);
+ count_VkSubpassEndInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubpassEndInfo*)(local_pSubpassEndInfo), countPtr);
}
uint32_t packetSize_vkCmdNextSubpass2KHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdNextSubpass2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdNextSubpass2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdNextSubpass2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdNextSubpass2KHR = OP_vkCmdNextSubpass2KHR;
- memcpy(streamPtr, &opcode_vkCmdNextSubpass2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdNextSubpass2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdNextSubpass2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdNextSubpass2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkSubpassBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassBeginInfo*)(local_pSubpassBeginInfo), streamPtrPtr);
- reservedmarshal_VkSubpassEndInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassEndInfo*)(local_pSubpassEndInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkSubpassBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubpassBeginInfo*)(local_pSubpassBeginInfo),
+ streamPtrPtr);
+ reservedmarshal_VkSubpassEndInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubpassEndInfo*)(local_pSubpassEndInfo), streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdEndRenderPass2KHR(
- VkCommandBuffer commandBuffer,
- const VkSubpassEndInfo* pSubpassEndInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
+ const VkSubpassEndInfo* pSubpassEndInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdEndRenderPass2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdEndRenderPass2KHR(commandBuffer:%p, pSubpassEndInfo:%p)", commandBuffer,
+ pSubpassEndInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -19817,40 +27751,44 @@
VkSubpassEndInfo* local_pSubpassEndInfo;
local_commandBuffer = commandBuffer;
local_pSubpassEndInfo = nullptr;
- if (pSubpassEndInfo)
- {
+ if (pSubpassEndInfo) {
local_pSubpassEndInfo = (VkSubpassEndInfo*)pool->alloc(sizeof(const VkSubpassEndInfo));
- deepcopy_VkSubpassEndInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassEndInfo, (VkSubpassEndInfo*)(local_pSubpassEndInfo));
+ deepcopy_VkSubpassEndInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubpassEndInfo,
+ (VkSubpassEndInfo*)(local_pSubpassEndInfo));
}
- if (local_pSubpassEndInfo)
- {
- transform_tohost_VkSubpassEndInfo(sResourceTracker, (VkSubpassEndInfo*)(local_pSubpassEndInfo));
+ if (local_pSubpassEndInfo) {
+ transform_tohost_VkSubpassEndInfo(sResourceTracker,
+ (VkSubpassEndInfo*)(local_pSubpassEndInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSubpassEndInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassEndInfo*)(local_pSubpassEndInfo), countPtr);
+ count_VkSubpassEndInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubpassEndInfo*)(local_pSubpassEndInfo), countPtr);
}
uint32_t packetSize_vkCmdEndRenderPass2KHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdEndRenderPass2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEndRenderPass2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdEndRenderPass2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdEndRenderPass2KHR = OP_vkCmdEndRenderPass2KHR;
- memcpy(streamPtr, &opcode_vkCmdEndRenderPass2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdEndRenderPass2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdEndRenderPass2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdEndRenderPass2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkSubpassEndInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubpassEndInfo*)(local_pSubpassEndInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkSubpassEndInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubpassEndInfo*)(local_pSubpassEndInfo), streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -19859,13 +27797,34 @@
#endif
#ifdef VK_KHR_shared_presentable_image
-VkResult VkEncoder::vkGetSwapchainStatusKHR(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetSwapchainStatusKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetSwapchainStatusKHR(device:%p, swapchain:%p)", device, swapchain);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -19881,14 +27840,23 @@
uint64_t cgen_var_1;
*countPtr += 1 * 8;
}
- uint32_t packetSize_vkGetSwapchainStatusKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetSwapchainStatusKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetSwapchainStatusKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetSwapchainStatusKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetSwapchainStatusKHR = OP_vkGetSwapchainStatusKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetSwapchainStatusKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetSwapchainStatusKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetSwapchainStatusKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetSwapchainStatusKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -19899,9 +27867,9 @@
*streamPtrPtr += 1 * 8;
VkResult vkGetSwapchainStatusKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetSwapchainStatusKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -19912,13 +27880,38 @@
#endif
#ifdef VK_KHR_external_fence_capabilities
void VkEncoder::vkGetPhysicalDeviceExternalFencePropertiesKHR(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
- VkExternalFenceProperties* pExternalFenceProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+ VkExternalFenceProperties* pExternalFenceProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceExternalFencePropertiesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice:%p, pExternalFenceInfo:%p, "
+ "pExternalFenceProperties:%p)",
+ physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -19926,45 +27919,67 @@
VkPhysicalDeviceExternalFenceInfo* local_pExternalFenceInfo;
local_physicalDevice = physicalDevice;
local_pExternalFenceInfo = nullptr;
- if (pExternalFenceInfo)
- {
- local_pExternalFenceInfo = (VkPhysicalDeviceExternalFenceInfo*)pool->alloc(sizeof(const VkPhysicalDeviceExternalFenceInfo));
- deepcopy_VkPhysicalDeviceExternalFenceInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExternalFenceInfo, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
+ if (pExternalFenceInfo) {
+ local_pExternalFenceInfo = (VkPhysicalDeviceExternalFenceInfo*)pool->alloc(
+ sizeof(const VkPhysicalDeviceExternalFenceInfo));
+ deepcopy_VkPhysicalDeviceExternalFenceInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExternalFenceInfo,
+ (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
}
- if (local_pExternalFenceInfo)
- {
- transform_tohost_VkPhysicalDeviceExternalFenceInfo(sResourceTracker, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
+ if (local_pExternalFenceInfo) {
+ transform_tohost_VkPhysicalDeviceExternalFenceInfo(
+ sResourceTracker, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceExternalFenceInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo), countPtr);
- count_VkExternalFenceProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalFenceProperties*)(pExternalFenceProperties), countPtr);
+ count_VkPhysicalDeviceExternalFenceInfo(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo), countPtr);
+ count_VkExternalFenceProperties(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExternalFenceProperties*)(pExternalFenceProperties),
+ countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceExternalFencePropertiesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceExternalFencePropertiesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceExternalFencePropertiesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceExternalFencePropertiesKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceExternalFencePropertiesKHR = OP_vkGetPhysicalDeviceExternalFencePropertiesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceExternalFencePropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceExternalFencePropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceExternalFencePropertiesKHR =
+ OP_vkGetPhysicalDeviceExternalFencePropertiesKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceExternalFencePropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceExternalFencePropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceExternalFenceInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo), streamPtrPtr);
- reservedmarshal_VkExternalFenceProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalFenceProperties*)(pExternalFenceProperties), streamPtrPtr);
- unmarshal_VkExternalFenceProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalFenceProperties*)(pExternalFenceProperties));
- if (pExternalFenceProperties)
- {
- transform_fromhost_VkExternalFenceProperties(sResourceTracker, (VkExternalFenceProperties*)(pExternalFenceProperties));
+ reservedmarshal_VkPhysicalDeviceExternalFenceInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo), streamPtrPtr);
+ reservedmarshal_VkExternalFenceProperties(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalFenceProperties*)(pExternalFenceProperties),
+ streamPtrPtr);
+ unmarshal_VkExternalFenceProperties(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExternalFenceProperties*)(pExternalFenceProperties));
+ if (pExternalFenceProperties) {
+ transform_fromhost_VkExternalFenceProperties(
+ sResourceTracker, (VkExternalFenceProperties*)(pExternalFenceProperties));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -19976,12 +27991,35 @@
#endif
#ifdef VK_KHR_external_fence_win32
VkResult VkEncoder::vkImportFenceWin32HandleKHR(
- VkDevice device,
- const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo,
- uint32_t doLock)
-{
+ VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkImportFenceWin32HandleKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkImportFenceWin32HandleKHR(device:%p, pImportFenceWin32HandleInfo:%p)",
+ device, pImportFenceWin32HandleInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -19989,40 +28027,56 @@
VkImportFenceWin32HandleInfoKHR* local_pImportFenceWin32HandleInfo;
local_device = device;
local_pImportFenceWin32HandleInfo = nullptr;
- if (pImportFenceWin32HandleInfo)
- {
- local_pImportFenceWin32HandleInfo = (VkImportFenceWin32HandleInfoKHR*)pool->alloc(sizeof(const VkImportFenceWin32HandleInfoKHR));
- deepcopy_VkImportFenceWin32HandleInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImportFenceWin32HandleInfo, (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo));
+ if (pImportFenceWin32HandleInfo) {
+ local_pImportFenceWin32HandleInfo = (VkImportFenceWin32HandleInfoKHR*)pool->alloc(
+ sizeof(const VkImportFenceWin32HandleInfoKHR));
+ deepcopy_VkImportFenceWin32HandleInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImportFenceWin32HandleInfo,
+ (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo));
}
- if (local_pImportFenceWin32HandleInfo)
- {
- transform_tohost_VkImportFenceWin32HandleInfoKHR(sResourceTracker, (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo));
+ if (local_pImportFenceWin32HandleInfo) {
+ transform_tohost_VkImportFenceWin32HandleInfoKHR(
+ sResourceTracker,
+ (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImportFenceWin32HandleInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo), countPtr);
+ count_VkImportFenceWin32HandleInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo), countPtr);
}
- uint32_t packetSize_vkImportFenceWin32HandleKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkImportFenceWin32HandleKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkImportFenceWin32HandleKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkImportFenceWin32HandleKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkImportFenceWin32HandleKHR = OP_vkImportFenceWin32HandleKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkImportFenceWin32HandleKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkImportFenceWin32HandleKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkImportFenceWin32HandleKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkImportFenceWin32HandleKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImportFenceWin32HandleInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo), streamPtrPtr);
+ reservedmarshal_VkImportFenceWin32HandleInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo), streamPtrPtr);
VkResult vkImportFenceWin32HandleKHR_VkResult_return = (VkResult)0;
stream->read(&vkImportFenceWin32HandleKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -20031,13 +28085,35 @@
}
VkResult VkEncoder::vkGetFenceWin32HandleKHR(
- VkDevice device,
- const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
- HANDLE* pHandle,
- uint32_t doLock)
-{
+ VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetFenceWin32HandleKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetFenceWin32HandleKHR(device:%p, pGetWin32HandleInfo:%p, pHandle:%p)",
+ device, pGetWin32HandleInfo, pHandle);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -20045,44 +28121,59 @@
VkFenceGetWin32HandleInfoKHR* local_pGetWin32HandleInfo;
local_device = device;
local_pGetWin32HandleInfo = nullptr;
- if (pGetWin32HandleInfo)
- {
- local_pGetWin32HandleInfo = (VkFenceGetWin32HandleInfoKHR*)pool->alloc(sizeof(const VkFenceGetWin32HandleInfoKHR));
- deepcopy_VkFenceGetWin32HandleInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetWin32HandleInfo, (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+ if (pGetWin32HandleInfo) {
+ local_pGetWin32HandleInfo =
+ (VkFenceGetWin32HandleInfoKHR*)pool->alloc(sizeof(const VkFenceGetWin32HandleInfoKHR));
+ deepcopy_VkFenceGetWin32HandleInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetWin32HandleInfo,
+ (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
}
- if (local_pGetWin32HandleInfo)
- {
- transform_tohost_VkFenceGetWin32HandleInfoKHR(sResourceTracker, (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
+ if (local_pGetWin32HandleInfo) {
+ transform_tohost_VkFenceGetWin32HandleInfoKHR(
+ sResourceTracker, (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkFenceGetWin32HandleInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo), countPtr);
+ count_VkFenceGetWin32HandleInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo), countPtr);
*countPtr += sizeof(HANDLE);
}
- uint32_t packetSize_vkGetFenceWin32HandleKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetFenceWin32HandleKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetFenceWin32HandleKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetFenceWin32HandleKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetFenceWin32HandleKHR = OP_vkGetFenceWin32HandleKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetFenceWin32HandleKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetFenceWin32HandleKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetFenceWin32HandleKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetFenceWin32HandleKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkFenceGetWin32HandleInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo), streamPtrPtr);
+ reservedmarshal_VkFenceGetWin32HandleInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo), streamPtrPtr);
memcpy(*streamPtrPtr, (HANDLE*)pHandle, sizeof(HANDLE));
*streamPtrPtr += sizeof(HANDLE);
stream->read((HANDLE*)pHandle, sizeof(HANDLE));
VkResult vkGetFenceWin32HandleKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetFenceWin32HandleKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -20092,13 +28183,36 @@
#endif
#ifdef VK_KHR_external_fence_fd
-VkResult VkEncoder::vkImportFenceFdKHR(
- VkDevice device,
- const VkImportFenceFdInfoKHR* pImportFenceFdInfo,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkImportFenceFdKHR(VkDevice device,
+ const VkImportFenceFdInfoKHR* pImportFenceFdInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkImportFenceFdKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkImportFenceFdKHR(device:%p, pImportFenceFdInfo:%p)", device,
+ pImportFenceFdInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -20106,40 +28220,53 @@
VkImportFenceFdInfoKHR* local_pImportFenceFdInfo;
local_device = device;
local_pImportFenceFdInfo = nullptr;
- if (pImportFenceFdInfo)
- {
- local_pImportFenceFdInfo = (VkImportFenceFdInfoKHR*)pool->alloc(sizeof(const VkImportFenceFdInfoKHR));
- deepcopy_VkImportFenceFdInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImportFenceFdInfo, (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo));
+ if (pImportFenceFdInfo) {
+ local_pImportFenceFdInfo =
+ (VkImportFenceFdInfoKHR*)pool->alloc(sizeof(const VkImportFenceFdInfoKHR));
+ deepcopy_VkImportFenceFdInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImportFenceFdInfo,
+ (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo));
}
- if (local_pImportFenceFdInfo)
- {
- transform_tohost_VkImportFenceFdInfoKHR(sResourceTracker, (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo));
+ if (local_pImportFenceFdInfo) {
+ transform_tohost_VkImportFenceFdInfoKHR(
+ sResourceTracker, (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImportFenceFdInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo), countPtr);
+ count_VkImportFenceFdInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo), countPtr);
}
- uint32_t packetSize_vkImportFenceFdKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkImportFenceFdKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkImportFenceFdKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkImportFenceFdKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkImportFenceFdKHR = OP_vkImportFenceFdKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkImportFenceFdKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkImportFenceFdKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkImportFenceFdKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkImportFenceFdKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImportFenceFdInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo), streamPtrPtr);
+ reservedmarshal_VkImportFenceFdInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo),
+ streamPtrPtr);
VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
stream->read(&vkImportFenceFdKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -20147,14 +28274,34 @@
return vkImportFenceFdKHR_VkResult_return;
}
-VkResult VkEncoder::vkGetFenceFdKHR(
- VkDevice device,
- const VkFenceGetFdInfoKHR* pGetFdInfo,
- int* pFd,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo,
+ int* pFd, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetFenceFdKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetFenceFdKHR(device:%p, pGetFdInfo:%p, pFd:%p)", device, pGetFdInfo, pFd);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -20162,44 +28309,54 @@
VkFenceGetFdInfoKHR* local_pGetFdInfo;
local_device = device;
local_pGetFdInfo = nullptr;
- if (pGetFdInfo)
- {
+ if (pGetFdInfo) {
local_pGetFdInfo = (VkFenceGetFdInfoKHR*)pool->alloc(sizeof(const VkFenceGetFdInfoKHR));
- deepcopy_VkFenceGetFdInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetFdInfo, (VkFenceGetFdInfoKHR*)(local_pGetFdInfo));
+ deepcopy_VkFenceGetFdInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetFdInfo,
+ (VkFenceGetFdInfoKHR*)(local_pGetFdInfo));
}
- if (local_pGetFdInfo)
- {
- transform_tohost_VkFenceGetFdInfoKHR(sResourceTracker, (VkFenceGetFdInfoKHR*)(local_pGetFdInfo));
+ if (local_pGetFdInfo) {
+ transform_tohost_VkFenceGetFdInfoKHR(sResourceTracker,
+ (VkFenceGetFdInfoKHR*)(local_pGetFdInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkFenceGetFdInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFenceGetFdInfoKHR*)(local_pGetFdInfo), countPtr);
+ count_VkFenceGetFdInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkFenceGetFdInfoKHR*)(local_pGetFdInfo), countPtr);
*countPtr += sizeof(int);
}
uint32_t packetSize_vkGetFenceFdKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetFenceFdKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetFenceFdKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetFenceFdKHR = OP_vkGetFenceFdKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetFenceFdKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetFenceFdKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetFenceFdKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetFenceFdKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkFenceGetFdInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFenceGetFdInfoKHR*)(local_pGetFdInfo), streamPtrPtr);
+ reservedmarshal_VkFenceGetFdInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkFenceGetFdInfoKHR*)(local_pGetFdInfo), streamPtrPtr);
memcpy(*streamPtrPtr, (int*)pFd, sizeof(int));
*streamPtrPtr += sizeof(int);
stream->read((int*)pFd, sizeof(int));
VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetFenceFdKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -20210,15 +28367,40 @@
#endif
#ifdef VK_KHR_performance_query
VkResult VkEncoder::vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- uint32_t* pCounterCount,
- VkPerformanceCounterKHR* pCounters,
- VkPerformanceCounterDescriptionKHR* pCounterDescriptions,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount,
+ VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(
+ *mHealthMonitor,
+ "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice:%p, "
+ "queueFamilyIndex:%d, pCounterCount:%p, pCounters:%p, pCounterDescriptions:%p)",
+ physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -20234,43 +28416,54 @@
*countPtr += sizeof(uint32_t);
// WARNING PTR CHECK
*countPtr += 8;
- if (pCounterCount)
- {
+ if (pCounterCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pCounters)
- {
- if (pCounterCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i)
- {
- count_VkPerformanceCounterKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceCounterKHR*)(pCounters + i), countPtr);
+ if (pCounters) {
+ if (pCounterCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i) {
+ count_VkPerformanceCounterKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPerformanceCounterKHR*)(pCounters + i),
+ countPtr);
}
}
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pCounterDescriptions)
- {
- if (pCounterCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i)
- {
- count_VkPerformanceCounterDescriptionKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceCounterDescriptionKHR*)(pCounterDescriptions + i), countPtr);
+ if (pCounterDescriptions) {
+ if (pCounterCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i) {
+ count_VkPerformanceCounterDescriptionKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPerformanceCounterDescriptionKHR*)(pCounterDescriptions + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- uint8_t* streamPtr = stream->reserve(packetSize_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR);
+ uint32_t packetSize_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(
+ packetSize_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR);
+ uint8_t* streamPtr =
+ stream->reserve(packetSize_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = OP_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR =
+ OP_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
+ sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
+ sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -20282,8 +28475,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pCounterCount)
- {
+ if (pCounterCount) {
memcpy(*streamPtrPtr, (uint32_t*)pCounterCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -20292,11 +28484,11 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pCounters)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i)
- {
- reservedmarshal_VkPerformanceCounterKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceCounterKHR*)(pCounters + i), streamPtrPtr);
+ if (pCounters) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i) {
+ reservedmarshal_VkPerformanceCounterKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPerformanceCounterKHR*)(pCounters + i),
+ streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -20304,20 +28496,18 @@
memcpy((*streamPtrPtr), &cgen_var_3, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pCounterDescriptions)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i)
- {
- reservedmarshal_VkPerformanceCounterDescriptionKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceCounterDescriptionKHR*)(pCounterDescriptions + i), streamPtrPtr);
+ if (pCounterDescriptions) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i) {
+ reservedmarshal_VkPerformanceCounterDescriptionKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPerformanceCounterDescriptionKHR*)(pCounterDescriptions + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pCounterCount;
check_pCounterCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pCounterCount)
- {
- if (!(check_pCounterCount))
- {
+ if (pCounterCount) {
+ if (!(check_pCounterCount)) {
fprintf(stderr, "fatal: pCounterCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pCounterCount, sizeof(uint32_t));
@@ -20325,62 +28515,56 @@
// WARNING PTR CHECK
VkPerformanceCounterKHR* check_pCounters;
check_pCounters = (VkPerformanceCounterKHR*)(uintptr_t)stream->getBe64();
- if (pCounters)
- {
- if (!(check_pCounters))
- {
+ if (pCounters) {
+ if (!(check_pCounters)) {
fprintf(stderr, "fatal: pCounters inconsistent between guest and host\n");
}
- if (pCounterCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i)
- {
- unmarshal_VkPerformanceCounterKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceCounterKHR*)(pCounters + i));
+ if (pCounterCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i) {
+ unmarshal_VkPerformanceCounterKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPerformanceCounterKHR*)(pCounters + i));
}
}
}
- if (pCounterCount)
- {
- if (pCounters)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i)
- {
- transform_fromhost_VkPerformanceCounterKHR(sResourceTracker, (VkPerformanceCounterKHR*)(pCounters + i));
+ if (pCounterCount) {
+ if (pCounters) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i) {
+ transform_fromhost_VkPerformanceCounterKHR(
+ sResourceTracker, (VkPerformanceCounterKHR*)(pCounters + i));
}
}
}
// WARNING PTR CHECK
VkPerformanceCounterDescriptionKHR* check_pCounterDescriptions;
check_pCounterDescriptions = (VkPerformanceCounterDescriptionKHR*)(uintptr_t)stream->getBe64();
- if (pCounterDescriptions)
- {
- if (!(check_pCounterDescriptions))
- {
+ if (pCounterDescriptions) {
+ if (!(check_pCounterDescriptions)) {
fprintf(stderr, "fatal: pCounterDescriptions inconsistent between guest and host\n");
}
- if (pCounterCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i)
- {
- unmarshal_VkPerformanceCounterDescriptionKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceCounterDescriptionKHR*)(pCounterDescriptions + i));
+ if (pCounterCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i) {
+ unmarshal_VkPerformanceCounterDescriptionKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPerformanceCounterDescriptionKHR*)(pCounterDescriptions + i));
}
}
}
- if (pCounterCount)
- {
- if (pCounterDescriptions)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i)
- {
- transform_fromhost_VkPerformanceCounterDescriptionKHR(sResourceTracker, (VkPerformanceCounterDescriptionKHR*)(pCounterDescriptions + i));
+ if (pCounterCount) {
+ if (pCounterDescriptions) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCounterCount)); ++i) {
+ transform_fromhost_VkPerformanceCounterDescriptionKHR(
+ sResourceTracker,
+ (VkPerformanceCounterDescriptionKHR*)(pCounterDescriptions + i));
}
}
}
- VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_VkResult_return = (VkResult)0;
- stream->read(&vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_VkResult_return =
+ (VkResult)0;
+ stream->read(&vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_VkResult_return,
+ sizeof(VkResult));
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -20390,12 +28574,39 @@
void VkEncoder::vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
VkPhysicalDevice physicalDevice,
- const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo,
- uint32_t* pNumPasses,
- uint32_t doLock)
-{
+ const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(
+ *mHealthMonitor,
+ "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice:%p, "
+ "pPerformanceQueryCreateInfo:%p, pNumPasses:%p)",
+ physicalDevice, pPerformanceQueryCreateInfo, pNumPasses);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -20403,55 +28614,98 @@
VkQueryPoolPerformanceCreateInfoKHR* local_pPerformanceQueryCreateInfo;
local_physicalDevice = physicalDevice;
local_pPerformanceQueryCreateInfo = nullptr;
- if (pPerformanceQueryCreateInfo)
- {
- local_pPerformanceQueryCreateInfo = (VkQueryPoolPerformanceCreateInfoKHR*)pool->alloc(sizeof(const VkQueryPoolPerformanceCreateInfoKHR));
- deepcopy_VkQueryPoolPerformanceCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pPerformanceQueryCreateInfo, (VkQueryPoolPerformanceCreateInfoKHR*)(local_pPerformanceQueryCreateInfo));
+ if (pPerformanceQueryCreateInfo) {
+ local_pPerformanceQueryCreateInfo = (VkQueryPoolPerformanceCreateInfoKHR*)pool->alloc(
+ sizeof(const VkQueryPoolPerformanceCreateInfoKHR));
+ deepcopy_VkQueryPoolPerformanceCreateInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pPerformanceQueryCreateInfo,
+ (VkQueryPoolPerformanceCreateInfoKHR*)(local_pPerformanceQueryCreateInfo));
}
- if (local_pPerformanceQueryCreateInfo)
- {
- transform_tohost_VkQueryPoolPerformanceCreateInfoKHR(sResourceTracker, (VkQueryPoolPerformanceCreateInfoKHR*)(local_pPerformanceQueryCreateInfo));
+ if (local_pPerformanceQueryCreateInfo) {
+ transform_tohost_VkQueryPoolPerformanceCreateInfoKHR(
+ sResourceTracker,
+ (VkQueryPoolPerformanceCreateInfoKHR*)(local_pPerformanceQueryCreateInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkQueryPoolPerformanceCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueryPoolPerformanceCreateInfoKHR*)(local_pPerformanceQueryCreateInfo), countPtr);
+ count_VkQueryPoolPerformanceCreateInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkQueryPoolPerformanceCreateInfoKHR*)(local_pPerformanceQueryCreateInfo), countPtr);
*countPtr += sizeof(uint32_t);
}
- uint32_t packetSize_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR);
+ uint32_t packetSize_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR);
+ uint8_t* streamPtr =
+ stream->reserve(packetSize_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = OP_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR =
+ OP_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
+ sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
+ sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkQueryPoolPerformanceCreateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkQueryPoolPerformanceCreateInfoKHR*)(local_pPerformanceQueryCreateInfo), streamPtrPtr);
+ reservedmarshal_VkQueryPoolPerformanceCreateInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkQueryPoolPerformanceCreateInfoKHR*)(local_pPerformanceQueryCreateInfo), streamPtrPtr);
memcpy(*streamPtrPtr, (uint32_t*)pNumPasses, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
stream->read((uint32_t*)pNumPasses, sizeof(uint32_t));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkAcquireProfilingLockKHR(
- VkDevice device,
- const VkAcquireProfilingLockInfoKHR* pInfo,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkAcquireProfilingLockKHR(VkDevice device,
+ const VkAcquireProfilingLockInfoKHR* pInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkAcquireProfilingLockKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkAcquireProfilingLockKHR(device:%p, pInfo:%p)", device, pInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -20459,40 +28713,54 @@
VkAcquireProfilingLockInfoKHR* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkAcquireProfilingLockInfoKHR*)pool->alloc(sizeof(const VkAcquireProfilingLockInfoKHR));
- deepcopy_VkAcquireProfilingLockInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkAcquireProfilingLockInfoKHR*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkAcquireProfilingLockInfoKHR*)pool->alloc(
+ sizeof(const VkAcquireProfilingLockInfoKHR));
+ deepcopy_VkAcquireProfilingLockInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkAcquireProfilingLockInfoKHR*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkAcquireProfilingLockInfoKHR(sResourceTracker, (VkAcquireProfilingLockInfoKHR*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkAcquireProfilingLockInfoKHR(
+ sResourceTracker, (VkAcquireProfilingLockInfoKHR*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkAcquireProfilingLockInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAcquireProfilingLockInfoKHR*)(local_pInfo), countPtr);
+ count_VkAcquireProfilingLockInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAcquireProfilingLockInfoKHR*)(local_pInfo),
+ countPtr);
}
- uint32_t packetSize_vkAcquireProfilingLockKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkAcquireProfilingLockKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkAcquireProfilingLockKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkAcquireProfilingLockKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkAcquireProfilingLockKHR = OP_vkAcquireProfilingLockKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkAcquireProfilingLockKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkAcquireProfilingLockKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkAcquireProfilingLockKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkAcquireProfilingLockKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkAcquireProfilingLockInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAcquireProfilingLockInfoKHR*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkAcquireProfilingLockInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAcquireProfilingLockInfoKHR*)(local_pInfo),
+ streamPtrPtr);
VkResult vkAcquireProfilingLockKHR_VkResult_return = (VkResult)0;
stream->read(&vkAcquireProfilingLockKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -20500,12 +28768,33 @@
return vkAcquireProfilingLockKHR_VkResult_return;
}
-void VkEncoder::vkReleaseProfilingLockKHR(
- VkDevice device,
- uint32_t doLock)
-{
+void VkEncoder::vkReleaseProfilingLockKHR(VkDevice device, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkReleaseProfilingLockKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkReleaseProfilingLockKHR(device:%p)", device);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -20517,22 +28806,31 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
}
- uint32_t packetSize_vkReleaseProfilingLockKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkReleaseProfilingLockKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkReleaseProfilingLockKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkReleaseProfilingLockKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkReleaseProfilingLockKHR = OP_vkReleaseProfilingLockKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkReleaseProfilingLockKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkReleaseProfilingLockKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkReleaseProfilingLockKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkReleaseProfilingLockKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -20544,13 +28842,38 @@
#endif
#ifdef VK_KHR_get_surface_capabilities2
VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilities2KHR(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
- VkSurfaceCapabilities2KHR* pSurfaceCapabilities,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ VkSurfaceCapabilities2KHR* pSurfaceCapabilities, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceSurfaceCapabilities2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice:%p, pSurfaceInfo:%p, "
+ "pSurfaceCapabilities:%p)",
+ physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -20558,47 +28881,69 @@
VkPhysicalDeviceSurfaceInfo2KHR* local_pSurfaceInfo;
local_physicalDevice = physicalDevice;
local_pSurfaceInfo = nullptr;
- if (pSurfaceInfo)
- {
- local_pSurfaceInfo = (VkPhysicalDeviceSurfaceInfo2KHR*)pool->alloc(sizeof(const VkPhysicalDeviceSurfaceInfo2KHR));
- deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSurfaceInfo, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+ if (pSurfaceInfo) {
+ local_pSurfaceInfo = (VkPhysicalDeviceSurfaceInfo2KHR*)pool->alloc(
+ sizeof(const VkPhysicalDeviceSurfaceInfo2KHR));
+ deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSurfaceInfo,
+ (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
}
- if (local_pSurfaceInfo)
- {
- transform_tohost_VkPhysicalDeviceSurfaceInfo2KHR(sResourceTracker, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+ if (local_pSurfaceInfo) {
+ transform_tohost_VkPhysicalDeviceSurfaceInfo2KHR(
+ sResourceTracker, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceSurfaceInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo), countPtr);
- count_VkSurfaceCapabilities2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities), countPtr);
+ count_VkPhysicalDeviceSurfaceInfo2KHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo), countPtr);
+ count_VkSurfaceCapabilities2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities),
+ countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceSurfaceCapabilities2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceSurfaceCapabilities2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceSurfaceCapabilities2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceSurfaceCapabilities2KHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceSurfaceCapabilities2KHR = OP_vkGetPhysicalDeviceSurfaceCapabilities2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSurfaceCapabilities2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSurfaceCapabilities2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceSurfaceCapabilities2KHR =
+ OP_vkGetPhysicalDeviceSurfaceCapabilities2KHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSurfaceCapabilities2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSurfaceCapabilities2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceSurfaceInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo), streamPtrPtr);
- reservedmarshal_VkSurfaceCapabilities2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities), streamPtrPtr);
- unmarshal_VkSurfaceCapabilities2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities));
- if (pSurfaceCapabilities)
- {
- transform_fromhost_VkSurfaceCapabilities2KHR(sResourceTracker, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities));
+ reservedmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo),
+ streamPtrPtr);
+ reservedmarshal_VkSurfaceCapabilities2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities),
+ streamPtrPtr);
+ unmarshal_VkSurfaceCapabilities2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities));
+ if (pSurfaceCapabilities) {
+ transform_fromhost_VkSurfaceCapabilities2KHR(
+ sResourceTracker, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities));
}
VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -20607,14 +28952,38 @@
}
VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormats2KHR(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
- uint32_t* pSurfaceFormatCount,
- VkSurfaceFormat2KHR* pSurfaceFormats,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceSurfaceFormats2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice:%p, pSurfaceInfo:%p, "
+ "pSurfaceFormatCount:%p, pSurfaceFormats:%p)",
+ physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -20622,60 +28991,74 @@
VkPhysicalDeviceSurfaceInfo2KHR* local_pSurfaceInfo;
local_physicalDevice = physicalDevice;
local_pSurfaceInfo = nullptr;
- if (pSurfaceInfo)
- {
- local_pSurfaceInfo = (VkPhysicalDeviceSurfaceInfo2KHR*)pool->alloc(sizeof(const VkPhysicalDeviceSurfaceInfo2KHR));
- deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSurfaceInfo, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+ if (pSurfaceInfo) {
+ local_pSurfaceInfo = (VkPhysicalDeviceSurfaceInfo2KHR*)pool->alloc(
+ sizeof(const VkPhysicalDeviceSurfaceInfo2KHR));
+ deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSurfaceInfo,
+ (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
}
- if (local_pSurfaceInfo)
- {
- transform_tohost_VkPhysicalDeviceSurfaceInfo2KHR(sResourceTracker, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+ if (local_pSurfaceInfo) {
+ transform_tohost_VkPhysicalDeviceSurfaceInfo2KHR(
+ sResourceTracker, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceSurfaceInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo), countPtr);
+ count_VkPhysicalDeviceSurfaceInfo2KHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (pSurfaceFormatCount)
- {
+ if (pSurfaceFormatCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pSurfaceFormats)
- {
- if (pSurfaceFormatCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
- {
- count_VkSurfaceFormat2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceFormat2KHR*)(pSurfaceFormats + i), countPtr);
+ if (pSurfaceFormats) {
+ if (pSurfaceFormatCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i) {
+ count_VkSurfaceFormat2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSurfaceFormat2KHR*)(pSurfaceFormats + i),
+ countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPhysicalDeviceSurfaceFormats2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceSurfaceFormats2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceSurfaceFormats2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceSurfaceFormats2KHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceSurfaceFormats2KHR = OP_vkGetPhysicalDeviceSurfaceFormats2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSurfaceFormats2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSurfaceFormats2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceSurfaceFormats2KHR =
+ OP_vkGetPhysicalDeviceSurfaceFormats2KHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSurfaceFormats2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSurfaceFormats2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceSurfaceInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo), streamPtrPtr);
+ reservedmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)pSurfaceFormatCount;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pSurfaceFormatCount)
- {
+ if (pSurfaceFormatCount) {
memcpy(*streamPtrPtr, (uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -20684,20 +29067,18 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pSurfaceFormats)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
- {
- reservedmarshal_VkSurfaceFormat2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceFormat2KHR*)(pSurfaceFormats + i), streamPtrPtr);
+ if (pSurfaceFormats) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i) {
+ reservedmarshal_VkSurfaceFormat2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSurfaceFormat2KHR*)(pSurfaceFormats + i),
+ streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pSurfaceFormatCount;
check_pSurfaceFormatCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pSurfaceFormatCount)
- {
- if (!(check_pSurfaceFormatCount))
- {
+ if (pSurfaceFormatCount) {
+ if (!(check_pSurfaceFormatCount)) {
fprintf(stderr, "fatal: pSurfaceFormatCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pSurfaceFormatCount, sizeof(uint32_t));
@@ -20705,35 +29086,30 @@
// WARNING PTR CHECK
VkSurfaceFormat2KHR* check_pSurfaceFormats;
check_pSurfaceFormats = (VkSurfaceFormat2KHR*)(uintptr_t)stream->getBe64();
- if (pSurfaceFormats)
- {
- if (!(check_pSurfaceFormats))
- {
+ if (pSurfaceFormats) {
+ if (!(check_pSurfaceFormats)) {
fprintf(stderr, "fatal: pSurfaceFormats inconsistent between guest and host\n");
}
- if (pSurfaceFormatCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
- {
- unmarshal_VkSurfaceFormat2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceFormat2KHR*)(pSurfaceFormats + i));
+ if (pSurfaceFormatCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i) {
+ unmarshal_VkSurfaceFormat2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSurfaceFormat2KHR*)(pSurfaceFormats + i));
}
}
}
- if (pSurfaceFormatCount)
- {
- if (pSurfaceFormats)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i)
- {
- transform_fromhost_VkSurfaceFormat2KHR(sResourceTracker, (VkSurfaceFormat2KHR*)(pSurfaceFormats + i));
+ if (pSurfaceFormatCount) {
+ if (pSurfaceFormats) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSurfaceFormatCount)); ++i) {
+ transform_fromhost_VkSurfaceFormat2KHR(sResourceTracker,
+ (VkSurfaceFormat2KHR*)(pSurfaceFormats + i));
}
}
}
VkResult vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -20745,14 +29121,40 @@
#ifdef VK_KHR_variable_pointers
#endif
#ifdef VK_KHR_get_display_properties2
-VkResult VkEncoder::vkGetPhysicalDeviceDisplayProperties2KHR(
- VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkDisplayProperties2KHR* pProperties,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayProperties2KHR* pProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceDisplayProperties2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceDisplayProperties2KHR(physicalDevice:%p, pPropertyCount:%p, "
+ "pProperties:%p)",
+ physicalDevice, pPropertyCount, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -20765,31 +29167,40 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pProperties)
- {
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- count_VkDisplayProperties2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayProperties2KHR*)(pProperties + i), countPtr);
+ if (pProperties) {
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ count_VkDisplayProperties2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayProperties2KHR*)(pProperties + i),
+ countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPhysicalDeviceDisplayProperties2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceDisplayProperties2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceDisplayProperties2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceDisplayProperties2KHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceDisplayProperties2KHR = OP_vkGetPhysicalDeviceDisplayProperties2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceDisplayProperties2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceDisplayProperties2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceDisplayProperties2KHR =
+ OP_vkGetPhysicalDeviceDisplayProperties2KHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceDisplayProperties2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceDisplayProperties2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -20799,8 +29210,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
memcpy(*streamPtrPtr, (uint32_t*)pPropertyCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -20809,20 +29219,18 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- reservedmarshal_VkDisplayProperties2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayProperties2KHR*)(pProperties + i), streamPtrPtr);
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ reservedmarshal_VkDisplayProperties2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayProperties2KHR*)(pProperties + i),
+ streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pPropertyCount)
- {
- if (!(check_pPropertyCount))
- {
+ if (pPropertyCount) {
+ if (!(check_pPropertyCount)) {
fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
@@ -20830,35 +29238,30 @@
// WARNING PTR CHECK
VkDisplayProperties2KHR* check_pProperties;
check_pProperties = (VkDisplayProperties2KHR*)(uintptr_t)stream->getBe64();
- if (pProperties)
- {
- if (!(check_pProperties))
- {
+ if (pProperties) {
+ if (!(check_pProperties)) {
fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
}
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- unmarshal_VkDisplayProperties2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayProperties2KHR*)(pProperties + i));
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ unmarshal_VkDisplayProperties2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayProperties2KHR*)(pProperties + i));
}
}
}
- if (pPropertyCount)
- {
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- transform_fromhost_VkDisplayProperties2KHR(sResourceTracker, (VkDisplayProperties2KHR*)(pProperties + i));
+ if (pPropertyCount) {
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ transform_fromhost_VkDisplayProperties2KHR(
+ sResourceTracker, (VkDisplayProperties2KHR*)(pProperties + i));
}
}
}
VkResult vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -20867,13 +29270,38 @@
}
VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
- VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkDisplayPlaneProperties2KHR* pProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount,
+ VkDisplayPlaneProperties2KHR* pProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceDisplayPlaneProperties2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice:%p, pPropertyCount:%p, "
+ "pProperties:%p)",
+ physicalDevice, pPropertyCount, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -20886,31 +29314,40 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pProperties)
- {
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- count_VkDisplayPlaneProperties2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlaneProperties2KHR*)(pProperties + i), countPtr);
+ if (pProperties) {
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ count_VkDisplayPlaneProperties2KHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayPlaneProperties2KHR*)(pProperties + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceDisplayPlaneProperties2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceDisplayPlaneProperties2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceDisplayPlaneProperties2KHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = OP_vkGetPhysicalDeviceDisplayPlaneProperties2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceDisplayPlaneProperties2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceDisplayPlaneProperties2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceDisplayPlaneProperties2KHR =
+ OP_vkGetPhysicalDeviceDisplayPlaneProperties2KHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceDisplayPlaneProperties2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceDisplayPlaneProperties2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -20920,8 +29357,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
memcpy(*streamPtrPtr, (uint32_t*)pPropertyCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -20930,20 +29366,18 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- reservedmarshal_VkDisplayPlaneProperties2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlaneProperties2KHR*)(pProperties + i), streamPtrPtr);
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ reservedmarshal_VkDisplayPlaneProperties2KHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayPlaneProperties2KHR*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pPropertyCount)
- {
- if (!(check_pPropertyCount))
- {
+ if (pPropertyCount) {
+ if (!(check_pPropertyCount)) {
fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
@@ -20951,35 +29385,31 @@
// WARNING PTR CHECK
VkDisplayPlaneProperties2KHR* check_pProperties;
check_pProperties = (VkDisplayPlaneProperties2KHR*)(uintptr_t)stream->getBe64();
- if (pProperties)
- {
- if (!(check_pProperties))
- {
+ if (pProperties) {
+ if (!(check_pProperties)) {
fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
}
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- unmarshal_VkDisplayPlaneProperties2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlaneProperties2KHR*)(pProperties + i));
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ unmarshal_VkDisplayPlaneProperties2KHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayPlaneProperties2KHR*)(pProperties + i));
}
}
}
- if (pPropertyCount)
- {
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- transform_fromhost_VkDisplayPlaneProperties2KHR(sResourceTracker, (VkDisplayPlaneProperties2KHR*)(pProperties + i));
+ if (pPropertyCount) {
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ transform_fromhost_VkDisplayPlaneProperties2KHR(
+ sResourceTracker, (VkDisplayPlaneProperties2KHR*)(pProperties + i));
}
}
}
VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -20987,15 +29417,39 @@
return vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return;
}
-VkResult VkEncoder::vkGetDisplayModeProperties2KHR(
- VkPhysicalDevice physicalDevice,
- VkDisplayKHR display,
- uint32_t* pPropertyCount,
- VkDisplayModeProperties2KHR* pProperties,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display, uint32_t* pPropertyCount,
+ VkDisplayModeProperties2KHR* pProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetDisplayModeProperties2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetDisplayModeProperties2KHR(physicalDevice:%p, display:%p, pPropertyCount:%p, "
+ "pProperties:%p)",
+ physicalDevice, display, pPropertyCount, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -21012,31 +29466,39 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pProperties)
- {
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- count_VkDisplayModeProperties2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayModeProperties2KHR*)(pProperties + i), countPtr);
+ if (pProperties) {
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ count_VkDisplayModeProperties2KHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayModeProperties2KHR*)(pProperties + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkGetDisplayModeProperties2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDisplayModeProperties2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDisplayModeProperties2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDisplayModeProperties2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDisplayModeProperties2KHR = OP_vkGetDisplayModeProperties2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDisplayModeProperties2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDisplayModeProperties2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDisplayModeProperties2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDisplayModeProperties2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -21050,8 +29512,7 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
memcpy(*streamPtrPtr, (uint32_t*)pPropertyCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -21060,20 +29521,18 @@
memcpy((*streamPtrPtr), &cgen_var_3, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- reservedmarshal_VkDisplayModeProperties2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayModeProperties2KHR*)(pProperties + i), streamPtrPtr);
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ reservedmarshal_VkDisplayModeProperties2KHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayModeProperties2KHR*)(pProperties + i),
+ streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pPropertyCount)
- {
- if (!(check_pPropertyCount))
- {
+ if (pPropertyCount) {
+ if (!(check_pPropertyCount)) {
fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
@@ -21081,35 +29540,31 @@
// WARNING PTR CHECK
VkDisplayModeProperties2KHR* check_pProperties;
check_pProperties = (VkDisplayModeProperties2KHR*)(uintptr_t)stream->getBe64();
- if (pProperties)
- {
- if (!(check_pProperties))
- {
+ if (pProperties) {
+ if (!(check_pProperties)) {
fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
}
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- unmarshal_VkDisplayModeProperties2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayModeProperties2KHR*)(pProperties + i));
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ unmarshal_VkDisplayModeProperties2KHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayModeProperties2KHR*)(pProperties + i));
}
}
}
- if (pPropertyCount)
- {
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- transform_fromhost_VkDisplayModeProperties2KHR(sResourceTracker, (VkDisplayModeProperties2KHR*)(pProperties + i));
+ if (pPropertyCount) {
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ transform_fromhost_VkDisplayModeProperties2KHR(
+ sResourceTracker, (VkDisplayModeProperties2KHR*)(pProperties + i));
}
}
}
VkResult vkGetDisplayModeProperties2KHR_VkResult_return = (VkResult)0;
stream->read(&vkGetDisplayModeProperties2KHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -21118,13 +29573,37 @@
}
VkResult VkEncoder::vkGetDisplayPlaneCapabilities2KHR(
- VkPhysicalDevice physicalDevice,
- const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
- VkDisplayPlaneCapabilities2KHR* pCapabilities,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
+ VkDisplayPlaneCapabilities2KHR* pCapabilities, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetDisplayPlaneCapabilities2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetDisplayPlaneCapabilities2KHR(physicalDevice:%p, pDisplayPlaneInfo:%p, "
+ "pCapabilities:%p)",
+ physicalDevice, pDisplayPlaneInfo, pCapabilities);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -21132,47 +29611,66 @@
VkDisplayPlaneInfo2KHR* local_pDisplayPlaneInfo;
local_physicalDevice = physicalDevice;
local_pDisplayPlaneInfo = nullptr;
- if (pDisplayPlaneInfo)
- {
- local_pDisplayPlaneInfo = (VkDisplayPlaneInfo2KHR*)pool->alloc(sizeof(const VkDisplayPlaneInfo2KHR));
- deepcopy_VkDisplayPlaneInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDisplayPlaneInfo, (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo));
+ if (pDisplayPlaneInfo) {
+ local_pDisplayPlaneInfo =
+ (VkDisplayPlaneInfo2KHR*)pool->alloc(sizeof(const VkDisplayPlaneInfo2KHR));
+ deepcopy_VkDisplayPlaneInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDisplayPlaneInfo,
+ (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo));
}
- if (local_pDisplayPlaneInfo)
- {
- transform_tohost_VkDisplayPlaneInfo2KHR(sResourceTracker, (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo));
+ if (local_pDisplayPlaneInfo) {
+ transform_tohost_VkDisplayPlaneInfo2KHR(sResourceTracker,
+ (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDisplayPlaneInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo), countPtr);
- count_VkDisplayPlaneCapabilities2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities), countPtr);
+ count_VkDisplayPlaneInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo), countPtr);
+ count_VkDisplayPlaneCapabilities2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayPlaneCapabilities2KHR*)(pCapabilities),
+ countPtr);
}
- uint32_t packetSize_vkGetDisplayPlaneCapabilities2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDisplayPlaneCapabilities2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDisplayPlaneCapabilities2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDisplayPlaneCapabilities2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDisplayPlaneCapabilities2KHR = OP_vkGetDisplayPlaneCapabilities2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDisplayPlaneCapabilities2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDisplayPlaneCapabilities2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDisplayPlaneCapabilities2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDisplayPlaneCapabilities2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDisplayPlaneInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo), streamPtrPtr);
- reservedmarshal_VkDisplayPlaneCapabilities2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities), streamPtrPtr);
- unmarshal_VkDisplayPlaneCapabilities2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities));
- if (pCapabilities)
- {
- transform_fromhost_VkDisplayPlaneCapabilities2KHR(sResourceTracker, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities));
+ reservedmarshal_VkDisplayPlaneInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo),
+ streamPtrPtr);
+ reservedmarshal_VkDisplayPlaneCapabilities2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayPlaneCapabilities2KHR*)(pCapabilities),
+ streamPtrPtr);
+ unmarshal_VkDisplayPlaneCapabilities2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayPlaneCapabilities2KHR*)(pCapabilities));
+ if (pCapabilities) {
+ transform_fromhost_VkDisplayPlaneCapabilities2KHR(
+ sResourceTracker, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities));
}
VkResult vkGetDisplayPlaneCapabilities2KHR_VkResult_return = (VkResult)0;
stream->read(&vkGetDisplayPlaneCapabilities2KHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -21188,14 +29686,38 @@
#ifdef VK_KHR_relaxed_block_layout
#endif
#ifdef VK_KHR_get_memory_requirements2
-void VkEncoder::vkGetImageMemoryRequirements2KHR(
- VkDevice device,
- const VkImageMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements,
- uint32_t doLock)
-{
+void VkEncoder::vkGetImageMemoryRequirements2KHR(VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetImageMemoryRequirements2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetImageMemoryRequirements2KHR(device:%p, pInfo:%p, pMemoryRequirements:%p)", device,
+ pInfo, pMemoryRequirements);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -21203,59 +29725,102 @@
VkImageMemoryRequirementsInfo2* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkImageMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkImageMemoryRequirementsInfo2));
- deepcopy_VkImageMemoryRequirementsInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkImageMemoryRequirementsInfo2*)pool->alloc(
+ sizeof(const VkImageMemoryRequirementsInfo2));
+ deepcopy_VkImageMemoryRequirementsInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkImageMemoryRequirementsInfo2*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkImageMemoryRequirementsInfo2(sResourceTracker, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkImageMemoryRequirementsInfo2(
+ sResourceTracker, (VkImageMemoryRequirementsInfo2*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImageMemoryRequirementsInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageMemoryRequirementsInfo2*)(local_pInfo), countPtr);
- count_VkMemoryRequirements2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements), countPtr);
+ count_VkImageMemoryRequirementsInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageMemoryRequirementsInfo2*)(local_pInfo),
+ countPtr);
+ count_VkMemoryRequirements2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements), countPtr);
}
- uint32_t packetSize_vkGetImageMemoryRequirements2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetImageMemoryRequirements2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetImageMemoryRequirements2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageMemoryRequirements2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetImageMemoryRequirements2KHR = OP_vkGetImageMemoryRequirements2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetImageMemoryRequirements2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetImageMemoryRequirements2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetImageMemoryRequirements2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetImageMemoryRequirements2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageMemoryRequirementsInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageMemoryRequirementsInfo2*)(local_pInfo), streamPtrPtr);
- reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements), streamPtrPtr);
- unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements));
- if (pMemoryRequirements)
- {
- transform_fromhost_VkMemoryRequirements2(sResourceTracker, (VkMemoryRequirements2*)(pMemoryRequirements));
+ reservedmarshal_VkImageMemoryRequirementsInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageMemoryRequirementsInfo2*)(local_pInfo),
+ streamPtrPtr);
+ reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements),
+ streamPtrPtr);
+ unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements));
+ if (pMemoryRequirements) {
+ transform_fromhost_VkMemoryRequirements2(sResourceTracker,
+ (VkMemoryRequirements2*)(pMemoryRequirements));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkGetBufferMemoryRequirements2KHR(
- VkDevice device,
- const VkBufferMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements,
- uint32_t doLock)
-{
+void VkEncoder::vkGetBufferMemoryRequirements2KHR(VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetBufferMemoryRequirements2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetBufferMemoryRequirements2KHR(device:%p, pInfo:%p, pMemoryRequirements:%p)", device,
+ pInfo, pMemoryRequirements);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -21263,45 +29828,64 @@
VkBufferMemoryRequirementsInfo2* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkBufferMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkBufferMemoryRequirementsInfo2));
- deepcopy_VkBufferMemoryRequirementsInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkBufferMemoryRequirementsInfo2*)pool->alloc(
+ sizeof(const VkBufferMemoryRequirementsInfo2));
+ deepcopy_VkBufferMemoryRequirementsInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkBufferMemoryRequirementsInfo2(sResourceTracker, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkBufferMemoryRequirementsInfo2(
+ sResourceTracker, (VkBufferMemoryRequirementsInfo2*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferMemoryRequirementsInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferMemoryRequirementsInfo2*)(local_pInfo), countPtr);
- count_VkMemoryRequirements2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements), countPtr);
+ count_VkBufferMemoryRequirementsInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferMemoryRequirementsInfo2*)(local_pInfo),
+ countPtr);
+ count_VkMemoryRequirements2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements), countPtr);
}
- uint32_t packetSize_vkGetBufferMemoryRequirements2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetBufferMemoryRequirements2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetBufferMemoryRequirements2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferMemoryRequirements2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetBufferMemoryRequirements2KHR = OP_vkGetBufferMemoryRequirements2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetBufferMemoryRequirements2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetBufferMemoryRequirements2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetBufferMemoryRequirements2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetBufferMemoryRequirements2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferMemoryRequirementsInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferMemoryRequirementsInfo2*)(local_pInfo), streamPtrPtr);
- reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements), streamPtrPtr);
- unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements));
- if (pMemoryRequirements)
- {
- transform_fromhost_VkMemoryRequirements2(sResourceTracker, (VkMemoryRequirements2*)(pMemoryRequirements));
+ reservedmarshal_VkBufferMemoryRequirementsInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferMemoryRequirementsInfo2*)(local_pInfo),
+ streamPtrPtr);
+ reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements),
+ streamPtrPtr);
+ unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements));
+ if (pMemoryRequirements) {
+ transform_fromhost_VkMemoryRequirements2(sResourceTracker,
+ (VkMemoryRequirements2*)(pMemoryRequirements));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -21309,14 +29893,39 @@
}
void VkEncoder::vkGetImageSparseMemoryRequirements2KHR(
- VkDevice device,
- const VkImageSparseMemoryRequirementsInfo2* pInfo,
+ VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements,
- uint32_t doLock)
-{
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetImageSparseMemoryRequirements2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetImageSparseMemoryRequirements2KHR(device:%p, pInfo:%p, "
+ "pSparseMemoryRequirementCount:%p, pSparseMemoryRequirements:%p)",
+ device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -21324,60 +29933,75 @@
VkImageSparseMemoryRequirementsInfo2* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkImageSparseMemoryRequirementsInfo2*)pool->alloc(sizeof(const VkImageSparseMemoryRequirementsInfo2));
- deepcopy_VkImageSparseMemoryRequirementsInfo2(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkImageSparseMemoryRequirementsInfo2*)pool->alloc(
+ sizeof(const VkImageSparseMemoryRequirementsInfo2));
+ deepcopy_VkImageSparseMemoryRequirementsInfo2(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkImageSparseMemoryRequirementsInfo2(sResourceTracker, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkImageSparseMemoryRequirementsInfo2(
+ sResourceTracker, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImageSparseMemoryRequirementsInfo2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo), countPtr);
+ count_VkImageSparseMemoryRequirementsInfo2(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (pSparseMemoryRequirementCount)
- {
+ if (pSparseMemoryRequirementCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pSparseMemoryRequirements)
- {
- if (pSparseMemoryRequirementCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
- {
- count_VkSparseImageMemoryRequirements2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), countPtr);
+ if (pSparseMemoryRequirements) {
+ if (pSparseMemoryRequirementCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
+ count_VkSparseImageMemoryRequirements2(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i),
+ countPtr);
}
}
}
}
- uint32_t packetSize_vkGetImageSparseMemoryRequirements2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetImageSparseMemoryRequirements2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetImageSparseMemoryRequirements2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageSparseMemoryRequirements2KHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetImageSparseMemoryRequirements2KHR = OP_vkGetImageSparseMemoryRequirements2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetImageSparseMemoryRequirements2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetImageSparseMemoryRequirements2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetImageSparseMemoryRequirements2KHR =
+ OP_vkGetImageSparseMemoryRequirements2KHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetImageSparseMemoryRequirements2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetImageSparseMemoryRequirements2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageSparseMemoryRequirementsInfo2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkImageSparseMemoryRequirementsInfo2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageSparseMemoryRequirementsInfo2*)(local_pInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pSparseMemoryRequirementCount)
- {
+ if (pSparseMemoryRequirementCount) {
memcpy(*streamPtrPtr, (uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -21386,54 +30010,52 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pSparseMemoryRequirements)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
- {
- reservedmarshal_VkSparseImageMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), streamPtrPtr);
+ if (pSparseMemoryRequirements) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
+ reservedmarshal_VkSparseImageMemoryRequirements2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pSparseMemoryRequirementCount;
check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pSparseMemoryRequirementCount)
- {
- if (!(check_pSparseMemoryRequirementCount))
- {
- fprintf(stderr, "fatal: pSparseMemoryRequirementCount inconsistent between guest and host\n");
+ if (pSparseMemoryRequirementCount) {
+ if (!(check_pSparseMemoryRequirementCount)) {
+ fprintf(stderr,
+ "fatal: pSparseMemoryRequirementCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
VkSparseImageMemoryRequirements2* check_pSparseMemoryRequirements;
- check_pSparseMemoryRequirements = (VkSparseImageMemoryRequirements2*)(uintptr_t)stream->getBe64();
- if (pSparseMemoryRequirements)
- {
- if (!(check_pSparseMemoryRequirements))
- {
- fprintf(stderr, "fatal: pSparseMemoryRequirements inconsistent between guest and host\n");
+ check_pSparseMemoryRequirements =
+ (VkSparseImageMemoryRequirements2*)(uintptr_t)stream->getBe64();
+ if (pSparseMemoryRequirements) {
+ if (!(check_pSparseMemoryRequirements)) {
+ fprintf(stderr,
+ "fatal: pSparseMemoryRequirements inconsistent between guest and host\n");
}
- if (pSparseMemoryRequirementCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
- {
- unmarshal_VkSparseImageMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+ if (pSparseMemoryRequirementCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
+ unmarshal_VkSparseImageMemoryRequirements2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
}
}
}
- if (pSparseMemoryRequirementCount)
- {
- if (pSparseMemoryRequirements)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
- {
- transform_fromhost_VkSparseImageMemoryRequirements2(sResourceTracker, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+ if (pSparseMemoryRequirementCount) {
+ if (pSparseMemoryRequirements) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
+ transform_fromhost_VkSparseImageMemoryRequirements2(
+ sResourceTracker,
+ (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
}
}
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -21445,14 +30067,38 @@
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
VkResult VkEncoder::vkCreateSamplerYcbcrConversionKHR(
- VkDevice device,
- const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSamplerYcbcrConversion* pYcbcrConversion,
- uint32_t doLock)
-{
+ VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateSamplerYcbcrConversionKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateSamplerYcbcrConversionKHR(device:%p, pCreateInfo:%p, pAllocator:%p, "
+ "pYcbcrConversion:%p)",
+ device, pCreateInfo, pAllocator, pYcbcrConversion);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -21461,62 +30107,79 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkSamplerYcbcrConversionCreateInfo*)pool->alloc(sizeof(const VkSamplerYcbcrConversionCreateInfo));
- deepcopy_VkSamplerYcbcrConversionCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkSamplerYcbcrConversionCreateInfo*)pool->alloc(
+ sizeof(const VkSamplerYcbcrConversionCreateInfo));
+ deepcopy_VkSamplerYcbcrConversionCreateInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkSamplerYcbcrConversionCreateInfo(sResourceTracker, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkSamplerYcbcrConversionCreateInfo(
+ sResourceTracker, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSamplerYcbcrConversionCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkSamplerYcbcrConversionCreateInfo(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateSamplerYcbcrConversionKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateSamplerYcbcrConversionKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCreateSamplerYcbcrConversionKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateSamplerYcbcrConversionKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateSamplerYcbcrConversionKHR = OP_vkCreateSamplerYcbcrConversionKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateSamplerYcbcrConversionKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateSamplerYcbcrConversionKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateSamplerYcbcrConversionKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateSamplerYcbcrConversionKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSamplerYcbcrConversionCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkSamplerYcbcrConversionCreateInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSamplerYcbcrConversionCreateInfo*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -21527,13 +30190,14 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_3, (VkSamplerYcbcrConversion*)pYcbcrConversion, 1);
+ stream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(
+ &cgen_var_3, (VkSamplerYcbcrConversion*)pYcbcrConversion, 1);
stream->unsetHandleMapping();
VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateSamplerYcbcrConversionKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -21541,14 +30205,38 @@
return vkCreateSamplerYcbcrConversionKHR_VkResult_return;
}
-void VkEncoder::vkDestroySamplerYcbcrConversionKHR(
- VkDevice device,
- VkSamplerYcbcrConversion ycbcrConversion,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroySamplerYcbcrConversionKHR(VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroySamplerYcbcrConversionKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkDestroySamplerYcbcrConversionKHR(device:%p, ycbcrConversion:%p, pAllocator:%p)", device,
+ ycbcrConversion, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -21558,15 +30246,15 @@
local_device = device;
local_ycbcrConversion = ycbcrConversion;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -21577,19 +30265,29 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroySamplerYcbcrConversionKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroySamplerYcbcrConversionKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkDestroySamplerYcbcrConversionKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroySamplerYcbcrConversionKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroySamplerYcbcrConversionKHR = OP_vkDestroySamplerYcbcrConversionKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroySamplerYcbcrConversionKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroySamplerYcbcrConversionKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroySamplerYcbcrConversionKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroySamplerYcbcrConversionKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -21603,15 +30301,17 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
- sResourceTracker->destroyMapping()->mapHandles_VkSamplerYcbcrConversion((VkSamplerYcbcrConversion*)&ycbcrConversion);
+ sResourceTracker->destroyMapping()->mapHandles_VkSamplerYcbcrConversion(
+ (VkSamplerYcbcrConversion*)&ycbcrConversion);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -21620,14 +30320,36 @@
#endif
#ifdef VK_KHR_bind_memory2
-VkResult VkEncoder::vkBindBufferMemory2KHR(
- VkDevice device,
- uint32_t bindInfoCount,
- const VkBindBufferMemoryInfo* pBindInfos,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkBindBufferMemory2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkBindBufferMemory2KHR(device:%p, bindInfoCount:%d, pBindInfos:%p)", device,
+ bindInfoCount, pBindInfos);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -21637,19 +30359,18 @@
local_device = device;
local_bindInfoCount = bindInfoCount;
local_pBindInfos = nullptr;
- if (pBindInfos)
- {
- local_pBindInfos = (VkBindBufferMemoryInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindBufferMemoryInfo));
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- deepcopy_VkBindBufferMemoryInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfos + i, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
+ if (pBindInfos) {
+ local_pBindInfos = (VkBindBufferMemoryInfo*)pool->alloc(
+ ((bindInfoCount)) * sizeof(const VkBindBufferMemoryInfo));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ deepcopy_VkBindBufferMemoryInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfos + i,
+ (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
}
}
- if (local_pBindInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- transform_tohost_VkBindBufferMemoryInfo(sResourceTracker, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
+ if (local_pBindInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ transform_tohost_VkBindBufferMemoryInfo(
+ sResourceTracker, (VkBindBufferMemoryInfo*)(local_pBindInfos + i));
}
}
size_t count = 0;
@@ -21658,34 +30379,44 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- count_VkBindBufferMemoryInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindBufferMemoryInfo*)(local_pBindInfos + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ count_VkBindBufferMemoryInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBindBufferMemoryInfo*)(local_pBindInfos + i), countPtr);
}
}
- uint32_t packetSize_vkBindBufferMemory2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkBindBufferMemory2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkBindBufferMemory2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkBindBufferMemory2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkBindBufferMemory2KHR = OP_vkBindBufferMemory2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkBindBufferMemory2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkBindBufferMemory2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkBindBufferMemory2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkBindBufferMemory2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- reservedmarshal_VkBindBufferMemoryInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindBufferMemoryInfo*)(local_pBindInfos + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ reservedmarshal_VkBindBufferMemoryInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBindBufferMemoryInfo*)(local_pBindInfos + i),
+ streamPtrPtr);
}
VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
stream->read(&vkBindBufferMemory2KHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -21693,14 +30424,36 @@
return vkBindBufferMemory2KHR_VkResult_return;
}
-VkResult VkEncoder::vkBindImageMemory2KHR(
- VkDevice device,
- uint32_t bindInfoCount,
- const VkBindImageMemoryInfo* pBindInfos,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkBindImageMemory2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkBindImageMemory2KHR(device:%p, bindInfoCount:%d, pBindInfos:%p)", device,
+ bindInfoCount, pBindInfos);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -21710,19 +30463,18 @@
local_device = device;
local_bindInfoCount = bindInfoCount;
local_pBindInfos = nullptr;
- if (pBindInfos)
- {
- local_pBindInfos = (VkBindImageMemoryInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindImageMemoryInfo));
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- deepcopy_VkBindImageMemoryInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfos + i, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
+ if (pBindInfos) {
+ local_pBindInfos = (VkBindImageMemoryInfo*)pool->alloc(((bindInfoCount)) *
+ sizeof(const VkBindImageMemoryInfo));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ deepcopy_VkBindImageMemoryInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfos + i,
+ (VkBindImageMemoryInfo*)(local_pBindInfos + i));
}
}
- if (local_pBindInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- transform_tohost_VkBindImageMemoryInfo(sResourceTracker, (VkBindImageMemoryInfo*)(local_pBindInfos + i));
+ if (local_pBindInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ transform_tohost_VkBindImageMemoryInfo(sResourceTracker,
+ (VkBindImageMemoryInfo*)(local_pBindInfos + i));
}
}
size_t count = 0;
@@ -21731,34 +30483,44 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- count_VkBindImageMemoryInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindImageMemoryInfo*)(local_pBindInfos + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ count_VkBindImageMemoryInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBindImageMemoryInfo*)(local_pBindInfos + i), countPtr);
}
}
- uint32_t packetSize_vkBindImageMemory2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkBindImageMemory2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkBindImageMemory2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkBindImageMemory2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkBindImageMemory2KHR = OP_vkBindImageMemory2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkBindImageMemory2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkBindImageMemory2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkBindImageMemory2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkBindImageMemory2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- reservedmarshal_VkBindImageMemoryInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindImageMemoryInfo*)(local_pBindInfos + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ reservedmarshal_VkBindImageMemoryInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBindImageMemoryInfo*)(local_pBindInfos + i),
+ streamPtrPtr);
}
VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
stream->read(&vkBindImageMemory2KHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -21771,13 +30533,35 @@
#endif
#ifdef VK_KHR_maintenance3
void VkEncoder::vkGetDescriptorSetLayoutSupportKHR(
- VkDevice device,
- const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- VkDescriptorSetLayoutSupport* pSupport,
- uint32_t doLock)
-{
+ VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetDescriptorSetLayoutSupportKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetDescriptorSetLayoutSupportKHR(device:%p, pCreateInfo:%p, pSupport:%p)",
+ device, pCreateInfo, pSupport);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -21785,45 +30569,65 @@
VkDescriptorSetLayoutCreateInfo* local_pCreateInfo;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkDescriptorSetLayoutCreateInfo*)pool->alloc(sizeof(const VkDescriptorSetLayoutCreateInfo));
- deepcopy_VkDescriptorSetLayoutCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkDescriptorSetLayoutCreateInfo*)pool->alloc(
+ sizeof(const VkDescriptorSetLayoutCreateInfo));
+ deepcopy_VkDescriptorSetLayoutCreateInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
}
- if (local_pCreateInfo)
- {
- transform_tohost_VkDescriptorSetLayoutCreateInfo(sResourceTracker, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkDescriptorSetLayoutCreateInfo(
+ sResourceTracker, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDescriptorSetLayoutCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo), countPtr);
- count_VkDescriptorSetLayoutSupport(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorSetLayoutSupport*)(pSupport), countPtr);
+ count_VkDescriptorSetLayoutCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo),
+ countPtr);
+ count_VkDescriptorSetLayoutSupport(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorSetLayoutSupport*)(pSupport), countPtr);
}
- uint32_t packetSize_vkGetDescriptorSetLayoutSupportKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDescriptorSetLayoutSupportKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDescriptorSetLayoutSupportKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDescriptorSetLayoutSupportKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDescriptorSetLayoutSupportKHR = OP_vkGetDescriptorSetLayoutSupportKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDescriptorSetLayoutSupportKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDescriptorSetLayoutSupportKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDescriptorSetLayoutSupportKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDescriptorSetLayoutSupportKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDescriptorSetLayoutCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo), streamPtrPtr);
- reservedmarshal_VkDescriptorSetLayoutSupport(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorSetLayoutSupport*)(pSupport), streamPtrPtr);
- unmarshal_VkDescriptorSetLayoutSupport(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorSetLayoutSupport*)(pSupport));
- if (pSupport)
- {
- transform_fromhost_VkDescriptorSetLayoutSupport(sResourceTracker, (VkDescriptorSetLayoutSupport*)(pSupport));
+ reservedmarshal_VkDescriptorSetLayoutCreateInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo),
+ streamPtrPtr);
+ reservedmarshal_VkDescriptorSetLayoutSupport(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorSetLayoutSupport*)(pSupport),
+ streamPtrPtr);
+ unmarshal_VkDescriptorSetLayoutSupport(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorSetLayoutSupport*)(pSupport));
+ if (pSupport) {
+ transform_fromhost_VkDescriptorSetLayoutSupport(sResourceTracker,
+ (VkDescriptorSetLayoutSupport*)(pSupport));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -21832,18 +30636,39 @@
#endif
#ifdef VK_KHR_draw_indirect_count
-void VkEncoder::vkCmdDrawIndirectCountKHR(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+ uint32_t stride, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDrawIndirectCountKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdDrawIndirectCountKHR(commandBuffer:%p, buffer:%p, offset:%ld, countBuffer:%p, "
+ "countBufferOffset:%ld, maxDrawCount:%d, stride:%d)",
+ commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -21876,14 +30701,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDrawIndirectCountKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDrawIndirectCountKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawIndirectCountKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawIndirectCountKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDrawIndirectCountKHR = OP_vkCmdDrawIndirectCountKHR;
- memcpy(streamPtr, &opcode_vkCmdDrawIndirectCountKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDrawIndirectCountKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDrawIndirectCountKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDrawIndirectCountKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -21905,27 +30732,49 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_stride, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdDrawIndexedIndirectCountKHR(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount, uint32_t stride,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDrawIndexedIndirectCountKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdDrawIndexedIndirectCountKHR(commandBuffer:%p, buffer:%p, offset:%ld, countBuffer:%p, "
+ "countBufferOffset:%ld, maxDrawCount:%d, stride:%d)",
+ commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -21958,14 +30807,17 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDrawIndexedIndirectCountKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdDrawIndexedIndirectCountKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawIndexedIndirectCountKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawIndexedIndirectCountKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDrawIndexedIndirectCountKHR = OP_vkCmdDrawIndexedIndirectCountKHR;
- memcpy(streamPtr, &opcode_vkCmdDrawIndexedIndirectCountKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDrawIndexedIndirectCountKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDrawIndexedIndirectCountKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDrawIndexedIndirectCountKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -21987,9 +30839,9 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_stride, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -22014,14 +30866,35 @@
#ifdef VK_KHR_swapchain_mutable_format
#endif
#ifdef VK_KHR_timeline_semaphore
-VkResult VkEncoder::vkGetSemaphoreCounterValueKHR(
- VkDevice device,
- VkSemaphore semaphore,
- uint64_t* pValue,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore,
+ uint64_t* pValue, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetSemaphoreCounterValueKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetSemaphoreCounterValueKHR(device:%p, semaphore:%p, pValue:%p)", device,
+ semaphore, pValue);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -22038,14 +30911,24 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint64_t);
}
- uint32_t packetSize_vkGetSemaphoreCounterValueKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetSemaphoreCounterValueKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetSemaphoreCounterValueKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetSemaphoreCounterValueKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetSemaphoreCounterValueKHR = OP_vkGetSemaphoreCounterValueKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetSemaphoreCounterValueKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetSemaphoreCounterValueKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetSemaphoreCounterValueKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetSemaphoreCounterValueKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -22059,9 +30942,9 @@
stream->read((uint64_t*)pValue, sizeof(uint64_t));
VkResult vkGetSemaphoreCounterValueKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetSemaphoreCounterValueKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -22069,14 +30952,35 @@
return vkGetSemaphoreCounterValueKHR_VkResult_return;
}
-VkResult VkEncoder::vkWaitSemaphoresKHR(
- VkDevice device,
- const VkSemaphoreWaitInfo* pWaitInfo,
- uint64_t timeout,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo,
+ uint64_t timeout, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkWaitSemaphoresKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkWaitSemaphoresKHR(device:%p, pWaitInfo:%p, timeout:%ld)", device,
+ pWaitInfo, timeout);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -22085,44 +30989,55 @@
uint64_t local_timeout;
local_device = device;
local_pWaitInfo = nullptr;
- if (pWaitInfo)
- {
+ if (pWaitInfo) {
local_pWaitInfo = (VkSemaphoreWaitInfo*)pool->alloc(sizeof(const VkSemaphoreWaitInfo));
- deepcopy_VkSemaphoreWaitInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pWaitInfo, (VkSemaphoreWaitInfo*)(local_pWaitInfo));
+ deepcopy_VkSemaphoreWaitInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pWaitInfo,
+ (VkSemaphoreWaitInfo*)(local_pWaitInfo));
}
local_timeout = timeout;
- if (local_pWaitInfo)
- {
- transform_tohost_VkSemaphoreWaitInfo(sResourceTracker, (VkSemaphoreWaitInfo*)(local_pWaitInfo));
+ if (local_pWaitInfo) {
+ transform_tohost_VkSemaphoreWaitInfo(sResourceTracker,
+ (VkSemaphoreWaitInfo*)(local_pWaitInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSemaphoreWaitInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSemaphoreWaitInfo*)(local_pWaitInfo), countPtr);
+ count_VkSemaphoreWaitInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSemaphoreWaitInfo*)(local_pWaitInfo), countPtr);
*countPtr += sizeof(uint64_t);
}
- uint32_t packetSize_vkWaitSemaphoresKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkWaitSemaphoresKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkWaitSemaphoresKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkWaitSemaphoresKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkWaitSemaphoresKHR = OP_vkWaitSemaphoresKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkWaitSemaphoresKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkWaitSemaphoresKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkWaitSemaphoresKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkWaitSemaphoresKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSemaphoreWaitInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSemaphoreWaitInfo*)(local_pWaitInfo), streamPtrPtr);
+ reservedmarshal_VkSemaphoreWaitInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSemaphoreWaitInfo*)(local_pWaitInfo), streamPtrPtr);
memcpy(*streamPtrPtr, (uint64_t*)&local_timeout, sizeof(uint64_t));
*streamPtrPtr += sizeof(uint64_t);
VkResult vkWaitSemaphoresKHR_VkResult_return = (VkResult)0;
stream->read(&vkWaitSemaphoresKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -22130,13 +31045,34 @@
return vkWaitSemaphoresKHR_VkResult_return;
}
-VkResult VkEncoder::vkSignalSemaphoreKHR(
- VkDevice device,
- const VkSemaphoreSignalInfo* pSignalInfo,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkSignalSemaphoreKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkSignalSemaphoreKHR(device:%p, pSignalInfo:%p)", device, pSignalInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -22144,40 +31080,53 @@
VkSemaphoreSignalInfo* local_pSignalInfo;
local_device = device;
local_pSignalInfo = nullptr;
- if (pSignalInfo)
- {
- local_pSignalInfo = (VkSemaphoreSignalInfo*)pool->alloc(sizeof(const VkSemaphoreSignalInfo));
- deepcopy_VkSemaphoreSignalInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSignalInfo, (VkSemaphoreSignalInfo*)(local_pSignalInfo));
+ if (pSignalInfo) {
+ local_pSignalInfo =
+ (VkSemaphoreSignalInfo*)pool->alloc(sizeof(const VkSemaphoreSignalInfo));
+ deepcopy_VkSemaphoreSignalInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSignalInfo,
+ (VkSemaphoreSignalInfo*)(local_pSignalInfo));
}
- if (local_pSignalInfo)
- {
- transform_tohost_VkSemaphoreSignalInfo(sResourceTracker, (VkSemaphoreSignalInfo*)(local_pSignalInfo));
+ if (local_pSignalInfo) {
+ transform_tohost_VkSemaphoreSignalInfo(sResourceTracker,
+ (VkSemaphoreSignalInfo*)(local_pSignalInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSemaphoreSignalInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSemaphoreSignalInfo*)(local_pSignalInfo), countPtr);
+ count_VkSemaphoreSignalInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSemaphoreSignalInfo*)(local_pSignalInfo), countPtr);
}
- uint32_t packetSize_vkSignalSemaphoreKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkSignalSemaphoreKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkSignalSemaphoreKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkSignalSemaphoreKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkSignalSemaphoreKHR = OP_vkSignalSemaphoreKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkSignalSemaphoreKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkSignalSemaphoreKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkSignalSemaphoreKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkSignalSemaphoreKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSemaphoreSignalInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSemaphoreSignalInfo*)(local_pSignalInfo), streamPtrPtr);
+ reservedmarshal_VkSemaphoreSignalInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSemaphoreSignalInfo*)(local_pSignalInfo),
+ streamPtrPtr);
VkResult vkSignalSemaphoreKHR_VkResult_return = (VkResult)0;
stream->read(&vkSignalSemaphoreKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -22192,13 +31141,38 @@
#endif
#ifdef VK_KHR_fragment_shading_rate
VkResult VkEncoder::vkGetPhysicalDeviceFragmentShadingRatesKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t* pFragmentShadingRateCount,
- VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount,
+ VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceFragmentShadingRatesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice:%p, "
+ "pFragmentShadingRateCount:%p, pFragmentShadingRates:%p)",
+ physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -22211,31 +31185,41 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pFragmentShadingRateCount)
- {
+ if (pFragmentShadingRateCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pFragmentShadingRates)
- {
- if (pFragmentShadingRateCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pFragmentShadingRateCount)); ++i)
- {
- count_VkPhysicalDeviceFragmentShadingRateKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFragmentShadingRateKHR*)(pFragmentShadingRates + i), countPtr);
+ if (pFragmentShadingRates) {
+ if (pFragmentShadingRateCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pFragmentShadingRateCount)); ++i) {
+ count_VkPhysicalDeviceFragmentShadingRateKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceFragmentShadingRateKHR*)(pFragmentShadingRates + i),
+ countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPhysicalDeviceFragmentShadingRatesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceFragmentShadingRatesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceFragmentShadingRatesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceFragmentShadingRatesKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceFragmentShadingRatesKHR = OP_vkGetPhysicalDeviceFragmentShadingRatesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceFragmentShadingRatesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceFragmentShadingRatesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceFragmentShadingRatesKHR =
+ OP_vkGetPhysicalDeviceFragmentShadingRatesKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceFragmentShadingRatesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceFragmentShadingRatesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -22245,8 +31229,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pFragmentShadingRateCount)
- {
+ if (pFragmentShadingRateCount) {
memcpy(*streamPtrPtr, (uint32_t*)pFragmentShadingRateCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -22255,56 +31238,53 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pFragmentShadingRates)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pFragmentShadingRateCount)); ++i)
- {
- reservedmarshal_VkPhysicalDeviceFragmentShadingRateKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFragmentShadingRateKHR*)(pFragmentShadingRates + i), streamPtrPtr);
+ if (pFragmentShadingRates) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pFragmentShadingRateCount)); ++i) {
+ reservedmarshal_VkPhysicalDeviceFragmentShadingRateKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceFragmentShadingRateKHR*)(pFragmentShadingRates + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pFragmentShadingRateCount;
check_pFragmentShadingRateCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pFragmentShadingRateCount)
- {
- if (!(check_pFragmentShadingRateCount))
- {
- fprintf(stderr, "fatal: pFragmentShadingRateCount inconsistent between guest and host\n");
+ if (pFragmentShadingRateCount) {
+ if (!(check_pFragmentShadingRateCount)) {
+ fprintf(stderr,
+ "fatal: pFragmentShadingRateCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pFragmentShadingRateCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
VkPhysicalDeviceFragmentShadingRateKHR* check_pFragmentShadingRates;
- check_pFragmentShadingRates = (VkPhysicalDeviceFragmentShadingRateKHR*)(uintptr_t)stream->getBe64();
- if (pFragmentShadingRates)
- {
- if (!(check_pFragmentShadingRates))
- {
+ check_pFragmentShadingRates =
+ (VkPhysicalDeviceFragmentShadingRateKHR*)(uintptr_t)stream->getBe64();
+ if (pFragmentShadingRates) {
+ if (!(check_pFragmentShadingRates)) {
fprintf(stderr, "fatal: pFragmentShadingRates inconsistent between guest and host\n");
}
- if (pFragmentShadingRateCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pFragmentShadingRateCount)); ++i)
- {
- unmarshal_VkPhysicalDeviceFragmentShadingRateKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceFragmentShadingRateKHR*)(pFragmentShadingRates + i));
+ if (pFragmentShadingRateCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pFragmentShadingRateCount)); ++i) {
+ unmarshal_VkPhysicalDeviceFragmentShadingRateKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceFragmentShadingRateKHR*)(pFragmentShadingRates + i));
}
}
}
- if (pFragmentShadingRateCount)
- {
- if (pFragmentShadingRates)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pFragmentShadingRateCount)); ++i)
- {
- transform_fromhost_VkPhysicalDeviceFragmentShadingRateKHR(sResourceTracker, (VkPhysicalDeviceFragmentShadingRateKHR*)(pFragmentShadingRates + i));
+ if (pFragmentShadingRateCount) {
+ if (pFragmentShadingRates) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pFragmentShadingRateCount)); ++i) {
+ transform_fromhost_VkPhysicalDeviceFragmentShadingRateKHR(
+ sResourceTracker,
+ (VkPhysicalDeviceFragmentShadingRateKHR*)(pFragmentShadingRates + i));
}
}
}
VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDeviceFragmentShadingRatesKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -22313,13 +31293,35 @@
}
void VkEncoder::vkCmdSetFragmentShadingRateKHR(
- VkCommandBuffer commandBuffer,
- const VkExtent2D* pFragmentSize,
- const VkFragmentShadingRateCombinerOpKHR combinerOps[2],
- uint32_t doLock)
-{
+ VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize,
+ const VkFragmentShadingRateCombinerOpKHR combinerOps[2], uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetFragmentShadingRateKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetFragmentShadingRateKHR(commandBuffer:%p, pFragmentSize:%p)",
+ commandBuffer, pFragmentSize);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -22328,14 +31330,13 @@
VkFragmentShadingRateCombinerOpKHR local_combinerOps[2];
local_commandBuffer = commandBuffer;
local_pFragmentSize = nullptr;
- if (pFragmentSize)
- {
+ if (pFragmentSize) {
local_pFragmentSize = (VkExtent2D*)pool->alloc(sizeof(const VkExtent2D));
- deepcopy_VkExtent2D(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pFragmentSize, (VkExtent2D*)(local_pFragmentSize));
+ deepcopy_VkExtent2D(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pFragmentSize,
+ (VkExtent2D*)(local_pFragmentSize));
}
memcpy(local_combinerOps, combinerOps, 2 * sizeof(const VkFragmentShadingRateCombinerOpKHR));
- if (local_pFragmentSize)
- {
+ if (local_pFragmentSize) {
transform_tohost_VkExtent2D(sResourceTracker, (VkExtent2D*)(local_pFragmentSize));
}
size_t count = 0;
@@ -22343,29 +31344,35 @@
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkExtent2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(local_pFragmentSize), countPtr);
+ count_VkExtent2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExtent2D*)(local_pFragmentSize), countPtr);
*countPtr += 2 * sizeof(VkFragmentShadingRateCombinerOpKHR);
}
uint32_t packetSize_vkCmdSetFragmentShadingRateKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdSetFragmentShadingRateKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetFragmentShadingRateKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetFragmentShadingRateKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetFragmentShadingRateKHR = OP_vkCmdSetFragmentShadingRateKHR;
- memcpy(streamPtr, &opcode_vkCmdSetFragmentShadingRateKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetFragmentShadingRateKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetFragmentShadingRateKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetFragmentShadingRateKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkExtent2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(local_pFragmentSize), streamPtrPtr);
- memcpy(*streamPtrPtr, (VkFragmentShadingRateCombinerOpKHR*)local_combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
+ reservedmarshal_VkExtent2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExtent2D*)(local_pFragmentSize), streamPtrPtr);
+ memcpy(*streamPtrPtr, (VkFragmentShadingRateCombinerOpKHR*)local_combinerOps,
+ 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
*streamPtrPtr += 2 * sizeof(VkFragmentShadingRateCombinerOpKHR);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -22380,15 +31387,35 @@
#ifdef VK_KHR_separate_depth_stencil_layouts
#endif
#ifdef VK_KHR_present_wait
-VkResult VkEncoder::vkWaitForPresentKHR(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint64_t presentId,
- uint64_t timeout,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain,
+ uint64_t presentId, uint64_t timeout, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkWaitForPresentKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkWaitForPresentKHR(device:%p, swapchain:%p, presentId:%ld, timeout:%ld)",
+ device, swapchain, presentId, timeout);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -22410,14 +31437,23 @@
*countPtr += sizeof(uint64_t);
*countPtr += sizeof(uint64_t);
}
- uint32_t packetSize_vkWaitForPresentKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkWaitForPresentKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkWaitForPresentKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkWaitForPresentKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkWaitForPresentKHR = OP_vkWaitForPresentKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkWaitForPresentKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkWaitForPresentKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkWaitForPresentKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkWaitForPresentKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -22432,9 +31468,9 @@
*streamPtrPtr += sizeof(uint64_t);
VkResult vkWaitForPresentKHR_VkResult_return = (VkResult)0;
stream->read(&vkWaitForPresentKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -22446,13 +31482,35 @@
#ifdef VK_KHR_uniform_buffer_standard_layout
#endif
#ifdef VK_KHR_buffer_device_address
-VkDeviceAddress VkEncoder::vkGetBufferDeviceAddressKHR(
- VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo,
- uint32_t doLock)
-{
+VkDeviceAddress VkEncoder::vkGetBufferDeviceAddressKHR(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetBufferDeviceAddressKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetBufferDeviceAddressKHR(device:%p, pInfo:%p)", device, pInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -22460,40 +31518,53 @@
VkBufferDeviceAddressInfo* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkBufferDeviceAddressInfo*)pool->alloc(sizeof(const VkBufferDeviceAddressInfo));
- deepcopy_VkBufferDeviceAddressInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkBufferDeviceAddressInfo*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo =
+ (VkBufferDeviceAddressInfo*)pool->alloc(sizeof(const VkBufferDeviceAddressInfo));
+ deepcopy_VkBufferDeviceAddressInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkBufferDeviceAddressInfo*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkBufferDeviceAddressInfo(sResourceTracker, (VkBufferDeviceAddressInfo*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkBufferDeviceAddressInfo(sResourceTracker,
+ (VkBufferDeviceAddressInfo*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferDeviceAddressInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferDeviceAddressInfo*)(local_pInfo), countPtr);
+ count_VkBufferDeviceAddressInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferDeviceAddressInfo*)(local_pInfo), countPtr);
}
- uint32_t packetSize_vkGetBufferDeviceAddressKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetBufferDeviceAddressKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetBufferDeviceAddressKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferDeviceAddressKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetBufferDeviceAddressKHR = OP_vkGetBufferDeviceAddressKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetBufferDeviceAddressKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetBufferDeviceAddressKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetBufferDeviceAddressKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetBufferDeviceAddressKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferDeviceAddressInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferDeviceAddressInfo*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkBufferDeviceAddressInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferDeviceAddressInfo*)(local_pInfo),
+ streamPtrPtr);
VkDeviceAddress vkGetBufferDeviceAddressKHR_VkDeviceAddress_return = (VkDeviceAddress)0;
stream->read(&vkGetBufferDeviceAddressKHR_VkDeviceAddress_return, sizeof(VkDeviceAddress));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -22501,13 +31572,35 @@
return vkGetBufferDeviceAddressKHR_VkDeviceAddress_return;
}
-uint64_t VkEncoder::vkGetBufferOpaqueCaptureAddressKHR(
- VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo,
- uint32_t doLock)
-{
+uint64_t VkEncoder::vkGetBufferOpaqueCaptureAddressKHR(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetBufferOpaqueCaptureAddressKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetBufferOpaqueCaptureAddressKHR(device:%p, pInfo:%p)", device, pInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -22515,40 +31608,54 @@
VkBufferDeviceAddressInfo* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkBufferDeviceAddressInfo*)pool->alloc(sizeof(const VkBufferDeviceAddressInfo));
- deepcopy_VkBufferDeviceAddressInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkBufferDeviceAddressInfo*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo =
+ (VkBufferDeviceAddressInfo*)pool->alloc(sizeof(const VkBufferDeviceAddressInfo));
+ deepcopy_VkBufferDeviceAddressInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkBufferDeviceAddressInfo*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkBufferDeviceAddressInfo(sResourceTracker, (VkBufferDeviceAddressInfo*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkBufferDeviceAddressInfo(sResourceTracker,
+ (VkBufferDeviceAddressInfo*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferDeviceAddressInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferDeviceAddressInfo*)(local_pInfo), countPtr);
+ count_VkBufferDeviceAddressInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferDeviceAddressInfo*)(local_pInfo), countPtr);
}
- uint32_t packetSize_vkGetBufferOpaqueCaptureAddressKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetBufferOpaqueCaptureAddressKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetBufferOpaqueCaptureAddressKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferOpaqueCaptureAddressKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetBufferOpaqueCaptureAddressKHR = OP_vkGetBufferOpaqueCaptureAddressKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetBufferOpaqueCaptureAddressKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetBufferOpaqueCaptureAddressKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetBufferOpaqueCaptureAddressKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetBufferOpaqueCaptureAddressKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferDeviceAddressInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferDeviceAddressInfo*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkBufferDeviceAddressInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferDeviceAddressInfo*)(local_pInfo),
+ streamPtrPtr);
uint64_t vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
stream->read(&vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return, sizeof(uint64_t));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -22557,12 +31664,35 @@
}
uint64_t VkEncoder::vkGetDeviceMemoryOpaqueCaptureAddressKHR(
- VkDevice device,
- const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo,
- uint32_t doLock)
-{
+ VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetDeviceMemoryOpaqueCaptureAddressKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetDeviceMemoryOpaqueCaptureAddressKHR(device:%p, pInfo:%p)", device,
+ pInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -22570,40 +31700,57 @@
VkDeviceMemoryOpaqueCaptureAddressInfo* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkDeviceMemoryOpaqueCaptureAddressInfo*)pool->alloc(sizeof(const VkDeviceMemoryOpaqueCaptureAddressInfo));
- deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkDeviceMemoryOpaqueCaptureAddressInfo*)pool->alloc(
+ sizeof(const VkDeviceMemoryOpaqueCaptureAddressInfo));
+ deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfo(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkDeviceMemoryOpaqueCaptureAddressInfo(sResourceTracker, (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkDeviceMemoryOpaqueCaptureAddressInfo(
+ sResourceTracker, (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDeviceMemoryOpaqueCaptureAddressInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo), countPtr);
+ count_VkDeviceMemoryOpaqueCaptureAddressInfo(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo), countPtr);
}
- uint32_t packetSize_vkGetDeviceMemoryOpaqueCaptureAddressKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDeviceMemoryOpaqueCaptureAddressKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDeviceMemoryOpaqueCaptureAddressKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceMemoryOpaqueCaptureAddressKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetDeviceMemoryOpaqueCaptureAddressKHR = OP_vkGetDeviceMemoryOpaqueCaptureAddressKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDeviceMemoryOpaqueCaptureAddressKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDeviceMemoryOpaqueCaptureAddressKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetDeviceMemoryOpaqueCaptureAddressKHR =
+ OP_vkGetDeviceMemoryOpaqueCaptureAddressKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDeviceMemoryOpaqueCaptureAddressKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDeviceMemoryOpaqueCaptureAddressKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceMemoryOpaqueCaptureAddressInfo*)(local_pInfo),
+ streamPtrPtr);
uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
stream->read(&vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return, sizeof(uint64_t));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -22613,14 +31760,38 @@
#endif
#ifdef VK_KHR_deferred_host_operations
-VkResult VkEncoder::vkCreateDeferredOperationKHR(
- VkDevice device,
- const VkAllocationCallbacks* pAllocator,
- VkDeferredOperationKHR* pDeferredOperation,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateDeferredOperationKHR(VkDevice device,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeferredOperationKHR* pDeferredOperation,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateDeferredOperationKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateDeferredOperationKHR(device:%p, pAllocator:%p, pDeferredOperation:%p)", device,
+ pAllocator, pDeferredOperation);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -22628,15 +31799,15 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -22645,20 +31816,30 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
*countPtr += 8;
}
- uint32_t packetSize_vkCreateDeferredOperationKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateDeferredOperationKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCreateDeferredOperationKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateDeferredOperationKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateDeferredOperationKHR = OP_vkCreateDeferredOperationKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateDeferredOperationKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateDeferredOperationKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateDeferredOperationKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateDeferredOperationKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -22668,9 +31849,10 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
uint64_t cgen_var_2 = (uint64_t)(*pDeferredOperation);
memcpy((*streamPtrPtr), &cgen_var_2, 8);
@@ -22679,9 +31861,9 @@
(*pDeferredOperation) = (VkDeferredOperationKHR)stream->getBe64();
VkResult vkCreateDeferredOperationKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateDeferredOperationKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -22689,14 +31871,36 @@
return vkCreateDeferredOperationKHR_VkResult_return;
}
-void VkEncoder::vkDestroyDeferredOperationKHR(
- VkDevice device,
- VkDeferredOperationKHR operation,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation,
+ const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyDeferredOperationKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyDeferredOperationKHR(device:%p, pAllocator:%p)", device,
+ pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -22706,15 +31910,15 @@
local_device = device;
local_operation = operation;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -22724,19 +31928,29 @@
*countPtr += 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyDeferredOperationKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyDeferredOperationKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkDestroyDeferredOperationKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyDeferredOperationKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyDeferredOperationKHR = OP_vkDestroyDeferredOperationKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyDeferredOperationKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyDeferredOperationKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyDeferredOperationKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyDeferredOperationKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -22750,27 +31964,51 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-uint32_t VkEncoder::vkGetDeferredOperationMaxConcurrencyKHR(
- VkDevice device,
- VkDeferredOperationKHR operation,
- uint32_t doLock)
-{
+uint32_t VkEncoder::vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device,
+ VkDeferredOperationKHR operation,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetDeferredOperationMaxConcurrencyKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetDeferredOperationMaxConcurrencyKHR(device:%p)", device);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -22785,14 +32023,25 @@
*countPtr += 1 * 8;
*countPtr += 8;
}
- uint32_t packetSize_vkGetDeferredOperationMaxConcurrencyKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDeferredOperationMaxConcurrencyKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDeferredOperationMaxConcurrencyKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeferredOperationMaxConcurrencyKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetDeferredOperationMaxConcurrencyKHR = OP_vkGetDeferredOperationMaxConcurrencyKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDeferredOperationMaxConcurrencyKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDeferredOperationMaxConcurrencyKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetDeferredOperationMaxConcurrencyKHR =
+ OP_vkGetDeferredOperationMaxConcurrencyKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDeferredOperationMaxConcurrencyKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDeferredOperationMaxConcurrencyKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -22803,9 +32052,9 @@
*streamPtrPtr += 8;
uint32_t vkGetDeferredOperationMaxConcurrencyKHR_uint32_t_return = (uint32_t)0;
stream->read(&vkGetDeferredOperationMaxConcurrencyKHR_uint32_t_return, sizeof(uint32_t));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -22813,13 +32062,35 @@
return vkGetDeferredOperationMaxConcurrencyKHR_uint32_t_return;
}
-VkResult VkEncoder::vkGetDeferredOperationResultKHR(
- VkDevice device,
- VkDeferredOperationKHR operation,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetDeferredOperationResultKHR(VkDevice device,
+ VkDeferredOperationKHR operation,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetDeferredOperationResultKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetDeferredOperationResultKHR(device:%p)", device);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -22834,14 +32105,24 @@
*countPtr += 1 * 8;
*countPtr += 8;
}
- uint32_t packetSize_vkGetDeferredOperationResultKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDeferredOperationResultKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDeferredOperationResultKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeferredOperationResultKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDeferredOperationResultKHR = OP_vkGetDeferredOperationResultKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDeferredOperationResultKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDeferredOperationResultKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDeferredOperationResultKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDeferredOperationResultKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -22852,9 +32133,9 @@
*streamPtrPtr += 8;
VkResult vkGetDeferredOperationResultKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetDeferredOperationResultKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -22862,13 +32143,34 @@
return vkGetDeferredOperationResultKHR_VkResult_return;
}
-VkResult VkEncoder::vkDeferredOperationJoinKHR(
- VkDevice device,
- VkDeferredOperationKHR operation,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDeferredOperationJoinKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDeferredOperationJoinKHR(device:%p)", device);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -22883,14 +32185,23 @@
*countPtr += 1 * 8;
*countPtr += 8;
}
- uint32_t packetSize_vkDeferredOperationJoinKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDeferredOperationJoinKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDeferredOperationJoinKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkDeferredOperationJoinKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDeferredOperationJoinKHR = OP_vkDeferredOperationJoinKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDeferredOperationJoinKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDeferredOperationJoinKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDeferredOperationJoinKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDeferredOperationJoinKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -22901,9 +32212,9 @@
*streamPtrPtr += 8;
VkResult vkDeferredOperationJoinKHR_VkResult_return = (VkResult)0;
stream->read(&vkDeferredOperationJoinKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -22914,14 +32225,37 @@
#endif
#ifdef VK_KHR_pipeline_executable_properties
VkResult VkEncoder::vkGetPipelineExecutablePropertiesKHR(
- VkDevice device,
- const VkPipelineInfoKHR* pPipelineInfo,
- uint32_t* pExecutableCount,
- VkPipelineExecutablePropertiesKHR* pProperties,
- uint32_t doLock)
-{
+ VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount,
+ VkPipelineExecutablePropertiesKHR* pProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetPipelineExecutablePropertiesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPipelineExecutablePropertiesKHR(device:%p, pPipelineInfo:%p, pExecutableCount:%p, "
+ "pProperties:%p)",
+ device, pPipelineInfo, pExecutableCount, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -22929,60 +32263,69 @@
VkPipelineInfoKHR* local_pPipelineInfo;
local_device = device;
local_pPipelineInfo = nullptr;
- if (pPipelineInfo)
- {
+ if (pPipelineInfo) {
local_pPipelineInfo = (VkPipelineInfoKHR*)pool->alloc(sizeof(const VkPipelineInfoKHR));
- deepcopy_VkPipelineInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pPipelineInfo, (VkPipelineInfoKHR*)(local_pPipelineInfo));
+ deepcopy_VkPipelineInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pPipelineInfo,
+ (VkPipelineInfoKHR*)(local_pPipelineInfo));
}
- if (local_pPipelineInfo)
- {
- transform_tohost_VkPipelineInfoKHR(sResourceTracker, (VkPipelineInfoKHR*)(local_pPipelineInfo));
+ if (local_pPipelineInfo) {
+ transform_tohost_VkPipelineInfoKHR(sResourceTracker,
+ (VkPipelineInfoKHR*)(local_pPipelineInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPipelineInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineInfoKHR*)(local_pPipelineInfo), countPtr);
+ count_VkPipelineInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPipelineInfoKHR*)(local_pPipelineInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (pExecutableCount)
- {
+ if (pExecutableCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pProperties)
- {
- if (pExecutableCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pExecutableCount)); ++i)
- {
- count_VkPipelineExecutablePropertiesKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutablePropertiesKHR*)(pProperties + i), countPtr);
+ if (pProperties) {
+ if (pExecutableCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pExecutableCount)); ++i) {
+ count_VkPipelineExecutablePropertiesKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPipelineExecutablePropertiesKHR*)(pProperties + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPipelineExecutablePropertiesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPipelineExecutablePropertiesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPipelineExecutablePropertiesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPipelineExecutablePropertiesKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPipelineExecutablePropertiesKHR = OP_vkGetPipelineExecutablePropertiesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPipelineExecutablePropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPipelineExecutablePropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPipelineExecutablePropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPipelineExecutablePropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPipelineInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineInfoKHR*)(local_pPipelineInfo), streamPtrPtr);
+ reservedmarshal_VkPipelineInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPipelineInfoKHR*)(local_pPipelineInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)pExecutableCount;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pExecutableCount)
- {
+ if (pExecutableCount) {
memcpy(*streamPtrPtr, (uint32_t*)pExecutableCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -22991,20 +32334,18 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pExecutableCount)); ++i)
- {
- reservedmarshal_VkPipelineExecutablePropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutablePropertiesKHR*)(pProperties + i), streamPtrPtr);
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pExecutableCount)); ++i) {
+ reservedmarshal_VkPipelineExecutablePropertiesKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPipelineExecutablePropertiesKHR*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pExecutableCount;
check_pExecutableCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pExecutableCount)
- {
- if (!(check_pExecutableCount))
- {
+ if (pExecutableCount) {
+ if (!(check_pExecutableCount)) {
fprintf(stderr, "fatal: pExecutableCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pExecutableCount, sizeof(uint32_t));
@@ -23012,35 +32353,31 @@
// WARNING PTR CHECK
VkPipelineExecutablePropertiesKHR* check_pProperties;
check_pProperties = (VkPipelineExecutablePropertiesKHR*)(uintptr_t)stream->getBe64();
- if (pProperties)
- {
- if (!(check_pProperties))
- {
+ if (pProperties) {
+ if (!(check_pProperties)) {
fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
}
- if (pExecutableCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pExecutableCount)); ++i)
- {
- unmarshal_VkPipelineExecutablePropertiesKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutablePropertiesKHR*)(pProperties + i));
+ if (pExecutableCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pExecutableCount)); ++i) {
+ unmarshal_VkPipelineExecutablePropertiesKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPipelineExecutablePropertiesKHR*)(pProperties + i));
}
}
}
- if (pExecutableCount)
- {
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pExecutableCount)); ++i)
- {
- transform_fromhost_VkPipelineExecutablePropertiesKHR(sResourceTracker, (VkPipelineExecutablePropertiesKHR*)(pProperties + i));
+ if (pExecutableCount) {
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pExecutableCount)); ++i) {
+ transform_fromhost_VkPipelineExecutablePropertiesKHR(
+ sResourceTracker, (VkPipelineExecutablePropertiesKHR*)(pProperties + i));
}
}
}
VkResult vkGetPipelineExecutablePropertiesKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetPipelineExecutablePropertiesKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -23049,14 +32386,37 @@
}
VkResult VkEncoder::vkGetPipelineExecutableStatisticsKHR(
- VkDevice device,
- const VkPipelineExecutableInfoKHR* pExecutableInfo,
- uint32_t* pStatisticCount,
- VkPipelineExecutableStatisticKHR* pStatistics,
- uint32_t doLock)
-{
+ VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount,
+ VkPipelineExecutableStatisticKHR* pStatistics, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetPipelineExecutableStatisticsKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPipelineExecutableStatisticsKHR(device:%p, pExecutableInfo:%p, pStatisticCount:%p, "
+ "pStatistics:%p)",
+ device, pExecutableInfo, pStatisticCount, pStatistics);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -23064,60 +32424,72 @@
VkPipelineExecutableInfoKHR* local_pExecutableInfo;
local_device = device;
local_pExecutableInfo = nullptr;
- if (pExecutableInfo)
- {
- local_pExecutableInfo = (VkPipelineExecutableInfoKHR*)pool->alloc(sizeof(const VkPipelineExecutableInfoKHR));
- deepcopy_VkPipelineExecutableInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExecutableInfo, (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo));
+ if (pExecutableInfo) {
+ local_pExecutableInfo =
+ (VkPipelineExecutableInfoKHR*)pool->alloc(sizeof(const VkPipelineExecutableInfoKHR));
+ deepcopy_VkPipelineExecutableInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExecutableInfo,
+ (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo));
}
- if (local_pExecutableInfo)
- {
- transform_tohost_VkPipelineExecutableInfoKHR(sResourceTracker, (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo));
+ if (local_pExecutableInfo) {
+ transform_tohost_VkPipelineExecutableInfoKHR(
+ sResourceTracker, (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPipelineExecutableInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo), countPtr);
+ count_VkPipelineExecutableInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo),
+ countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (pStatisticCount)
- {
+ if (pStatisticCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pStatistics)
- {
- if (pStatisticCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pStatisticCount)); ++i)
- {
- count_VkPipelineExecutableStatisticKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutableStatisticKHR*)(pStatistics + i), countPtr);
+ if (pStatistics) {
+ if (pStatisticCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pStatisticCount)); ++i) {
+ count_VkPipelineExecutableStatisticKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPipelineExecutableStatisticKHR*)(pStatistics + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPipelineExecutableStatisticsKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPipelineExecutableStatisticsKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPipelineExecutableStatisticsKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPipelineExecutableStatisticsKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPipelineExecutableStatisticsKHR = OP_vkGetPipelineExecutableStatisticsKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPipelineExecutableStatisticsKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPipelineExecutableStatisticsKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPipelineExecutableStatisticsKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPipelineExecutableStatisticsKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPipelineExecutableInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo), streamPtrPtr);
+ reservedmarshal_VkPipelineExecutableInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)pStatisticCount;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pStatisticCount)
- {
+ if (pStatisticCount) {
memcpy(*streamPtrPtr, (uint32_t*)pStatisticCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -23126,20 +32498,18 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pStatistics)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pStatisticCount)); ++i)
- {
- reservedmarshal_VkPipelineExecutableStatisticKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutableStatisticKHR*)(pStatistics + i), streamPtrPtr);
+ if (pStatistics) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pStatisticCount)); ++i) {
+ reservedmarshal_VkPipelineExecutableStatisticKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPipelineExecutableStatisticKHR*)(pStatistics + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pStatisticCount;
check_pStatisticCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pStatisticCount)
- {
- if (!(check_pStatisticCount))
- {
+ if (pStatisticCount) {
+ if (!(check_pStatisticCount)) {
fprintf(stderr, "fatal: pStatisticCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pStatisticCount, sizeof(uint32_t));
@@ -23147,35 +32517,31 @@
// WARNING PTR CHECK
VkPipelineExecutableStatisticKHR* check_pStatistics;
check_pStatistics = (VkPipelineExecutableStatisticKHR*)(uintptr_t)stream->getBe64();
- if (pStatistics)
- {
- if (!(check_pStatistics))
- {
+ if (pStatistics) {
+ if (!(check_pStatistics)) {
fprintf(stderr, "fatal: pStatistics inconsistent between guest and host\n");
}
- if (pStatisticCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pStatisticCount)); ++i)
- {
- unmarshal_VkPipelineExecutableStatisticKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutableStatisticKHR*)(pStatistics + i));
+ if (pStatisticCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pStatisticCount)); ++i) {
+ unmarshal_VkPipelineExecutableStatisticKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPipelineExecutableStatisticKHR*)(pStatistics + i));
}
}
}
- if (pStatisticCount)
- {
- if (pStatistics)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pStatisticCount)); ++i)
- {
- transform_fromhost_VkPipelineExecutableStatisticKHR(sResourceTracker, (VkPipelineExecutableStatisticKHR*)(pStatistics + i));
+ if (pStatisticCount) {
+ if (pStatistics) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pStatisticCount)); ++i) {
+ transform_fromhost_VkPipelineExecutableStatisticKHR(
+ sResourceTracker, (VkPipelineExecutableStatisticKHR*)(pStatistics + i));
}
}
}
VkResult vkGetPipelineExecutableStatisticsKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetPipelineExecutableStatisticsKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -23184,14 +32550,39 @@
}
VkResult VkEncoder::vkGetPipelineExecutableInternalRepresentationsKHR(
- VkDevice device,
- const VkPipelineExecutableInfoKHR* pExecutableInfo,
+ VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo,
uint32_t* pInternalRepresentationCount,
- VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations,
- uint32_t doLock)
-{
+ VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPipelineExecutableInternalRepresentationsKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPipelineExecutableInternalRepresentationsKHR(device:%p, pExecutableInfo:%p, "
+ "pInternalRepresentationCount:%p, pInternalRepresentations:%p)",
+ device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -23199,60 +32590,77 @@
VkPipelineExecutableInfoKHR* local_pExecutableInfo;
local_device = device;
local_pExecutableInfo = nullptr;
- if (pExecutableInfo)
- {
- local_pExecutableInfo = (VkPipelineExecutableInfoKHR*)pool->alloc(sizeof(const VkPipelineExecutableInfoKHR));
- deepcopy_VkPipelineExecutableInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExecutableInfo, (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo));
+ if (pExecutableInfo) {
+ local_pExecutableInfo =
+ (VkPipelineExecutableInfoKHR*)pool->alloc(sizeof(const VkPipelineExecutableInfoKHR));
+ deepcopy_VkPipelineExecutableInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExecutableInfo,
+ (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo));
}
- if (local_pExecutableInfo)
- {
- transform_tohost_VkPipelineExecutableInfoKHR(sResourceTracker, (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo));
+ if (local_pExecutableInfo) {
+ transform_tohost_VkPipelineExecutableInfoKHR(
+ sResourceTracker, (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPipelineExecutableInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo), countPtr);
+ count_VkPipelineExecutableInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo),
+ countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (pInternalRepresentationCount)
- {
+ if (pInternalRepresentationCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pInternalRepresentations)
- {
- if (pInternalRepresentationCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pInternalRepresentationCount)); ++i)
- {
- count_VkPipelineExecutableInternalRepresentationKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutableInternalRepresentationKHR*)(pInternalRepresentations + i), countPtr);
+ if (pInternalRepresentations) {
+ if (pInternalRepresentationCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pInternalRepresentationCount)); ++i) {
+ count_VkPipelineExecutableInternalRepresentationKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPipelineExecutableInternalRepresentationKHR*)(pInternalRepresentations +
+ i),
+ countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPipelineExecutableInternalRepresentationsKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- uint8_t* streamPtr = stream->reserve(packetSize_vkGetPipelineExecutableInternalRepresentationsKHR);
+ uint32_t packetSize_vkGetPipelineExecutableInternalRepresentationsKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPipelineExecutableInternalRepresentationsKHR);
+ uint8_t* streamPtr =
+ stream->reserve(packetSize_vkGetPipelineExecutableInternalRepresentationsKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPipelineExecutableInternalRepresentationsKHR = OP_vkGetPipelineExecutableInternalRepresentationsKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPipelineExecutableInternalRepresentationsKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPipelineExecutableInternalRepresentationsKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPipelineExecutableInternalRepresentationsKHR =
+ OP_vkGetPipelineExecutableInternalRepresentationsKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPipelineExecutableInternalRepresentationsKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPipelineExecutableInternalRepresentationsKHR,
+ sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPipelineExecutableInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo), streamPtrPtr);
+ reservedmarshal_VkPipelineExecutableInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutableInfoKHR*)(local_pExecutableInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)pInternalRepresentationCount;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pInternalRepresentationCount)
- {
+ if (pInternalRepresentationCount) {
memcpy(*streamPtrPtr, (uint32_t*)pInternalRepresentationCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -23261,56 +32669,56 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pInternalRepresentations)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pInternalRepresentationCount)); ++i)
- {
- reservedmarshal_VkPipelineExecutableInternalRepresentationKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutableInternalRepresentationKHR*)(pInternalRepresentations + i), streamPtrPtr);
+ if (pInternalRepresentations) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pInternalRepresentationCount)); ++i) {
+ reservedmarshal_VkPipelineExecutableInternalRepresentationKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPipelineExecutableInternalRepresentationKHR*)(pInternalRepresentations + i),
+ streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pInternalRepresentationCount;
check_pInternalRepresentationCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pInternalRepresentationCount)
- {
- if (!(check_pInternalRepresentationCount))
- {
- fprintf(stderr, "fatal: pInternalRepresentationCount inconsistent between guest and host\n");
+ if (pInternalRepresentationCount) {
+ if (!(check_pInternalRepresentationCount)) {
+ fprintf(stderr,
+ "fatal: pInternalRepresentationCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pInternalRepresentationCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
VkPipelineExecutableInternalRepresentationKHR* check_pInternalRepresentations;
- check_pInternalRepresentations = (VkPipelineExecutableInternalRepresentationKHR*)(uintptr_t)stream->getBe64();
- if (pInternalRepresentations)
- {
- if (!(check_pInternalRepresentations))
- {
- fprintf(stderr, "fatal: pInternalRepresentations inconsistent between guest and host\n");
+ check_pInternalRepresentations =
+ (VkPipelineExecutableInternalRepresentationKHR*)(uintptr_t)stream->getBe64();
+ if (pInternalRepresentations) {
+ if (!(check_pInternalRepresentations)) {
+ fprintf(stderr,
+ "fatal: pInternalRepresentations inconsistent between guest and host\n");
}
- if (pInternalRepresentationCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pInternalRepresentationCount)); ++i)
- {
- unmarshal_VkPipelineExecutableInternalRepresentationKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPipelineExecutableInternalRepresentationKHR*)(pInternalRepresentations + i));
+ if (pInternalRepresentationCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pInternalRepresentationCount)); ++i) {
+ unmarshal_VkPipelineExecutableInternalRepresentationKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPipelineExecutableInternalRepresentationKHR*)(pInternalRepresentations + i));
}
}
}
- if (pInternalRepresentationCount)
- {
- if (pInternalRepresentations)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pInternalRepresentationCount)); ++i)
- {
- transform_fromhost_VkPipelineExecutableInternalRepresentationKHR(sResourceTracker, (VkPipelineExecutableInternalRepresentationKHR*)(pInternalRepresentations + i));
+ if (pInternalRepresentationCount) {
+ if (pInternalRepresentations) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pInternalRepresentationCount)); ++i) {
+ transform_fromhost_VkPipelineExecutableInternalRepresentationKHR(
+ sResourceTracker,
+ (VkPipelineExecutableInternalRepresentationKHR*)(pInternalRepresentations + i));
}
}
}
VkResult vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return = (VkResult)0;
- stream->read(&vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ stream->read(&vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return,
+ sizeof(VkResult));
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -23328,13 +32736,35 @@
#ifdef VK_KHR_present_id
#endif
#ifdef VK_KHR_video_encode_queue
-void VkEncoder::vkCmdEncodeVideoKHR(
- VkCommandBuffer commandBuffer,
- const VkVideoEncodeInfoKHR* pEncodeInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer,
+ const VkVideoEncodeInfoKHR* pEncodeInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdEncodeVideoKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdEncodeVideoKHR(commandBuffer:%p, pEncodeInfo:%p)", commandBuffer,
+ pEncodeInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -23342,40 +32772,44 @@
VkVideoEncodeInfoKHR* local_pEncodeInfo;
local_commandBuffer = commandBuffer;
local_pEncodeInfo = nullptr;
- if (pEncodeInfo)
- {
+ if (pEncodeInfo) {
local_pEncodeInfo = (VkVideoEncodeInfoKHR*)pool->alloc(sizeof(const VkVideoEncodeInfoKHR));
- deepcopy_VkVideoEncodeInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pEncodeInfo, (VkVideoEncodeInfoKHR*)(local_pEncodeInfo));
+ deepcopy_VkVideoEncodeInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pEncodeInfo,
+ (VkVideoEncodeInfoKHR*)(local_pEncodeInfo));
}
- if (local_pEncodeInfo)
- {
- transform_tohost_VkVideoEncodeInfoKHR(sResourceTracker, (VkVideoEncodeInfoKHR*)(local_pEncodeInfo));
+ if (local_pEncodeInfo) {
+ transform_tohost_VkVideoEncodeInfoKHR(sResourceTracker,
+ (VkVideoEncodeInfoKHR*)(local_pEncodeInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkVideoEncodeInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoEncodeInfoKHR*)(local_pEncodeInfo), countPtr);
+ count_VkVideoEncodeInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoEncodeInfoKHR*)(local_pEncodeInfo), countPtr);
}
uint32_t packetSize_vkCmdEncodeVideoKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdEncodeVideoKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEncodeVideoKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdEncodeVideoKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdEncodeVideoKHR = OP_vkCmdEncodeVideoKHR;
- memcpy(streamPtr, &opcode_vkCmdEncodeVideoKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdEncodeVideoKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdEncodeVideoKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdEncodeVideoKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkVideoEncodeInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVideoEncodeInfoKHR*)(local_pEncodeInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkVideoEncodeInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVideoEncodeInfoKHR*)(local_pEncodeInfo), streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -23384,14 +32818,35 @@
#endif
#ifdef VK_KHR_synchronization2
-void VkEncoder::vkCmdSetEvent2KHR(
- VkCommandBuffer commandBuffer,
- VkEvent event,
- const VkDependencyInfoKHR* pDependencyInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
+ const VkDependencyInfoKHR* pDependencyInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetEvent2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetEvent2KHR(commandBuffer:%p, event:%p, pDependencyInfo:%p)",
+ commandBuffer, event, pDependencyInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -23401,14 +32856,15 @@
local_commandBuffer = commandBuffer;
local_event = event;
local_pDependencyInfo = nullptr;
- if (pDependencyInfo)
- {
- local_pDependencyInfo = (VkDependencyInfoKHR*)pool->alloc(sizeof(const VkDependencyInfoKHR));
- deepcopy_VkDependencyInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDependencyInfo, (VkDependencyInfoKHR*)(local_pDependencyInfo));
+ if (pDependencyInfo) {
+ local_pDependencyInfo =
+ (VkDependencyInfoKHR*)pool->alloc(sizeof(const VkDependencyInfoKHR));
+ deepcopy_VkDependencyInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDependencyInfo,
+ (VkDependencyInfoKHR*)(local_pDependencyInfo));
}
- if (local_pDependencyInfo)
- {
- transform_tohost_VkDependencyInfoKHR(sResourceTracker, (VkDependencyInfoKHR*)(local_pDependencyInfo));
+ if (local_pDependencyInfo) {
+ transform_tohost_VkDependencyInfoKHR(sResourceTracker,
+ (VkDependencyInfoKHR*)(local_pDependencyInfo));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -23417,17 +32873,20 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkDependencyInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDependencyInfoKHR*)(local_pDependencyInfo), countPtr);
+ count_VkDependencyInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDependencyInfoKHR*)(local_pDependencyInfo), countPtr);
}
uint32_t packetSize_vkCmdSetEvent2KHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetEvent2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetEvent2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetEvent2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetEvent2KHR = OP_vkCmdSetEvent2KHR;
- memcpy(streamPtr, &opcode_vkCmdSetEvent2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetEvent2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetEvent2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetEvent2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -23437,24 +32896,46 @@
*&cgen_var_0 = get_host_u64_VkEvent((*&local_event));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDependencyInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDependencyInfoKHR*)(local_pDependencyInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkDependencyInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDependencyInfoKHR*)(local_pDependencyInfo),
+ streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdResetEvent2KHR(
- VkCommandBuffer commandBuffer,
- VkEvent event,
- VkPipelineStageFlags2KHR stageMask,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
+ VkPipelineStageFlags2KHR stageMask, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdResetEvent2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdResetEvent2KHR(commandBuffer:%p, event:%p)", commandBuffer, event);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -23474,14 +32955,16 @@
*countPtr += sizeof(VkPipelineStageFlags2KHR);
}
uint32_t packetSize_vkCmdResetEvent2KHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdResetEvent2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdResetEvent2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdResetEvent2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdResetEvent2KHR = OP_vkCmdResetEvent2KHR;
- memcpy(streamPtr, &opcode_vkCmdResetEvent2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdResetEvent2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdResetEvent2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdResetEvent2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -23491,26 +32974,49 @@
*&cgen_var_0 = get_host_u64_VkEvent((*&local_event));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- memcpy(*streamPtrPtr, (VkPipelineStageFlags2KHR*)&local_stageMask, sizeof(VkPipelineStageFlags2KHR));
+ memcpy(*streamPtrPtr, (VkPipelineStageFlags2KHR*)&local_stageMask,
+ sizeof(VkPipelineStageFlags2KHR));
*streamPtrPtr += sizeof(VkPipelineStageFlags2KHR);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdWaitEvents2KHR(
- VkCommandBuffer commandBuffer,
- uint32_t eventCount,
- const VkEvent* pEvents,
- const VkDependencyInfoKHR* pDependencyInfos,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount,
+ const VkEvent* pEvents,
+ const VkDependencyInfoKHR* pDependencyInfos, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdWaitEvents2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdWaitEvents2KHR(commandBuffer:%p, eventCount:%d, pEvents:%p, pDependencyInfos:%p)",
+ commandBuffer, eventCount, pEvents, pDependencyInfos);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -23523,19 +33029,18 @@
// Avoiding deepcopy for pEvents
local_pEvents = (VkEvent*)pEvents;
local_pDependencyInfos = nullptr;
- if (pDependencyInfos)
- {
- local_pDependencyInfos = (VkDependencyInfoKHR*)pool->alloc(((eventCount)) * sizeof(const VkDependencyInfoKHR));
- for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i)
- {
- deepcopy_VkDependencyInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDependencyInfos + i, (VkDependencyInfoKHR*)(local_pDependencyInfos + i));
+ if (pDependencyInfos) {
+ local_pDependencyInfos =
+ (VkDependencyInfoKHR*)pool->alloc(((eventCount)) * sizeof(const VkDependencyInfoKHR));
+ for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
+ deepcopy_VkDependencyInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDependencyInfos + i,
+ (VkDependencyInfoKHR*)(local_pDependencyInfos + i));
}
}
- if (local_pDependencyInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i)
- {
- transform_tohost_VkDependencyInfoKHR(sResourceTracker, (VkDependencyInfoKHR*)(local_pDependencyInfos + i));
+ if (local_pDependencyInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
+ transform_tohost_VkDependencyInfoKHR(
+ sResourceTracker, (VkDependencyInfoKHR*)(local_pDependencyInfos + i));
}
}
size_t count = 0;
@@ -23544,24 +33049,25 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- if (((eventCount)))
- {
+ if (((eventCount))) {
*countPtr += ((eventCount)) * 8;
}
- for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i)
- {
- count_VkDependencyInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDependencyInfoKHR*)(local_pDependencyInfos + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
+ count_VkDependencyInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDependencyInfoKHR*)(local_pDependencyInfos + i), countPtr);
}
}
uint32_t packetSize_vkCmdWaitEvents2KHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdWaitEvents2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdWaitEvents2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdWaitEvents2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdWaitEvents2KHR = OP_vkCmdWaitEvents2KHR;
- memcpy(streamPtr, &opcode_vkCmdWaitEvents2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdWaitEvents2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdWaitEvents2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdWaitEvents2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -23569,36 +33075,58 @@
}
memcpy(*streamPtrPtr, (uint32_t*)&local_eventCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (((eventCount)))
- {
+ if (((eventCount))) {
uint8_t* cgen_var_0_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((eventCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((eventCount)); ++k) {
uint64_t tmpval = get_host_u64_VkEvent(local_pEvents[k]);
memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
*streamPtrPtr += 8 * ((eventCount));
}
- for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i)
- {
- reservedmarshal_VkDependencyInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDependencyInfoKHR*)(local_pDependencyInfos + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
+ reservedmarshal_VkDependencyInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDependencyInfoKHR*)(local_pDependencyInfos + i),
+ streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdPipelineBarrier2KHR(
- VkCommandBuffer commandBuffer,
- const VkDependencyInfoKHR* pDependencyInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,
+ const VkDependencyInfoKHR* pDependencyInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdPipelineBarrier2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdPipelineBarrier2KHR(commandBuffer:%p, pDependencyInfo:%p)",
+ commandBuffer, pDependencyInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -23606,55 +33134,82 @@
VkDependencyInfoKHR* local_pDependencyInfo;
local_commandBuffer = commandBuffer;
local_pDependencyInfo = nullptr;
- if (pDependencyInfo)
- {
- local_pDependencyInfo = (VkDependencyInfoKHR*)pool->alloc(sizeof(const VkDependencyInfoKHR));
- deepcopy_VkDependencyInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDependencyInfo, (VkDependencyInfoKHR*)(local_pDependencyInfo));
+ if (pDependencyInfo) {
+ local_pDependencyInfo =
+ (VkDependencyInfoKHR*)pool->alloc(sizeof(const VkDependencyInfoKHR));
+ deepcopy_VkDependencyInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDependencyInfo,
+ (VkDependencyInfoKHR*)(local_pDependencyInfo));
}
- if (local_pDependencyInfo)
- {
- transform_tohost_VkDependencyInfoKHR(sResourceTracker, (VkDependencyInfoKHR*)(local_pDependencyInfo));
+ if (local_pDependencyInfo) {
+ transform_tohost_VkDependencyInfoKHR(sResourceTracker,
+ (VkDependencyInfoKHR*)(local_pDependencyInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDependencyInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDependencyInfoKHR*)(local_pDependencyInfo), countPtr);
+ count_VkDependencyInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDependencyInfoKHR*)(local_pDependencyInfo), countPtr);
}
uint32_t packetSize_vkCmdPipelineBarrier2KHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdPipelineBarrier2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdPipelineBarrier2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdPipelineBarrier2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdPipelineBarrier2KHR = OP_vkCmdPipelineBarrier2KHR;
- memcpy(streamPtr, &opcode_vkCmdPipelineBarrier2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdPipelineBarrier2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdPipelineBarrier2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdPipelineBarrier2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkDependencyInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDependencyInfoKHR*)(local_pDependencyInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkDependencyInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDependencyInfoKHR*)(local_pDependencyInfo),
+ streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdWriteTimestamp2KHR(
- VkCommandBuffer commandBuffer,
- VkPipelineStageFlags2KHR stage,
- VkQueryPool queryPool,
- uint32_t query,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer,
+ VkPipelineStageFlags2KHR stage, VkQueryPool queryPool,
+ uint32_t query, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdWriteTimestamp2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdWriteTimestamp2KHR(commandBuffer:%p, queryPool:%p, query:%d)",
+ commandBuffer, queryPool, query);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -23677,20 +33232,23 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdWriteTimestamp2KHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdWriteTimestamp2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdWriteTimestamp2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdWriteTimestamp2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdWriteTimestamp2KHR = OP_vkCmdWriteTimestamp2KHR;
- memcpy(streamPtr, &opcode_vkCmdWriteTimestamp2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdWriteTimestamp2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdWriteTimestamp2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdWriteTimestamp2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- memcpy(*streamPtrPtr, (VkPipelineStageFlags2KHR*)&local_stage, sizeof(VkPipelineStageFlags2KHR));
+ memcpy(*streamPtrPtr, (VkPipelineStageFlags2KHR*)&local_stage,
+ sizeof(VkPipelineStageFlags2KHR));
*streamPtrPtr += sizeof(VkPipelineStageFlags2KHR);
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkQueryPool((*&local_queryPool));
@@ -23698,24 +33256,45 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_query, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkQueueSubmit2KHR(
- VkQueue queue,
- uint32_t submitCount,
- const VkSubmitInfo2KHR* pSubmits,
- VkFence fence,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount,
+ const VkSubmitInfo2KHR* pSubmits, VkFence fence,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkQueueSubmit2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkQueueSubmit2KHR(queue:%p, submitCount:%d, pSubmits:%p, fence:%p)", queue,
+ submitCount, pSubmits, fence);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -23726,20 +33305,19 @@
local_queue = queue;
local_submitCount = submitCount;
local_pSubmits = nullptr;
- if (pSubmits)
- {
- local_pSubmits = (VkSubmitInfo2KHR*)pool->alloc(((submitCount)) * sizeof(const VkSubmitInfo2KHR));
- for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
- {
- deepcopy_VkSubmitInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubmits + i, (VkSubmitInfo2KHR*)(local_pSubmits + i));
+ if (pSubmits) {
+ local_pSubmits =
+ (VkSubmitInfo2KHR*)pool->alloc(((submitCount)) * sizeof(const VkSubmitInfo2KHR));
+ for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
+ deepcopy_VkSubmitInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubmits + i,
+ (VkSubmitInfo2KHR*)(local_pSubmits + i));
}
}
local_fence = fence;
- if (local_pSubmits)
- {
- for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
- {
- transform_tohost_VkSubmitInfo2KHR(sResourceTracker, (VkSubmitInfo2KHR*)(local_pSubmits + i));
+ if (local_pSubmits) {
+ for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
+ transform_tohost_VkSubmitInfo2KHR(sResourceTracker,
+ (VkSubmitInfo2KHR*)(local_pSubmits + i));
}
}
size_t count = 0;
@@ -23748,30 +33326,39 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
- {
- count_VkSubmitInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubmitInfo2KHR*)(local_pSubmits + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
+ count_VkSubmitInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubmitInfo2KHR*)(local_pSubmits + i), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 1 * 8;
}
- uint32_t packetSize_vkQueueSubmit2KHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkQueueSubmit2KHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkQueueSubmit2KHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueSubmit2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueSubmit2KHR = OP_vkQueueSubmit2KHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkQueueSubmit2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkQueueSubmit2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkQueueSubmit2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkQueueSubmit2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_submitCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
- {
- reservedmarshal_VkSubmitInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubmitInfo2KHR*)(local_pSubmits + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
+ reservedmarshal_VkSubmitInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubmitInfo2KHR*)(local_pSubmits + i), streamPtrPtr);
}
uint64_t cgen_var_1;
*&cgen_var_1 = get_host_u64_VkFence((*&local_fence));
@@ -23779,9 +33366,9 @@
*streamPtrPtr += 1 * 8;
VkResult vkQueueSubmit2KHR_VkResult_return = (VkResult)0;
stream->read(&vkQueueSubmit2KHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -23789,16 +33376,38 @@
return vkQueueSubmit2KHR_VkResult_return;
}
-void VkEncoder::vkCmdWriteBufferMarker2AMD(
- VkCommandBuffer commandBuffer,
- VkPipelineStageFlags2KHR stage,
- VkBuffer dstBuffer,
- VkDeviceSize dstOffset,
- uint32_t marker,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,
+ VkPipelineStageFlags2KHR stage, VkBuffer dstBuffer,
+ VkDeviceSize dstOffset, uint32_t marker,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdWriteBufferMarker2AMD in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdWriteBufferMarker2AMD(commandBuffer:%p, dstBuffer:%p, dstOffset:%ld, marker:%d)",
+ commandBuffer, dstBuffer, dstOffset, marker);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -23824,20 +33433,23 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdWriteBufferMarker2AMD = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdWriteBufferMarker2AMD);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdWriteBufferMarker2AMD -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdWriteBufferMarker2AMD);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdWriteBufferMarker2AMD = OP_vkCmdWriteBufferMarker2AMD;
- memcpy(streamPtr, &opcode_vkCmdWriteBufferMarker2AMD, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdWriteBufferMarker2AMD, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdWriteBufferMarker2AMD, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdWriteBufferMarker2AMD, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- memcpy(*streamPtrPtr, (VkPipelineStageFlags2KHR*)&local_stage, sizeof(VkPipelineStageFlags2KHR));
+ memcpy(*streamPtrPtr, (VkPipelineStageFlags2KHR*)&local_stage,
+ sizeof(VkPipelineStageFlags2KHR));
*streamPtrPtr += sizeof(VkPipelineStageFlags2KHR);
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkBuffer((*&local_dstBuffer));
@@ -23847,23 +33459,45 @@
*streamPtrPtr += sizeof(VkDeviceSize);
memcpy(*streamPtrPtr, (uint32_t*)&local_marker, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkGetQueueCheckpointData2NV(
- VkQueue queue,
- uint32_t* pCheckpointDataCount,
- VkCheckpointData2NV* pCheckpointData,
- uint32_t doLock)
-{
+void VkEncoder::vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount,
+ VkCheckpointData2NV* pCheckpointData, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetQueueCheckpointData2NV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetQueueCheckpointData2NV(queue:%p, pCheckpointDataCount:%p, pCheckpointData:%p)", queue,
+ pCheckpointDataCount, pCheckpointData);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -23876,31 +33510,38 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pCheckpointDataCount)
- {
+ if (pCheckpointDataCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pCheckpointData)
- {
- if (pCheckpointDataCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
- {
- count_VkCheckpointData2NV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCheckpointData2NV*)(pCheckpointData + i), countPtr);
+ if (pCheckpointData) {
+ if (pCheckpointDataCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i) {
+ count_VkCheckpointData2NV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCheckpointData2NV*)(pCheckpointData + i),
+ countPtr);
}
}
}
}
- uint32_t packetSize_vkGetQueueCheckpointData2NV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetQueueCheckpointData2NV =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetQueueCheckpointData2NV);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetQueueCheckpointData2NV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetQueueCheckpointData2NV = OP_vkGetQueueCheckpointData2NV;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetQueueCheckpointData2NV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetQueueCheckpointData2NV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetQueueCheckpointData2NV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetQueueCheckpointData2NV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -23910,8 +33551,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pCheckpointDataCount)
- {
+ if (pCheckpointDataCount) {
memcpy(*streamPtrPtr, (uint32_t*)pCheckpointDataCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -23920,20 +33560,18 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pCheckpointData)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
- {
- reservedmarshal_VkCheckpointData2NV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCheckpointData2NV*)(pCheckpointData + i), streamPtrPtr);
+ if (pCheckpointData) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i) {
+ reservedmarshal_VkCheckpointData2NV(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCheckpointData2NV*)(pCheckpointData + i),
+ streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pCheckpointDataCount;
check_pCheckpointDataCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pCheckpointDataCount)
- {
- if (!(check_pCheckpointDataCount))
- {
+ if (pCheckpointDataCount) {
+ if (!(check_pCheckpointDataCount)) {
fprintf(stderr, "fatal: pCheckpointDataCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pCheckpointDataCount, sizeof(uint32_t));
@@ -23941,33 +33579,28 @@
// WARNING PTR CHECK
VkCheckpointData2NV* check_pCheckpointData;
check_pCheckpointData = (VkCheckpointData2NV*)(uintptr_t)stream->getBe64();
- if (pCheckpointData)
- {
- if (!(check_pCheckpointData))
- {
+ if (pCheckpointData) {
+ if (!(check_pCheckpointData)) {
fprintf(stderr, "fatal: pCheckpointData inconsistent between guest and host\n");
}
- if (pCheckpointDataCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
- {
- unmarshal_VkCheckpointData2NV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCheckpointData2NV*)(pCheckpointData + i));
+ if (pCheckpointDataCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i) {
+ unmarshal_VkCheckpointData2NV(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCheckpointData2NV*)(pCheckpointData + i));
}
}
}
- if (pCheckpointDataCount)
- {
- if (pCheckpointData)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
- {
- transform_fromhost_VkCheckpointData2NV(sResourceTracker, (VkCheckpointData2NV*)(pCheckpointData + i));
+ if (pCheckpointDataCount) {
+ if (pCheckpointData) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i) {
+ transform_fromhost_VkCheckpointData2NV(sResourceTracker,
+ (VkCheckpointData2NV*)(pCheckpointData + i));
}
}
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -23982,13 +33615,35 @@
#ifdef VK_KHR_workgroup_memory_explicit_layout
#endif
#ifdef VK_KHR_copy_commands2
-void VkEncoder::vkCmdCopyBuffer2KHR(
- VkCommandBuffer commandBuffer,
- const VkCopyBufferInfo2KHR* pCopyBufferInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
+ const VkCopyBufferInfo2KHR* pCopyBufferInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdCopyBuffer2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdCopyBuffer2KHR(commandBuffer:%p, pCopyBufferInfo:%p)", commandBuffer,
+ pCopyBufferInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -23996,53 +33651,81 @@
VkCopyBufferInfo2KHR* local_pCopyBufferInfo;
local_commandBuffer = commandBuffer;
local_pCopyBufferInfo = nullptr;
- if (pCopyBufferInfo)
- {
- local_pCopyBufferInfo = (VkCopyBufferInfo2KHR*)pool->alloc(sizeof(const VkCopyBufferInfo2KHR));
- deepcopy_VkCopyBufferInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyBufferInfo, (VkCopyBufferInfo2KHR*)(local_pCopyBufferInfo));
+ if (pCopyBufferInfo) {
+ local_pCopyBufferInfo =
+ (VkCopyBufferInfo2KHR*)pool->alloc(sizeof(const VkCopyBufferInfo2KHR));
+ deepcopy_VkCopyBufferInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyBufferInfo,
+ (VkCopyBufferInfo2KHR*)(local_pCopyBufferInfo));
}
- if (local_pCopyBufferInfo)
- {
- transform_tohost_VkCopyBufferInfo2KHR(sResourceTracker, (VkCopyBufferInfo2KHR*)(local_pCopyBufferInfo));
+ if (local_pCopyBufferInfo) {
+ transform_tohost_VkCopyBufferInfo2KHR(sResourceTracker,
+ (VkCopyBufferInfo2KHR*)(local_pCopyBufferInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCopyBufferInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyBufferInfo2KHR*)(local_pCopyBufferInfo), countPtr);
+ count_VkCopyBufferInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyBufferInfo2KHR*)(local_pCopyBufferInfo), countPtr);
}
uint32_t packetSize_vkCmdCopyBuffer2KHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyBuffer2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyBuffer2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyBuffer2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdCopyBuffer2KHR = OP_vkCmdCopyBuffer2KHR;
- memcpy(streamPtr, &opcode_vkCmdCopyBuffer2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdCopyBuffer2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdCopyBuffer2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdCopyBuffer2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkCopyBufferInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyBufferInfo2KHR*)(local_pCopyBufferInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkCopyBufferInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyBufferInfo2KHR*)(local_pCopyBufferInfo),
+ streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdCopyImage2KHR(
- VkCommandBuffer commandBuffer,
- const VkCopyImageInfo2KHR* pCopyImageInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer,
+ const VkCopyImageInfo2KHR* pCopyImageInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdCopyImage2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdCopyImage2KHR(commandBuffer:%p, pCopyImageInfo:%p)", commandBuffer,
+ pCopyImageInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -24050,40 +33733,44 @@
VkCopyImageInfo2KHR* local_pCopyImageInfo;
local_commandBuffer = commandBuffer;
local_pCopyImageInfo = nullptr;
- if (pCopyImageInfo)
- {
+ if (pCopyImageInfo) {
local_pCopyImageInfo = (VkCopyImageInfo2KHR*)pool->alloc(sizeof(const VkCopyImageInfo2KHR));
- deepcopy_VkCopyImageInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyImageInfo, (VkCopyImageInfo2KHR*)(local_pCopyImageInfo));
+ deepcopy_VkCopyImageInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyImageInfo,
+ (VkCopyImageInfo2KHR*)(local_pCopyImageInfo));
}
- if (local_pCopyImageInfo)
- {
- transform_tohost_VkCopyImageInfo2KHR(sResourceTracker, (VkCopyImageInfo2KHR*)(local_pCopyImageInfo));
+ if (local_pCopyImageInfo) {
+ transform_tohost_VkCopyImageInfo2KHR(sResourceTracker,
+ (VkCopyImageInfo2KHR*)(local_pCopyImageInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCopyImageInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyImageInfo2KHR*)(local_pCopyImageInfo), countPtr);
+ count_VkCopyImageInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyImageInfo2KHR*)(local_pCopyImageInfo), countPtr);
}
uint32_t packetSize_vkCmdCopyImage2KHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyImage2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyImage2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyImage2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdCopyImage2KHR = OP_vkCmdCopyImage2KHR;
- memcpy(streamPtr, &opcode_vkCmdCopyImage2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdCopyImage2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdCopyImage2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdCopyImage2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkCopyImageInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyImageInfo2KHR*)(local_pCopyImageInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkCopyImageInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyImageInfo2KHR*)(local_pCopyImageInfo), streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -24091,12 +33778,35 @@
}
void VkEncoder::vkCmdCopyBufferToImage2KHR(
- VkCommandBuffer commandBuffer,
- const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo,
- uint32_t doLock)
-{
+ VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdCopyBufferToImage2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdCopyBufferToImage2KHR(commandBuffer:%p, pCopyBufferToImageInfo:%p)",
+ commandBuffer, pCopyBufferToImageInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -24104,40 +33814,48 @@
VkCopyBufferToImageInfo2KHR* local_pCopyBufferToImageInfo;
local_commandBuffer = commandBuffer;
local_pCopyBufferToImageInfo = nullptr;
- if (pCopyBufferToImageInfo)
- {
- local_pCopyBufferToImageInfo = (VkCopyBufferToImageInfo2KHR*)pool->alloc(sizeof(const VkCopyBufferToImageInfo2KHR));
- deepcopy_VkCopyBufferToImageInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyBufferToImageInfo, (VkCopyBufferToImageInfo2KHR*)(local_pCopyBufferToImageInfo));
+ if (pCopyBufferToImageInfo) {
+ local_pCopyBufferToImageInfo =
+ (VkCopyBufferToImageInfo2KHR*)pool->alloc(sizeof(const VkCopyBufferToImageInfo2KHR));
+ deepcopy_VkCopyBufferToImageInfo2KHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyBufferToImageInfo,
+ (VkCopyBufferToImageInfo2KHR*)(local_pCopyBufferToImageInfo));
}
- if (local_pCopyBufferToImageInfo)
- {
- transform_tohost_VkCopyBufferToImageInfo2KHR(sResourceTracker, (VkCopyBufferToImageInfo2KHR*)(local_pCopyBufferToImageInfo));
+ if (local_pCopyBufferToImageInfo) {
+ transform_tohost_VkCopyBufferToImageInfo2KHR(
+ sResourceTracker, (VkCopyBufferToImageInfo2KHR*)(local_pCopyBufferToImageInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCopyBufferToImageInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyBufferToImageInfo2KHR*)(local_pCopyBufferToImageInfo), countPtr);
+ count_VkCopyBufferToImageInfo2KHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyBufferToImageInfo2KHR*)(local_pCopyBufferToImageInfo), countPtr);
}
uint32_t packetSize_vkCmdCopyBufferToImage2KHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyBufferToImage2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyBufferToImage2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyBufferToImage2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdCopyBufferToImage2KHR = OP_vkCmdCopyBufferToImage2KHR;
- memcpy(streamPtr, &opcode_vkCmdCopyBufferToImage2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdCopyBufferToImage2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdCopyBufferToImage2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdCopyBufferToImage2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkCopyBufferToImageInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyBufferToImageInfo2KHR*)(local_pCopyBufferToImageInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkCopyBufferToImageInfo2KHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyBufferToImageInfo2KHR*)(local_pCopyBufferToImageInfo), streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -24145,12 +33863,35 @@
}
void VkEncoder::vkCmdCopyImageToBuffer2KHR(
- VkCommandBuffer commandBuffer,
- const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo,
- uint32_t doLock)
-{
+ VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdCopyImageToBuffer2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdCopyImageToBuffer2KHR(commandBuffer:%p, pCopyImageToBufferInfo:%p)",
+ commandBuffer, pCopyImageToBufferInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -24158,53 +33899,83 @@
VkCopyImageToBufferInfo2KHR* local_pCopyImageToBufferInfo;
local_commandBuffer = commandBuffer;
local_pCopyImageToBufferInfo = nullptr;
- if (pCopyImageToBufferInfo)
- {
- local_pCopyImageToBufferInfo = (VkCopyImageToBufferInfo2KHR*)pool->alloc(sizeof(const VkCopyImageToBufferInfo2KHR));
- deepcopy_VkCopyImageToBufferInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyImageToBufferInfo, (VkCopyImageToBufferInfo2KHR*)(local_pCopyImageToBufferInfo));
+ if (pCopyImageToBufferInfo) {
+ local_pCopyImageToBufferInfo =
+ (VkCopyImageToBufferInfo2KHR*)pool->alloc(sizeof(const VkCopyImageToBufferInfo2KHR));
+ deepcopy_VkCopyImageToBufferInfo2KHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCopyImageToBufferInfo,
+ (VkCopyImageToBufferInfo2KHR*)(local_pCopyImageToBufferInfo));
}
- if (local_pCopyImageToBufferInfo)
- {
- transform_tohost_VkCopyImageToBufferInfo2KHR(sResourceTracker, (VkCopyImageToBufferInfo2KHR*)(local_pCopyImageToBufferInfo));
+ if (local_pCopyImageToBufferInfo) {
+ transform_tohost_VkCopyImageToBufferInfo2KHR(
+ sResourceTracker, (VkCopyImageToBufferInfo2KHR*)(local_pCopyImageToBufferInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCopyImageToBufferInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyImageToBufferInfo2KHR*)(local_pCopyImageToBufferInfo), countPtr);
+ count_VkCopyImageToBufferInfo2KHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyImageToBufferInfo2KHR*)(local_pCopyImageToBufferInfo), countPtr);
}
uint32_t packetSize_vkCmdCopyImageToBuffer2KHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCopyImageToBuffer2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyImageToBuffer2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyImageToBuffer2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdCopyImageToBuffer2KHR = OP_vkCmdCopyImageToBuffer2KHR;
- memcpy(streamPtr, &opcode_vkCmdCopyImageToBuffer2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdCopyImageToBuffer2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdCopyImageToBuffer2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdCopyImageToBuffer2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkCopyImageToBufferInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyImageToBufferInfo2KHR*)(local_pCopyImageToBufferInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkCopyImageToBufferInfo2KHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyImageToBufferInfo2KHR*)(local_pCopyImageToBufferInfo), streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdBlitImage2KHR(
- VkCommandBuffer commandBuffer,
- const VkBlitImageInfo2KHR* pBlitImageInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer,
+ const VkBlitImageInfo2KHR* pBlitImageInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBlitImage2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdBlitImage2KHR(commandBuffer:%p, pBlitImageInfo:%p)", commandBuffer,
+ pBlitImageInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -24212,53 +33983,80 @@
VkBlitImageInfo2KHR* local_pBlitImageInfo;
local_commandBuffer = commandBuffer;
local_pBlitImageInfo = nullptr;
- if (pBlitImageInfo)
- {
+ if (pBlitImageInfo) {
local_pBlitImageInfo = (VkBlitImageInfo2KHR*)pool->alloc(sizeof(const VkBlitImageInfo2KHR));
- deepcopy_VkBlitImageInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBlitImageInfo, (VkBlitImageInfo2KHR*)(local_pBlitImageInfo));
+ deepcopy_VkBlitImageInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBlitImageInfo,
+ (VkBlitImageInfo2KHR*)(local_pBlitImageInfo));
}
- if (local_pBlitImageInfo)
- {
- transform_tohost_VkBlitImageInfo2KHR(sResourceTracker, (VkBlitImageInfo2KHR*)(local_pBlitImageInfo));
+ if (local_pBlitImageInfo) {
+ transform_tohost_VkBlitImageInfo2KHR(sResourceTracker,
+ (VkBlitImageInfo2KHR*)(local_pBlitImageInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBlitImageInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBlitImageInfo2KHR*)(local_pBlitImageInfo), countPtr);
+ count_VkBlitImageInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBlitImageInfo2KHR*)(local_pBlitImageInfo), countPtr);
}
uint32_t packetSize_vkCmdBlitImage2KHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBlitImage2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBlitImage2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBlitImage2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBlitImage2KHR = OP_vkCmdBlitImage2KHR;
- memcpy(streamPtr, &opcode_vkCmdBlitImage2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBlitImage2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBlitImage2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBlitImage2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkBlitImageInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBlitImageInfo2KHR*)(local_pBlitImageInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkBlitImageInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBlitImageInfo2KHR*)(local_pBlitImageInfo), streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdResolveImage2KHR(
- VkCommandBuffer commandBuffer,
- const VkResolveImageInfo2KHR* pResolveImageInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer,
+ const VkResolveImageInfo2KHR* pResolveImageInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdResolveImage2KHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdResolveImage2KHR(commandBuffer:%p, pResolveImageInfo:%p)",
+ commandBuffer, pResolveImageInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -24266,40 +34064,46 @@
VkResolveImageInfo2KHR* local_pResolveImageInfo;
local_commandBuffer = commandBuffer;
local_pResolveImageInfo = nullptr;
- if (pResolveImageInfo)
- {
- local_pResolveImageInfo = (VkResolveImageInfo2KHR*)pool->alloc(sizeof(const VkResolveImageInfo2KHR));
- deepcopy_VkResolveImageInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pResolveImageInfo, (VkResolveImageInfo2KHR*)(local_pResolveImageInfo));
+ if (pResolveImageInfo) {
+ local_pResolveImageInfo =
+ (VkResolveImageInfo2KHR*)pool->alloc(sizeof(const VkResolveImageInfo2KHR));
+ deepcopy_VkResolveImageInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pResolveImageInfo,
+ (VkResolveImageInfo2KHR*)(local_pResolveImageInfo));
}
- if (local_pResolveImageInfo)
- {
- transform_tohost_VkResolveImageInfo2KHR(sResourceTracker, (VkResolveImageInfo2KHR*)(local_pResolveImageInfo));
+ if (local_pResolveImageInfo) {
+ transform_tohost_VkResolveImageInfo2KHR(sResourceTracker,
+ (VkResolveImageInfo2KHR*)(local_pResolveImageInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkResolveImageInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkResolveImageInfo2KHR*)(local_pResolveImageInfo), countPtr);
+ count_VkResolveImageInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkResolveImageInfo2KHR*)(local_pResolveImageInfo), countPtr);
}
uint32_t packetSize_vkCmdResolveImage2KHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdResolveImage2KHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdResolveImage2KHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdResolveImage2KHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdResolveImage2KHR = OP_vkCmdResolveImage2KHR;
- memcpy(streamPtr, &opcode_vkCmdResolveImage2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdResolveImage2KHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdResolveImage2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdResolveImage2KHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkResolveImageInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkResolveImageInfo2KHR*)(local_pResolveImageInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkResolveImageInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkResolveImageInfo2KHR*)(local_pResolveImageInfo),
+ streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -24311,13 +34115,37 @@
#endif
#ifdef VK_KHR_maintenance4
void VkEncoder::vkGetDeviceBufferMemoryRequirementsKHR(
- VkDevice device,
- const VkDeviceBufferMemoryRequirementsKHR* pInfo,
- VkMemoryRequirements2* pMemoryRequirements,
- uint32_t doLock)
-{
+ VkDevice device, const VkDeviceBufferMemoryRequirementsKHR* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetDeviceBufferMemoryRequirementsKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetDeviceBufferMemoryRequirementsKHR(device:%p, pInfo:%p, pMemoryRequirements:%p)",
+ device, pInfo, pMemoryRequirements);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -24325,45 +34153,66 @@
VkDeviceBufferMemoryRequirementsKHR* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkDeviceBufferMemoryRequirementsKHR*)pool->alloc(sizeof(const VkDeviceBufferMemoryRequirementsKHR));
- deepcopy_VkDeviceBufferMemoryRequirementsKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkDeviceBufferMemoryRequirementsKHR*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkDeviceBufferMemoryRequirementsKHR*)pool->alloc(
+ sizeof(const VkDeviceBufferMemoryRequirementsKHR));
+ deepcopy_VkDeviceBufferMemoryRequirementsKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkDeviceBufferMemoryRequirementsKHR*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkDeviceBufferMemoryRequirementsKHR(sResourceTracker, (VkDeviceBufferMemoryRequirementsKHR*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkDeviceBufferMemoryRequirementsKHR(
+ sResourceTracker, (VkDeviceBufferMemoryRequirementsKHR*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDeviceBufferMemoryRequirementsKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceBufferMemoryRequirementsKHR*)(local_pInfo), countPtr);
- count_VkMemoryRequirements2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements), countPtr);
+ count_VkDeviceBufferMemoryRequirementsKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDeviceBufferMemoryRequirementsKHR*)(local_pInfo), countPtr);
+ count_VkMemoryRequirements2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements), countPtr);
}
- uint32_t packetSize_vkGetDeviceBufferMemoryRequirementsKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDeviceBufferMemoryRequirementsKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDeviceBufferMemoryRequirementsKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceBufferMemoryRequirementsKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetDeviceBufferMemoryRequirementsKHR = OP_vkGetDeviceBufferMemoryRequirementsKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDeviceBufferMemoryRequirementsKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDeviceBufferMemoryRequirementsKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetDeviceBufferMemoryRequirementsKHR =
+ OP_vkGetDeviceBufferMemoryRequirementsKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDeviceBufferMemoryRequirementsKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDeviceBufferMemoryRequirementsKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDeviceBufferMemoryRequirementsKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceBufferMemoryRequirementsKHR*)(local_pInfo), streamPtrPtr);
- reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements), streamPtrPtr);
- unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements));
- if (pMemoryRequirements)
- {
- transform_fromhost_VkMemoryRequirements2(sResourceTracker, (VkMemoryRequirements2*)(pMemoryRequirements));
+ reservedmarshal_VkDeviceBufferMemoryRequirementsKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceBufferMemoryRequirementsKHR*)(local_pInfo),
+ streamPtrPtr);
+ reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements),
+ streamPtrPtr);
+ unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements));
+ if (pMemoryRequirements) {
+ transform_fromhost_VkMemoryRequirements2(sResourceTracker,
+ (VkMemoryRequirements2*)(pMemoryRequirements));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -24371,13 +34220,37 @@
}
void VkEncoder::vkGetDeviceImageMemoryRequirementsKHR(
- VkDevice device,
- const VkDeviceImageMemoryRequirementsKHR* pInfo,
- VkMemoryRequirements2* pMemoryRequirements,
- uint32_t doLock)
-{
+ VkDevice device, const VkDeviceImageMemoryRequirementsKHR* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetDeviceImageMemoryRequirementsKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetDeviceImageMemoryRequirementsKHR(device:%p, pInfo:%p, pMemoryRequirements:%p)",
+ device, pInfo, pMemoryRequirements);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -24385,45 +34258,66 @@
VkDeviceImageMemoryRequirementsKHR* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkDeviceImageMemoryRequirementsKHR*)pool->alloc(sizeof(const VkDeviceImageMemoryRequirementsKHR));
- deepcopy_VkDeviceImageMemoryRequirementsKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkDeviceImageMemoryRequirementsKHR*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkDeviceImageMemoryRequirementsKHR*)pool->alloc(
+ sizeof(const VkDeviceImageMemoryRequirementsKHR));
+ deepcopy_VkDeviceImageMemoryRequirementsKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkDeviceImageMemoryRequirementsKHR*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkDeviceImageMemoryRequirementsKHR(sResourceTracker, (VkDeviceImageMemoryRequirementsKHR*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkDeviceImageMemoryRequirementsKHR(
+ sResourceTracker, (VkDeviceImageMemoryRequirementsKHR*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDeviceImageMemoryRequirementsKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceImageMemoryRequirementsKHR*)(local_pInfo), countPtr);
- count_VkMemoryRequirements2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements), countPtr);
+ count_VkDeviceImageMemoryRequirementsKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDeviceImageMemoryRequirementsKHR*)(local_pInfo),
+ countPtr);
+ count_VkMemoryRequirements2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements), countPtr);
}
- uint32_t packetSize_vkGetDeviceImageMemoryRequirementsKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDeviceImageMemoryRequirementsKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDeviceImageMemoryRequirementsKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceImageMemoryRequirementsKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetDeviceImageMemoryRequirementsKHR = OP_vkGetDeviceImageMemoryRequirementsKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDeviceImageMemoryRequirementsKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDeviceImageMemoryRequirementsKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetDeviceImageMemoryRequirementsKHR =
+ OP_vkGetDeviceImageMemoryRequirementsKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDeviceImageMemoryRequirementsKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDeviceImageMemoryRequirementsKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDeviceImageMemoryRequirementsKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceImageMemoryRequirementsKHR*)(local_pInfo), streamPtrPtr);
- reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements), streamPtrPtr);
- unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements));
- if (pMemoryRequirements)
- {
- transform_fromhost_VkMemoryRequirements2(sResourceTracker, (VkMemoryRequirements2*)(pMemoryRequirements));
+ reservedmarshal_VkDeviceImageMemoryRequirementsKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceImageMemoryRequirementsKHR*)(local_pInfo),
+ streamPtrPtr);
+ reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements),
+ streamPtrPtr);
+ unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements));
+ if (pMemoryRequirements) {
+ transform_fromhost_VkMemoryRequirements2(sResourceTracker,
+ (VkMemoryRequirements2*)(pMemoryRequirements));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -24431,14 +34325,39 @@
}
void VkEncoder::vkGetDeviceImageSparseMemoryRequirementsKHR(
- VkDevice device,
- const VkDeviceImageMemoryRequirementsKHR* pInfo,
+ VkDevice device, const VkDeviceImageMemoryRequirementsKHR* pInfo,
uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements,
- uint32_t doLock)
-{
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetDeviceImageSparseMemoryRequirementsKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetDeviceImageSparseMemoryRequirementsKHR(device:%p, pInfo:%p, "
+ "pSparseMemoryRequirementCount:%p, pSparseMemoryRequirements:%p)",
+ device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -24446,60 +34365,75 @@
VkDeviceImageMemoryRequirementsKHR* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkDeviceImageMemoryRequirementsKHR*)pool->alloc(sizeof(const VkDeviceImageMemoryRequirementsKHR));
- deepcopy_VkDeviceImageMemoryRequirementsKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkDeviceImageMemoryRequirementsKHR*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkDeviceImageMemoryRequirementsKHR*)pool->alloc(
+ sizeof(const VkDeviceImageMemoryRequirementsKHR));
+ deepcopy_VkDeviceImageMemoryRequirementsKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkDeviceImageMemoryRequirementsKHR*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkDeviceImageMemoryRequirementsKHR(sResourceTracker, (VkDeviceImageMemoryRequirementsKHR*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkDeviceImageMemoryRequirementsKHR(
+ sResourceTracker, (VkDeviceImageMemoryRequirementsKHR*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDeviceImageMemoryRequirementsKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceImageMemoryRequirementsKHR*)(local_pInfo), countPtr);
+ count_VkDeviceImageMemoryRequirementsKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDeviceImageMemoryRequirementsKHR*)(local_pInfo),
+ countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (pSparseMemoryRequirementCount)
- {
+ if (pSparseMemoryRequirementCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pSparseMemoryRequirements)
- {
- if (pSparseMemoryRequirementCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
- {
- count_VkSparseImageMemoryRequirements2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), countPtr);
+ if (pSparseMemoryRequirements) {
+ if (pSparseMemoryRequirementCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
+ count_VkSparseImageMemoryRequirements2(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i),
+ countPtr);
}
}
}
}
- uint32_t packetSize_vkGetDeviceImageSparseMemoryRequirementsKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDeviceImageSparseMemoryRequirementsKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDeviceImageSparseMemoryRequirementsKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceImageSparseMemoryRequirementsKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetDeviceImageSparseMemoryRequirementsKHR = OP_vkGetDeviceImageSparseMemoryRequirementsKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDeviceImageSparseMemoryRequirementsKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDeviceImageSparseMemoryRequirementsKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetDeviceImageSparseMemoryRequirementsKHR =
+ OP_vkGetDeviceImageSparseMemoryRequirementsKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDeviceImageSparseMemoryRequirementsKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDeviceImageSparseMemoryRequirementsKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDeviceImageMemoryRequirementsKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceImageMemoryRequirementsKHR*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkDeviceImageMemoryRequirementsKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceImageMemoryRequirementsKHR*)(local_pInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pSparseMemoryRequirementCount)
- {
+ if (pSparseMemoryRequirementCount) {
memcpy(*streamPtrPtr, (uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -24508,54 +34442,52 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pSparseMemoryRequirements)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
- {
- reservedmarshal_VkSparseImageMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), streamPtrPtr);
+ if (pSparseMemoryRequirements) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
+ reservedmarshal_VkSparseImageMemoryRequirements2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pSparseMemoryRequirementCount;
check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pSparseMemoryRequirementCount)
- {
- if (!(check_pSparseMemoryRequirementCount))
- {
- fprintf(stderr, "fatal: pSparseMemoryRequirementCount inconsistent between guest and host\n");
+ if (pSparseMemoryRequirementCount) {
+ if (!(check_pSparseMemoryRequirementCount)) {
+ fprintf(stderr,
+ "fatal: pSparseMemoryRequirementCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
VkSparseImageMemoryRequirements2* check_pSparseMemoryRequirements;
- check_pSparseMemoryRequirements = (VkSparseImageMemoryRequirements2*)(uintptr_t)stream->getBe64();
- if (pSparseMemoryRequirements)
- {
- if (!(check_pSparseMemoryRequirements))
- {
- fprintf(stderr, "fatal: pSparseMemoryRequirements inconsistent between guest and host\n");
+ check_pSparseMemoryRequirements =
+ (VkSparseImageMemoryRequirements2*)(uintptr_t)stream->getBe64();
+ if (pSparseMemoryRequirements) {
+ if (!(check_pSparseMemoryRequirements)) {
+ fprintf(stderr,
+ "fatal: pSparseMemoryRequirements inconsistent between guest and host\n");
}
- if (pSparseMemoryRequirementCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
- {
- unmarshal_VkSparseImageMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+ if (pSparseMemoryRequirementCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
+ unmarshal_VkSparseImageMemoryRequirements2(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
}
}
}
- if (pSparseMemoryRequirementCount)
- {
- if (pSparseMemoryRequirements)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i)
- {
- transform_fromhost_VkSparseImageMemoryRequirements2(sResourceTracker, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+ if (pSparseMemoryRequirementCount) {
+ if (pSparseMemoryRequirements) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
+ transform_fromhost_VkSparseImageMemoryRequirements2(
+ sResourceTracker,
+ (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
}
}
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -24564,15 +34496,37 @@
#endif
#ifdef VK_ANDROID_native_buffer
-VkResult VkEncoder::vkGetSwapchainGrallocUsageANDROID(
- VkDevice device,
- VkFormat format,
- VkImageUsageFlags imageUsage,
- int* grallocUsage,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format,
+ VkImageUsageFlags imageUsage,
+ int* grallocUsage, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetSwapchainGrallocUsageANDROID in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetSwapchainGrallocUsageANDROID(device:%p, format:%d, imageUsage:%d, grallocUsage:%p)",
+ device, format, imageUsage, grallocUsage);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -24591,14 +34545,24 @@
*countPtr += sizeof(VkImageUsageFlags);
*countPtr += sizeof(int);
}
- uint32_t packetSize_vkGetSwapchainGrallocUsageANDROID = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetSwapchainGrallocUsageANDROID =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetSwapchainGrallocUsageANDROID);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetSwapchainGrallocUsageANDROID);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetSwapchainGrallocUsageANDROID = OP_vkGetSwapchainGrallocUsageANDROID;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetSwapchainGrallocUsageANDROID, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetSwapchainGrallocUsageANDROID, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetSwapchainGrallocUsageANDROID, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetSwapchainGrallocUsageANDROID, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -24612,9 +34576,9 @@
stream->read((int*)grallocUsage, sizeof(int));
VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
stream->read(&vkGetSwapchainGrallocUsageANDROID_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -24622,16 +34586,33 @@
return vkGetSwapchainGrallocUsageANDROID_VkResult_return;
}
-VkResult VkEncoder::vkAcquireImageANDROID(
- VkDevice device,
- VkImage image,
- int nativeFenceFd,
- VkSemaphore semaphore,
- VkFence fence,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkAcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd,
+ VkSemaphore semaphore, VkFence fence, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkAcquireImageANDROID in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -24645,7 +34626,8 @@
local_nativeFenceFd = nativeFenceFd;
local_semaphore = semaphore;
local_fence = fence;
- sResourceTracker->unwrap_vkAcquireImageANDROID_nativeFenceFd(nativeFenceFd, &local_nativeFenceFd);
+ sResourceTracker->unwrap_vkAcquireImageANDROID_nativeFenceFd(nativeFenceFd,
+ &local_nativeFenceFd);
size_t count = 0;
size_t* countPtr = &count;
{
@@ -24659,14 +34641,23 @@
uint64_t cgen_var_3;
*countPtr += 1 * 8;
}
- uint32_t packetSize_vkAcquireImageANDROID = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkAcquireImageANDROID =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkAcquireImageANDROID);
uint8_t* streamPtr = stream->reserve(packetSize_vkAcquireImageANDROID);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkAcquireImageANDROID = OP_vkAcquireImageANDROID;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkAcquireImageANDROID, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkAcquireImageANDROID, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkAcquireImageANDROID, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkAcquireImageANDROID, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -24687,9 +34678,9 @@
*streamPtrPtr += 1 * 8;
VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
stream->read(&vkAcquireImageANDROID_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -24697,16 +34688,39 @@
return vkAcquireImageANDROID_VkResult_return;
}
-VkResult VkEncoder::vkQueueSignalReleaseImageANDROID(
- VkQueue queue,
- uint32_t waitSemaphoreCount,
- const VkSemaphore* pWaitSemaphores,
- VkImage image,
- int* pNativeFenceFd,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkQueueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount,
+ const VkSemaphore* pWaitSemaphores,
+ VkImage image, int* pNativeFenceFd,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkQueueSignalReleaseImageANDROID in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkQueueSignalReleaseImageANDROID(queue:%p, waitSemaphoreCount:%d, pWaitSemaphores:%p, "
+ "image:%p, pNativeFenceFd:%p)",
+ queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -24727,10 +34741,8 @@
*countPtr += sizeof(uint32_t);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pWaitSemaphores)
- {
- if (((waitSemaphoreCount)))
- {
+ if (local_pWaitSemaphores) {
+ if (((waitSemaphoreCount))) {
*countPtr += ((waitSemaphoreCount)) * 8;
}
}
@@ -24738,14 +34750,24 @@
*countPtr += 1 * 8;
*countPtr += sizeof(int);
}
- uint32_t packetSize_vkQueueSignalReleaseImageANDROID = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkQueueSignalReleaseImageANDROID =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkQueueSignalReleaseImageANDROID);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueSignalReleaseImageANDROID);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueSignalReleaseImageANDROID = OP_vkQueueSignalReleaseImageANDROID;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkQueueSignalReleaseImageANDROID, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkQueueSignalReleaseImageANDROID, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkQueueSignalReleaseImageANDROID, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkQueueSignalReleaseImageANDROID, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -24757,13 +34779,10 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pWaitSemaphores)
- {
- if (((waitSemaphoreCount)))
- {
+ if (local_pWaitSemaphores) {
+ if (((waitSemaphoreCount))) {
uint8_t* cgen_var_1_0_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((waitSemaphoreCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((waitSemaphoreCount)); ++k) {
uint64_t tmpval = get_host_u64_VkSemaphore(local_pWaitSemaphores[k]);
memcpy(cgen_var_1_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -24780,9 +34799,9 @@
VkResult vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0;
stream->read(&vkQueueSignalReleaseImageANDROID_VkResult_return, sizeof(VkResult));
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -24793,14 +34812,36 @@
#endif
#ifdef VK_EXT_debug_report
VkResult VkEncoder::vkCreateDebugReportCallbackEXT(
- VkInstance instance,
- const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDebugReportCallbackEXT* pCallback,
- uint32_t doLock)
-{
+ VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateDebugReportCallbackEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateDebugReportCallbackEXT(instance:%p, pCreateInfo:%p, pAllocator:%p, pCallback:%p)",
+ instance, pCreateInfo, pAllocator, pCallback);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -24809,62 +34850,79 @@
VkAllocationCallbacks* local_pAllocator;
local_instance = instance;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkDebugReportCallbackCreateInfoEXT*)pool->alloc(sizeof(const VkDebugReportCallbackCreateInfoEXT));
- deepcopy_VkDebugReportCallbackCreateInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDebugReportCallbackCreateInfoEXT*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkDebugReportCallbackCreateInfoEXT*)pool->alloc(
+ sizeof(const VkDebugReportCallbackCreateInfoEXT));
+ deepcopy_VkDebugReportCallbackCreateInfoEXT(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkDebugReportCallbackCreateInfoEXT*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkDebugReportCallbackCreateInfoEXT(sResourceTracker, (VkDebugReportCallbackCreateInfoEXT*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkDebugReportCallbackCreateInfoEXT(
+ sResourceTracker, (VkDebugReportCallbackCreateInfoEXT*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugReportCallbackCreateInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugReportCallbackCreateInfoEXT*)(local_pCreateInfo), countPtr);
+ count_VkDebugReportCallbackCreateInfoEXT(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugReportCallbackCreateInfoEXT*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateDebugReportCallbackEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateDebugReportCallbackEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCreateDebugReportCallbackEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateDebugReportCallbackEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateDebugReportCallbackEXT = OP_vkCreateDebugReportCallbackEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateDebugReportCallbackEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateDebugReportCallbackEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateDebugReportCallbackEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateDebugReportCallbackEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDebugReportCallbackCreateInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugReportCallbackCreateInfoEXT*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkDebugReportCallbackCreateInfoEXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugReportCallbackCreateInfoEXT*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -24875,13 +34933,14 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkDebugReportCallbackEXT(&cgen_var_3, (VkDebugReportCallbackEXT*)pCallback, 1);
+ stream->handleMapping()->mapHandles_u64_VkDebugReportCallbackEXT(
+ &cgen_var_3, (VkDebugReportCallbackEXT*)pCallback, 1);
stream->unsetHandleMapping();
VkResult vkCreateDebugReportCallbackEXT_VkResult_return = (VkResult)0;
stream->read(&vkCreateDebugReportCallbackEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -24889,14 +34948,37 @@
return vkCreateDebugReportCallbackEXT_VkResult_return;
}
-void VkEncoder::vkDestroyDebugReportCallbackEXT(
- VkInstance instance,
- VkDebugReportCallbackEXT callback,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyDebugReportCallbackEXT(VkInstance instance,
+ VkDebugReportCallbackEXT callback,
+ const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyDebugReportCallbackEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyDebugReportCallbackEXT(instance:%p, callback:%p, pAllocator:%p)",
+ instance, callback, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -24906,15 +34988,15 @@
local_instance = instance;
local_callback = callback;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -24925,19 +35007,29 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyDebugReportCallbackEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyDebugReportCallbackEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkDestroyDebugReportCallbackEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyDebugReportCallbackEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyDebugReportCallbackEXT = OP_vkDestroyDebugReportCallbackEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyDebugReportCallbackEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyDebugReportCallbackEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyDebugReportCallbackEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyDebugReportCallbackEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -24951,34 +35043,57 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
- sResourceTracker->destroyMapping()->mapHandles_VkDebugReportCallbackEXT((VkDebugReportCallbackEXT*)&callback);
+ sResourceTracker->destroyMapping()->mapHandles_VkDebugReportCallbackEXT(
+ (VkDebugReportCallbackEXT*)&callback);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkDebugReportMessageEXT(
- VkInstance instance,
- VkDebugReportFlagsEXT flags,
- VkDebugReportObjectTypeEXT objectType,
- uint64_t object,
- size_t location,
- int32_t messageCode,
- const char* pLayerPrefix,
- const char* pMessage,
- uint32_t doLock)
-{
+void VkEncoder::vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
+ VkDebugReportObjectTypeEXT objectType, uint64_t object,
+ size_t location, int32_t messageCode,
+ const char* pLayerPrefix, const char* pMessage,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDebugReportMessageEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkDebugReportMessageEXT(instance:%p, object:%ld, location:%ld, messageCode:%d, "
+ "pLayerPrefix:%p, pMessage:%p)",
+ instance, object, location, messageCode, pLayerPrefix, pMessage);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -25013,21 +35128,31 @@
*countPtr += sizeof(uint32_t) + (local_pLayerPrefix ? strlen(local_pLayerPrefix) : 0);
*countPtr += sizeof(uint32_t) + (local_pMessage ? strlen(local_pMessage) : 0);
}
- uint32_t packetSize_vkDebugReportMessageEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDebugReportMessageEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDebugReportMessageEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkDebugReportMessageEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDebugReportMessageEXT = OP_vkDebugReportMessageEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDebugReportMessageEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDebugReportMessageEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDebugReportMessageEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDebugReportMessageEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkDebugReportFlagsEXT*)&local_flags, sizeof(VkDebugReportFlagsEXT));
*streamPtrPtr += sizeof(VkDebugReportFlagsEXT);
- memcpy(*streamPtrPtr, (VkDebugReportObjectTypeEXT*)&local_objectType, sizeof(VkDebugReportObjectTypeEXT));
+ memcpy(*streamPtrPtr, (VkDebugReportObjectTypeEXT*)&local_objectType,
+ sizeof(VkDebugReportObjectTypeEXT));
*streamPtrPtr += sizeof(VkDebugReportObjectTypeEXT);
memcpy(*streamPtrPtr, (uint64_t*)&local_object, sizeof(uint64_t));
*streamPtrPtr += sizeof(uint64_t);
@@ -25038,7 +35163,7 @@
memcpy(*streamPtrPtr, (int32_t*)&local_messageCode, sizeof(int32_t));
*streamPtrPtr += sizeof(int32_t);
{
- uint32_t l = local_pLayerPrefix ? strlen(local_pLayerPrefix): 0;
+ uint32_t l = local_pLayerPrefix ? strlen(local_pLayerPrefix) : 0;
memcpy(*streamPtrPtr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*streamPtrPtr);
*streamPtrPtr += sizeof(uint32_t);
@@ -25046,7 +35171,7 @@
*streamPtrPtr += l;
}
{
- uint32_t l = local_pMessage ? strlen(local_pMessage): 0;
+ uint32_t l = local_pMessage ? strlen(local_pMessage) : 0;
memcpy(*streamPtrPtr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*streamPtrPtr);
*streamPtrPtr += sizeof(uint32_t);
@@ -25054,9 +35179,9 @@
*streamPtrPtr += l;
}
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -25077,13 +35202,35 @@
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
-VkResult VkEncoder::vkDebugMarkerSetObjectTagEXT(
- VkDevice device,
- const VkDebugMarkerObjectTagInfoEXT* pTagInfo,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkDebugMarkerSetObjectTagEXT(VkDevice device,
+ const VkDebugMarkerObjectTagInfoEXT* pTagInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDebugMarkerSetObjectTagEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDebugMarkerSetObjectTagEXT(device:%p, pTagInfo:%p)", device, pTagInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -25091,40 +35238,55 @@
VkDebugMarkerObjectTagInfoEXT* local_pTagInfo;
local_device = device;
local_pTagInfo = nullptr;
- if (pTagInfo)
- {
- local_pTagInfo = (VkDebugMarkerObjectTagInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerObjectTagInfoEXT));
- deepcopy_VkDebugMarkerObjectTagInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pTagInfo, (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo));
+ if (pTagInfo) {
+ local_pTagInfo = (VkDebugMarkerObjectTagInfoEXT*)pool->alloc(
+ sizeof(const VkDebugMarkerObjectTagInfoEXT));
+ deepcopy_VkDebugMarkerObjectTagInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pTagInfo,
+ (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo));
}
- if (local_pTagInfo)
- {
- transform_tohost_VkDebugMarkerObjectTagInfoEXT(sResourceTracker, (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo));
+ if (local_pTagInfo) {
+ transform_tohost_VkDebugMarkerObjectTagInfoEXT(
+ sResourceTracker, (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugMarkerObjectTagInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo), countPtr);
+ count_VkDebugMarkerObjectTagInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo),
+ countPtr);
}
- uint32_t packetSize_vkDebugMarkerSetObjectTagEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDebugMarkerSetObjectTagEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkDebugMarkerSetObjectTagEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkDebugMarkerSetObjectTagEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDebugMarkerSetObjectTagEXT = OP_vkDebugMarkerSetObjectTagEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDebugMarkerSetObjectTagEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDebugMarkerSetObjectTagEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDebugMarkerSetObjectTagEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDebugMarkerSetObjectTagEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDebugMarkerObjectTagInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo), streamPtrPtr);
+ reservedmarshal_VkDebugMarkerObjectTagInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo),
+ streamPtrPtr);
VkResult vkDebugMarkerSetObjectTagEXT_VkResult_return = (VkResult)0;
stream->read(&vkDebugMarkerSetObjectTagEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -25132,13 +35294,35 @@
return vkDebugMarkerSetObjectTagEXT_VkResult_return;
}
-VkResult VkEncoder::vkDebugMarkerSetObjectNameEXT(
- VkDevice device,
- const VkDebugMarkerObjectNameInfoEXT* pNameInfo,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkDebugMarkerSetObjectNameEXT(VkDevice device,
+ const VkDebugMarkerObjectNameInfoEXT* pNameInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDebugMarkerSetObjectNameEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDebugMarkerSetObjectNameEXT(device:%p, pNameInfo:%p)", device, pNameInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -25146,40 +35330,55 @@
VkDebugMarkerObjectNameInfoEXT* local_pNameInfo;
local_device = device;
local_pNameInfo = nullptr;
- if (pNameInfo)
- {
- local_pNameInfo = (VkDebugMarkerObjectNameInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerObjectNameInfoEXT));
- deepcopy_VkDebugMarkerObjectNameInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pNameInfo, (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo));
+ if (pNameInfo) {
+ local_pNameInfo = (VkDebugMarkerObjectNameInfoEXT*)pool->alloc(
+ sizeof(const VkDebugMarkerObjectNameInfoEXT));
+ deepcopy_VkDebugMarkerObjectNameInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pNameInfo,
+ (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo));
}
- if (local_pNameInfo)
- {
- transform_tohost_VkDebugMarkerObjectNameInfoEXT(sResourceTracker, (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo));
+ if (local_pNameInfo) {
+ transform_tohost_VkDebugMarkerObjectNameInfoEXT(
+ sResourceTracker, (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugMarkerObjectNameInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo), countPtr);
+ count_VkDebugMarkerObjectNameInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo),
+ countPtr);
}
- uint32_t packetSize_vkDebugMarkerSetObjectNameEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDebugMarkerSetObjectNameEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkDebugMarkerSetObjectNameEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkDebugMarkerSetObjectNameEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDebugMarkerSetObjectNameEXT = OP_vkDebugMarkerSetObjectNameEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDebugMarkerSetObjectNameEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDebugMarkerSetObjectNameEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDebugMarkerSetObjectNameEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDebugMarkerSetObjectNameEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDebugMarkerObjectNameInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo), streamPtrPtr);
+ reservedmarshal_VkDebugMarkerObjectNameInfoEXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo),
+ streamPtrPtr);
VkResult vkDebugMarkerSetObjectNameEXT_VkResult_return = (VkResult)0;
stream->read(&vkDebugMarkerSetObjectNameEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -25187,13 +35386,36 @@
return vkDebugMarkerSetObjectNameEXT_VkResult_return;
}
-void VkEncoder::vkCmdDebugMarkerBeginEXT(
- VkCommandBuffer commandBuffer,
- const VkDebugMarkerMarkerInfoEXT* pMarkerInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDebugMarkerBeginEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdDebugMarkerBeginEXT(commandBuffer:%p, pMarkerInfo:%p)", commandBuffer,
+ pMarkerInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -25201,52 +35423,80 @@
VkDebugMarkerMarkerInfoEXT* local_pMarkerInfo;
local_commandBuffer = commandBuffer;
local_pMarkerInfo = nullptr;
- if (pMarkerInfo)
- {
- local_pMarkerInfo = (VkDebugMarkerMarkerInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerMarkerInfoEXT));
- deepcopy_VkDebugMarkerMarkerInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMarkerInfo, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+ if (pMarkerInfo) {
+ local_pMarkerInfo =
+ (VkDebugMarkerMarkerInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerMarkerInfoEXT));
+ deepcopy_VkDebugMarkerMarkerInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMarkerInfo,
+ (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
}
- if (local_pMarkerInfo)
- {
- transform_tohost_VkDebugMarkerMarkerInfoEXT(sResourceTracker, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+ if (local_pMarkerInfo) {
+ transform_tohost_VkDebugMarkerMarkerInfoEXT(
+ sResourceTracker, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugMarkerMarkerInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo), countPtr);
+ count_VkDebugMarkerMarkerInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo),
+ countPtr);
}
uint32_t packetSize_vkCmdDebugMarkerBeginEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDebugMarkerBeginEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDebugMarkerBeginEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDebugMarkerBeginEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDebugMarkerBeginEXT = OP_vkCmdDebugMarkerBeginEXT;
- memcpy(streamPtr, &opcode_vkCmdDebugMarkerBeginEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDebugMarkerBeginEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDebugMarkerBeginEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDebugMarkerBeginEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkDebugMarkerMarkerInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkDebugMarkerMarkerInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo),
+ streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdDebugMarkerEndEXT(
- VkCommandBuffer commandBuffer,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDebugMarkerEndEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdDebugMarkerEndEXT(commandBuffer:%p)", commandBuffer);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -25259,35 +35509,60 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkCmdDebugMarkerEndEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDebugMarkerEndEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDebugMarkerEndEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDebugMarkerEndEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDebugMarkerEndEXT = OP_vkCmdDebugMarkerEndEXT;
- memcpy(streamPtr, &opcode_vkCmdDebugMarkerEndEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDebugMarkerEndEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDebugMarkerEndEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDebugMarkerEndEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdDebugMarkerInsertEXT(
- VkCommandBuffer commandBuffer,
- const VkDebugMarkerMarkerInfoEXT* pMarkerInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDebugMarkerInsertEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdDebugMarkerInsertEXT(commandBuffer:%p, pMarkerInfo:%p)", commandBuffer,
+ pMarkerInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -25295,40 +35570,47 @@
VkDebugMarkerMarkerInfoEXT* local_pMarkerInfo;
local_commandBuffer = commandBuffer;
local_pMarkerInfo = nullptr;
- if (pMarkerInfo)
- {
- local_pMarkerInfo = (VkDebugMarkerMarkerInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerMarkerInfoEXT));
- deepcopy_VkDebugMarkerMarkerInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMarkerInfo, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+ if (pMarkerInfo) {
+ local_pMarkerInfo =
+ (VkDebugMarkerMarkerInfoEXT*)pool->alloc(sizeof(const VkDebugMarkerMarkerInfoEXT));
+ deepcopy_VkDebugMarkerMarkerInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMarkerInfo,
+ (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
}
- if (local_pMarkerInfo)
- {
- transform_tohost_VkDebugMarkerMarkerInfoEXT(sResourceTracker, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
+ if (local_pMarkerInfo) {
+ transform_tohost_VkDebugMarkerMarkerInfoEXT(
+ sResourceTracker, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugMarkerMarkerInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo), countPtr);
+ count_VkDebugMarkerMarkerInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo),
+ countPtr);
}
uint32_t packetSize_vkCmdDebugMarkerInsertEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDebugMarkerInsertEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDebugMarkerInsertEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDebugMarkerInsertEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDebugMarkerInsertEXT = OP_vkCmdDebugMarkerInsertEXT;
- memcpy(streamPtr, &opcode_vkCmdDebugMarkerInsertEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDebugMarkerInsertEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDebugMarkerInsertEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDebugMarkerInsertEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkDebugMarkerMarkerInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkDebugMarkerMarkerInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo),
+ streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -25341,17 +35623,40 @@
#ifdef VK_NV_dedicated_allocation
#endif
#ifdef VK_EXT_transform_feedback
-void VkEncoder::vkCmdBindTransformFeedbackBuffersEXT(
- VkCommandBuffer commandBuffer,
- uint32_t firstBinding,
- uint32_t bindingCount,
- const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets,
- const VkDeviceSize* pSizes,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer,
+ uint32_t firstBinding, uint32_t bindingCount,
+ const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets,
+ const VkDeviceSize* pSizes, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBindTransformFeedbackBuffersEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdBindTransformFeedbackBuffersEXT(commandBuffer:%p, firstBinding:%d, bindingCount:%d, "
+ "pBuffers:%p, pOffsets:%p, pSizes:%p)",
+ commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -25377,27 +35682,28 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
*countPtr += sizeof(uint32_t);
- if (((bindingCount)))
- {
+ if (((bindingCount))) {
*countPtr += ((bindingCount)) * 8;
}
*countPtr += ((bindingCount)) * sizeof(VkDeviceSize);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pSizes)
- {
+ if (local_pSizes) {
*countPtr += ((bindingCount)) * sizeof(VkDeviceSize);
}
}
uint32_t packetSize_vkCmdBindTransformFeedbackBuffersEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdBindTransformFeedbackBuffersEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBindTransformFeedbackBuffersEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBindTransformFeedbackBuffersEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBindTransformFeedbackBuffersEXT = OP_vkCmdBindTransformFeedbackBuffersEXT;
- memcpy(streamPtr, &opcode_vkCmdBindTransformFeedbackBuffersEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBindTransformFeedbackBuffersEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBindTransformFeedbackBuffersEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBindTransformFeedbackBuffersEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -25407,11 +35713,9 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_bindingCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (((bindingCount)))
- {
+ if (((bindingCount))) {
uint8_t* cgen_var_0_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((bindingCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((bindingCount)); ++k) {
uint64_t tmpval = get_host_u64_VkBuffer(local_pBuffers[k]);
memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -25424,14 +35728,13 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pSizes)
- {
+ if (local_pSizes) {
memcpy(*streamPtrPtr, (VkDeviceSize*)local_pSizes, ((bindingCount)) * sizeof(VkDeviceSize));
*streamPtrPtr += ((bindingCount)) * sizeof(VkDeviceSize);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -25439,15 +35742,38 @@
}
void VkEncoder::vkCmdBeginTransformFeedbackEXT(
- VkCommandBuffer commandBuffer,
- uint32_t firstCounterBuffer,
- uint32_t counterBufferCount,
- const VkBuffer* pCounterBuffers,
- const VkDeviceSize* pCounterBufferOffsets,
- uint32_t doLock)
-{
+ VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount,
+ const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBeginTransformFeedbackEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdBeginTransformFeedbackEXT(commandBuffer:%p, firstCounterBuffer:%d, "
+ "counterBufferCount:%d, pCounterBuffers:%p, pCounterBufferOffsets:%p)",
+ commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers,
+ pCounterBufferOffsets);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -25472,29 +35798,29 @@
*countPtr += sizeof(uint32_t);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pCounterBuffers)
- {
- if (((counterBufferCount)))
- {
+ if (local_pCounterBuffers) {
+ if (((counterBufferCount))) {
*countPtr += ((counterBufferCount)) * 8;
}
}
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pCounterBufferOffsets)
- {
+ if (local_pCounterBufferOffsets) {
*countPtr += ((counterBufferCount)) * sizeof(VkDeviceSize);
}
}
uint32_t packetSize_vkCmdBeginTransformFeedbackEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdBeginTransformFeedbackEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginTransformFeedbackEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBeginTransformFeedbackEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBeginTransformFeedbackEXT = OP_vkCmdBeginTransformFeedbackEXT;
- memcpy(streamPtr, &opcode_vkCmdBeginTransformFeedbackEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBeginTransformFeedbackEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBeginTransformFeedbackEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBeginTransformFeedbackEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -25509,13 +35835,10 @@
memcpy((*streamPtrPtr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pCounterBuffers)
- {
- if (((counterBufferCount)))
- {
+ if (local_pCounterBuffers) {
+ if (((counterBufferCount))) {
uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((counterBufferCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((counterBufferCount)); ++k) {
uint64_t tmpval = get_host_u64_VkBuffer(local_pCounterBuffers[k]);
memcpy(cgen_var_0_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -25527,14 +35850,14 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pCounterBufferOffsets)
- {
- memcpy(*streamPtrPtr, (VkDeviceSize*)local_pCounterBufferOffsets, ((counterBufferCount)) * sizeof(VkDeviceSize));
+ if (local_pCounterBufferOffsets) {
+ memcpy(*streamPtrPtr, (VkDeviceSize*)local_pCounterBufferOffsets,
+ ((counterBufferCount)) * sizeof(VkDeviceSize));
*streamPtrPtr += ((counterBufferCount)) * sizeof(VkDeviceSize);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -25542,15 +35865,38 @@
}
void VkEncoder::vkCmdEndTransformFeedbackEXT(
- VkCommandBuffer commandBuffer,
- uint32_t firstCounterBuffer,
- uint32_t counterBufferCount,
- const VkBuffer* pCounterBuffers,
- const VkDeviceSize* pCounterBufferOffsets,
- uint32_t doLock)
-{
+ VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount,
+ const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdEndTransformFeedbackEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdEndTransformFeedbackEXT(commandBuffer:%p, firstCounterBuffer:%d, "
+ "counterBufferCount:%d, pCounterBuffers:%p, pCounterBufferOffsets:%p)",
+ commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers,
+ pCounterBufferOffsets);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -25575,29 +35921,29 @@
*countPtr += sizeof(uint32_t);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pCounterBuffers)
- {
- if (((counterBufferCount)))
- {
+ if (local_pCounterBuffers) {
+ if (((counterBufferCount))) {
*countPtr += ((counterBufferCount)) * 8;
}
}
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pCounterBufferOffsets)
- {
+ if (local_pCounterBufferOffsets) {
*countPtr += ((counterBufferCount)) * sizeof(VkDeviceSize);
}
}
uint32_t packetSize_vkCmdEndTransformFeedbackEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdEndTransformFeedbackEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEndTransformFeedbackEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdEndTransformFeedbackEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdEndTransformFeedbackEXT = OP_vkCmdEndTransformFeedbackEXT;
- memcpy(streamPtr, &opcode_vkCmdEndTransformFeedbackEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdEndTransformFeedbackEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdEndTransformFeedbackEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdEndTransformFeedbackEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -25612,13 +35958,10 @@
memcpy((*streamPtrPtr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pCounterBuffers)
- {
- if (((counterBufferCount)))
- {
+ if (local_pCounterBuffers) {
+ if (((counterBufferCount))) {
uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((counterBufferCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((counterBufferCount)); ++k) {
uint64_t tmpval = get_host_u64_VkBuffer(local_pCounterBuffers[k]);
memcpy(cgen_var_0_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -25630,30 +35973,51 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pCounterBufferOffsets)
- {
- memcpy(*streamPtrPtr, (VkDeviceSize*)local_pCounterBufferOffsets, ((counterBufferCount)) * sizeof(VkDeviceSize));
+ if (local_pCounterBufferOffsets) {
+ memcpy(*streamPtrPtr, (VkDeviceSize*)local_pCounterBufferOffsets,
+ ((counterBufferCount)) * sizeof(VkDeviceSize));
*streamPtrPtr += ((counterBufferCount)) * sizeof(VkDeviceSize);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdBeginQueryIndexedEXT(
- VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t query,
- VkQueryControlFlags flags,
- uint32_t index,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t query, VkQueryControlFlags flags, uint32_t index,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBeginQueryIndexedEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdBeginQueryIndexedEXT(commandBuffer:%p, queryPool:%p, query:%d, flags:%d, index:%d)",
+ commandBuffer, queryPool, query, flags, index);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -25679,14 +36043,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdBeginQueryIndexedEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBeginQueryIndexedEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginQueryIndexedEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBeginQueryIndexedEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBeginQueryIndexedEXT = OP_vkCmdBeginQueryIndexedEXT;
- memcpy(streamPtr, &opcode_vkCmdBeginQueryIndexedEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBeginQueryIndexedEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBeginQueryIndexedEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBeginQueryIndexedEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -25702,24 +36068,44 @@
*streamPtrPtr += sizeof(VkQueryControlFlags);
memcpy(*streamPtrPtr, (uint32_t*)&local_index, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdEndQueryIndexedEXT(
- VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t query,
- uint32_t index,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t query, uint32_t index, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdEndQueryIndexedEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdEndQueryIndexedEXT(commandBuffer:%p, queryPool:%p, query:%d, index:%d)",
+ commandBuffer, queryPool, query, index);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -25742,14 +36128,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdEndQueryIndexedEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdEndQueryIndexedEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEndQueryIndexedEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdEndQueryIndexedEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdEndQueryIndexedEXT = OP_vkCmdEndQueryIndexedEXT;
- memcpy(streamPtr, &opcode_vkCmdEndQueryIndexedEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdEndQueryIndexedEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdEndQueryIndexedEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdEndQueryIndexedEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -25763,27 +36151,50 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_index, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdDrawIndirectByteCountEXT(
- VkCommandBuffer commandBuffer,
- uint32_t instanceCount,
- uint32_t firstInstance,
- VkBuffer counterBuffer,
- VkDeviceSize counterBufferOffset,
- uint32_t counterOffset,
- uint32_t vertexStride,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount,
+ uint32_t firstInstance, VkBuffer counterBuffer,
+ VkDeviceSize counterBufferOffset,
+ uint32_t counterOffset, uint32_t vertexStride,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDrawIndirectByteCountEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdDrawIndirectByteCountEXT(commandBuffer:%p, instanceCount:%d, firstInstance:%d, "
+ "counterBuffer:%p, counterBufferOffset:%ld, counterOffset:%d, vertexStride:%d)",
+ commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset,
+ counterOffset, vertexStride);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -25815,14 +36226,17 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDrawIndirectByteCountEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdDrawIndirectByteCountEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawIndirectByteCountEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawIndirectByteCountEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDrawIndirectByteCountEXT = OP_vkCmdDrawIndirectByteCountEXT;
- memcpy(streamPtr, &opcode_vkCmdDrawIndirectByteCountEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDrawIndirectByteCountEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDrawIndirectByteCountEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDrawIndirectByteCountEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -25842,9 +36256,9 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_vertexStride, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -25853,15 +36267,36 @@
#endif
#ifdef VK_NVX_binary_import
-VkResult VkEncoder::vkCreateCuModuleNVX(
- VkDevice device,
- const VkCuModuleCreateInfoNVX* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkCuModuleNVX* pModule,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCuModuleNVX* pModule, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateCuModuleNVX in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCreateCuModuleNVX(device:%p, pCreateInfo:%p, pAllocator:%p, pModule:%p)",
+ device, pCreateInfo, pAllocator, pModule);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -25870,61 +36305,75 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkCuModuleCreateInfoNVX*)pool->alloc(sizeof(const VkCuModuleCreateInfoNVX));
- deepcopy_VkCuModuleCreateInfoNVX(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkCuModuleCreateInfoNVX*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkCuModuleCreateInfoNVX*)pool->alloc(sizeof(const VkCuModuleCreateInfoNVX));
+ deepcopy_VkCuModuleCreateInfoNVX(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkCuModuleCreateInfoNVX*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkCuModuleCreateInfoNVX(sResourceTracker, (VkCuModuleCreateInfoNVX*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkCuModuleCreateInfoNVX(sResourceTracker,
+ (VkCuModuleCreateInfoNVX*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCuModuleCreateInfoNVX(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCuModuleCreateInfoNVX*)(local_pCreateInfo), countPtr);
+ count_VkCuModuleCreateInfoNVX(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCuModuleCreateInfoNVX*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
*countPtr += 8;
}
- uint32_t packetSize_vkCreateCuModuleNVX = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateCuModuleNVX =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateCuModuleNVX);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateCuModuleNVX);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateCuModuleNVX = OP_vkCreateCuModuleNVX;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateCuModuleNVX, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateCuModuleNVX, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateCuModuleNVX, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateCuModuleNVX, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkCuModuleCreateInfoNVX(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCuModuleCreateInfoNVX*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkCuModuleCreateInfoNVX(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCuModuleCreateInfoNVX*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
uint64_t cgen_var_2 = (uint64_t)(*pModule);
memcpy((*streamPtrPtr), &cgen_var_2, 8);
@@ -25933,9 +36382,9 @@
(*pModule) = (VkCuModuleNVX)stream->getBe64();
VkResult vkCreateCuModuleNVX_VkResult_return = (VkResult)0;
stream->read(&vkCreateCuModuleNVX_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -25943,15 +36392,38 @@
return vkCreateCuModuleNVX_VkResult_return;
}
-VkResult VkEncoder::vkCreateCuFunctionNVX(
- VkDevice device,
- const VkCuFunctionCreateInfoNVX* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkCuFunctionNVX* pFunction,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateCuFunctionNVX(VkDevice device,
+ const VkCuFunctionCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCuFunctionNVX* pFunction, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateCuFunctionNVX in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateCuFunctionNVX(device:%p, pCreateInfo:%p, pAllocator:%p, pFunction:%p)", device,
+ pCreateInfo, pAllocator, pFunction);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -25960,61 +36432,75 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkCuFunctionCreateInfoNVX*)pool->alloc(sizeof(const VkCuFunctionCreateInfoNVX));
- deepcopy_VkCuFunctionCreateInfoNVX(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkCuFunctionCreateInfoNVX*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkCuFunctionCreateInfoNVX*)pool->alloc(sizeof(const VkCuFunctionCreateInfoNVX));
+ deepcopy_VkCuFunctionCreateInfoNVX(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkCuFunctionCreateInfoNVX*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkCuFunctionCreateInfoNVX(sResourceTracker, (VkCuFunctionCreateInfoNVX*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkCuFunctionCreateInfoNVX(sResourceTracker,
+ (VkCuFunctionCreateInfoNVX*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCuFunctionCreateInfoNVX(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCuFunctionCreateInfoNVX*)(local_pCreateInfo), countPtr);
+ count_VkCuFunctionCreateInfoNVX(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCuFunctionCreateInfoNVX*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
*countPtr += 8;
}
- uint32_t packetSize_vkCreateCuFunctionNVX = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateCuFunctionNVX =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateCuFunctionNVX);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateCuFunctionNVX);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateCuFunctionNVX = OP_vkCreateCuFunctionNVX;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateCuFunctionNVX, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateCuFunctionNVX, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateCuFunctionNVX, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateCuFunctionNVX, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkCuFunctionCreateInfoNVX(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCuFunctionCreateInfoNVX*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkCuFunctionCreateInfoNVX(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCuFunctionCreateInfoNVX*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
uint64_t cgen_var_2 = (uint64_t)(*pFunction);
memcpy((*streamPtrPtr), &cgen_var_2, 8);
@@ -26023,9 +36509,9 @@
(*pFunction) = (VkCuFunctionNVX)stream->getBe64();
VkResult vkCreateCuFunctionNVX_VkResult_return = (VkResult)0;
stream->read(&vkCreateCuFunctionNVX_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -26033,14 +36519,34 @@
return vkCreateCuFunctionNVX_VkResult_return;
}
-void VkEncoder::vkDestroyCuModuleNVX(
- VkDevice device,
- VkCuModuleNVX module,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyCuModuleNVX in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyCuModuleNVX(device:%p, pAllocator:%p)", device, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -26050,15 +36556,15 @@
local_device = device;
local_module = module;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -26068,19 +36574,28 @@
*countPtr += 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyCuModuleNVX = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyCuModuleNVX =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyCuModuleNVX);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyCuModuleNVX);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyCuModuleNVX = OP_vkDestroyCuModuleNVX;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyCuModuleNVX, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyCuModuleNVX, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyCuModuleNVX, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyCuModuleNVX, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -26094,28 +36609,49 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkDestroyCuFunctionNVX(
- VkDevice device,
- VkCuFunctionNVX function,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyCuFunctionNVX in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyCuFunctionNVX(device:%p, pAllocator:%p)", device, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -26125,15 +36661,15 @@
local_device = device;
local_function = function;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -26143,19 +36679,28 @@
*countPtr += 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyCuFunctionNVX = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyCuFunctionNVX =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyCuFunctionNVX);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyCuFunctionNVX);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyCuFunctionNVX = OP_vkDestroyCuFunctionNVX;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyCuFunctionNVX, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyCuFunctionNVX, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyCuFunctionNVX, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyCuFunctionNVX, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -26169,27 +36714,50 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdCuLaunchKernelNVX(
- VkCommandBuffer commandBuffer,
- const VkCuLaunchInfoNVX* pLaunchInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer,
+ const VkCuLaunchInfoNVX* pLaunchInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdCuLaunchKernelNVX in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdCuLaunchKernelNVX(commandBuffer:%p, pLaunchInfo:%p)", commandBuffer,
+ pLaunchInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -26197,40 +36765,44 @@
VkCuLaunchInfoNVX* local_pLaunchInfo;
local_commandBuffer = commandBuffer;
local_pLaunchInfo = nullptr;
- if (pLaunchInfo)
- {
+ if (pLaunchInfo) {
local_pLaunchInfo = (VkCuLaunchInfoNVX*)pool->alloc(sizeof(const VkCuLaunchInfoNVX));
- deepcopy_VkCuLaunchInfoNVX(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pLaunchInfo, (VkCuLaunchInfoNVX*)(local_pLaunchInfo));
+ deepcopy_VkCuLaunchInfoNVX(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pLaunchInfo,
+ (VkCuLaunchInfoNVX*)(local_pLaunchInfo));
}
- if (local_pLaunchInfo)
- {
- transform_tohost_VkCuLaunchInfoNVX(sResourceTracker, (VkCuLaunchInfoNVX*)(local_pLaunchInfo));
+ if (local_pLaunchInfo) {
+ transform_tohost_VkCuLaunchInfoNVX(sResourceTracker,
+ (VkCuLaunchInfoNVX*)(local_pLaunchInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCuLaunchInfoNVX(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCuLaunchInfoNVX*)(local_pLaunchInfo), countPtr);
+ count_VkCuLaunchInfoNVX(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCuLaunchInfoNVX*)(local_pLaunchInfo), countPtr);
}
uint32_t packetSize_vkCmdCuLaunchKernelNVX = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdCuLaunchKernelNVX);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCuLaunchKernelNVX -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCuLaunchKernelNVX);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdCuLaunchKernelNVX = OP_vkCmdCuLaunchKernelNVX;
- memcpy(streamPtr, &opcode_vkCmdCuLaunchKernelNVX, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdCuLaunchKernelNVX, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdCuLaunchKernelNVX, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdCuLaunchKernelNVX, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkCuLaunchInfoNVX(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCuLaunchInfoNVX*)(local_pLaunchInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkCuLaunchInfoNVX(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCuLaunchInfoNVX*)(local_pLaunchInfo), streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -26239,13 +36811,34 @@
#endif
#ifdef VK_NVX_image_view_handle
-uint32_t VkEncoder::vkGetImageViewHandleNVX(
- VkDevice device,
- const VkImageViewHandleInfoNVX* pInfo,
- uint32_t doLock)
-{
+uint32_t VkEncoder::vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetImageViewHandleNVX in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetImageViewHandleNVX(device:%p, pInfo:%p)", device, pInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -26253,40 +36846,52 @@
VkImageViewHandleInfoNVX* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkImageViewHandleInfoNVX*)pool->alloc(sizeof(const VkImageViewHandleInfoNVX));
- deepcopy_VkImageViewHandleInfoNVX(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkImageViewHandleInfoNVX*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo =
+ (VkImageViewHandleInfoNVX*)pool->alloc(sizeof(const VkImageViewHandleInfoNVX));
+ deepcopy_VkImageViewHandleInfoNVX(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkImageViewHandleInfoNVX*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkImageViewHandleInfoNVX(sResourceTracker, (VkImageViewHandleInfoNVX*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkImageViewHandleInfoNVX(sResourceTracker,
+ (VkImageViewHandleInfoNVX*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImageViewHandleInfoNVX(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageViewHandleInfoNVX*)(local_pInfo), countPtr);
+ count_VkImageViewHandleInfoNVX(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageViewHandleInfoNVX*)(local_pInfo), countPtr);
}
- uint32_t packetSize_vkGetImageViewHandleNVX = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetImageViewHandleNVX =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetImageViewHandleNVX);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageViewHandleNVX);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetImageViewHandleNVX = OP_vkGetImageViewHandleNVX;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetImageViewHandleNVX, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetImageViewHandleNVX, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetImageViewHandleNVX, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetImageViewHandleNVX, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageViewHandleInfoNVX(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageViewHandleInfoNVX*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkImageViewHandleInfoNVX(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageViewHandleInfoNVX*)(local_pInfo), streamPtrPtr);
uint32_t vkGetImageViewHandleNVX_uint32_t_return = (uint32_t)0;
stream->read(&vkGetImageViewHandleNVX_uint32_t_return, sizeof(uint32_t));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -26294,14 +36899,36 @@
return vkGetImageViewHandleNVX_uint32_t_return;
}
-VkResult VkEncoder::vkGetImageViewAddressNVX(
- VkDevice device,
- VkImageView imageView,
- VkImageViewAddressPropertiesNVX* pProperties,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView,
+ VkImageViewAddressPropertiesNVX* pProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetImageViewAddressNVX in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetImageViewAddressNVX(device:%p, imageView:%p, pProperties:%p)", device,
+ imageView, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -26316,16 +36943,27 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkImageViewAddressPropertiesNVX(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageViewAddressPropertiesNVX*)(pProperties), countPtr);
+ count_VkImageViewAddressPropertiesNVX(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageViewAddressPropertiesNVX*)(pProperties),
+ countPtr);
}
- uint32_t packetSize_vkGetImageViewAddressNVX = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetImageViewAddressNVX =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetImageViewAddressNVX);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageViewAddressNVX);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetImageViewAddressNVX = OP_vkGetImageViewAddressNVX;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetImageViewAddressNVX, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetImageViewAddressNVX, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetImageViewAddressNVX, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetImageViewAddressNVX, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -26334,17 +36972,20 @@
*&cgen_var_1 = get_host_u64_VkImageView((*&local_imageView));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageViewAddressPropertiesNVX(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageViewAddressPropertiesNVX*)(pProperties), streamPtrPtr);
- unmarshal_VkImageViewAddressPropertiesNVX(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageViewAddressPropertiesNVX*)(pProperties));
- if (pProperties)
- {
- transform_fromhost_VkImageViewAddressPropertiesNVX(sResourceTracker, (VkImageViewAddressPropertiesNVX*)(pProperties));
+ reservedmarshal_VkImageViewAddressPropertiesNVX(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageViewAddressPropertiesNVX*)(pProperties),
+ streamPtrPtr);
+ unmarshal_VkImageViewAddressPropertiesNVX(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageViewAddressPropertiesNVX*)(pProperties));
+ if (pProperties) {
+ transform_fromhost_VkImageViewAddressPropertiesNVX(
+ sResourceTracker, (VkImageViewAddressPropertiesNVX*)(pProperties));
}
VkResult vkGetImageViewAddressNVX_VkResult_return = (VkResult)0;
stream->read(&vkGetImageViewAddressNVX_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -26354,18 +36995,39 @@
#endif
#ifdef VK_AMD_draw_indirect_count
-void VkEncoder::vkCmdDrawIndirectCountAMD(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+ uint32_t stride, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDrawIndirectCountAMD in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdDrawIndirectCountAMD(commandBuffer:%p, buffer:%p, offset:%ld, countBuffer:%p, "
+ "countBufferOffset:%ld, maxDrawCount:%d, stride:%d)",
+ commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -26398,14 +37060,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDrawIndirectCountAMD = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDrawIndirectCountAMD);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawIndirectCountAMD -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawIndirectCountAMD);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDrawIndirectCountAMD = OP_vkCmdDrawIndirectCountAMD;
- memcpy(streamPtr, &opcode_vkCmdDrawIndirectCountAMD, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDrawIndirectCountAMD, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDrawIndirectCountAMD, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDrawIndirectCountAMD, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -26427,27 +37091,49 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_stride, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdDrawIndexedIndirectCountAMD(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount, uint32_t stride,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDrawIndexedIndirectCountAMD in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdDrawIndexedIndirectCountAMD(commandBuffer:%p, buffer:%p, offset:%ld, countBuffer:%p, "
+ "countBufferOffset:%ld, maxDrawCount:%d, stride:%d)",
+ commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -26480,14 +37166,17 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDrawIndexedIndirectCountAMD = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdDrawIndexedIndirectCountAMD);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawIndexedIndirectCountAMD -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawIndexedIndirectCountAMD);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDrawIndexedIndirectCountAMD = OP_vkCmdDrawIndexedIndirectCountAMD;
- memcpy(streamPtr, &opcode_vkCmdDrawIndexedIndirectCountAMD, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDrawIndexedIndirectCountAMD, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDrawIndexedIndirectCountAMD, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDrawIndexedIndirectCountAMD, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -26509,9 +37198,9 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_stride, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -26534,17 +37223,37 @@
#ifdef VK_AMD_texture_gather_bias_lod
#endif
#ifdef VK_AMD_shader_info
-VkResult VkEncoder::vkGetShaderInfoAMD(
- VkDevice device,
- VkPipeline pipeline,
- VkShaderStageFlagBits shaderStage,
- VkShaderInfoTypeAMD infoType,
- size_t* pInfoSize,
- void* pInfo,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline,
+ VkShaderStageFlagBits shaderStage,
+ VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetShaderInfoAMD in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetShaderInfoAMD(device:%p, pipeline:%p, pInfoSize:%p, pInfo:%p)", device,
+ pipeline, pInfoSize, pInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -26567,28 +37276,34 @@
*countPtr += sizeof(VkShaderInfoTypeAMD);
// WARNING PTR CHECK
*countPtr += 8;
- if (pInfoSize)
- {
+ if (pInfoSize) {
*countPtr += 8;
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pInfo)
- {
- if (pInfoSize)
- {
+ if (pInfo) {
+ if (pInfoSize) {
*countPtr += (*(pInfoSize)) * sizeof(uint8_t);
}
}
}
- uint32_t packetSize_vkGetShaderInfoAMD = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetShaderInfoAMD =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetShaderInfoAMD);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetShaderInfoAMD);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetShaderInfoAMD = OP_vkGetShaderInfoAMD;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetShaderInfoAMD, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetShaderInfoAMD, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetShaderInfoAMD, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetShaderInfoAMD, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -26597,7 +37312,8 @@
*&cgen_var_1 = get_host_u64_VkPipeline((*&local_pipeline));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- memcpy(*streamPtrPtr, (VkShaderStageFlagBits*)&local_shaderStage, sizeof(VkShaderStageFlagBits));
+ memcpy(*streamPtrPtr, (VkShaderStageFlagBits*)&local_shaderStage,
+ sizeof(VkShaderStageFlagBits));
*streamPtrPtr += sizeof(VkShaderStageFlagBits);
memcpy(*streamPtrPtr, (VkShaderInfoTypeAMD*)&local_infoType, sizeof(VkShaderInfoTypeAMD));
*streamPtrPtr += sizeof(VkShaderInfoTypeAMD);
@@ -26606,8 +37322,7 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pInfoSize)
- {
+ if (pInfoSize) {
uint64_t cgen_var_2_0 = (uint64_t)(*pInfoSize);
memcpy((*streamPtrPtr), &cgen_var_2_0, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
@@ -26618,18 +37333,15 @@
memcpy((*streamPtrPtr), &cgen_var_3, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pInfo)
- {
+ if (pInfo) {
memcpy(*streamPtrPtr, (void*)pInfo, (*(pInfoSize)) * sizeof(uint8_t));
*streamPtrPtr += (*(pInfoSize)) * sizeof(uint8_t);
}
// WARNING PTR CHECK
size_t* check_pInfoSize;
check_pInfoSize = (size_t*)(uintptr_t)stream->getBe64();
- if (pInfoSize)
- {
- if (!(check_pInfoSize))
- {
+ if (pInfoSize) {
+ if (!(check_pInfoSize)) {
fprintf(stderr, "fatal: pInfoSize inconsistent between guest and host\n");
}
(*pInfoSize) = (size_t)stream->getBe64();
@@ -26637,19 +37349,17 @@
// WARNING PTR CHECK
void* check_pInfo;
check_pInfo = (void*)(uintptr_t)stream->getBe64();
- if (pInfo)
- {
- if (!(check_pInfo))
- {
+ if (pInfo) {
+ if (!(check_pInfo)) {
fprintf(stderr, "fatal: pInfo inconsistent between guest and host\n");
}
stream->read((void*)pInfo, (*(pInfoSize)) * sizeof(uint8_t));
}
VkResult vkGetShaderInfoAMD_VkResult_return = (VkResult)0;
stream->read(&vkGetShaderInfoAMD_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -26662,14 +37372,37 @@
#endif
#ifdef VK_GGP_stream_descriptor_surface
VkResult VkEncoder::vkCreateStreamDescriptorSurfaceGGP(
- VkInstance instance,
- const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock)
-{
+ VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateStreamDescriptorSurfaceGGP in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateStreamDescriptorSurfaceGGP(instance:%p, pCreateInfo:%p, pAllocator:%p, "
+ "pSurface:%p)",
+ instance, pCreateInfo, pAllocator, pSurface);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -26678,62 +37411,79 @@
VkAllocationCallbacks* local_pAllocator;
local_instance = instance;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkStreamDescriptorSurfaceCreateInfoGGP*)pool->alloc(sizeof(const VkStreamDescriptorSurfaceCreateInfoGGP));
- deepcopy_VkStreamDescriptorSurfaceCreateInfoGGP(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkStreamDescriptorSurfaceCreateInfoGGP*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkStreamDescriptorSurfaceCreateInfoGGP*)pool->alloc(
+ sizeof(const VkStreamDescriptorSurfaceCreateInfoGGP));
+ deepcopy_VkStreamDescriptorSurfaceCreateInfoGGP(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkStreamDescriptorSurfaceCreateInfoGGP*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkStreamDescriptorSurfaceCreateInfoGGP(sResourceTracker, (VkStreamDescriptorSurfaceCreateInfoGGP*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkStreamDescriptorSurfaceCreateInfoGGP(
+ sResourceTracker, (VkStreamDescriptorSurfaceCreateInfoGGP*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkStreamDescriptorSurfaceCreateInfoGGP(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStreamDescriptorSurfaceCreateInfoGGP*)(local_pCreateInfo), countPtr);
+ count_VkStreamDescriptorSurfaceCreateInfoGGP(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStreamDescriptorSurfaceCreateInfoGGP*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateStreamDescriptorSurfaceGGP = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateStreamDescriptorSurfaceGGP =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCreateStreamDescriptorSurfaceGGP);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateStreamDescriptorSurfaceGGP);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateStreamDescriptorSurfaceGGP = OP_vkCreateStreamDescriptorSurfaceGGP;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateStreamDescriptorSurfaceGGP, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateStreamDescriptorSurfaceGGP, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateStreamDescriptorSurfaceGGP, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateStreamDescriptorSurfaceGGP, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkStreamDescriptorSurfaceCreateInfoGGP(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStreamDescriptorSurfaceCreateInfoGGP*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkStreamDescriptorSurfaceCreateInfoGGP(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStreamDescriptorSurfaceCreateInfoGGP*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -26746,9 +37496,9 @@
stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_3, (VkSurfaceKHR*)pSurface, 1);
VkResult vkCreateStreamDescriptorSurfaceGGP_VkResult_return = (VkResult)0;
stream->read(&vkCreateStreamDescriptorSurfaceGGP_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -26763,18 +37513,40 @@
#endif
#ifdef VK_NV_external_memory_capabilities
VkResult VkEncoder::vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
- VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkImageType type,
- VkImageTiling tiling,
- VkImageUsageFlags usage,
- VkImageCreateFlags flags,
+ VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling,
+ VkImageUsageFlags usage, VkImageCreateFlags flags,
VkExternalMemoryHandleTypeFlagsNV externalHandleType,
- VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties,
- uint32_t doLock)
-{
+ VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceExternalImageFormatPropertiesNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice:%p, format:%d, "
+ "usage:%d, flags:%d, pExternalImageFormatProperties:%p)",
+ physicalDevice, format, usage, flags, pExternalImageFormatProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -26803,16 +37575,31 @@
*countPtr += sizeof(VkImageUsageFlags);
*countPtr += sizeof(VkImageCreateFlags);
*countPtr += sizeof(VkExternalMemoryHandleTypeFlagsNV);
- count_VkExternalImageFormatPropertiesNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties), countPtr);
+ count_VkExternalImageFormatPropertiesNV(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties), countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceExternalImageFormatPropertiesNV);
+ uint32_t packetSize_vkGetPhysicalDeviceExternalImageFormatPropertiesNV =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceExternalImageFormatPropertiesNV);
+ uint8_t* streamPtr =
+ stream->reserve(packetSize_vkGetPhysicalDeviceExternalImageFormatPropertiesNV);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = OP_vkGetPhysicalDeviceExternalImageFormatPropertiesNV;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceExternalImageFormatPropertiesNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceExternalImageFormatPropertiesNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceExternalImageFormatPropertiesNV =
+ OP_vkGetPhysicalDeviceExternalImageFormatPropertiesNV;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceExternalImageFormatPropertiesNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceExternalImageFormatPropertiesNV,
+ sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -26827,19 +37614,25 @@
*streamPtrPtr += sizeof(VkImageUsageFlags);
memcpy(*streamPtrPtr, (VkImageCreateFlags*)&local_flags, sizeof(VkImageCreateFlags));
*streamPtrPtr += sizeof(VkImageCreateFlags);
- memcpy(*streamPtrPtr, (VkExternalMemoryHandleTypeFlagsNV*)&local_externalHandleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ memcpy(*streamPtrPtr, (VkExternalMemoryHandleTypeFlagsNV*)&local_externalHandleType,
+ sizeof(VkExternalMemoryHandleTypeFlagsNV));
*streamPtrPtr += sizeof(VkExternalMemoryHandleTypeFlagsNV);
- reservedmarshal_VkExternalImageFormatPropertiesNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties), streamPtrPtr);
- unmarshal_VkExternalImageFormatPropertiesNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties));
- if (pExternalImageFormatProperties)
- {
- transform_fromhost_VkExternalImageFormatPropertiesNV(sResourceTracker, (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties));
+ reservedmarshal_VkExternalImageFormatPropertiesNV(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties), streamPtrPtr);
+ unmarshal_VkExternalImageFormatPropertiesNV(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties));
+ if (pExternalImageFormatProperties) {
+ transform_fromhost_VkExternalImageFormatPropertiesNV(
+ sResourceTracker, (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties));
}
VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return = (VkResult)0;
- stream->read(&vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ stream->read(&vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return,
+ sizeof(VkResult));
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -26851,15 +37644,36 @@
#ifdef VK_NV_external_memory
#endif
#ifdef VK_NV_external_memory_win32
-VkResult VkEncoder::vkGetMemoryWin32HandleNV(
- VkDevice device,
- VkDeviceMemory memory,
- VkExternalMemoryHandleTypeFlagsNV handleType,
- HANDLE* pHandle,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory,
+ VkExternalMemoryHandleTypeFlagsNV handleType,
+ HANDLE* pHandle, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetMemoryWin32HandleNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetMemoryWin32HandleNV(device:%p, memory:%p, pHandle:%p)", device, memory,
+ pHandle);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -26869,7 +37683,9 @@
local_device = device;
local_memory = memory;
local_handleType = handleType;
- sResourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ sResourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0,
+ (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
size_t count = 0;
size_t* countPtr = &count;
{
@@ -26880,14 +37696,23 @@
*countPtr += sizeof(VkExternalMemoryHandleTypeFlagsNV);
*countPtr += sizeof(HANDLE);
}
- uint32_t packetSize_vkGetMemoryWin32HandleNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetMemoryWin32HandleNV =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetMemoryWin32HandleNV);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetMemoryWin32HandleNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetMemoryWin32HandleNV = OP_vkGetMemoryWin32HandleNV;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetMemoryWin32HandleNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetMemoryWin32HandleNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetMemoryWin32HandleNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetMemoryWin32HandleNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -26896,16 +37721,17 @@
*&cgen_var_1 = get_host_u64_VkDeviceMemory((*&local_memory));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- memcpy(*streamPtrPtr, (VkExternalMemoryHandleTypeFlagsNV*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ memcpy(*streamPtrPtr, (VkExternalMemoryHandleTypeFlagsNV*)&local_handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagsNV));
*streamPtrPtr += sizeof(VkExternalMemoryHandleTypeFlagsNV);
memcpy(*streamPtrPtr, (HANDLE*)pHandle, sizeof(HANDLE));
*streamPtrPtr += sizeof(HANDLE);
stream->read((HANDLE*)pHandle, sizeof(HANDLE));
VkResult vkGetMemoryWin32HandleNV_VkResult_return = (VkResult)0;
stream->read(&vkGetMemoryWin32HandleNV_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -26919,15 +37745,38 @@
#ifdef VK_EXT_validation_flags
#endif
#ifdef VK_NN_vi_surface
-VkResult VkEncoder::vkCreateViSurfaceNN(
- VkInstance instance,
- const VkViSurfaceCreateInfoNN* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateViSurfaceNN(VkInstance instance,
+ const VkViSurfaceCreateInfoNN* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateViSurfaceNN in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateViSurfaceNN(instance:%p, pCreateInfo:%p, pAllocator:%p, pSurface:%p)", instance,
+ pCreateInfo, pAllocator, pSurface);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -26936,62 +37785,76 @@
VkAllocationCallbacks* local_pAllocator;
local_instance = instance;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkViSurfaceCreateInfoNN*)pool->alloc(sizeof(const VkViSurfaceCreateInfoNN));
- deepcopy_VkViSurfaceCreateInfoNN(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkViSurfaceCreateInfoNN*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkViSurfaceCreateInfoNN*)pool->alloc(sizeof(const VkViSurfaceCreateInfoNN));
+ deepcopy_VkViSurfaceCreateInfoNN(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkViSurfaceCreateInfoNN*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkViSurfaceCreateInfoNN(sResourceTracker, (VkViSurfaceCreateInfoNN*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkViSurfaceCreateInfoNN(sResourceTracker,
+ (VkViSurfaceCreateInfoNN*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkViSurfaceCreateInfoNN(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkViSurfaceCreateInfoNN*)(local_pCreateInfo), countPtr);
+ count_VkViSurfaceCreateInfoNN(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkViSurfaceCreateInfoNN*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateViSurfaceNN = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateViSurfaceNN =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateViSurfaceNN);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateViSurfaceNN);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateViSurfaceNN = OP_vkCreateViSurfaceNN;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateViSurfaceNN, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateViSurfaceNN, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateViSurfaceNN, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateViSurfaceNN, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkViSurfaceCreateInfoNN(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkViSurfaceCreateInfoNN*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkViSurfaceCreateInfoNN(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkViSurfaceCreateInfoNN*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -27004,9 +37867,9 @@
stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_3, (VkSurfaceKHR*)pSurface, 1);
VkResult vkCreateViSurfaceNN_VkResult_return = (VkResult)0;
stream->read(&vkCreateViSurfaceNN_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -27026,11 +37889,35 @@
#ifdef VK_EXT_conditional_rendering
void VkEncoder::vkCmdBeginConditionalRenderingEXT(
VkCommandBuffer commandBuffer,
- const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin,
- uint32_t doLock)
-{
+ const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBeginConditionalRenderingEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdBeginConditionalRenderingEXT(commandBuffer:%p, pConditionalRenderingBegin:%p)",
+ commandBuffer, pConditionalRenderingBegin);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -27038,52 +37925,83 @@
VkConditionalRenderingBeginInfoEXT* local_pConditionalRenderingBegin;
local_commandBuffer = commandBuffer;
local_pConditionalRenderingBegin = nullptr;
- if (pConditionalRenderingBegin)
- {
- local_pConditionalRenderingBegin = (VkConditionalRenderingBeginInfoEXT*)pool->alloc(sizeof(const VkConditionalRenderingBeginInfoEXT));
- deepcopy_VkConditionalRenderingBeginInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pConditionalRenderingBegin, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin));
+ if (pConditionalRenderingBegin) {
+ local_pConditionalRenderingBegin = (VkConditionalRenderingBeginInfoEXT*)pool->alloc(
+ sizeof(const VkConditionalRenderingBeginInfoEXT));
+ deepcopy_VkConditionalRenderingBeginInfoEXT(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pConditionalRenderingBegin,
+ (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin));
}
- if (local_pConditionalRenderingBegin)
- {
- transform_tohost_VkConditionalRenderingBeginInfoEXT(sResourceTracker, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin));
+ if (local_pConditionalRenderingBegin) {
+ transform_tohost_VkConditionalRenderingBeginInfoEXT(
+ sResourceTracker,
+ (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkConditionalRenderingBeginInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin), countPtr);
+ count_VkConditionalRenderingBeginInfoEXT(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin), countPtr);
}
uint32_t packetSize_vkCmdBeginConditionalRenderingEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdBeginConditionalRenderingEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginConditionalRenderingEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBeginConditionalRenderingEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBeginConditionalRenderingEXT = OP_vkCmdBeginConditionalRenderingEXT;
- memcpy(streamPtr, &opcode_vkCmdBeginConditionalRenderingEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBeginConditionalRenderingEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBeginConditionalRenderingEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBeginConditionalRenderingEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkConditionalRenderingBeginInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkConditionalRenderingBeginInfoEXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin), streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdEndConditionalRenderingEXT(
- VkCommandBuffer commandBuffer,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdEndConditionalRenderingEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdEndConditionalRenderingEXT(commandBuffer:%p)", commandBuffer);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -27096,22 +38014,25 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkCmdEndConditionalRenderingEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdEndConditionalRenderingEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEndConditionalRenderingEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdEndConditionalRenderingEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdEndConditionalRenderingEXT = OP_vkCmdEndConditionalRenderingEXT;
- memcpy(streamPtr, &opcode_vkCmdEndConditionalRenderingEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdEndConditionalRenderingEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdEndConditionalRenderingEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdEndConditionalRenderingEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -27120,15 +38041,39 @@
#endif
#ifdef VK_NV_clip_space_w_scaling
-void VkEncoder::vkCmdSetViewportWScalingNV(
- VkCommandBuffer commandBuffer,
- uint32_t firstViewport,
- uint32_t viewportCount,
- const VkViewportWScalingNV* pViewportWScalings,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewportWScalingNV* pViewportWScalings,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetViewportWScalingNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdSetViewportWScalingNV(commandBuffer:%p, firstViewport:%d, viewportCount:%d, "
+ "pViewportWScalings:%p)",
+ commandBuffer, firstViewport, viewportCount, pViewportWScalings);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -27140,19 +38085,18 @@
local_firstViewport = firstViewport;
local_viewportCount = viewportCount;
local_pViewportWScalings = nullptr;
- if (pViewportWScalings)
- {
- local_pViewportWScalings = (VkViewportWScalingNV*)pool->alloc(((viewportCount)) * sizeof(const VkViewportWScalingNV));
- for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
- {
- deepcopy_VkViewportWScalingNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pViewportWScalings + i, (VkViewportWScalingNV*)(local_pViewportWScalings + i));
+ if (pViewportWScalings) {
+ local_pViewportWScalings = (VkViewportWScalingNV*)pool->alloc(
+ ((viewportCount)) * sizeof(const VkViewportWScalingNV));
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+ deepcopy_VkViewportWScalingNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pViewportWScalings + i,
+ (VkViewportWScalingNV*)(local_pViewportWScalings + i));
}
}
- if (local_pViewportWScalings)
- {
- for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
- {
- transform_tohost_VkViewportWScalingNV(sResourceTracker, (VkViewportWScalingNV*)(local_pViewportWScalings + i));
+ if (local_pViewportWScalings) {
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+ transform_tohost_VkViewportWScalingNV(
+ sResourceTracker, (VkViewportWScalingNV*)(local_pViewportWScalings + i));
}
}
size_t count = 0;
@@ -27162,20 +38106,23 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
- {
- count_VkViewportWScalingNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkViewportWScalingNV*)(local_pViewportWScalings + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+ count_VkViewportWScalingNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkViewportWScalingNV*)(local_pViewportWScalings + i),
+ countPtr);
}
}
uint32_t packetSize_vkCmdSetViewportWScalingNV = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetViewportWScalingNV);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetViewportWScalingNV -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetViewportWScalingNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetViewportWScalingNV = OP_vkCmdSetViewportWScalingNV;
- memcpy(streamPtr, &opcode_vkCmdSetViewportWScalingNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetViewportWScalingNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetViewportWScalingNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetViewportWScalingNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -27185,13 +38132,14 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_viewportCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
- {
- reservedmarshal_VkViewportWScalingNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkViewportWScalingNV*)(local_pViewportWScalings + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+ reservedmarshal_VkViewportWScalingNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkViewportWScalingNV*)(local_pViewportWScalings + i),
+ streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -27200,13 +38148,35 @@
#endif
#ifdef VK_EXT_direct_mode_display
-VkResult VkEncoder::vkReleaseDisplayEXT(
- VkPhysicalDevice physicalDevice,
- VkDisplayKHR display,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkReleaseDisplayEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkReleaseDisplayEXT(physicalDevice:%p, display:%p)", physicalDevice,
+ display);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -27222,14 +38192,23 @@
uint64_t cgen_var_1;
*countPtr += 1 * 8;
}
- uint32_t packetSize_vkReleaseDisplayEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkReleaseDisplayEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkReleaseDisplayEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkReleaseDisplayEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkReleaseDisplayEXT = OP_vkReleaseDisplayEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkReleaseDisplayEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkReleaseDisplayEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkReleaseDisplayEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkReleaseDisplayEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -27240,9 +38219,9 @@
*streamPtrPtr += 1 * 8;
VkResult vkReleaseDisplayEXT_VkResult_return = (VkResult)0;
stream->read(&vkReleaseDisplayEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -27252,14 +38231,35 @@
#endif
#ifdef VK_EXT_acquire_xlib_display
-VkResult VkEncoder::vkAcquireXlibDisplayEXT(
- VkPhysicalDevice physicalDevice,
- Display* dpy,
- VkDisplayKHR display,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy,
+ VkDisplayKHR display, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkAcquireXlibDisplayEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkAcquireXlibDisplayEXT(physicalDevice:%p, dpy:%p, display:%p)",
+ physicalDevice, dpy, display);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -27276,14 +38276,23 @@
uint64_t cgen_var_1;
*countPtr += 1 * 8;
}
- uint32_t packetSize_vkAcquireXlibDisplayEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkAcquireXlibDisplayEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkAcquireXlibDisplayEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkAcquireXlibDisplayEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkAcquireXlibDisplayEXT = OP_vkAcquireXlibDisplayEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkAcquireXlibDisplayEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkAcquireXlibDisplayEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkAcquireXlibDisplayEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkAcquireXlibDisplayEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -27297,9 +38306,9 @@
stream->read((Display*)dpy, sizeof(Display));
VkResult vkAcquireXlibDisplayEXT_VkResult_return = (VkResult)0;
stream->read(&vkAcquireXlibDisplayEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -27307,15 +38316,36 @@
return vkAcquireXlibDisplayEXT_VkResult_return;
}
-VkResult VkEncoder::vkGetRandROutputDisplayEXT(
- VkPhysicalDevice physicalDevice,
- Display* dpy,
- RROutput rrOutput,
- VkDisplayKHR* pDisplay,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy,
+ RROutput rrOutput, VkDisplayKHR* pDisplay,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetRandROutputDisplayEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetRandROutputDisplayEXT(physicalDevice:%p, dpy:%p, pDisplay:%p)",
+ physicalDevice, dpy, pDisplay);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -27333,14 +38363,23 @@
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkGetRandROutputDisplayEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetRandROutputDisplayEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetRandROutputDisplayEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetRandROutputDisplayEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetRandROutputDisplayEXT = OP_vkGetRandROutputDisplayEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetRandROutputDisplayEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetRandROutputDisplayEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetRandROutputDisplayEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetRandROutputDisplayEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -27361,9 +38400,9 @@
stream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_2, (VkDisplayKHR*)pDisplay, 1);
VkResult vkGetRandROutputDisplayEXT_VkResult_return = (VkResult)0;
stream->read(&vkGetRandROutputDisplayEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -27374,13 +38413,38 @@
#endif
#ifdef VK_EXT_display_surface_counter
VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilities2EXT(
- VkPhysicalDevice physicalDevice,
- VkSurfaceKHR surface,
- VkSurfaceCapabilities2EXT* pSurfaceCapabilities,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+ VkSurfaceCapabilities2EXT* pSurfaceCapabilities, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceSurfaceCapabilities2EXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice:%p, surface:%p, "
+ "pSurfaceCapabilities:%p)",
+ physicalDevice, surface, pSurfaceCapabilities);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -27395,16 +38459,29 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkSurfaceCapabilities2EXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities), countPtr);
+ count_VkSurfaceCapabilities2EXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities),
+ countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceSurfaceCapabilities2EXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceSurfaceCapabilities2EXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceSurfaceCapabilities2EXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceSurfaceCapabilities2EXT);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceSurfaceCapabilities2EXT = OP_vkGetPhysicalDeviceSurfaceCapabilities2EXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSurfaceCapabilities2EXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSurfaceCapabilities2EXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceSurfaceCapabilities2EXT =
+ OP_vkGetPhysicalDeviceSurfaceCapabilities2EXT;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSurfaceCapabilities2EXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSurfaceCapabilities2EXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -27413,17 +38490,20 @@
*&cgen_var_1 = get_host_u64_VkSurfaceKHR((*&local_surface));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSurfaceCapabilities2EXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities), streamPtrPtr);
- unmarshal_VkSurfaceCapabilities2EXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities));
- if (pSurfaceCapabilities)
- {
- transform_fromhost_VkSurfaceCapabilities2EXT(sResourceTracker, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities));
+ reservedmarshal_VkSurfaceCapabilities2EXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities),
+ streamPtrPtr);
+ unmarshal_VkSurfaceCapabilities2EXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities));
+ if (pSurfaceCapabilities) {
+ transform_fromhost_VkSurfaceCapabilities2EXT(
+ sResourceTracker, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities));
}
VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -27433,14 +38513,36 @@
#endif
#ifdef VK_EXT_display_control
-VkResult VkEncoder::vkDisplayPowerControlEXT(
- VkDevice device,
- VkDisplayKHR display,
- const VkDisplayPowerInfoEXT* pDisplayPowerInfo,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display,
+ const VkDisplayPowerInfoEXT* pDisplayPowerInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDisplayPowerControlEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDisplayPowerControlEXT(device:%p, display:%p, pDisplayPowerInfo:%p)",
+ device, display, pDisplayPowerInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -27450,14 +38552,15 @@
local_device = device;
local_display = display;
local_pDisplayPowerInfo = nullptr;
- if (pDisplayPowerInfo)
- {
- local_pDisplayPowerInfo = (VkDisplayPowerInfoEXT*)pool->alloc(sizeof(const VkDisplayPowerInfoEXT));
- deepcopy_VkDisplayPowerInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDisplayPowerInfo, (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo));
+ if (pDisplayPowerInfo) {
+ local_pDisplayPowerInfo =
+ (VkDisplayPowerInfoEXT*)pool->alloc(sizeof(const VkDisplayPowerInfoEXT));
+ deepcopy_VkDisplayPowerInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDisplayPowerInfo,
+ (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo));
}
- if (local_pDisplayPowerInfo)
- {
- transform_tohost_VkDisplayPowerInfoEXT(sResourceTracker, (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo));
+ if (local_pDisplayPowerInfo) {
+ transform_tohost_VkDisplayPowerInfoEXT(sResourceTracker,
+ (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -27466,16 +38569,26 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkDisplayPowerInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo), countPtr);
+ count_VkDisplayPowerInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo), countPtr);
}
- uint32_t packetSize_vkDisplayPowerControlEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDisplayPowerControlEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDisplayPowerControlEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkDisplayPowerControlEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDisplayPowerControlEXT = OP_vkDisplayPowerControlEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDisplayPowerControlEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDisplayPowerControlEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDisplayPowerControlEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDisplayPowerControlEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -27484,12 +38597,14 @@
*&cgen_var_1 = get_host_u64_VkDisplayKHR((*&local_display));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDisplayPowerInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo), streamPtrPtr);
+ reservedmarshal_VkDisplayPowerInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo),
+ streamPtrPtr);
VkResult vkDisplayPowerControlEXT_VkResult_return = (VkResult)0;
stream->read(&vkDisplayPowerControlEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -27497,15 +38612,38 @@
return vkDisplayPowerControlEXT_VkResult_return;
}
-VkResult VkEncoder::vkRegisterDeviceEventEXT(
- VkDevice device,
- const VkDeviceEventInfoEXT* pDeviceEventInfo,
- const VkAllocationCallbacks* pAllocator,
- VkFence* pFence,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkRegisterDeviceEventEXT(VkDevice device,
+ const VkDeviceEventInfoEXT* pDeviceEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkRegisterDeviceEventEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkRegisterDeviceEventEXT(device:%p, pDeviceEventInfo:%p, pAllocator:%p, pFence:%p)",
+ device, pDeviceEventInfo, pAllocator, pFence);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -27514,62 +38652,76 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pDeviceEventInfo = nullptr;
- if (pDeviceEventInfo)
- {
- local_pDeviceEventInfo = (VkDeviceEventInfoEXT*)pool->alloc(sizeof(const VkDeviceEventInfoEXT));
- deepcopy_VkDeviceEventInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDeviceEventInfo, (VkDeviceEventInfoEXT*)(local_pDeviceEventInfo));
+ if (pDeviceEventInfo) {
+ local_pDeviceEventInfo =
+ (VkDeviceEventInfoEXT*)pool->alloc(sizeof(const VkDeviceEventInfoEXT));
+ deepcopy_VkDeviceEventInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDeviceEventInfo,
+ (VkDeviceEventInfoEXT*)(local_pDeviceEventInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pDeviceEventInfo)
- {
- transform_tohost_VkDeviceEventInfoEXT(sResourceTracker, (VkDeviceEventInfoEXT*)(local_pDeviceEventInfo));
+ if (local_pDeviceEventInfo) {
+ transform_tohost_VkDeviceEventInfoEXT(sResourceTracker,
+ (VkDeviceEventInfoEXT*)(local_pDeviceEventInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDeviceEventInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceEventInfoEXT*)(local_pDeviceEventInfo), countPtr);
+ count_VkDeviceEventInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDeviceEventInfoEXT*)(local_pDeviceEventInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkRegisterDeviceEventEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkRegisterDeviceEventEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkRegisterDeviceEventEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkRegisterDeviceEventEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkRegisterDeviceEventEXT = OP_vkRegisterDeviceEventEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkRegisterDeviceEventEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkRegisterDeviceEventEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkRegisterDeviceEventEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkRegisterDeviceEventEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDeviceEventInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDeviceEventInfoEXT*)(local_pDeviceEventInfo), streamPtrPtr);
+ reservedmarshal_VkDeviceEventInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDeviceEventInfoEXT*)(local_pDeviceEventInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -27582,9 +38734,9 @@
stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_3, (VkFence*)pFence, 1);
VkResult vkRegisterDeviceEventEXT_VkResult_return = (VkResult)0;
stream->read(&vkRegisterDeviceEventEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -27592,16 +38744,39 @@
return vkRegisterDeviceEventEXT_VkResult_return;
}
-VkResult VkEncoder::vkRegisterDisplayEventEXT(
- VkDevice device,
- VkDisplayKHR display,
- const VkDisplayEventInfoEXT* pDisplayEventInfo,
- const VkAllocationCallbacks* pAllocator,
- VkFence* pFence,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display,
+ const VkDisplayEventInfoEXT* pDisplayEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkRegisterDisplayEventEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkRegisterDisplayEventEXT(device:%p, display:%p, pDisplayEventInfo:%p, pAllocator:%p, "
+ "pFence:%p)",
+ device, display, pDisplayEventInfo, pAllocator, pFence);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -27612,25 +38787,26 @@
local_device = device;
local_display = display;
local_pDisplayEventInfo = nullptr;
- if (pDisplayEventInfo)
- {
- local_pDisplayEventInfo = (VkDisplayEventInfoEXT*)pool->alloc(sizeof(const VkDisplayEventInfoEXT));
- deepcopy_VkDisplayEventInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDisplayEventInfo, (VkDisplayEventInfoEXT*)(local_pDisplayEventInfo));
+ if (pDisplayEventInfo) {
+ local_pDisplayEventInfo =
+ (VkDisplayEventInfoEXT*)pool->alloc(sizeof(const VkDisplayEventInfoEXT));
+ deepcopy_VkDisplayEventInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDisplayEventInfo,
+ (VkDisplayEventInfoEXT*)(local_pDisplayEventInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pDisplayEventInfo)
- {
- transform_tohost_VkDisplayEventInfoEXT(sResourceTracker, (VkDisplayEventInfoEXT*)(local_pDisplayEventInfo));
+ if (local_pDisplayEventInfo) {
+ transform_tohost_VkDisplayEventInfoEXT(sResourceTracker,
+ (VkDisplayEventInfoEXT*)(local_pDisplayEventInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -27639,24 +38815,34 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkDisplayEventInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayEventInfoEXT*)(local_pDisplayEventInfo), countPtr);
+ count_VkDisplayEventInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayEventInfoEXT*)(local_pDisplayEventInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_2;
*countPtr += 8;
}
- uint32_t packetSize_vkRegisterDisplayEventEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkRegisterDisplayEventEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkRegisterDisplayEventEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkRegisterDisplayEventEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkRegisterDisplayEventEXT = OP_vkRegisterDisplayEventEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkRegisterDisplayEventEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkRegisterDisplayEventEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkRegisterDisplayEventEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkRegisterDisplayEventEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -27665,15 +38851,18 @@
*&cgen_var_1 = get_host_u64_VkDisplayKHR((*&local_display));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDisplayEventInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDisplayEventInfoEXT*)(local_pDisplayEventInfo), streamPtrPtr);
+ reservedmarshal_VkDisplayEventInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDisplayEventInfoEXT*)(local_pDisplayEventInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_2 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_3;
@@ -27686,9 +38875,9 @@
stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_4, (VkFence*)pFence, 1);
VkResult vkRegisterDisplayEventEXT_VkResult_return = (VkResult)0;
stream->read(&vkRegisterDisplayEventEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -27696,15 +38885,36 @@
return vkRegisterDisplayEventEXT_VkResult_return;
}
-VkResult VkEncoder::vkGetSwapchainCounterEXT(
- VkDevice device,
- VkSwapchainKHR swapchain,
- VkSurfaceCounterFlagBitsEXT counter,
- uint64_t* pCounterValue,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain,
+ VkSurfaceCounterFlagBitsEXT counter,
+ uint64_t* pCounterValue, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetSwapchainCounterEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetSwapchainCounterEXT(device:%p, swapchain:%p, pCounterValue:%p)", device,
+ swapchain, pCounterValue);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -27724,14 +38934,23 @@
*countPtr += sizeof(VkSurfaceCounterFlagBitsEXT);
*countPtr += sizeof(uint64_t);
}
- uint32_t packetSize_vkGetSwapchainCounterEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetSwapchainCounterEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetSwapchainCounterEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetSwapchainCounterEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetSwapchainCounterEXT = OP_vkGetSwapchainCounterEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetSwapchainCounterEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetSwapchainCounterEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetSwapchainCounterEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetSwapchainCounterEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -27740,16 +38959,17 @@
*&cgen_var_1 = get_host_u64_VkSwapchainKHR((*&local_swapchain));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- memcpy(*streamPtrPtr, (VkSurfaceCounterFlagBitsEXT*)&local_counter, sizeof(VkSurfaceCounterFlagBitsEXT));
+ memcpy(*streamPtrPtr, (VkSurfaceCounterFlagBitsEXT*)&local_counter,
+ sizeof(VkSurfaceCounterFlagBitsEXT));
*streamPtrPtr += sizeof(VkSurfaceCounterFlagBitsEXT);
memcpy(*streamPtrPtr, (uint64_t*)pCounterValue, sizeof(uint64_t));
*streamPtrPtr += sizeof(uint64_t);
stream->read((uint64_t*)pCounterValue, sizeof(uint64_t));
VkResult vkGetSwapchainCounterEXT_VkResult_return = (VkResult)0;
stream->read(&vkGetSwapchainCounterEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -27760,13 +38980,36 @@
#endif
#ifdef VK_GOOGLE_display_timing
VkResult VkEncoder::vkGetRefreshCycleDurationGOOGLE(
- VkDevice device,
- VkSwapchainKHR swapchain,
- VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties,
- uint32_t doLock)
-{
+ VkDevice device, VkSwapchainKHR swapchain,
+ VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetRefreshCycleDurationGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetRefreshCycleDurationGOOGLE(device:%p, swapchain:%p, pDisplayTimingProperties:%p)",
+ device, swapchain, pDisplayTimingProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -27781,16 +39024,28 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkRefreshCycleDurationGOOGLE(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties), countPtr);
+ count_VkRefreshCycleDurationGOOGLE(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties), countPtr);
}
- uint32_t packetSize_vkGetRefreshCycleDurationGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetRefreshCycleDurationGOOGLE =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetRefreshCycleDurationGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetRefreshCycleDurationGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetRefreshCycleDurationGOOGLE = OP_vkGetRefreshCycleDurationGOOGLE;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetRefreshCycleDurationGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetRefreshCycleDurationGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetRefreshCycleDurationGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetRefreshCycleDurationGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -27799,17 +39054,21 @@
*&cgen_var_1 = get_host_u64_VkSwapchainKHR((*&local_swapchain));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkRefreshCycleDurationGOOGLE(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties), streamPtrPtr);
- unmarshal_VkRefreshCycleDurationGOOGLE(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties));
- if (pDisplayTimingProperties)
- {
- transform_fromhost_VkRefreshCycleDurationGOOGLE(sResourceTracker, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties));
+ reservedmarshal_VkRefreshCycleDurationGOOGLE(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties), streamPtrPtr);
+ unmarshal_VkRefreshCycleDurationGOOGLE(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties));
+ if (pDisplayTimingProperties) {
+ transform_fromhost_VkRefreshCycleDurationGOOGLE(
+ sResourceTracker, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties));
}
VkResult vkGetRefreshCycleDurationGOOGLE_VkResult_return = (VkResult)0;
stream->read(&vkGetRefreshCycleDurationGOOGLE_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -27818,14 +39077,37 @@
}
VkResult VkEncoder::vkGetPastPresentationTimingGOOGLE(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint32_t* pPresentationTimingCount,
- VkPastPresentationTimingGOOGLE* pPresentationTimings,
- uint32_t doLock)
-{
+ VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount,
+ VkPastPresentationTimingGOOGLE* pPresentationTimings, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetPastPresentationTimingGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPastPresentationTimingGOOGLE(device:%p, swapchain:%p, pPresentationTimingCount:%p, "
+ "pPresentationTimings:%p)",
+ device, swapchain, pPresentationTimingCount, pPresentationTimings);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -27842,31 +39124,39 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pPresentationTimingCount)
- {
+ if (pPresentationTimingCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pPresentationTimings)
- {
- if (pPresentationTimingCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i)
- {
- count_VkPastPresentationTimingGOOGLE(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i), countPtr);
+ if (pPresentationTimings) {
+ if (pPresentationTimingCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i) {
+ count_VkPastPresentationTimingGOOGLE(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPastPresentationTimingGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPastPresentationTimingGOOGLE =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPastPresentationTimingGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPastPresentationTimingGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPastPresentationTimingGOOGLE = OP_vkGetPastPresentationTimingGOOGLE;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPastPresentationTimingGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPastPresentationTimingGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPastPresentationTimingGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPastPresentationTimingGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -27880,8 +39170,7 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPresentationTimingCount)
- {
+ if (pPresentationTimingCount) {
memcpy(*streamPtrPtr, (uint32_t*)pPresentationTimingCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -27890,56 +39179,51 @@
memcpy((*streamPtrPtr), &cgen_var_3, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPresentationTimings)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i)
- {
- reservedmarshal_VkPastPresentationTimingGOOGLE(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i), streamPtrPtr);
+ if (pPresentationTimings) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i) {
+ reservedmarshal_VkPastPresentationTimingGOOGLE(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pPresentationTimingCount;
check_pPresentationTimingCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pPresentationTimingCount)
- {
- if (!(check_pPresentationTimingCount))
- {
- fprintf(stderr, "fatal: pPresentationTimingCount inconsistent between guest and host\n");
+ if (pPresentationTimingCount) {
+ if (!(check_pPresentationTimingCount)) {
+ fprintf(stderr,
+ "fatal: pPresentationTimingCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pPresentationTimingCount, sizeof(uint32_t));
}
// WARNING PTR CHECK
VkPastPresentationTimingGOOGLE* check_pPresentationTimings;
check_pPresentationTimings = (VkPastPresentationTimingGOOGLE*)(uintptr_t)stream->getBe64();
- if (pPresentationTimings)
- {
- if (!(check_pPresentationTimings))
- {
+ if (pPresentationTimings) {
+ if (!(check_pPresentationTimings)) {
fprintf(stderr, "fatal: pPresentationTimings inconsistent between guest and host\n");
}
- if (pPresentationTimingCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i)
- {
- unmarshal_VkPastPresentationTimingGOOGLE(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i));
+ if (pPresentationTimingCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i) {
+ unmarshal_VkPastPresentationTimingGOOGLE(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i));
}
}
}
- if (pPresentationTimingCount)
- {
- if (pPresentationTimings)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i)
- {
- transform_fromhost_VkPastPresentationTimingGOOGLE(sResourceTracker, (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i));
+ if (pPresentationTimingCount) {
+ if (pPresentationTimings) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPresentationTimingCount)); ++i) {
+ transform_fromhost_VkPastPresentationTimingGOOGLE(
+ sResourceTracker, (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i));
}
}
}
VkResult vkGetPastPresentationTimingGOOGLE_VkResult_return = (VkResult)0;
stream->read(&vkGetPastPresentationTimingGOOGLE_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -27959,15 +39243,39 @@
#ifdef VK_NV_viewport_swizzle
#endif
#ifdef VK_EXT_discard_rectangles
-void VkEncoder::vkCmdSetDiscardRectangleEXT(
- VkCommandBuffer commandBuffer,
- uint32_t firstDiscardRectangle,
- uint32_t discardRectangleCount,
- const VkRect2D* pDiscardRectangles,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer,
+ uint32_t firstDiscardRectangle,
+ uint32_t discardRectangleCount,
+ const VkRect2D* pDiscardRectangles, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetDiscardRectangleEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdSetDiscardRectangleEXT(commandBuffer:%p, firstDiscardRectangle:%d, "
+ "discardRectangleCount:%d, pDiscardRectangles:%p)",
+ commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -27979,18 +39287,16 @@
local_firstDiscardRectangle = firstDiscardRectangle;
local_discardRectangleCount = discardRectangleCount;
local_pDiscardRectangles = nullptr;
- if (pDiscardRectangles)
- {
- local_pDiscardRectangles = (VkRect2D*)pool->alloc(((discardRectangleCount)) * sizeof(const VkRect2D));
- for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i)
- {
- deepcopy_VkRect2D(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDiscardRectangles + i, (VkRect2D*)(local_pDiscardRectangles + i));
+ if (pDiscardRectangles) {
+ local_pDiscardRectangles =
+ (VkRect2D*)pool->alloc(((discardRectangleCount)) * sizeof(const VkRect2D));
+ for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i) {
+ deepcopy_VkRect2D(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pDiscardRectangles + i,
+ (VkRect2D*)(local_pDiscardRectangles + i));
}
}
- if (local_pDiscardRectangles)
- {
- for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i)
- {
+ if (local_pDiscardRectangles) {
+ for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i) {
transform_tohost_VkRect2D(sResourceTracker, (VkRect2D*)(local_pDiscardRectangles + i));
}
}
@@ -28001,20 +39307,22 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i)
- {
- count_VkRect2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(local_pDiscardRectangles + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i) {
+ count_VkRect2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRect2D*)(local_pDiscardRectangles + i), countPtr);
}
}
uint32_t packetSize_vkCmdSetDiscardRectangleEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetDiscardRectangleEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDiscardRectangleEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDiscardRectangleEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetDiscardRectangleEXT = OP_vkCmdSetDiscardRectangleEXT;
- memcpy(streamPtr, &opcode_vkCmdSetDiscardRectangleEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetDiscardRectangleEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetDiscardRectangleEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetDiscardRectangleEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -28024,13 +39332,13 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_discardRectangleCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i)
- {
- reservedmarshal_VkRect2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(local_pDiscardRectangles + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((discardRectangleCount)); ++i) {
+ reservedmarshal_VkRect2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRect2D*)(local_pDiscardRectangles + i), streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -28045,15 +39353,37 @@
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
-void VkEncoder::vkSetHdrMetadataEXT(
- VkDevice device,
- uint32_t swapchainCount,
- const VkSwapchainKHR* pSwapchains,
- const VkHdrMetadataEXT* pMetadata,
- uint32_t doLock)
-{
+void VkEncoder::vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount,
+ const VkSwapchainKHR* pSwapchains,
+ const VkHdrMetadataEXT* pMetadata, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkSetHdrMetadataEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkSetHdrMetadataEXT(device:%p, swapchainCount:%d, pSwapchains:%p, pMetadata:%p)", device,
+ swapchainCount, pSwapchains, pMetadata);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -28066,19 +39396,18 @@
// Avoiding deepcopy for pSwapchains
local_pSwapchains = (VkSwapchainKHR*)pSwapchains;
local_pMetadata = nullptr;
- if (pMetadata)
- {
- local_pMetadata = (VkHdrMetadataEXT*)pool->alloc(((swapchainCount)) * sizeof(const VkHdrMetadataEXT));
- for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
- {
- deepcopy_VkHdrMetadataEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMetadata + i, (VkHdrMetadataEXT*)(local_pMetadata + i));
+ if (pMetadata) {
+ local_pMetadata =
+ (VkHdrMetadataEXT*)pool->alloc(((swapchainCount)) * sizeof(const VkHdrMetadataEXT));
+ for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i) {
+ deepcopy_VkHdrMetadataEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMetadata + i,
+ (VkHdrMetadataEXT*)(local_pMetadata + i));
}
}
- if (local_pMetadata)
- {
- for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
- {
- transform_tohost_VkHdrMetadataEXT(sResourceTracker, (VkHdrMetadataEXT*)(local_pMetadata + i));
+ if (local_pMetadata) {
+ for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i) {
+ transform_tohost_VkHdrMetadataEXT(sResourceTracker,
+ (VkHdrMetadataEXT*)(local_pMetadata + i));
}
}
size_t count = 0;
@@ -28087,47 +39416,53 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- if (((swapchainCount)))
- {
+ if (((swapchainCount))) {
*countPtr += ((swapchainCount)) * 8;
}
- for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
- {
- count_VkHdrMetadataEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkHdrMetadataEXT*)(local_pMetadata + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i) {
+ count_VkHdrMetadataEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkHdrMetadataEXT*)(local_pMetadata + i), countPtr);
}
}
- uint32_t packetSize_vkSetHdrMetadataEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkSetHdrMetadataEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkSetHdrMetadataEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkSetHdrMetadataEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkSetHdrMetadataEXT = OP_vkSetHdrMetadataEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkSetHdrMetadataEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkSetHdrMetadataEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkSetHdrMetadataEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkSetHdrMetadataEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_swapchainCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (((swapchainCount)))
- {
+ if (((swapchainCount))) {
uint8_t* cgen_var_1_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((swapchainCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((swapchainCount)); ++k) {
uint64_t tmpval = get_host_u64_VkSwapchainKHR(local_pSwapchains[k]);
memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
*streamPtrPtr += 8 * ((swapchainCount));
}
- for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i)
- {
- reservedmarshal_VkHdrMetadataEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkHdrMetadataEXT*)(local_pMetadata + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((swapchainCount)); ++i) {
+ reservedmarshal_VkHdrMetadataEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkHdrMetadataEXT*)(local_pMetadata + i), streamPtrPtr);
}
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -28136,15 +39471,38 @@
#endif
#ifdef VK_MVK_ios_surface
-VkResult VkEncoder::vkCreateIOSSurfaceMVK(
- VkInstance instance,
- const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateIOSSurfaceMVK(VkInstance instance,
+ const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateIOSSurfaceMVK in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateIOSSurfaceMVK(instance:%p, pCreateInfo:%p, pAllocator:%p, pSurface:%p)", instance,
+ pCreateInfo, pAllocator, pSurface);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -28153,62 +39511,76 @@
VkAllocationCallbacks* local_pAllocator;
local_instance = instance;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkIOSSurfaceCreateInfoMVK*)pool->alloc(sizeof(const VkIOSSurfaceCreateInfoMVK));
- deepcopy_VkIOSSurfaceCreateInfoMVK(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkIOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkIOSSurfaceCreateInfoMVK*)pool->alloc(sizeof(const VkIOSSurfaceCreateInfoMVK));
+ deepcopy_VkIOSSurfaceCreateInfoMVK(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkIOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkIOSSurfaceCreateInfoMVK(sResourceTracker, (VkIOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkIOSSurfaceCreateInfoMVK(sResourceTracker,
+ (VkIOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkIOSSurfaceCreateInfoMVK(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkIOSSurfaceCreateInfoMVK*)(local_pCreateInfo), countPtr);
+ count_VkIOSSurfaceCreateInfoMVK(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkIOSSurfaceCreateInfoMVK*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateIOSSurfaceMVK = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateIOSSurfaceMVK =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateIOSSurfaceMVK);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateIOSSurfaceMVK);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateIOSSurfaceMVK = OP_vkCreateIOSSurfaceMVK;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateIOSSurfaceMVK, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateIOSSurfaceMVK, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateIOSSurfaceMVK, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateIOSSurfaceMVK, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkIOSSurfaceCreateInfoMVK(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkIOSSurfaceCreateInfoMVK*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkIOSSurfaceCreateInfoMVK(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkIOSSurfaceCreateInfoMVK*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -28221,9 +39593,9 @@
stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_3, (VkSurfaceKHR*)pSurface, 1);
VkResult vkCreateIOSSurfaceMVK_VkResult_return = (VkResult)0;
stream->read(&vkCreateIOSSurfaceMVK_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -28233,15 +39605,38 @@
#endif
#ifdef VK_MVK_macos_surface
-VkResult VkEncoder::vkCreateMacOSSurfaceMVK(
- VkInstance instance,
- const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateMacOSSurfaceMVK(VkInstance instance,
+ const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateMacOSSurfaceMVK in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateMacOSSurfaceMVK(instance:%p, pCreateInfo:%p, pAllocator:%p, pSurface:%p)",
+ instance, pCreateInfo, pAllocator, pSurface);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -28250,62 +39645,77 @@
VkAllocationCallbacks* local_pAllocator;
local_instance = instance;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkMacOSSurfaceCreateInfoMVK*)pool->alloc(sizeof(const VkMacOSSurfaceCreateInfoMVK));
- deepcopy_VkMacOSSurfaceCreateInfoMVK(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkMacOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkMacOSSurfaceCreateInfoMVK*)pool->alloc(sizeof(const VkMacOSSurfaceCreateInfoMVK));
+ deepcopy_VkMacOSSurfaceCreateInfoMVK(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkMacOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkMacOSSurfaceCreateInfoMVK(sResourceTracker, (VkMacOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkMacOSSurfaceCreateInfoMVK(
+ sResourceTracker, (VkMacOSSurfaceCreateInfoMVK*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkMacOSSurfaceCreateInfoMVK(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMacOSSurfaceCreateInfoMVK*)(local_pCreateInfo), countPtr);
+ count_VkMacOSSurfaceCreateInfoMVK(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMacOSSurfaceCreateInfoMVK*)(local_pCreateInfo),
+ countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateMacOSSurfaceMVK = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateMacOSSurfaceMVK =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateMacOSSurfaceMVK);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateMacOSSurfaceMVK);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateMacOSSurfaceMVK = OP_vkCreateMacOSSurfaceMVK;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateMacOSSurfaceMVK, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateMacOSSurfaceMVK, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateMacOSSurfaceMVK, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateMacOSSurfaceMVK, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkMacOSSurfaceCreateInfoMVK(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMacOSSurfaceCreateInfoMVK*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkMacOSSurfaceCreateInfoMVK(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMacOSSurfaceCreateInfoMVK*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -28318,9 +39728,9 @@
stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_3, (VkSurfaceKHR*)pSurface, 1);
VkResult vkCreateMacOSSurfaceMVK_VkResult_return = (VkResult)0;
stream->read(&vkCreateMacOSSurfaceMVK_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -28330,13 +39740,35 @@
#endif
#ifdef VK_MVK_moltenvk
-void VkEncoder::vkGetMTLDeviceMVK(
- VkPhysicalDevice physicalDevice,
- void** pMTLDevice,
- uint32_t doLock)
-{
+void VkEncoder::vkGetMTLDeviceMVK(VkPhysicalDevice physicalDevice, void** pMTLDevice,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetMTLDeviceMVK in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetMTLDeviceMVK(physicalDevice:%p, pMTLDevice:%p)", physicalDevice,
+ pMTLDevice);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -28349,14 +39781,23 @@
*countPtr += 1 * 8;
*countPtr += sizeof(void*);
}
- uint32_t packetSize_vkGetMTLDeviceMVK = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetMTLDeviceMVK =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetMTLDeviceMVK);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetMTLDeviceMVK);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetMTLDeviceMVK = OP_vkGetMTLDeviceMVK;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetMTLDeviceMVK, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetMTLDeviceMVK, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetMTLDeviceMVK, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetMTLDeviceMVK, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -28364,22 +39805,42 @@
memcpy(*streamPtrPtr, (void**)pMTLDevice, sizeof(void*));
*streamPtrPtr += sizeof(void*);
stream->read((void**)pMTLDevice, sizeof(void*));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkSetMTLTextureMVK(
- VkImage image,
- void* mtlTexture,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkSetMTLTextureMVK(VkImage image, void* mtlTexture, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkSetMTLTextureMVK in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkSetMTLTextureMVK(image:%p, mtlTexture:%p)", image, mtlTexture);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -28392,14 +39853,23 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint8_t);
}
- uint32_t packetSize_vkSetMTLTextureMVK = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkSetMTLTextureMVK =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkSetMTLTextureMVK);
uint8_t* streamPtr = stream->reserve(packetSize_vkSetMTLTextureMVK);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkSetMTLTextureMVK = OP_vkSetMTLTextureMVK;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkSetMTLTextureMVK, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkSetMTLTextureMVK, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkSetMTLTextureMVK, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkSetMTLTextureMVK, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkImage((*&local_image));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -28409,9 +39879,9 @@
stream->read((void*)mtlTexture, sizeof(uint8_t));
VkResult vkSetMTLTextureMVK_VkResult_return = (VkResult)0;
stream->read(&vkSetMTLTextureMVK_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -28419,13 +39889,33 @@
return vkSetMTLTextureMVK_VkResult_return;
}
-void VkEncoder::vkGetMTLTextureMVK(
- VkImage image,
- void** pMTLTexture,
- uint32_t doLock)
-{
+void VkEncoder::vkGetMTLTextureMVK(VkImage image, void** pMTLTexture, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetMTLTextureMVK in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetMTLTextureMVK(image:%p, pMTLTexture:%p)", image, pMTLTexture);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -28438,14 +39928,23 @@
*countPtr += 1 * 8;
*countPtr += sizeof(void*);
}
- uint32_t packetSize_vkGetMTLTextureMVK = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetMTLTextureMVK =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetMTLTextureMVK);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetMTLTextureMVK);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetMTLTextureMVK = OP_vkGetMTLTextureMVK;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetMTLTextureMVK, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetMTLTextureMVK, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetMTLTextureMVK, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetMTLTextureMVK, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkImage((*&local_image));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -28453,22 +39952,42 @@
memcpy(*streamPtrPtr, (void**)pMTLTexture, sizeof(void*));
*streamPtrPtr += sizeof(void*);
stream->read((void**)pMTLTexture, sizeof(void*));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkGetMTLBufferMVK(
- VkBuffer buffer,
- void** pMTLBuffer,
- uint32_t doLock)
-{
+void VkEncoder::vkGetMTLBufferMVK(VkBuffer buffer, void** pMTLBuffer, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetMTLBufferMVK in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetMTLBufferMVK(buffer:%p, pMTLBuffer:%p)", buffer, pMTLBuffer);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -28481,14 +40000,23 @@
*countPtr += 1 * 8;
*countPtr += sizeof(void*);
}
- uint32_t packetSize_vkGetMTLBufferMVK = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetMTLBufferMVK =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetMTLBufferMVK);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetMTLBufferMVK);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetMTLBufferMVK = OP_vkGetMTLBufferMVK;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetMTLBufferMVK, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetMTLBufferMVK, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetMTLBufferMVK, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetMTLBufferMVK, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkBuffer((*&local_buffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -28496,22 +40024,42 @@
memcpy(*streamPtrPtr, (void**)pMTLBuffer, sizeof(void*));
*streamPtrPtr += sizeof(void*);
stream->read((void**)pMTLBuffer, sizeof(void*));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkUseIOSurfaceMVK(
- VkImage image,
- void* ioSurface,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkUseIOSurfaceMVK(VkImage image, void* ioSurface, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkUseIOSurfaceMVK in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkUseIOSurfaceMVK(image:%p, ioSurface:%p)", image, ioSurface);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -28524,14 +40072,23 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint8_t);
}
- uint32_t packetSize_vkUseIOSurfaceMVK = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkUseIOSurfaceMVK =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkUseIOSurfaceMVK);
uint8_t* streamPtr = stream->reserve(packetSize_vkUseIOSurfaceMVK);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkUseIOSurfaceMVK = OP_vkUseIOSurfaceMVK;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkUseIOSurfaceMVK, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkUseIOSurfaceMVK, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkUseIOSurfaceMVK, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkUseIOSurfaceMVK, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkImage((*&local_image));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -28541,9 +40098,9 @@
stream->read((void*)ioSurface, sizeof(uint8_t));
VkResult vkUseIOSurfaceMVK_VkResult_return = (VkResult)0;
stream->read(&vkUseIOSurfaceMVK_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -28551,13 +40108,33 @@
return vkUseIOSurfaceMVK_VkResult_return;
}
-void VkEncoder::vkGetIOSurfaceMVK(
- VkImage image,
- void** pIOSurface,
- uint32_t doLock)
-{
+void VkEncoder::vkGetIOSurfaceMVK(VkImage image, void** pIOSurface, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetIOSurfaceMVK in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetIOSurfaceMVK(image:%p, pIOSurface:%p)", image, pIOSurface);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -28570,14 +40147,23 @@
*countPtr += 1 * 8;
*countPtr += sizeof(void*);
}
- uint32_t packetSize_vkGetIOSurfaceMVK = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetIOSurfaceMVK =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetIOSurfaceMVK);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetIOSurfaceMVK);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetIOSurfaceMVK = OP_vkGetIOSurfaceMVK;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetIOSurfaceMVK, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetIOSurfaceMVK, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetIOSurfaceMVK, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetIOSurfaceMVK, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkImage((*&local_image));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -28585,9 +40171,9 @@
memcpy(*streamPtrPtr, (void**)pIOSurface, sizeof(void*));
*streamPtrPtr += sizeof(void*);
stream->read((void**)pIOSurface, sizeof(void*));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -28600,13 +40186,35 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
-VkResult VkEncoder::vkSetDebugUtilsObjectNameEXT(
- VkDevice device,
- const VkDebugUtilsObjectNameInfoEXT* pNameInfo,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkSetDebugUtilsObjectNameEXT(VkDevice device,
+ const VkDebugUtilsObjectNameInfoEXT* pNameInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkSetDebugUtilsObjectNameEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkSetDebugUtilsObjectNameEXT(device:%p, pNameInfo:%p)", device, pNameInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -28614,40 +40222,55 @@
VkDebugUtilsObjectNameInfoEXT* local_pNameInfo;
local_device = device;
local_pNameInfo = nullptr;
- if (pNameInfo)
- {
- local_pNameInfo = (VkDebugUtilsObjectNameInfoEXT*)pool->alloc(sizeof(const VkDebugUtilsObjectNameInfoEXT));
- deepcopy_VkDebugUtilsObjectNameInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pNameInfo, (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo));
+ if (pNameInfo) {
+ local_pNameInfo = (VkDebugUtilsObjectNameInfoEXT*)pool->alloc(
+ sizeof(const VkDebugUtilsObjectNameInfoEXT));
+ deepcopy_VkDebugUtilsObjectNameInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pNameInfo,
+ (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo));
}
- if (local_pNameInfo)
- {
- transform_tohost_VkDebugUtilsObjectNameInfoEXT(sResourceTracker, (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo));
+ if (local_pNameInfo) {
+ transform_tohost_VkDebugUtilsObjectNameInfoEXT(
+ sResourceTracker, (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugUtilsObjectNameInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo), countPtr);
+ count_VkDebugUtilsObjectNameInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo),
+ countPtr);
}
- uint32_t packetSize_vkSetDebugUtilsObjectNameEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkSetDebugUtilsObjectNameEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkSetDebugUtilsObjectNameEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkSetDebugUtilsObjectNameEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkSetDebugUtilsObjectNameEXT = OP_vkSetDebugUtilsObjectNameEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkSetDebugUtilsObjectNameEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkSetDebugUtilsObjectNameEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkSetDebugUtilsObjectNameEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkSetDebugUtilsObjectNameEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDebugUtilsObjectNameInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo), streamPtrPtr);
+ reservedmarshal_VkDebugUtilsObjectNameInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo),
+ streamPtrPtr);
VkResult vkSetDebugUtilsObjectNameEXT_VkResult_return = (VkResult)0;
stream->read(&vkSetDebugUtilsObjectNameEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -28655,13 +40278,35 @@
return vkSetDebugUtilsObjectNameEXT_VkResult_return;
}
-VkResult VkEncoder::vkSetDebugUtilsObjectTagEXT(
- VkDevice device,
- const VkDebugUtilsObjectTagInfoEXT* pTagInfo,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkSetDebugUtilsObjectTagEXT(VkDevice device,
+ const VkDebugUtilsObjectTagInfoEXT* pTagInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkSetDebugUtilsObjectTagEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkSetDebugUtilsObjectTagEXT(device:%p, pTagInfo:%p)", device, pTagInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -28669,40 +40314,54 @@
VkDebugUtilsObjectTagInfoEXT* local_pTagInfo;
local_device = device;
local_pTagInfo = nullptr;
- if (pTagInfo)
- {
- local_pTagInfo = (VkDebugUtilsObjectTagInfoEXT*)pool->alloc(sizeof(const VkDebugUtilsObjectTagInfoEXT));
- deepcopy_VkDebugUtilsObjectTagInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pTagInfo, (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo));
+ if (pTagInfo) {
+ local_pTagInfo =
+ (VkDebugUtilsObjectTagInfoEXT*)pool->alloc(sizeof(const VkDebugUtilsObjectTagInfoEXT));
+ deepcopy_VkDebugUtilsObjectTagInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pTagInfo,
+ (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo));
}
- if (local_pTagInfo)
- {
- transform_tohost_VkDebugUtilsObjectTagInfoEXT(sResourceTracker, (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo));
+ if (local_pTagInfo) {
+ transform_tohost_VkDebugUtilsObjectTagInfoEXT(
+ sResourceTracker, (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugUtilsObjectTagInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo), countPtr);
+ count_VkDebugUtilsObjectTagInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo),
+ countPtr);
}
- uint32_t packetSize_vkSetDebugUtilsObjectTagEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkSetDebugUtilsObjectTagEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkSetDebugUtilsObjectTagEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkSetDebugUtilsObjectTagEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkSetDebugUtilsObjectTagEXT = OP_vkSetDebugUtilsObjectTagEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkSetDebugUtilsObjectTagEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkSetDebugUtilsObjectTagEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkSetDebugUtilsObjectTagEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkSetDebugUtilsObjectTagEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDebugUtilsObjectTagInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo), streamPtrPtr);
+ reservedmarshal_VkDebugUtilsObjectTagInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo),
+ streamPtrPtr);
VkResult vkSetDebugUtilsObjectTagEXT_VkResult_return = (VkResult)0;
stream->read(&vkSetDebugUtilsObjectTagEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -28710,13 +40369,35 @@
return vkSetDebugUtilsObjectTagEXT_VkResult_return;
}
-void VkEncoder::vkQueueBeginDebugUtilsLabelEXT(
- VkQueue queue,
- const VkDebugUtilsLabelEXT* pLabelInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkQueueBeginDebugUtilsLabelEXT(VkQueue queue,
+ const VkDebugUtilsLabelEXT* pLabelInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkQueueBeginDebugUtilsLabelEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkQueueBeginDebugUtilsLabelEXT(queue:%p, pLabelInfo:%p)", queue, pLabelInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -28724,51 +40405,84 @@
VkDebugUtilsLabelEXT* local_pLabelInfo;
local_queue = queue;
local_pLabelInfo = nullptr;
- if (pLabelInfo)
- {
+ if (pLabelInfo) {
local_pLabelInfo = (VkDebugUtilsLabelEXT*)pool->alloc(sizeof(const VkDebugUtilsLabelEXT));
- deepcopy_VkDebugUtilsLabelEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ deepcopy_VkDebugUtilsLabelEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pLabelInfo,
+ (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
}
- if (local_pLabelInfo)
- {
- transform_tohost_VkDebugUtilsLabelEXT(sResourceTracker, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ if (local_pLabelInfo) {
+ transform_tohost_VkDebugUtilsLabelEXT(sResourceTracker,
+ (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugUtilsLabelEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsLabelEXT*)(local_pLabelInfo), countPtr);
+ count_VkDebugUtilsLabelEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsLabelEXT*)(local_pLabelInfo), countPtr);
}
- uint32_t packetSize_vkQueueBeginDebugUtilsLabelEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkQueueBeginDebugUtilsLabelEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkQueueBeginDebugUtilsLabelEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueBeginDebugUtilsLabelEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueBeginDebugUtilsLabelEXT = OP_vkQueueBeginDebugUtilsLabelEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkQueueBeginDebugUtilsLabelEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkQueueBeginDebugUtilsLabelEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkQueueBeginDebugUtilsLabelEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkQueueBeginDebugUtilsLabelEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDebugUtilsLabelEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsLabelEXT*)(local_pLabelInfo), streamPtrPtr);
+ reservedmarshal_VkDebugUtilsLabelEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsLabelEXT*)(local_pLabelInfo), streamPtrPtr);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkQueueEndDebugUtilsLabelEXT(
- VkQueue queue,
- uint32_t doLock)
-{
+void VkEncoder::vkQueueEndDebugUtilsLabelEXT(VkQueue queue, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkQueueEndDebugUtilsLabelEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkQueueEndDebugUtilsLabelEXT(queue:%p)", queue);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -28780,35 +40494,68 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
}
- uint32_t packetSize_vkQueueEndDebugUtilsLabelEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkQueueEndDebugUtilsLabelEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkQueueEndDebugUtilsLabelEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueEndDebugUtilsLabelEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueEndDebugUtilsLabelEXT = OP_vkQueueEndDebugUtilsLabelEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkQueueEndDebugUtilsLabelEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkQueueEndDebugUtilsLabelEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkQueueEndDebugUtilsLabelEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkQueueEndDebugUtilsLabelEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkQueueInsertDebugUtilsLabelEXT(
- VkQueue queue,
- const VkDebugUtilsLabelEXT* pLabelInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkQueueInsertDebugUtilsLabelEXT(VkQueue queue,
+ const VkDebugUtilsLabelEXT* pLabelInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkQueueInsertDebugUtilsLabelEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkQueueInsertDebugUtilsLabelEXT(queue:%p, pLabelInfo:%p)", queue,
+ pLabelInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -28816,52 +40563,87 @@
VkDebugUtilsLabelEXT* local_pLabelInfo;
local_queue = queue;
local_pLabelInfo = nullptr;
- if (pLabelInfo)
- {
+ if (pLabelInfo) {
local_pLabelInfo = (VkDebugUtilsLabelEXT*)pool->alloc(sizeof(const VkDebugUtilsLabelEXT));
- deepcopy_VkDebugUtilsLabelEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ deepcopy_VkDebugUtilsLabelEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pLabelInfo,
+ (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
}
- if (local_pLabelInfo)
- {
- transform_tohost_VkDebugUtilsLabelEXT(sResourceTracker, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ if (local_pLabelInfo) {
+ transform_tohost_VkDebugUtilsLabelEXT(sResourceTracker,
+ (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugUtilsLabelEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsLabelEXT*)(local_pLabelInfo), countPtr);
+ count_VkDebugUtilsLabelEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsLabelEXT*)(local_pLabelInfo), countPtr);
}
- uint32_t packetSize_vkQueueInsertDebugUtilsLabelEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkQueueInsertDebugUtilsLabelEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkQueueInsertDebugUtilsLabelEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueInsertDebugUtilsLabelEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueInsertDebugUtilsLabelEXT = OP_vkQueueInsertDebugUtilsLabelEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkQueueInsertDebugUtilsLabelEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkQueueInsertDebugUtilsLabelEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkQueueInsertDebugUtilsLabelEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkQueueInsertDebugUtilsLabelEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDebugUtilsLabelEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsLabelEXT*)(local_pLabelInfo), streamPtrPtr);
+ reservedmarshal_VkDebugUtilsLabelEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsLabelEXT*)(local_pLabelInfo), streamPtrPtr);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdBeginDebugUtilsLabelEXT(
- VkCommandBuffer commandBuffer,
- const VkDebugUtilsLabelEXT* pLabelInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBeginDebugUtilsLabelEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdBeginDebugUtilsLabelEXT(commandBuffer:%p, pLabelInfo:%p)",
+ commandBuffer, pLabelInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -28869,52 +40651,78 @@
VkDebugUtilsLabelEXT* local_pLabelInfo;
local_commandBuffer = commandBuffer;
local_pLabelInfo = nullptr;
- if (pLabelInfo)
- {
+ if (pLabelInfo) {
local_pLabelInfo = (VkDebugUtilsLabelEXT*)pool->alloc(sizeof(const VkDebugUtilsLabelEXT));
- deepcopy_VkDebugUtilsLabelEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ deepcopy_VkDebugUtilsLabelEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pLabelInfo,
+ (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
}
- if (local_pLabelInfo)
- {
- transform_tohost_VkDebugUtilsLabelEXT(sResourceTracker, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ if (local_pLabelInfo) {
+ transform_tohost_VkDebugUtilsLabelEXT(sResourceTracker,
+ (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugUtilsLabelEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsLabelEXT*)(local_pLabelInfo), countPtr);
+ count_VkDebugUtilsLabelEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsLabelEXT*)(local_pLabelInfo), countPtr);
}
uint32_t packetSize_vkCmdBeginDebugUtilsLabelEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdBeginDebugUtilsLabelEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBeginDebugUtilsLabelEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBeginDebugUtilsLabelEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBeginDebugUtilsLabelEXT = OP_vkCmdBeginDebugUtilsLabelEXT;
- memcpy(streamPtr, &opcode_vkCmdBeginDebugUtilsLabelEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBeginDebugUtilsLabelEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBeginDebugUtilsLabelEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBeginDebugUtilsLabelEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkDebugUtilsLabelEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsLabelEXT*)(local_pLabelInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkDebugUtilsLabelEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsLabelEXT*)(local_pLabelInfo), streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdEndDebugUtilsLabelEXT(
- VkCommandBuffer commandBuffer,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdEndDebugUtilsLabelEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdEndDebugUtilsLabelEXT(commandBuffer:%p)", commandBuffer);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -28927,35 +40735,60 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkCmdEndDebugUtilsLabelEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdEndDebugUtilsLabelEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdEndDebugUtilsLabelEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdEndDebugUtilsLabelEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdEndDebugUtilsLabelEXT = OP_vkCmdEndDebugUtilsLabelEXT;
- memcpy(streamPtr, &opcode_vkCmdEndDebugUtilsLabelEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdEndDebugUtilsLabelEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdEndDebugUtilsLabelEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdEndDebugUtilsLabelEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdInsertDebugUtilsLabelEXT(
- VkCommandBuffer commandBuffer,
- const VkDebugUtilsLabelEXT* pLabelInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdInsertDebugUtilsLabelEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdInsertDebugUtilsLabelEXT(commandBuffer:%p, pLabelInfo:%p)",
+ commandBuffer, pLabelInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -28963,40 +40796,45 @@
VkDebugUtilsLabelEXT* local_pLabelInfo;
local_commandBuffer = commandBuffer;
local_pLabelInfo = nullptr;
- if (pLabelInfo)
- {
+ if (pLabelInfo) {
local_pLabelInfo = (VkDebugUtilsLabelEXT*)pool->alloc(sizeof(const VkDebugUtilsLabelEXT));
- deepcopy_VkDebugUtilsLabelEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pLabelInfo, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ deepcopy_VkDebugUtilsLabelEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pLabelInfo,
+ (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
}
- if (local_pLabelInfo)
- {
- transform_tohost_VkDebugUtilsLabelEXT(sResourceTracker, (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
+ if (local_pLabelInfo) {
+ transform_tohost_VkDebugUtilsLabelEXT(sResourceTracker,
+ (VkDebugUtilsLabelEXT*)(local_pLabelInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugUtilsLabelEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsLabelEXT*)(local_pLabelInfo), countPtr);
+ count_VkDebugUtilsLabelEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsLabelEXT*)(local_pLabelInfo), countPtr);
}
uint32_t packetSize_vkCmdInsertDebugUtilsLabelEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdInsertDebugUtilsLabelEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdInsertDebugUtilsLabelEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdInsertDebugUtilsLabelEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdInsertDebugUtilsLabelEXT = OP_vkCmdInsertDebugUtilsLabelEXT;
- memcpy(streamPtr, &opcode_vkCmdInsertDebugUtilsLabelEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdInsertDebugUtilsLabelEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdInsertDebugUtilsLabelEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdInsertDebugUtilsLabelEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkDebugUtilsLabelEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsLabelEXT*)(local_pLabelInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkDebugUtilsLabelEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsLabelEXT*)(local_pLabelInfo), streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -29004,14 +40842,37 @@
}
VkResult VkEncoder::vkCreateDebugUtilsMessengerEXT(
- VkInstance instance,
- const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDebugUtilsMessengerEXT* pMessenger,
- uint32_t doLock)
-{
+ VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateDebugUtilsMessengerEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateDebugUtilsMessengerEXT(instance:%p, pCreateInfo:%p, pAllocator:%p, pMessenger:%p)",
+ instance, pCreateInfo, pAllocator, pMessenger);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -29020,62 +40881,79 @@
VkAllocationCallbacks* local_pAllocator;
local_instance = instance;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkDebugUtilsMessengerCreateInfoEXT*)pool->alloc(sizeof(const VkDebugUtilsMessengerCreateInfoEXT));
- deepcopy_VkDebugUtilsMessengerCreateInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDebugUtilsMessengerCreateInfoEXT*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkDebugUtilsMessengerCreateInfoEXT*)pool->alloc(
+ sizeof(const VkDebugUtilsMessengerCreateInfoEXT));
+ deepcopy_VkDebugUtilsMessengerCreateInfoEXT(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkDebugUtilsMessengerCreateInfoEXT*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkDebugUtilsMessengerCreateInfoEXT(sResourceTracker, (VkDebugUtilsMessengerCreateInfoEXT*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkDebugUtilsMessengerCreateInfoEXT(
+ sResourceTracker, (VkDebugUtilsMessengerCreateInfoEXT*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDebugUtilsMessengerCreateInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsMessengerCreateInfoEXT*)(local_pCreateInfo), countPtr);
+ count_VkDebugUtilsMessengerCreateInfoEXT(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsMessengerCreateInfoEXT*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateDebugUtilsMessengerEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateDebugUtilsMessengerEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCreateDebugUtilsMessengerEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateDebugUtilsMessengerEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateDebugUtilsMessengerEXT = OP_vkCreateDebugUtilsMessengerEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateDebugUtilsMessengerEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateDebugUtilsMessengerEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateDebugUtilsMessengerEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateDebugUtilsMessengerEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDebugUtilsMessengerCreateInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsMessengerCreateInfoEXT*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkDebugUtilsMessengerCreateInfoEXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsMessengerCreateInfoEXT*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -29086,13 +40964,14 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkDebugUtilsMessengerEXT(&cgen_var_3, (VkDebugUtilsMessengerEXT*)pMessenger, 1);
+ stream->handleMapping()->mapHandles_u64_VkDebugUtilsMessengerEXT(
+ &cgen_var_3, (VkDebugUtilsMessengerEXT*)pMessenger, 1);
stream->unsetHandleMapping();
VkResult vkCreateDebugUtilsMessengerEXT_VkResult_return = (VkResult)0;
stream->read(&vkCreateDebugUtilsMessengerEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -29100,14 +40979,37 @@
return vkCreateDebugUtilsMessengerEXT_VkResult_return;
}
-void VkEncoder::vkDestroyDebugUtilsMessengerEXT(
- VkInstance instance,
- VkDebugUtilsMessengerEXT messenger,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyDebugUtilsMessengerEXT(VkInstance instance,
+ VkDebugUtilsMessengerEXT messenger,
+ const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyDebugUtilsMessengerEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyDebugUtilsMessengerEXT(instance:%p, messenger:%p, pAllocator:%p)",
+ instance, messenger, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -29117,15 +41019,15 @@
local_instance = instance;
local_messenger = messenger;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -29136,19 +41038,29 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyDebugUtilsMessengerEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyDebugUtilsMessengerEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkDestroyDebugUtilsMessengerEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyDebugUtilsMessengerEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyDebugUtilsMessengerEXT = OP_vkDestroyDebugUtilsMessengerEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyDebugUtilsMessengerEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyDebugUtilsMessengerEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyDebugUtilsMessengerEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyDebugUtilsMessengerEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -29162,15 +41074,17 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
- sResourceTracker->destroyMapping()->mapHandles_VkDebugUtilsMessengerEXT((VkDebugUtilsMessengerEXT*)&messenger);
+ sResourceTracker->destroyMapping()->mapHandles_VkDebugUtilsMessengerEXT(
+ (VkDebugUtilsMessengerEXT*)&messenger);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -29178,14 +41092,36 @@
}
void VkEncoder::vkSubmitDebugUtilsMessageEXT(
- VkInstance instance,
- VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+ VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
VkDebugUtilsMessageTypeFlagsEXT messageTypes,
- const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
- uint32_t doLock)
-{
+ const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkSubmitDebugUtilsMessageEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkSubmitDebugUtilsMessageEXT(instance:%p, pCallbackData:%p)", instance,
+ pCallbackData);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -29197,14 +41133,16 @@
local_messageSeverity = messageSeverity;
local_messageTypes = messageTypes;
local_pCallbackData = nullptr;
- if (pCallbackData)
- {
- local_pCallbackData = (VkDebugUtilsMessengerCallbackDataEXT*)pool->alloc(sizeof(const VkDebugUtilsMessengerCallbackDataEXT));
- deepcopy_VkDebugUtilsMessengerCallbackDataEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCallbackData, (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData));
+ if (pCallbackData) {
+ local_pCallbackData = (VkDebugUtilsMessengerCallbackDataEXT*)pool->alloc(
+ sizeof(const VkDebugUtilsMessengerCallbackDataEXT));
+ deepcopy_VkDebugUtilsMessengerCallbackDataEXT(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCallbackData,
+ (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData));
}
- if (local_pCallbackData)
- {
- transform_tohost_VkDebugUtilsMessengerCallbackDataEXT(sResourceTracker, (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData));
+ if (local_pCallbackData) {
+ transform_tohost_VkDebugUtilsMessengerCallbackDataEXT(
+ sResourceTracker, (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -29213,29 +41151,45 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT);
*countPtr += sizeof(VkDebugUtilsMessageTypeFlagsEXT);
- count_VkDebugUtilsMessengerCallbackDataEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData), countPtr);
+ count_VkDebugUtilsMessengerCallbackDataEXT(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData), countPtr);
}
- uint32_t packetSize_vkSubmitDebugUtilsMessageEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkSubmitDebugUtilsMessageEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkSubmitDebugUtilsMessageEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkSubmitDebugUtilsMessageEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkSubmitDebugUtilsMessageEXT = OP_vkSubmitDebugUtilsMessageEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkSubmitDebugUtilsMessageEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkSubmitDebugUtilsMessageEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkSubmitDebugUtilsMessageEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkSubmitDebugUtilsMessageEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- memcpy(*streamPtrPtr, (VkDebugUtilsMessageSeverityFlagBitsEXT*)&local_messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT));
+ memcpy(*streamPtrPtr, (VkDebugUtilsMessageSeverityFlagBitsEXT*)&local_messageSeverity,
+ sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT));
*streamPtrPtr += sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT);
- memcpy(*streamPtrPtr, (VkDebugUtilsMessageTypeFlagsEXT*)&local_messageTypes, sizeof(VkDebugUtilsMessageTypeFlagsEXT));
+ memcpy(*streamPtrPtr, (VkDebugUtilsMessageTypeFlagsEXT*)&local_messageTypes,
+ sizeof(VkDebugUtilsMessageTypeFlagsEXT));
*streamPtrPtr += sizeof(VkDebugUtilsMessageTypeFlagsEXT);
- reservedmarshal_VkDebugUtilsMessengerCallbackDataEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData), streamPtrPtr);
+ reservedmarshal_VkDebugUtilsMessengerCallbackDataEXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData), streamPtrPtr);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -29245,13 +41199,37 @@
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
VkResult VkEncoder::vkGetAndroidHardwareBufferPropertiesANDROID(
- VkDevice device,
- const AHardwareBuffer* buffer,
- VkAndroidHardwareBufferPropertiesANDROID* pProperties,
- uint32_t doLock)
-{
+ VkDevice device, const AHardwareBuffer* buffer,
+ VkAndroidHardwareBufferPropertiesANDROID* pProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetAndroidHardwareBufferPropertiesANDROID in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetAndroidHardwareBufferPropertiesANDROID(device:%p, buffer:%p, pProperties:%p)", device,
+ buffer, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -29266,33 +41244,50 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(AHardwareBuffer);
- count_VkAndroidHardwareBufferPropertiesANDROID(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties), countPtr);
+ count_VkAndroidHardwareBufferPropertiesANDROID(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties), countPtr);
}
- uint32_t packetSize_vkGetAndroidHardwareBufferPropertiesANDROID = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetAndroidHardwareBufferPropertiesANDROID =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetAndroidHardwareBufferPropertiesANDROID);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetAndroidHardwareBufferPropertiesANDROID);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetAndroidHardwareBufferPropertiesANDROID = OP_vkGetAndroidHardwareBufferPropertiesANDROID;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetAndroidHardwareBufferPropertiesANDROID, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetAndroidHardwareBufferPropertiesANDROID, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetAndroidHardwareBufferPropertiesANDROID =
+ OP_vkGetAndroidHardwareBufferPropertiesANDROID;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetAndroidHardwareBufferPropertiesANDROID, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetAndroidHardwareBufferPropertiesANDROID, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (AHardwareBuffer*)local_buffer, sizeof(AHardwareBuffer));
*streamPtrPtr += sizeof(AHardwareBuffer);
- reservedmarshal_VkAndroidHardwareBufferPropertiesANDROID(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties), streamPtrPtr);
- unmarshal_VkAndroidHardwareBufferPropertiesANDROID(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties));
- if (pProperties)
- {
- transform_fromhost_VkAndroidHardwareBufferPropertiesANDROID(sResourceTracker, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties));
+ reservedmarshal_VkAndroidHardwareBufferPropertiesANDROID(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties), streamPtrPtr);
+ unmarshal_VkAndroidHardwareBufferPropertiesANDROID(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties));
+ if (pProperties) {
+ transform_fromhost_VkAndroidHardwareBufferPropertiesANDROID(
+ sResourceTracker, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties));
}
VkResult vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
stream->read(&vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -29301,13 +41296,36 @@
}
VkResult VkEncoder::vkGetMemoryAndroidHardwareBufferANDROID(
- VkDevice device,
- const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
- AHardwareBuffer** pBuffer,
- uint32_t doLock)
-{
+ VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
+ AHardwareBuffer** pBuffer, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetMemoryAndroidHardwareBufferANDROID in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetMemoryAndroidHardwareBufferANDROID(device:%p, pInfo:%p, pBuffer:%p)",
+ device, pInfo, pBuffer);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -29315,44 +41333,61 @@
VkMemoryGetAndroidHardwareBufferInfoANDROID* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkMemoryGetAndroidHardwareBufferInfoANDROID*)pool->alloc(sizeof(const VkMemoryGetAndroidHardwareBufferInfoANDROID));
- deepcopy_VkMemoryGetAndroidHardwareBufferInfoANDROID(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkMemoryGetAndroidHardwareBufferInfoANDROID*)pool->alloc(
+ sizeof(const VkMemoryGetAndroidHardwareBufferInfoANDROID));
+ deepcopy_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkMemoryGetAndroidHardwareBufferInfoANDROID(sResourceTracker, (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+ sResourceTracker, (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkMemoryGetAndroidHardwareBufferInfoANDROID(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo), countPtr);
+ count_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo), countPtr);
*countPtr += sizeof(AHardwareBuffer*);
}
- uint32_t packetSize_vkGetMemoryAndroidHardwareBufferANDROID = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetMemoryAndroidHardwareBufferANDROID =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetMemoryAndroidHardwareBufferANDROID);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetMemoryAndroidHardwareBufferANDROID);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetMemoryAndroidHardwareBufferANDROID = OP_vkGetMemoryAndroidHardwareBufferANDROID;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetMemoryAndroidHardwareBufferANDROID, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetMemoryAndroidHardwareBufferANDROID, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetMemoryAndroidHardwareBufferANDROID =
+ OP_vkGetMemoryAndroidHardwareBufferANDROID;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetMemoryAndroidHardwareBufferANDROID, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetMemoryAndroidHardwareBufferANDROID, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo), streamPtrPtr);
memcpy(*streamPtrPtr, (AHardwareBuffer**)pBuffer, sizeof(AHardwareBuffer*));
*streamPtrPtr += sizeof(AHardwareBuffer*);
stream->read((AHardwareBuffer**)pBuffer, sizeof(AHardwareBuffer*));
VkResult vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
stream->read(&vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -29374,13 +41409,36 @@
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
-void VkEncoder::vkCmdSetSampleLocationsEXT(
- VkCommandBuffer commandBuffer,
- const VkSampleLocationsInfoEXT* pSampleLocationsInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer,
+ const VkSampleLocationsInfoEXT* pSampleLocationsInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetSampleLocationsEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetSampleLocationsEXT(commandBuffer:%p, pSampleLocationsInfo:%p)",
+ commandBuffer, pSampleLocationsInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -29388,40 +41446,47 @@
VkSampleLocationsInfoEXT* local_pSampleLocationsInfo;
local_commandBuffer = commandBuffer;
local_pSampleLocationsInfo = nullptr;
- if (pSampleLocationsInfo)
- {
- local_pSampleLocationsInfo = (VkSampleLocationsInfoEXT*)pool->alloc(sizeof(const VkSampleLocationsInfoEXT));
- deepcopy_VkSampleLocationsInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSampleLocationsInfo, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo));
+ if (pSampleLocationsInfo) {
+ local_pSampleLocationsInfo =
+ (VkSampleLocationsInfoEXT*)pool->alloc(sizeof(const VkSampleLocationsInfoEXT));
+ deepcopy_VkSampleLocationsInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSampleLocationsInfo,
+ (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo));
}
- if (local_pSampleLocationsInfo)
- {
- transform_tohost_VkSampleLocationsInfoEXT(sResourceTracker, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo));
+ if (local_pSampleLocationsInfo) {
+ transform_tohost_VkSampleLocationsInfoEXT(
+ sResourceTracker, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSampleLocationsInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo), countPtr);
+ count_VkSampleLocationsInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo),
+ countPtr);
}
uint32_t packetSize_vkCmdSetSampleLocationsEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetSampleLocationsEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetSampleLocationsEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetSampleLocationsEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetSampleLocationsEXT = OP_vkCmdSetSampleLocationsEXT;
- memcpy(streamPtr, &opcode_vkCmdSetSampleLocationsEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetSampleLocationsEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetSampleLocationsEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetSampleLocationsEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkSampleLocationsInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkSampleLocationsInfoEXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo),
+ streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -29429,13 +41494,37 @@
}
void VkEncoder::vkGetPhysicalDeviceMultisamplePropertiesEXT(
- VkPhysicalDevice physicalDevice,
- VkSampleCountFlagBits samples,
- VkMultisamplePropertiesEXT* pMultisampleProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples,
+ VkMultisamplePropertiesEXT* pMultisampleProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceMultisamplePropertiesEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice:%p, pMultisampleProperties:%p)",
+ physicalDevice, pMultisampleProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -29449,31 +41538,47 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(VkSampleCountFlagBits);
- count_VkMultisamplePropertiesEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMultisamplePropertiesEXT*)(pMultisampleProperties), countPtr);
+ count_VkMultisamplePropertiesEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMultisamplePropertiesEXT*)(pMultisampleProperties),
+ countPtr);
}
- uint32_t packetSize_vkGetPhysicalDeviceMultisamplePropertiesEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceMultisamplePropertiesEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceMultisamplePropertiesEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceMultisamplePropertiesEXT);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceMultisamplePropertiesEXT = OP_vkGetPhysicalDeviceMultisamplePropertiesEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceMultisamplePropertiesEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceMultisamplePropertiesEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceMultisamplePropertiesEXT =
+ OP_vkGetPhysicalDeviceMultisamplePropertiesEXT;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceMultisamplePropertiesEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceMultisamplePropertiesEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkSampleCountFlagBits*)&local_samples, sizeof(VkSampleCountFlagBits));
*streamPtrPtr += sizeof(VkSampleCountFlagBits);
- reservedmarshal_VkMultisamplePropertiesEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMultisamplePropertiesEXT*)(pMultisampleProperties), streamPtrPtr);
- unmarshal_VkMultisamplePropertiesEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMultisamplePropertiesEXT*)(pMultisampleProperties));
- if (pMultisampleProperties)
- {
- transform_fromhost_VkMultisamplePropertiesEXT(sResourceTracker, (VkMultisamplePropertiesEXT*)(pMultisampleProperties));
+ reservedmarshal_VkMultisamplePropertiesEXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMultisamplePropertiesEXT*)(pMultisampleProperties),
+ streamPtrPtr);
+ unmarshal_VkMultisamplePropertiesEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMultisamplePropertiesEXT*)(pMultisampleProperties));
+ if (pMultisampleProperties) {
+ transform_fromhost_VkMultisamplePropertiesEXT(
+ sResourceTracker, (VkMultisamplePropertiesEXT*)(pMultisampleProperties));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -29495,13 +41600,37 @@
#endif
#ifdef VK_EXT_image_drm_format_modifier
VkResult VkEncoder::vkGetImageDrmFormatModifierPropertiesEXT(
- VkDevice device,
- VkImage image,
- VkImageDrmFormatModifierPropertiesEXT* pProperties,
- uint32_t doLock)
-{
+ VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetImageDrmFormatModifierPropertiesEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetImageDrmFormatModifierPropertiesEXT(device:%p, image:%p, pProperties:%p)", device,
+ image, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -29516,16 +41645,29 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkImageDrmFormatModifierPropertiesEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageDrmFormatModifierPropertiesEXT*)(pProperties), countPtr);
+ count_VkImageDrmFormatModifierPropertiesEXT(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageDrmFormatModifierPropertiesEXT*)(pProperties), countPtr);
}
- uint32_t packetSize_vkGetImageDrmFormatModifierPropertiesEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetImageDrmFormatModifierPropertiesEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetImageDrmFormatModifierPropertiesEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetImageDrmFormatModifierPropertiesEXT);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetImageDrmFormatModifierPropertiesEXT = OP_vkGetImageDrmFormatModifierPropertiesEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetImageDrmFormatModifierPropertiesEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetImageDrmFormatModifierPropertiesEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetImageDrmFormatModifierPropertiesEXT =
+ OP_vkGetImageDrmFormatModifierPropertiesEXT;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetImageDrmFormatModifierPropertiesEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetImageDrmFormatModifierPropertiesEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -29534,17 +41676,20 @@
*&cgen_var_1 = get_host_u64_VkImage((*&local_image));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageDrmFormatModifierPropertiesEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageDrmFormatModifierPropertiesEXT*)(pProperties), streamPtrPtr);
- unmarshal_VkImageDrmFormatModifierPropertiesEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageDrmFormatModifierPropertiesEXT*)(pProperties));
- if (pProperties)
- {
- transform_fromhost_VkImageDrmFormatModifierPropertiesEXT(sResourceTracker, (VkImageDrmFormatModifierPropertiesEXT*)(pProperties));
+ reservedmarshal_VkImageDrmFormatModifierPropertiesEXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageDrmFormatModifierPropertiesEXT*)(pProperties),
+ streamPtrPtr);
+ unmarshal_VkImageDrmFormatModifierPropertiesEXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageDrmFormatModifierPropertiesEXT*)(pProperties));
+ if (pProperties) {
+ transform_fromhost_VkImageDrmFormatModifierPropertiesEXT(
+ sResourceTracker, (VkImageDrmFormatModifierPropertiesEXT*)(pProperties));
}
VkResult vkGetImageDrmFormatModifierPropertiesEXT_VkResult_return = (VkResult)0;
stream->read(&vkGetImageDrmFormatModifierPropertiesEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -29554,15 +41699,39 @@
#endif
#ifdef VK_EXT_validation_cache
-VkResult VkEncoder::vkCreateValidationCacheEXT(
- VkDevice device,
- const VkValidationCacheCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkValidationCacheEXT* pValidationCache,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateValidationCacheEXT(VkDevice device,
+ const VkValidationCacheCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkValidationCacheEXT* pValidationCache,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateValidationCacheEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateValidationCacheEXT(device:%p, pCreateInfo:%p, pAllocator:%p, pValidationCache:%p)",
+ device, pCreateInfo, pAllocator, pValidationCache);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -29571,62 +41740,78 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkValidationCacheCreateInfoEXT*)pool->alloc(sizeof(const VkValidationCacheCreateInfoEXT));
- deepcopy_VkValidationCacheCreateInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkValidationCacheCreateInfoEXT*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkValidationCacheCreateInfoEXT*)pool->alloc(
+ sizeof(const VkValidationCacheCreateInfoEXT));
+ deepcopy_VkValidationCacheCreateInfoEXT(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkValidationCacheCreateInfoEXT*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkValidationCacheCreateInfoEXT(sResourceTracker, (VkValidationCacheCreateInfoEXT*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkValidationCacheCreateInfoEXT(
+ sResourceTracker, (VkValidationCacheCreateInfoEXT*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkValidationCacheCreateInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkValidationCacheCreateInfoEXT*)(local_pCreateInfo), countPtr);
+ count_VkValidationCacheCreateInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkValidationCacheCreateInfoEXT*)(local_pCreateInfo),
+ countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateValidationCacheEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateValidationCacheEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateValidationCacheEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateValidationCacheEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateValidationCacheEXT = OP_vkCreateValidationCacheEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateValidationCacheEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateValidationCacheEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateValidationCacheEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateValidationCacheEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkValidationCacheCreateInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkValidationCacheCreateInfoEXT*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkValidationCacheCreateInfoEXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkValidationCacheCreateInfoEXT*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -29637,13 +41822,14 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(&cgen_var_3, (VkValidationCacheEXT*)pValidationCache, 1);
+ stream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(
+ &cgen_var_3, (VkValidationCacheEXT*)pValidationCache, 1);
stream->unsetHandleMapping();
VkResult vkCreateValidationCacheEXT_VkResult_return = (VkResult)0;
stream->read(&vkCreateValidationCacheEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -29651,14 +41837,36 @@
return vkCreateValidationCacheEXT_VkResult_return;
}
-void VkEncoder::vkDestroyValidationCacheEXT(
- VkDevice device,
- VkValidationCacheEXT validationCache,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache,
+ const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyValidationCacheEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyValidationCacheEXT(device:%p, validationCache:%p, pAllocator:%p)",
+ device, validationCache, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -29668,15 +41876,15 @@
local_device = device;
local_validationCache = validationCache;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -29687,19 +41895,28 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyValidationCacheEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyValidationCacheEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyValidationCacheEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyValidationCacheEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyValidationCacheEXT = OP_vkDestroyValidationCacheEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyValidationCacheEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyValidationCacheEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyValidationCacheEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyValidationCacheEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -29713,30 +41930,55 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
- sResourceTracker->destroyMapping()->mapHandles_VkValidationCacheEXT((VkValidationCacheEXT*)&validationCache);
+ sResourceTracker->destroyMapping()->mapHandles_VkValidationCacheEXT(
+ (VkValidationCacheEXT*)&validationCache);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkMergeValidationCachesEXT(
- VkDevice device,
- VkValidationCacheEXT dstCache,
- uint32_t srcCacheCount,
- const VkValidationCacheEXT* pSrcCaches,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache,
+ uint32_t srcCacheCount,
+ const VkValidationCacheEXT* pSrcCaches,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkMergeValidationCachesEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkMergeValidationCachesEXT(device:%p, dstCache:%p, srcCacheCount:%d, pSrcCaches:%p)",
+ device, dstCache, srcCacheCount, pSrcCaches);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -29757,19 +41999,27 @@
uint64_t cgen_var_1;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- if (((srcCacheCount)))
- {
+ if (((srcCacheCount))) {
*countPtr += ((srcCacheCount)) * 8;
}
}
- uint32_t packetSize_vkMergeValidationCachesEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkMergeValidationCachesEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkMergeValidationCachesEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkMergeValidationCachesEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkMergeValidationCachesEXT = OP_vkMergeValidationCachesEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkMergeValidationCachesEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkMergeValidationCachesEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkMergeValidationCachesEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkMergeValidationCachesEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -29780,11 +42030,9 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_srcCacheCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (((srcCacheCount)))
- {
+ if (((srcCacheCount))) {
uint8_t* cgen_var_2_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((srcCacheCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((srcCacheCount)); ++k) {
uint64_t tmpval = get_host_u64_VkValidationCacheEXT(local_pSrcCaches[k]);
memcpy(cgen_var_2_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -29792,9 +42040,9 @@
}
VkResult vkMergeValidationCachesEXT_VkResult_return = (VkResult)0;
stream->read(&vkMergeValidationCachesEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -29802,15 +42050,37 @@
return vkMergeValidationCachesEXT_VkResult_return;
}
-VkResult VkEncoder::vkGetValidationCacheDataEXT(
- VkDevice device,
- VkValidationCacheEXT validationCache,
- size_t* pDataSize,
- void* pData,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetValidationCacheDataEXT(VkDevice device,
+ VkValidationCacheEXT validationCache,
+ size_t* pDataSize, void* pData, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetValidationCacheDataEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetValidationCacheDataEXT(device:%p, validationCache:%p, pDataSize:%p, pData:%p)",
+ device, validationCache, pDataSize, pData);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -29827,28 +42097,34 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pDataSize)
- {
+ if (pDataSize) {
*countPtr += 8;
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pData)
- {
- if (pDataSize)
- {
+ if (pData) {
+ if (pDataSize) {
*countPtr += (*(pDataSize)) * sizeof(uint8_t);
}
}
}
- uint32_t packetSize_vkGetValidationCacheDataEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetValidationCacheDataEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetValidationCacheDataEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetValidationCacheDataEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetValidationCacheDataEXT = OP_vkGetValidationCacheDataEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetValidationCacheDataEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetValidationCacheDataEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetValidationCacheDataEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetValidationCacheDataEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -29862,8 +42138,7 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pDataSize)
- {
+ if (pDataSize) {
uint64_t cgen_var_2_0 = (uint64_t)(*pDataSize);
memcpy((*streamPtrPtr), &cgen_var_2_0, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
@@ -29874,18 +42149,15 @@
memcpy((*streamPtrPtr), &cgen_var_3, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pData)
- {
+ if (pData) {
memcpy(*streamPtrPtr, (void*)pData, (*(pDataSize)) * sizeof(uint8_t));
*streamPtrPtr += (*(pDataSize)) * sizeof(uint8_t);
}
// WARNING PTR CHECK
size_t* check_pDataSize;
check_pDataSize = (size_t*)(uintptr_t)stream->getBe64();
- if (pDataSize)
- {
- if (!(check_pDataSize))
- {
+ if (pDataSize) {
+ if (!(check_pDataSize)) {
fprintf(stderr, "fatal: pDataSize inconsistent between guest and host\n");
}
(*pDataSize) = (size_t)stream->getBe64();
@@ -29893,19 +42165,17 @@
// WARNING PTR CHECK
void* check_pData;
check_pData = (void*)(uintptr_t)stream->getBe64();
- if (pData)
- {
- if (!(check_pData))
- {
+ if (pData) {
+ if (!(check_pData)) {
fprintf(stderr, "fatal: pData inconsistent between guest and host\n");
}
stream->read((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
}
VkResult vkGetValidationCacheDataEXT_VkResult_return = (VkResult)0;
stream->read(&vkGetValidationCacheDataEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -29919,14 +42189,35 @@
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_NV_shading_rate_image
-void VkEncoder::vkCmdBindShadingRateImageNV(
- VkCommandBuffer commandBuffer,
- VkImageView imageView,
- VkImageLayout imageLayout,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView,
+ VkImageLayout imageLayout, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBindShadingRateImageNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdBindShadingRateImageNV(commandBuffer:%p, imageView:%p, imageLayout:%d)",
+ commandBuffer, imageView, imageLayout);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -29946,14 +42237,16 @@
*countPtr += sizeof(VkImageLayout);
}
uint32_t packetSize_vkCmdBindShadingRateImageNV = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBindShadingRateImageNV);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBindShadingRateImageNV -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBindShadingRateImageNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBindShadingRateImageNV = OP_vkCmdBindShadingRateImageNV;
- memcpy(streamPtr, &opcode_vkCmdBindShadingRateImageNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBindShadingRateImageNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBindShadingRateImageNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBindShadingRateImageNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -29965,9 +42258,9 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
*streamPtrPtr += sizeof(VkImageLayout);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -29975,14 +42268,37 @@
}
void VkEncoder::vkCmdSetViewportShadingRatePaletteNV(
- VkCommandBuffer commandBuffer,
- uint32_t firstViewport,
- uint32_t viewportCount,
- const VkShadingRatePaletteNV* pShadingRatePalettes,
- uint32_t doLock)
-{
+ VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount,
+ const VkShadingRatePaletteNV* pShadingRatePalettes, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetViewportShadingRatePaletteNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdSetViewportShadingRatePaletteNV(commandBuffer:%p, firstViewport:%d, "
+ "viewportCount:%d, pShadingRatePalettes:%p)",
+ commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -29994,19 +42310,19 @@
local_firstViewport = firstViewport;
local_viewportCount = viewportCount;
local_pShadingRatePalettes = nullptr;
- if (pShadingRatePalettes)
- {
- local_pShadingRatePalettes = (VkShadingRatePaletteNV*)pool->alloc(((viewportCount)) * sizeof(const VkShadingRatePaletteNV));
- for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
- {
- deepcopy_VkShadingRatePaletteNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pShadingRatePalettes + i, (VkShadingRatePaletteNV*)(local_pShadingRatePalettes + i));
+ if (pShadingRatePalettes) {
+ local_pShadingRatePalettes = (VkShadingRatePaletteNV*)pool->alloc(
+ ((viewportCount)) * sizeof(const VkShadingRatePaletteNV));
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+ deepcopy_VkShadingRatePaletteNV(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pShadingRatePalettes + i,
+ (VkShadingRatePaletteNV*)(local_pShadingRatePalettes + i));
}
}
- if (local_pShadingRatePalettes)
- {
- for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
- {
- transform_tohost_VkShadingRatePaletteNV(sResourceTracker, (VkShadingRatePaletteNV*)(local_pShadingRatePalettes + i));
+ if (local_pShadingRatePalettes) {
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+ transform_tohost_VkShadingRatePaletteNV(
+ sResourceTracker, (VkShadingRatePaletteNV*)(local_pShadingRatePalettes + i));
}
}
size_t count = 0;
@@ -30016,20 +42332,24 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
- {
- count_VkShadingRatePaletteNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkShadingRatePaletteNV*)(local_pShadingRatePalettes + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+ count_VkShadingRatePaletteNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkShadingRatePaletteNV*)(local_pShadingRatePalettes + i),
+ countPtr);
}
}
uint32_t packetSize_vkCmdSetViewportShadingRatePaletteNV = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdSetViewportShadingRatePaletteNV);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetViewportShadingRatePaletteNV -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetViewportShadingRatePaletteNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetViewportShadingRatePaletteNV = OP_vkCmdSetViewportShadingRatePaletteNV;
- memcpy(streamPtr, &opcode_vkCmdSetViewportShadingRatePaletteNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetViewportShadingRatePaletteNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetViewportShadingRatePaletteNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetViewportShadingRatePaletteNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -30039,28 +42359,54 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_viewportCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
- {
- reservedmarshal_VkShadingRatePaletteNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkShadingRatePaletteNV*)(local_pShadingRatePalettes + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+ reservedmarshal_VkShadingRatePaletteNV(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkShadingRatePaletteNV*)(local_pShadingRatePalettes + i), streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetCoarseSampleOrderNV(
- VkCommandBuffer commandBuffer,
- VkCoarseSampleOrderTypeNV sampleOrderType,
- uint32_t customSampleOrderCount,
- const VkCoarseSampleOrderCustomNV* pCustomSampleOrders,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer,
+ VkCoarseSampleOrderTypeNV sampleOrderType,
+ uint32_t customSampleOrderCount,
+ const VkCoarseSampleOrderCustomNV* pCustomSampleOrders,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetCoarseSampleOrderNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdSetCoarseSampleOrderNV(commandBuffer:%p, customSampleOrderCount:%d, "
+ "pCustomSampleOrders:%p)",
+ commandBuffer, customSampleOrderCount, pCustomSampleOrders);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -30072,19 +42418,19 @@
local_sampleOrderType = sampleOrderType;
local_customSampleOrderCount = customSampleOrderCount;
local_pCustomSampleOrders = nullptr;
- if (pCustomSampleOrders)
- {
- local_pCustomSampleOrders = (VkCoarseSampleOrderCustomNV*)pool->alloc(((customSampleOrderCount)) * sizeof(const VkCoarseSampleOrderCustomNV));
- for (uint32_t i = 0; i < (uint32_t)((customSampleOrderCount)); ++i)
- {
- deepcopy_VkCoarseSampleOrderCustomNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCustomSampleOrders + i, (VkCoarseSampleOrderCustomNV*)(local_pCustomSampleOrders + i));
+ if (pCustomSampleOrders) {
+ local_pCustomSampleOrders = (VkCoarseSampleOrderCustomNV*)pool->alloc(
+ ((customSampleOrderCount)) * sizeof(const VkCoarseSampleOrderCustomNV));
+ for (uint32_t i = 0; i < (uint32_t)((customSampleOrderCount)); ++i) {
+ deepcopy_VkCoarseSampleOrderCustomNV(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCustomSampleOrders + i,
+ (VkCoarseSampleOrderCustomNV*)(local_pCustomSampleOrders + i));
}
}
- if (local_pCustomSampleOrders)
- {
- for (uint32_t i = 0; i < (uint32_t)((customSampleOrderCount)); ++i)
- {
- transform_tohost_VkCoarseSampleOrderCustomNV(sResourceTracker, (VkCoarseSampleOrderCustomNV*)(local_pCustomSampleOrders + i));
+ if (local_pCustomSampleOrders) {
+ for (uint32_t i = 0; i < (uint32_t)((customSampleOrderCount)); ++i) {
+ transform_tohost_VkCoarseSampleOrderCustomNV(
+ sResourceTracker, (VkCoarseSampleOrderCustomNV*)(local_pCustomSampleOrders + i));
}
}
size_t count = 0;
@@ -30094,36 +42440,41 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkCoarseSampleOrderTypeNV);
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((customSampleOrderCount)); ++i)
- {
- count_VkCoarseSampleOrderCustomNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCoarseSampleOrderCustomNV*)(local_pCustomSampleOrders + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((customSampleOrderCount)); ++i) {
+ count_VkCoarseSampleOrderCustomNV(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCoarseSampleOrderCustomNV*)(local_pCustomSampleOrders + i), countPtr);
}
}
uint32_t packetSize_vkCmdSetCoarseSampleOrderNV = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetCoarseSampleOrderNV);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetCoarseSampleOrderNV -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetCoarseSampleOrderNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetCoarseSampleOrderNV = OP_vkCmdSetCoarseSampleOrderNV;
- memcpy(streamPtr, &opcode_vkCmdSetCoarseSampleOrderNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetCoarseSampleOrderNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetCoarseSampleOrderNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetCoarseSampleOrderNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- memcpy(*streamPtrPtr, (VkCoarseSampleOrderTypeNV*)&local_sampleOrderType, sizeof(VkCoarseSampleOrderTypeNV));
+ memcpy(*streamPtrPtr, (VkCoarseSampleOrderTypeNV*)&local_sampleOrderType,
+ sizeof(VkCoarseSampleOrderTypeNV));
*streamPtrPtr += sizeof(VkCoarseSampleOrderTypeNV);
memcpy(*streamPtrPtr, (uint32_t*)&local_customSampleOrderCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((customSampleOrderCount)); ++i)
- {
- reservedmarshal_VkCoarseSampleOrderCustomNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCoarseSampleOrderCustomNV*)(local_pCustomSampleOrders + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((customSampleOrderCount)); ++i) {
+ reservedmarshal_VkCoarseSampleOrderCustomNV(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCoarseSampleOrderCustomNV*)(local_pCustomSampleOrders + i), streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -30133,14 +42484,38 @@
#endif
#ifdef VK_NV_ray_tracing
VkResult VkEncoder::vkCreateAccelerationStructureNV(
- VkDevice device,
- const VkAccelerationStructureCreateInfoNV* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkAccelerationStructureNV* pAccelerationStructure,
- uint32_t doLock)
-{
+ VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateAccelerationStructureNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateAccelerationStructureNV(device:%p, pCreateInfo:%p, pAllocator:%p, "
+ "pAccelerationStructure:%p)",
+ device, pCreateInfo, pAllocator, pAccelerationStructure);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -30149,62 +42524,79 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkAccelerationStructureCreateInfoNV*)pool->alloc(sizeof(const VkAccelerationStructureCreateInfoNV));
- deepcopy_VkAccelerationStructureCreateInfoNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkAccelerationStructureCreateInfoNV*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkAccelerationStructureCreateInfoNV*)pool->alloc(
+ sizeof(const VkAccelerationStructureCreateInfoNV));
+ deepcopy_VkAccelerationStructureCreateInfoNV(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkAccelerationStructureCreateInfoNV*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkAccelerationStructureCreateInfoNV(sResourceTracker, (VkAccelerationStructureCreateInfoNV*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkAccelerationStructureCreateInfoNV(
+ sResourceTracker, (VkAccelerationStructureCreateInfoNV*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkAccelerationStructureCreateInfoNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureCreateInfoNV*)(local_pCreateInfo), countPtr);
+ count_VkAccelerationStructureCreateInfoNV(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureCreateInfoNV*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateAccelerationStructureNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateAccelerationStructureNV =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCreateAccelerationStructureNV);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateAccelerationStructureNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateAccelerationStructureNV = OP_vkCreateAccelerationStructureNV;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateAccelerationStructureNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateAccelerationStructureNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateAccelerationStructureNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateAccelerationStructureNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkAccelerationStructureCreateInfoNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureCreateInfoNV*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkAccelerationStructureCreateInfoNV(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureCreateInfoNV*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -30215,13 +42607,14 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkAccelerationStructureNV(&cgen_var_3, (VkAccelerationStructureNV*)pAccelerationStructure, 1);
+ stream->handleMapping()->mapHandles_u64_VkAccelerationStructureNV(
+ &cgen_var_3, (VkAccelerationStructureNV*)pAccelerationStructure, 1);
stream->unsetHandleMapping();
VkResult vkCreateAccelerationStructureNV_VkResult_return = (VkResult)0;
stream->read(&vkCreateAccelerationStructureNV_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -30229,14 +42622,38 @@
return vkCreateAccelerationStructureNV_VkResult_return;
}
-void VkEncoder::vkDestroyAccelerationStructureNV(
- VkDevice device,
- VkAccelerationStructureNV accelerationStructure,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyAccelerationStructureNV(VkDevice device,
+ VkAccelerationStructureNV accelerationStructure,
+ const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyAccelerationStructureNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkDestroyAccelerationStructureNV(device:%p, accelerationStructure:%p, pAllocator:%p)",
+ device, accelerationStructure, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -30246,15 +42663,15 @@
local_device = device;
local_accelerationStructure = accelerationStructure;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -30265,19 +42682,29 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyAccelerationStructureNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyAccelerationStructureNV =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkDestroyAccelerationStructureNV);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyAccelerationStructureNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyAccelerationStructureNV = OP_vkDestroyAccelerationStructureNV;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyAccelerationStructureNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyAccelerationStructureNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyAccelerationStructureNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyAccelerationStructureNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -30291,15 +42718,17 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
- sResourceTracker->destroyMapping()->mapHandles_VkAccelerationStructureNV((VkAccelerationStructureNV*)&accelerationStructure);
+ sResourceTracker->destroyMapping()->mapHandles_VkAccelerationStructureNV(
+ (VkAccelerationStructureNV*)&accelerationStructure);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -30307,13 +42736,38 @@
}
void VkEncoder::vkGetAccelerationStructureMemoryRequirementsNV(
- VkDevice device,
- const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
- VkMemoryRequirements2KHR* pMemoryRequirements,
- uint32_t doLock)
-{
+ VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
+ VkMemoryRequirements2KHR* pMemoryRequirements, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetAccelerationStructureMemoryRequirementsNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetAccelerationStructureMemoryRequirementsNV(device:%p, pInfo:%p, "
+ "pMemoryRequirements:%p)",
+ device, pInfo, pMemoryRequirements);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -30321,45 +42775,66 @@
VkAccelerationStructureMemoryRequirementsInfoNV* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkAccelerationStructureMemoryRequirementsInfoNV*)pool->alloc(sizeof(const VkAccelerationStructureMemoryRequirementsInfoNV));
- deepcopy_VkAccelerationStructureMemoryRequirementsInfoNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkAccelerationStructureMemoryRequirementsInfoNV*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkAccelerationStructureMemoryRequirementsInfoNV*)pool->alloc(
+ sizeof(const VkAccelerationStructureMemoryRequirementsInfoNV));
+ deepcopy_VkAccelerationStructureMemoryRequirementsInfoNV(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkAccelerationStructureMemoryRequirementsInfoNV*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkAccelerationStructureMemoryRequirementsInfoNV(sResourceTracker, (VkAccelerationStructureMemoryRequirementsInfoNV*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkAccelerationStructureMemoryRequirementsInfoNV(
+ sResourceTracker, (VkAccelerationStructureMemoryRequirementsInfoNV*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkAccelerationStructureMemoryRequirementsInfoNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureMemoryRequirementsInfoNV*)(local_pInfo), countPtr);
- count_VkMemoryRequirements2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2KHR*)(pMemoryRequirements), countPtr);
+ count_VkAccelerationStructureMemoryRequirementsInfoNV(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureMemoryRequirementsInfoNV*)(local_pInfo), countPtr);
+ count_VkMemoryRequirements2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2KHR*)(pMemoryRequirements), countPtr);
}
- uint32_t packetSize_vkGetAccelerationStructureMemoryRequirementsNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetAccelerationStructureMemoryRequirementsNV =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetAccelerationStructureMemoryRequirementsNV);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetAccelerationStructureMemoryRequirementsNV);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetAccelerationStructureMemoryRequirementsNV = OP_vkGetAccelerationStructureMemoryRequirementsNV;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetAccelerationStructureMemoryRequirementsNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetAccelerationStructureMemoryRequirementsNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetAccelerationStructureMemoryRequirementsNV =
+ OP_vkGetAccelerationStructureMemoryRequirementsNV;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetAccelerationStructureMemoryRequirementsNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetAccelerationStructureMemoryRequirementsNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkAccelerationStructureMemoryRequirementsInfoNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureMemoryRequirementsInfoNV*)(local_pInfo), streamPtrPtr);
- reservedmarshal_VkMemoryRequirements2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2KHR*)(pMemoryRequirements), streamPtrPtr);
- unmarshal_VkMemoryRequirements2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2KHR*)(pMemoryRequirements));
- if (pMemoryRequirements)
- {
- transform_fromhost_VkMemoryRequirements2KHR(sResourceTracker, (VkMemoryRequirements2KHR*)(pMemoryRequirements));
+ reservedmarshal_VkAccelerationStructureMemoryRequirementsInfoNV(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureMemoryRequirementsInfoNV*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkMemoryRequirements2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2KHR*)(pMemoryRequirements),
+ streamPtrPtr);
+ unmarshal_VkMemoryRequirements2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2KHR*)(pMemoryRequirements));
+ if (pMemoryRequirements) {
+ transform_fromhost_VkMemoryRequirements2KHR(
+ sResourceTracker, (VkMemoryRequirements2KHR*)(pMemoryRequirements));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -30367,13 +42842,36 @@
}
VkResult VkEncoder::vkBindAccelerationStructureMemoryNV(
- VkDevice device,
- uint32_t bindInfoCount,
- const VkBindAccelerationStructureMemoryInfoNV* pBindInfos,
- uint32_t doLock)
-{
+ VkDevice device, uint32_t bindInfoCount,
+ const VkBindAccelerationStructureMemoryInfoNV* pBindInfos, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkBindAccelerationStructureMemoryNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkBindAccelerationStructureMemoryNV(device:%p, bindInfoCount:%d, pBindInfos:%p)", device,
+ bindInfoCount, pBindInfos);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -30383,19 +42881,19 @@
local_device = device;
local_bindInfoCount = bindInfoCount;
local_pBindInfos = nullptr;
- if (pBindInfos)
- {
- local_pBindInfos = (VkBindAccelerationStructureMemoryInfoNV*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindAccelerationStructureMemoryInfoNV));
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- deepcopy_VkBindAccelerationStructureMemoryInfoNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfos + i, (VkBindAccelerationStructureMemoryInfoNV*)(local_pBindInfos + i));
+ if (pBindInfos) {
+ local_pBindInfos = (VkBindAccelerationStructureMemoryInfoNV*)pool->alloc(
+ ((bindInfoCount)) * sizeof(const VkBindAccelerationStructureMemoryInfoNV));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ deepcopy_VkBindAccelerationStructureMemoryInfoNV(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfos + i,
+ (VkBindAccelerationStructureMemoryInfoNV*)(local_pBindInfos + i));
}
}
- if (local_pBindInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- transform_tohost_VkBindAccelerationStructureMemoryInfoNV(sResourceTracker, (VkBindAccelerationStructureMemoryInfoNV*)(local_pBindInfos + i));
+ if (local_pBindInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ transform_tohost_VkBindAccelerationStructureMemoryInfoNV(
+ sResourceTracker, (VkBindAccelerationStructureMemoryInfoNV*)(local_pBindInfos + i));
}
}
size_t count = 0;
@@ -30404,34 +42902,46 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- count_VkBindAccelerationStructureMemoryInfoNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindAccelerationStructureMemoryInfoNV*)(local_pBindInfos + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ count_VkBindAccelerationStructureMemoryInfoNV(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBindAccelerationStructureMemoryInfoNV*)(local_pBindInfos + i), countPtr);
}
}
- uint32_t packetSize_vkBindAccelerationStructureMemoryNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkBindAccelerationStructureMemoryNV =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkBindAccelerationStructureMemoryNV);
uint8_t* streamPtr = stream->reserve(packetSize_vkBindAccelerationStructureMemoryNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkBindAccelerationStructureMemoryNV = OP_vkBindAccelerationStructureMemoryNV;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkBindAccelerationStructureMemoryNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkBindAccelerationStructureMemoryNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkBindAccelerationStructureMemoryNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkBindAccelerationStructureMemoryNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- reservedmarshal_VkBindAccelerationStructureMemoryInfoNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindAccelerationStructureMemoryInfoNV*)(local_pBindInfos + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ reservedmarshal_VkBindAccelerationStructureMemoryInfoNV(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBindAccelerationStructureMemoryInfoNV*)(local_pBindInfos + i), streamPtrPtr);
}
VkResult vkBindAccelerationStructureMemoryNV_VkResult_return = (VkResult)0;
stream->read(&vkBindAccelerationStructureMemoryNV_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -30439,20 +42949,43 @@
return vkBindAccelerationStructureMemoryNV_VkResult_return;
}
-void VkEncoder::vkCmdBuildAccelerationStructureNV(
- VkCommandBuffer commandBuffer,
- const VkAccelerationStructureInfoNV* pInfo,
- VkBuffer instanceData,
- VkDeviceSize instanceOffset,
- VkBool32 update,
- VkAccelerationStructureNV dst,
- VkAccelerationStructureNV src,
- VkBuffer scratch,
- VkDeviceSize scratchOffset,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer,
+ const VkAccelerationStructureInfoNV* pInfo,
+ VkBuffer instanceData,
+ VkDeviceSize instanceOffset, VkBool32 update,
+ VkAccelerationStructureNV dst,
+ VkAccelerationStructureNV src, VkBuffer scratch,
+ VkDeviceSize scratchOffset, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBuildAccelerationStructureNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdBuildAccelerationStructureNV(commandBuffer:%p, pInfo:%p, instanceData:%p, "
+ "instanceOffset:%ld, update:%d, dst:%p, src:%p, scratch:%p, scratchOffset:%ld)",
+ commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch,
+ scratchOffset);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -30467,10 +43000,11 @@
VkDeviceSize local_scratchOffset;
local_commandBuffer = commandBuffer;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkAccelerationStructureInfoNV*)pool->alloc(sizeof(const VkAccelerationStructureInfoNV));
- deepcopy_VkAccelerationStructureInfoNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkAccelerationStructureInfoNV*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkAccelerationStructureInfoNV*)pool->alloc(
+ sizeof(const VkAccelerationStructureInfoNV));
+ deepcopy_VkAccelerationStructureInfoNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkAccelerationStructureInfoNV*)(local_pInfo));
}
local_instanceData = instanceData;
local_instanceOffset = instanceOffset;
@@ -30479,16 +43013,18 @@
local_src = src;
local_scratch = scratch;
local_scratchOffset = scratchOffset;
- if (local_pInfo)
- {
- transform_tohost_VkAccelerationStructureInfoNV(sResourceTracker, (VkAccelerationStructureInfoNV*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkAccelerationStructureInfoNV(
+ sResourceTracker, (VkAccelerationStructureInfoNV*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkAccelerationStructureInfoNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureInfoNV*)(local_pInfo), countPtr);
+ count_VkAccelerationStructureInfoNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureInfoNV*)(local_pInfo),
+ countPtr);
uint64_t cgen_var_1;
*countPtr += 1 * 8;
*countPtr += sizeof(VkDeviceSize);
@@ -30502,20 +43038,25 @@
*countPtr += sizeof(VkDeviceSize);
}
uint32_t packetSize_vkCmdBuildAccelerationStructureNV = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdBuildAccelerationStructureNV);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBuildAccelerationStructureNV -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBuildAccelerationStructureNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBuildAccelerationStructureNV = OP_vkCmdBuildAccelerationStructureNV;
- memcpy(streamPtr, &opcode_vkCmdBuildAccelerationStructureNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBuildAccelerationStructureNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBuildAccelerationStructureNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBuildAccelerationStructureNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkAccelerationStructureInfoNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureInfoNV*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkAccelerationStructureInfoNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureInfoNV*)(local_pInfo),
+ streamPtrPtr);
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkBuffer((*&local_instanceData));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -30538,24 +43079,47 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkDeviceSize*)&local_scratchOffset, sizeof(VkDeviceSize));
*streamPtrPtr += sizeof(VkDeviceSize);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdCopyAccelerationStructureNV(
- VkCommandBuffer commandBuffer,
- VkAccelerationStructureNV dst,
- VkAccelerationStructureNV src,
- VkCopyAccelerationStructureModeKHR mode,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer,
+ VkAccelerationStructureNV dst,
+ VkAccelerationStructureNV src,
+ VkCopyAccelerationStructureModeKHR mode,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdCopyAccelerationStructureNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdCopyAccelerationStructureNV(commandBuffer:%p, dst:%p, src:%p)",
+ commandBuffer, dst, src);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -30579,14 +43143,17 @@
*countPtr += sizeof(VkCopyAccelerationStructureModeKHR);
}
uint32_t packetSize_vkCmdCopyAccelerationStructureNV = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdCopyAccelerationStructureNV);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyAccelerationStructureNV -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyAccelerationStructureNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdCopyAccelerationStructureNV = OP_vkCmdCopyAccelerationStructureNV;
- memcpy(streamPtr, &opcode_vkCmdCopyAccelerationStructureNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdCopyAccelerationStructureNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdCopyAccelerationStructureNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdCopyAccelerationStructureNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -30600,11 +43167,12 @@
*&cgen_var_1 = get_host_u64_VkAccelerationStructureNV((*&local_src));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- memcpy(*streamPtrPtr, (VkCopyAccelerationStructureModeKHR*)&local_mode, sizeof(VkCopyAccelerationStructureModeKHR));
+ memcpy(*streamPtrPtr, (VkCopyAccelerationStructureModeKHR*)&local_mode,
+ sizeof(VkCopyAccelerationStructureModeKHR));
*streamPtrPtr += sizeof(VkCopyAccelerationStructureModeKHR);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -30612,25 +43180,50 @@
}
void VkEncoder::vkCmdTraceRaysNV(
- VkCommandBuffer commandBuffer,
- VkBuffer raygenShaderBindingTableBuffer,
- VkDeviceSize raygenShaderBindingOffset,
- VkBuffer missShaderBindingTableBuffer,
- VkDeviceSize missShaderBindingOffset,
- VkDeviceSize missShaderBindingStride,
- VkBuffer hitShaderBindingTableBuffer,
- VkDeviceSize hitShaderBindingOffset,
- VkDeviceSize hitShaderBindingStride,
- VkBuffer callableShaderBindingTableBuffer,
- VkDeviceSize callableShaderBindingOffset,
- VkDeviceSize callableShaderBindingStride,
- uint32_t width,
- uint32_t height,
- uint32_t depth,
- uint32_t doLock)
-{
+ VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer,
+ VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer,
+ VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride,
+ VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset,
+ VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer,
+ VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride,
+ uint32_t width, uint32_t height, uint32_t depth, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdTraceRaysNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdTraceRaysNV(commandBuffer:%p, raygenShaderBindingTableBuffer:%p, "
+ "raygenShaderBindingOffset:%ld, missShaderBindingTableBuffer:%p, "
+ "missShaderBindingOffset:%ld, missShaderBindingStride:%ld, hitShaderBindingTableBuffer:%p, "
+ "hitShaderBindingOffset:%ld, hitShaderBindingStride:%ld, "
+ "callableShaderBindingTableBuffer:%p, callableShaderBindingOffset:%ld, "
+ "callableShaderBindingStride:%ld, width:%d, height:%d, depth:%d)",
+ commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset,
+ missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride,
+ hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride,
+ callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride,
+ width, height, depth);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -30689,14 +43282,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdTraceRaysNV = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdTraceRaysNV);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdTraceRaysNV -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdTraceRaysNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdTraceRaysNV = OP_vkCmdTraceRaysNV;
- memcpy(streamPtr, &opcode_vkCmdTraceRaysNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdTraceRaysNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdTraceRaysNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdTraceRaysNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -30738,9 +43333,9 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_depth, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -30748,16 +43343,38 @@
}
VkResult VkEncoder::vkCreateRayTracingPipelinesNV(
- VkDevice device,
- VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines,
- uint32_t doLock)
-{
+ VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount,
+ const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateRayTracingPipelinesNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateRayTracingPipelinesNV(device:%p, pipelineCache:%p, createInfoCount:%d, "
+ "pCreateInfos:%p, pAllocator:%p, pPipelines:%p)",
+ device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -30770,31 +43387,31 @@
local_pipelineCache = pipelineCache;
local_createInfoCount = createInfoCount;
local_pCreateInfos = nullptr;
- if (pCreateInfos)
- {
- local_pCreateInfos = (VkRayTracingPipelineCreateInfoNV*)pool->alloc(((createInfoCount)) * sizeof(const VkRayTracingPipelineCreateInfoNV));
- for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
- {
- deepcopy_VkRayTracingPipelineCreateInfoNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfos + i, (VkRayTracingPipelineCreateInfoNV*)(local_pCreateInfos + i));
+ if (pCreateInfos) {
+ local_pCreateInfos = (VkRayTracingPipelineCreateInfoNV*)pool->alloc(
+ ((createInfoCount)) * sizeof(const VkRayTracingPipelineCreateInfoNV));
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+ deepcopy_VkRayTracingPipelineCreateInfoNV(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfos + i,
+ (VkRayTracingPipelineCreateInfoNV*)(local_pCreateInfos + i));
}
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
- {
- transform_tohost_VkRayTracingPipelineCreateInfoNV(sResourceTracker, (VkRayTracingPipelineCreateInfoNV*)(local_pCreateInfos + i));
+ if (local_pCreateInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+ transform_tohost_VkRayTracingPipelineCreateInfoNV(
+ sResourceTracker, (VkRayTracingPipelineCreateInfoNV*)(local_pCreateInfos + i));
}
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -30804,29 +43421,39 @@
uint64_t cgen_var_1;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
- {
- count_VkRayTracingPipelineCreateInfoNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRayTracingPipelineCreateInfoNV*)(local_pCreateInfos + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+ count_VkRayTracingPipelineCreateInfoNV(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRayTracingPipelineCreateInfoNV*)(local_pCreateInfos + i), countPtr);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
- if (((createInfoCount)))
- {
+ if (((createInfoCount))) {
*countPtr += ((createInfoCount)) * 8;
}
}
- uint32_t packetSize_vkCreateRayTracingPipelinesNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateRayTracingPipelinesNV =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCreateRayTracingPipelinesNV);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateRayTracingPipelinesNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateRayTracingPipelinesNV = OP_vkCreateRayTracingPipelinesNV;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateRayTracingPipelinesNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateRayTracingPipelinesNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateRayTracingPipelinesNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateRayTracingPipelinesNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -30837,43 +43464,43 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_createInfoCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
- {
- reservedmarshal_VkRayTracingPipelineCreateInfoNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRayTracingPipelineCreateInfoNV*)(local_pCreateInfos + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+ reservedmarshal_VkRayTracingPipelineCreateInfoNV(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRayTracingPipelineCreateInfoNV*)(local_pCreateInfos + i), streamPtrPtr);
}
// WARNING PTR CHECK
uint64_t cgen_var_2 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
- if (((createInfoCount)))
- {
+ if (((createInfoCount))) {
uint8_t* cgen_var_3_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((createInfoCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((createInfoCount)); ++k) {
uint64_t tmpval = (uint64_t)(pPipelines[k]);
memcpy(cgen_var_3_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
*streamPtrPtr += 8 * ((createInfoCount));
}
/* is handle, possibly out */;
- if (((createInfoCount)))
- {
+ if (((createInfoCount))) {
uint64_t* cgen_var_4;
stream->alloc((void**)&cgen_var_4, ((createInfoCount)) * 8);
stream->read((uint64_t*)cgen_var_4, ((createInfoCount)) * 8);
- stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_4, (VkPipeline*)pPipelines, ((createInfoCount)));
+ stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_4, (VkPipeline*)pPipelines,
+ ((createInfoCount)));
}
VkResult vkCreateRayTracingPipelinesNV_VkResult_return = (VkResult)0;
stream->read(&vkCreateRayTracingPipelinesNV_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -30881,17 +43508,39 @@
return vkCreateRayTracingPipelinesNV_VkResult_return;
}
-VkResult VkEncoder::vkGetRayTracingShaderGroupHandlesKHR(
- VkDevice device,
- VkPipeline pipeline,
- uint32_t firstGroup,
- uint32_t groupCount,
- size_t dataSize,
- void* pData,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline,
+ uint32_t firstGroup, uint32_t groupCount,
+ size_t dataSize, void* pData,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetRayTracingShaderGroupHandlesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetRayTracingShaderGroupHandlesKHR(device:%p, pipeline:%p, firstGroup:%d, "
+ "groupCount:%d, dataSize:%ld, pData:%p)",
+ device, pipeline, firstGroup, groupCount, dataSize, pData);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -30917,14 +43566,24 @@
*countPtr += 8;
*countPtr += ((dataSize)) * sizeof(uint8_t);
}
- uint32_t packetSize_vkGetRayTracingShaderGroupHandlesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetRayTracingShaderGroupHandlesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetRayTracingShaderGroupHandlesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetRayTracingShaderGroupHandlesKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetRayTracingShaderGroupHandlesKHR = OP_vkGetRayTracingShaderGroupHandlesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetRayTracingShaderGroupHandlesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetRayTracingShaderGroupHandlesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetRayTracingShaderGroupHandlesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetRayTracingShaderGroupHandlesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -30946,9 +43605,9 @@
stream->read((void*)pData, ((dataSize)) * sizeof(uint8_t));
VkResult vkGetRayTracingShaderGroupHandlesKHR_VkResult_return = (VkResult)0;
stream->read(&vkGetRayTracingShaderGroupHandlesKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -30956,17 +43615,39 @@
return vkGetRayTracingShaderGroupHandlesKHR_VkResult_return;
}
-VkResult VkEncoder::vkGetRayTracingShaderGroupHandlesNV(
- VkDevice device,
- VkPipeline pipeline,
- uint32_t firstGroup,
- uint32_t groupCount,
- size_t dataSize,
- void* pData,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline,
+ uint32_t firstGroup, uint32_t groupCount,
+ size_t dataSize, void* pData,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetRayTracingShaderGroupHandlesNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetRayTracingShaderGroupHandlesNV(device:%p, pipeline:%p, firstGroup:%d, groupCount:%d, "
+ "dataSize:%ld, pData:%p)",
+ device, pipeline, firstGroup, groupCount, dataSize, pData);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -30992,14 +43673,24 @@
*countPtr += 8;
*countPtr += ((dataSize)) * sizeof(uint8_t);
}
- uint32_t packetSize_vkGetRayTracingShaderGroupHandlesNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetRayTracingShaderGroupHandlesNV =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetRayTracingShaderGroupHandlesNV);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetRayTracingShaderGroupHandlesNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetRayTracingShaderGroupHandlesNV = OP_vkGetRayTracingShaderGroupHandlesNV;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetRayTracingShaderGroupHandlesNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetRayTracingShaderGroupHandlesNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetRayTracingShaderGroupHandlesNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetRayTracingShaderGroupHandlesNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -31021,9 +43712,9 @@
stream->read((void*)pData, ((dataSize)) * sizeof(uint8_t));
VkResult vkGetRayTracingShaderGroupHandlesNV_VkResult_return = (VkResult)0;
stream->read(&vkGetRayTracingShaderGroupHandlesNV_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -31032,14 +43723,37 @@
}
VkResult VkEncoder::vkGetAccelerationStructureHandleNV(
- VkDevice device,
- VkAccelerationStructureNV accelerationStructure,
- size_t dataSize,
- void* pData,
- uint32_t doLock)
-{
+ VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetAccelerationStructureHandleNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetAccelerationStructureHandleNV(device:%p, accelerationStructure:%p, dataSize:%ld, "
+ "pData:%p)",
+ device, accelerationStructure, dataSize, pData);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -31059,14 +43773,24 @@
*countPtr += 8;
*countPtr += ((dataSize)) * sizeof(uint8_t);
}
- uint32_t packetSize_vkGetAccelerationStructureHandleNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetAccelerationStructureHandleNV =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetAccelerationStructureHandleNV);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetAccelerationStructureHandleNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetAccelerationStructureHandleNV = OP_vkGetAccelerationStructureHandleNV;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetAccelerationStructureHandleNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetAccelerationStructureHandleNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetAccelerationStructureHandleNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetAccelerationStructureHandleNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -31084,9 +43808,9 @@
stream->read((void*)pData, ((dataSize)) * sizeof(uint8_t));
VkResult vkGetAccelerationStructureHandleNV_VkResult_return = (VkResult)0;
stream->read(&vkGetAccelerationStructureHandleNV_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -31095,16 +43819,39 @@
}
void VkEncoder::vkCmdWriteAccelerationStructuresPropertiesNV(
- VkCommandBuffer commandBuffer,
- uint32_t accelerationStructureCount,
- const VkAccelerationStructureNV* pAccelerationStructures,
- VkQueryType queryType,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t doLock)
-{
+ VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount,
+ const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType,
+ VkQueryPool queryPool, uint32_t firstQuery, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkCmdWriteAccelerationStructuresPropertiesNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer:%p, "
+ "accelerationStructureCount:%d, pAccelerationStructures:%p, queryPool:%p, firstQuery:%d)",
+ commandBuffer, accelerationStructureCount, pAccelerationStructures, queryPool, firstQuery);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -31127,8 +43874,7 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- if (((accelerationStructureCount)))
- {
+ if (((accelerationStructureCount))) {
*countPtr += ((accelerationStructureCount)) * 8;
}
*countPtr += sizeof(VkQueryType);
@@ -31137,14 +43883,19 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdWriteAccelerationStructuresPropertiesNV = 4 + 4 + count;
- if (queueSubmitWithCommandsEnabled) packetSize_vkCmdWriteAccelerationStructuresPropertiesNV -= 8;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdWriteAccelerationStructuresPropertiesNV);
+ if (queueSubmitWithCommandsEnabled)
+ packetSize_vkCmdWriteAccelerationStructuresPropertiesNV -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdWriteAccelerationStructuresPropertiesNV);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkCmdWriteAccelerationStructuresPropertiesNV = OP_vkCmdWriteAccelerationStructuresPropertiesNV;
- memcpy(streamPtr, &opcode_vkCmdWriteAccelerationStructuresPropertiesNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdWriteAccelerationStructuresPropertiesNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ uint32_t opcode_vkCmdWriteAccelerationStructuresPropertiesNV =
+ OP_vkCmdWriteAccelerationStructuresPropertiesNV;
+ memcpy(streamPtr, &opcode_vkCmdWriteAccelerationStructuresPropertiesNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdWriteAccelerationStructuresPropertiesNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -31152,12 +43903,11 @@
}
memcpy(*streamPtrPtr, (uint32_t*)&local_accelerationStructureCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (((accelerationStructureCount)))
- {
+ if (((accelerationStructureCount))) {
uint8_t* cgen_var_0_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((accelerationStructureCount)); ++k)
- {
- uint64_t tmpval = get_host_u64_VkAccelerationStructureNV(local_pAccelerationStructures[k]);
+ for (uint32_t k = 0; k < ((accelerationStructureCount)); ++k) {
+ uint64_t tmpval =
+ get_host_u64_VkAccelerationStructureNV(local_pAccelerationStructures[k]);
memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
*streamPtrPtr += 8 * ((accelerationStructureCount));
@@ -31170,23 +43920,44 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_firstQuery, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkCompileDeferredNV(
- VkDevice device,
- VkPipeline pipeline,
- uint32_t shader,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCompileDeferredNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCompileDeferredNV(device:%p, pipeline:%p, shader:%d)", device, pipeline,
+ shader);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -31205,14 +43976,23 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
}
- uint32_t packetSize_vkCompileDeferredNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCompileDeferredNV =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCompileDeferredNV);
uint8_t* streamPtr = stream->reserve(packetSize_vkCompileDeferredNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCompileDeferredNV = OP_vkCompileDeferredNV;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCompileDeferredNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCompileDeferredNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCompileDeferredNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCompileDeferredNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -31225,9 +44005,9 @@
*streamPtrPtr += sizeof(uint32_t);
VkResult vkCompileDeferredNV_VkResult_return = (VkResult)0;
stream->read(&vkCompileDeferredNV_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -31246,14 +44026,37 @@
#endif
#ifdef VK_EXT_external_memory_host
VkResult VkEncoder::vkGetMemoryHostPointerPropertiesEXT(
- VkDevice device,
- VkExternalMemoryHandleTypeFlagBits handleType,
- const void* pHostPointer,
- VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties,
- uint32_t doLock)
-{
+ VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer,
+ VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetMemoryHostPointerPropertiesEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetMemoryHostPointerPropertiesEXT(device:%p, pHostPointer:%p, "
+ "pMemoryHostPointerProperties:%p)",
+ device, pHostPointer, pMemoryHostPointerProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -31272,47 +44075,62 @@
*countPtr += sizeof(VkExternalMemoryHandleTypeFlagBits);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pHostPointer)
- {
+ if (local_pHostPointer) {
*countPtr += sizeof(uint8_t);
}
- count_VkMemoryHostPointerPropertiesEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties), countPtr);
+ count_VkMemoryHostPointerPropertiesEXT(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties), countPtr);
}
- uint32_t packetSize_vkGetMemoryHostPointerPropertiesEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetMemoryHostPointerPropertiesEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetMemoryHostPointerPropertiesEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetMemoryHostPointerPropertiesEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetMemoryHostPointerPropertiesEXT = OP_vkGetMemoryHostPointerPropertiesEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetMemoryHostPointerPropertiesEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetMemoryHostPointerPropertiesEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetMemoryHostPointerPropertiesEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetMemoryHostPointerPropertiesEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- memcpy(*streamPtrPtr, (VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ memcpy(*streamPtrPtr, (VkExternalMemoryHandleTypeFlagBits*)&local_handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
*streamPtrPtr += sizeof(VkExternalMemoryHandleTypeFlagBits);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pHostPointer;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pHostPointer)
- {
+ if (local_pHostPointer) {
memcpy(*streamPtrPtr, (void*)local_pHostPointer, sizeof(uint8_t));
*streamPtrPtr += sizeof(uint8_t);
}
- reservedmarshal_VkMemoryHostPointerPropertiesEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties), streamPtrPtr);
- unmarshal_VkMemoryHostPointerPropertiesEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties));
- if (pMemoryHostPointerProperties)
- {
- transform_fromhost_VkMemoryHostPointerPropertiesEXT(sResourceTracker, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties));
+ reservedmarshal_VkMemoryHostPointerPropertiesEXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties), streamPtrPtr);
+ unmarshal_VkMemoryHostPointerPropertiesEXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties));
+ if (pMemoryHostPointerProperties) {
+ transform_fromhost_VkMemoryHostPointerPropertiesEXT(
+ sResourceTracker, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties));
}
VkResult vkGetMemoryHostPointerPropertiesEXT_VkResult_return = (VkResult)0;
stream->read(&vkGetMemoryHostPointerPropertiesEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -31322,16 +44140,38 @@
#endif
#ifdef VK_AMD_buffer_marker
-void VkEncoder::vkCmdWriteBufferMarkerAMD(
- VkCommandBuffer commandBuffer,
- VkPipelineStageFlagBits pipelineStage,
- VkBuffer dstBuffer,
- VkDeviceSize dstOffset,
- uint32_t marker,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer,
+ VkDeviceSize dstOffset, uint32_t marker,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdWriteBufferMarkerAMD in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdWriteBufferMarkerAMD(commandBuffer:%p, dstBuffer:%p, dstOffset:%ld, marker:%d)",
+ commandBuffer, dstBuffer, dstOffset, marker);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -31357,20 +44197,23 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdWriteBufferMarkerAMD = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdWriteBufferMarkerAMD);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdWriteBufferMarkerAMD -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdWriteBufferMarkerAMD);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdWriteBufferMarkerAMD = OP_vkCmdWriteBufferMarkerAMD;
- memcpy(streamPtr, &opcode_vkCmdWriteBufferMarkerAMD, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdWriteBufferMarkerAMD, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdWriteBufferMarkerAMD, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdWriteBufferMarkerAMD, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- memcpy(*streamPtrPtr, (VkPipelineStageFlagBits*)&local_pipelineStage, sizeof(VkPipelineStageFlagBits));
+ memcpy(*streamPtrPtr, (VkPipelineStageFlagBits*)&local_pipelineStage,
+ sizeof(VkPipelineStageFlagBits));
*streamPtrPtr += sizeof(VkPipelineStageFlagBits);
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkBuffer((*&local_dstBuffer));
@@ -31380,9 +44223,9 @@
*streamPtrPtr += sizeof(VkDeviceSize);
memcpy(*streamPtrPtr, (uint32_t*)&local_marker, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -31393,14 +44236,40 @@
#ifdef VK_AMD_pipeline_compiler_control
#endif
#ifdef VK_EXT_calibrated_timestamps
-VkResult VkEncoder::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
- VkPhysicalDevice physicalDevice,
- uint32_t* pTimeDomainCount,
- VkTimeDomainEXT* pTimeDomains,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice,
+ uint32_t* pTimeDomainCount,
+ VkTimeDomainEXT* pTimeDomains,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice:%p, pTimeDomainCount:%p, "
+ "pTimeDomains:%p)",
+ physicalDevice, pTimeDomainCount, pTimeDomains);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -31413,28 +44282,36 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pTimeDomainCount)
- {
+ if (pTimeDomainCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pTimeDomains)
- {
- if (pTimeDomainCount)
- {
+ if (pTimeDomains) {
+ if (pTimeDomainCount) {
*countPtr += (*(pTimeDomainCount)) * sizeof(VkTimeDomainEXT);
}
}
}
- uint32_t packetSize_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = OP_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT =
+ OP_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -31444,8 +44321,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pTimeDomainCount)
- {
+ if (pTimeDomainCount) {
memcpy(*streamPtrPtr, (uint32_t*)pTimeDomainCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -31454,18 +44330,16 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pTimeDomains)
- {
- memcpy(*streamPtrPtr, (VkTimeDomainEXT*)pTimeDomains, (*(pTimeDomainCount)) * sizeof(VkTimeDomainEXT));
+ if (pTimeDomains) {
+ memcpy(*streamPtrPtr, (VkTimeDomainEXT*)pTimeDomains,
+ (*(pTimeDomainCount)) * sizeof(VkTimeDomainEXT));
*streamPtrPtr += (*(pTimeDomainCount)) * sizeof(VkTimeDomainEXT);
}
// WARNING PTR CHECK
uint32_t* check_pTimeDomainCount;
check_pTimeDomainCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pTimeDomainCount)
- {
- if (!(check_pTimeDomainCount))
- {
+ if (pTimeDomainCount) {
+ if (!(check_pTimeDomainCount)) {
fprintf(stderr, "fatal: pTimeDomainCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pTimeDomainCount, sizeof(uint32_t));
@@ -31473,19 +44347,18 @@
// WARNING PTR CHECK
VkTimeDomainEXT* check_pTimeDomains;
check_pTimeDomains = (VkTimeDomainEXT*)(uintptr_t)stream->getBe64();
- if (pTimeDomains)
- {
- if (!(check_pTimeDomains))
- {
+ if (pTimeDomains) {
+ if (!(check_pTimeDomains)) {
fprintf(stderr, "fatal: pTimeDomains inconsistent between guest and host\n");
}
- stream->read((VkTimeDomainEXT*)pTimeDomains, (*(pTimeDomainCount)) * sizeof(VkTimeDomainEXT));
+ stream->read((VkTimeDomainEXT*)pTimeDomains,
+ (*(pTimeDomainCount)) * sizeof(VkTimeDomainEXT));
}
VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -31494,15 +44367,37 @@
}
VkResult VkEncoder::vkGetCalibratedTimestampsEXT(
- VkDevice device,
- uint32_t timestampCount,
- const VkCalibratedTimestampInfoEXT* pTimestampInfos,
- uint64_t* pTimestamps,
- uint64_t* pMaxDeviation,
- uint32_t doLock)
-{
+ VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos,
+ uint64_t* pTimestamps, uint64_t* pMaxDeviation, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetCalibratedTimestampsEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetCalibratedTimestampsEXT(device:%p, timestampCount:%d, pTimestampInfos:%p, "
+ "pTimestamps:%p, pMaxDeviation:%p)",
+ device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -31512,19 +44407,19 @@
local_device = device;
local_timestampCount = timestampCount;
local_pTimestampInfos = nullptr;
- if (pTimestampInfos)
- {
- local_pTimestampInfos = (VkCalibratedTimestampInfoEXT*)pool->alloc(((timestampCount)) * sizeof(const VkCalibratedTimestampInfoEXT));
- for (uint32_t i = 0; i < (uint32_t)((timestampCount)); ++i)
- {
- deepcopy_VkCalibratedTimestampInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pTimestampInfos + i, (VkCalibratedTimestampInfoEXT*)(local_pTimestampInfos + i));
+ if (pTimestampInfos) {
+ local_pTimestampInfos = (VkCalibratedTimestampInfoEXT*)pool->alloc(
+ ((timestampCount)) * sizeof(const VkCalibratedTimestampInfoEXT));
+ for (uint32_t i = 0; i < (uint32_t)((timestampCount)); ++i) {
+ deepcopy_VkCalibratedTimestampInfoEXT(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pTimestampInfos + i,
+ (VkCalibratedTimestampInfoEXT*)(local_pTimestampInfos + i));
}
}
- if (local_pTimestampInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((timestampCount)); ++i)
- {
- transform_tohost_VkCalibratedTimestampInfoEXT(sResourceTracker, (VkCalibratedTimestampInfoEXT*)(local_pTimestampInfos + i));
+ if (local_pTimestampInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((timestampCount)); ++i) {
+ transform_tohost_VkCalibratedTimestampInfoEXT(
+ sResourceTracker, (VkCalibratedTimestampInfoEXT*)(local_pTimestampInfos + i));
}
}
size_t count = 0;
@@ -31533,30 +44428,42 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((timestampCount)); ++i)
- {
- count_VkCalibratedTimestampInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCalibratedTimestampInfoEXT*)(local_pTimestampInfos + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((timestampCount)); ++i) {
+ count_VkCalibratedTimestampInfoEXT(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCalibratedTimestampInfoEXT*)(local_pTimestampInfos + i), countPtr);
}
*countPtr += ((timestampCount)) * sizeof(uint64_t);
*countPtr += sizeof(uint64_t);
}
- uint32_t packetSize_vkGetCalibratedTimestampsEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetCalibratedTimestampsEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetCalibratedTimestampsEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetCalibratedTimestampsEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetCalibratedTimestampsEXT = OP_vkGetCalibratedTimestampsEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetCalibratedTimestampsEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetCalibratedTimestampsEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetCalibratedTimestampsEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetCalibratedTimestampsEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_timestampCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((timestampCount)); ++i)
- {
- reservedmarshal_VkCalibratedTimestampInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCalibratedTimestampInfoEXT*)(local_pTimestampInfos + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((timestampCount)); ++i) {
+ reservedmarshal_VkCalibratedTimestampInfoEXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCalibratedTimestampInfoEXT*)(local_pTimestampInfos + i), streamPtrPtr);
}
memcpy(*streamPtrPtr, (uint64_t*)pTimestamps, ((timestampCount)) * sizeof(uint64_t));
*streamPtrPtr += ((timestampCount)) * sizeof(uint64_t);
@@ -31566,9 +44473,9 @@
stream->read((uint64_t*)pMaxDeviation, sizeof(uint64_t));
VkResult vkGetCalibratedTimestampsEXT_VkResult_return = (VkResult)0;
stream->read(&vkGetCalibratedTimestampsEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -31594,14 +44501,35 @@
#ifdef VK_NV_compute_shader_derivatives
#endif
#ifdef VK_NV_mesh_shader
-void VkEncoder::vkCmdDrawMeshTasksNV(
- VkCommandBuffer commandBuffer,
- uint32_t taskCount,
- uint32_t firstTask,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount,
+ uint32_t firstTask, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDrawMeshTasksNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdDrawMeshTasksNV(commandBuffer:%p, taskCount:%d, firstTask:%d)",
+ commandBuffer, taskCount, firstTask);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -31620,14 +44548,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDrawMeshTasksNV = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDrawMeshTasksNV);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawMeshTasksNV -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawMeshTasksNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDrawMeshTasksNV = OP_vkCmdDrawMeshTasksNV;
- memcpy(streamPtr, &opcode_vkCmdDrawMeshTasksNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDrawMeshTasksNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDrawMeshTasksNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDrawMeshTasksNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -31637,25 +44567,47 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_firstTask, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdDrawMeshTasksIndirectNV(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- uint32_t drawCount,
- uint32_t stride,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, uint32_t drawCount,
+ uint32_t stride, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDrawMeshTasksIndirectNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdDrawMeshTasksIndirectNV(commandBuffer:%p, buffer:%p, offset:%ld, drawCount:%d, "
+ "stride:%d)",
+ commandBuffer, buffer, offset, drawCount, stride);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -31681,14 +44633,17 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDrawMeshTasksIndirectNV = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdDrawMeshTasksIndirectNV);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawMeshTasksIndirectNV -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawMeshTasksIndirectNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDrawMeshTasksIndirectNV = OP_vkCmdDrawMeshTasksIndirectNV;
- memcpy(streamPtr, &opcode_vkCmdDrawMeshTasksIndirectNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDrawMeshTasksIndirectNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDrawMeshTasksIndirectNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDrawMeshTasksIndirectNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -31704,27 +44659,49 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_stride, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdDrawMeshTasksIndirectCountNV(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount, uint32_t stride,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDrawMeshTasksIndirectCountNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdDrawMeshTasksIndirectCountNV(commandBuffer:%p, buffer:%p, offset:%ld, "
+ "countBuffer:%p, countBufferOffset:%ld, maxDrawCount:%d, stride:%d)",
+ commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -31757,14 +44734,17 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDrawMeshTasksIndirectCountNV = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdDrawMeshTasksIndirectCountNV);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawMeshTasksIndirectCountNV -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawMeshTasksIndirectCountNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDrawMeshTasksIndirectCountNV = OP_vkCmdDrawMeshTasksIndirectCountNV;
- memcpy(streamPtr, &opcode_vkCmdDrawMeshTasksIndirectCountNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDrawMeshTasksIndirectCountNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDrawMeshTasksIndirectCountNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDrawMeshTasksIndirectCountNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -31786,9 +44766,9 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_stride, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -31801,15 +44781,39 @@
#ifdef VK_NV_shader_image_footprint
#endif
#ifdef VK_NV_scissor_exclusive
-void VkEncoder::vkCmdSetExclusiveScissorNV(
- VkCommandBuffer commandBuffer,
- uint32_t firstExclusiveScissor,
- uint32_t exclusiveScissorCount,
- const VkRect2D* pExclusiveScissors,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer,
+ uint32_t firstExclusiveScissor,
+ uint32_t exclusiveScissorCount,
+ const VkRect2D* pExclusiveScissors, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetExclusiveScissorNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdSetExclusiveScissorNV(commandBuffer:%p, firstExclusiveScissor:%d, "
+ "exclusiveScissorCount:%d, pExclusiveScissors:%p)",
+ commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -31821,18 +44825,16 @@
local_firstExclusiveScissor = firstExclusiveScissor;
local_exclusiveScissorCount = exclusiveScissorCount;
local_pExclusiveScissors = nullptr;
- if (pExclusiveScissors)
- {
- local_pExclusiveScissors = (VkRect2D*)pool->alloc(((exclusiveScissorCount)) * sizeof(const VkRect2D));
- for (uint32_t i = 0; i < (uint32_t)((exclusiveScissorCount)); ++i)
- {
- deepcopy_VkRect2D(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExclusiveScissors + i, (VkRect2D*)(local_pExclusiveScissors + i));
+ if (pExclusiveScissors) {
+ local_pExclusiveScissors =
+ (VkRect2D*)pool->alloc(((exclusiveScissorCount)) * sizeof(const VkRect2D));
+ for (uint32_t i = 0; i < (uint32_t)((exclusiveScissorCount)); ++i) {
+ deepcopy_VkRect2D(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pExclusiveScissors + i,
+ (VkRect2D*)(local_pExclusiveScissors + i));
}
}
- if (local_pExclusiveScissors)
- {
- for (uint32_t i = 0; i < (uint32_t)((exclusiveScissorCount)); ++i)
- {
+ if (local_pExclusiveScissors) {
+ for (uint32_t i = 0; i < (uint32_t)((exclusiveScissorCount)); ++i) {
transform_tohost_VkRect2D(sResourceTracker, (VkRect2D*)(local_pExclusiveScissors + i));
}
}
@@ -31843,20 +44845,22 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((exclusiveScissorCount)); ++i)
- {
- count_VkRect2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(local_pExclusiveScissors + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((exclusiveScissorCount)); ++i) {
+ count_VkRect2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRect2D*)(local_pExclusiveScissors + i), countPtr);
}
}
uint32_t packetSize_vkCmdSetExclusiveScissorNV = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetExclusiveScissorNV);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetExclusiveScissorNV -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetExclusiveScissorNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetExclusiveScissorNV = OP_vkCmdSetExclusiveScissorNV;
- memcpy(streamPtr, &opcode_vkCmdSetExclusiveScissorNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetExclusiveScissorNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetExclusiveScissorNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetExclusiveScissorNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -31866,13 +44870,13 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_exclusiveScissorCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((exclusiveScissorCount)); ++i)
- {
- reservedmarshal_VkRect2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(local_pExclusiveScissors + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((exclusiveScissorCount)); ++i) {
+ reservedmarshal_VkRect2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRect2D*)(local_pExclusiveScissors + i), streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -31881,13 +44885,35 @@
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
-void VkEncoder::vkCmdSetCheckpointNV(
- VkCommandBuffer commandBuffer,
- const void* pCheckpointMarker,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetCheckpointNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetCheckpointNV(commandBuffer:%p, pCheckpointMarker:%p)", commandBuffer,
+ pCheckpointMarker);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -31903,20 +44929,21 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pCheckpointMarker)
- {
+ if (local_pCheckpointMarker) {
*countPtr += sizeof(uint8_t);
}
}
uint32_t packetSize_vkCmdSetCheckpointNV = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetCheckpointNV);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetCheckpointNV -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetCheckpointNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetCheckpointNV = OP_vkCmdSetCheckpointNV;
- memcpy(streamPtr, &opcode_vkCmdSetCheckpointNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetCheckpointNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetCheckpointNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetCheckpointNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -31927,28 +44954,49 @@
memcpy((*streamPtrPtr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pCheckpointMarker)
- {
+ if (local_pCheckpointMarker) {
memcpy(*streamPtrPtr, (void*)local_pCheckpointMarker, sizeof(uint8_t));
*streamPtrPtr += sizeof(uint8_t);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkGetQueueCheckpointDataNV(
- VkQueue queue,
- uint32_t* pCheckpointDataCount,
- VkCheckpointDataNV* pCheckpointData,
- uint32_t doLock)
-{
+void VkEncoder::vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount,
+ VkCheckpointDataNV* pCheckpointData, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetQueueCheckpointDataNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetQueueCheckpointDataNV(queue:%p, pCheckpointDataCount:%p, pCheckpointData:%p)", queue,
+ pCheckpointDataCount, pCheckpointData);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -31961,31 +45009,37 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pCheckpointDataCount)
- {
+ if (pCheckpointDataCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pCheckpointData)
- {
- if (pCheckpointDataCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
- {
- count_VkCheckpointDataNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCheckpointDataNV*)(pCheckpointData + i), countPtr);
+ if (pCheckpointData) {
+ if (pCheckpointDataCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i) {
+ count_VkCheckpointDataNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCheckpointDataNV*)(pCheckpointData + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkGetQueueCheckpointDataNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetQueueCheckpointDataNV =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetQueueCheckpointDataNV);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetQueueCheckpointDataNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetQueueCheckpointDataNV = OP_vkGetQueueCheckpointDataNV;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetQueueCheckpointDataNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetQueueCheckpointDataNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetQueueCheckpointDataNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetQueueCheckpointDataNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -31995,8 +45049,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pCheckpointDataCount)
- {
+ if (pCheckpointDataCount) {
memcpy(*streamPtrPtr, (uint32_t*)pCheckpointDataCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -32005,20 +45058,18 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pCheckpointData)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
- {
- reservedmarshal_VkCheckpointDataNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCheckpointDataNV*)(pCheckpointData + i), streamPtrPtr);
+ if (pCheckpointData) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i) {
+ reservedmarshal_VkCheckpointDataNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCheckpointDataNV*)(pCheckpointData + i),
+ streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pCheckpointDataCount;
check_pCheckpointDataCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pCheckpointDataCount)
- {
- if (!(check_pCheckpointDataCount))
- {
+ if (pCheckpointDataCount) {
+ if (!(check_pCheckpointDataCount)) {
fprintf(stderr, "fatal: pCheckpointDataCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pCheckpointDataCount, sizeof(uint32_t));
@@ -32026,33 +45077,28 @@
// WARNING PTR CHECK
VkCheckpointDataNV* check_pCheckpointData;
check_pCheckpointData = (VkCheckpointDataNV*)(uintptr_t)stream->getBe64();
- if (pCheckpointData)
- {
- if (!(check_pCheckpointData))
- {
+ if (pCheckpointData) {
+ if (!(check_pCheckpointData)) {
fprintf(stderr, "fatal: pCheckpointData inconsistent between guest and host\n");
}
- if (pCheckpointDataCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
- {
- unmarshal_VkCheckpointDataNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCheckpointDataNV*)(pCheckpointData + i));
+ if (pCheckpointDataCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i) {
+ unmarshal_VkCheckpointDataNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCheckpointDataNV*)(pCheckpointData + i));
}
}
}
- if (pCheckpointDataCount)
- {
- if (pCheckpointData)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i)
- {
- transform_fromhost_VkCheckpointDataNV(sResourceTracker, (VkCheckpointDataNV*)(pCheckpointData + i));
+ if (pCheckpointDataCount) {
+ if (pCheckpointData) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCheckpointDataCount)); ++i) {
+ transform_fromhost_VkCheckpointDataNV(sResourceTracker,
+ (VkCheckpointDataNV*)(pCheckpointData + i));
}
}
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -32064,12 +45110,34 @@
#endif
#ifdef VK_INTEL_performance_query
VkResult VkEncoder::vkInitializePerformanceApiINTEL(
- VkDevice device,
- const VkInitializePerformanceApiInfoINTEL* pInitializeInfo,
- uint32_t doLock)
-{
+ VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkInitializePerformanceApiINTEL in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkInitializePerformanceApiINTEL(device:%p, pInitializeInfo:%p)", device,
+ pInitializeInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -32077,40 +45145,56 @@
VkInitializePerformanceApiInfoINTEL* local_pInitializeInfo;
local_device = device;
local_pInitializeInfo = nullptr;
- if (pInitializeInfo)
- {
- local_pInitializeInfo = (VkInitializePerformanceApiInfoINTEL*)pool->alloc(sizeof(const VkInitializePerformanceApiInfoINTEL));
- deepcopy_VkInitializePerformanceApiInfoINTEL(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInitializeInfo, (VkInitializePerformanceApiInfoINTEL*)(local_pInitializeInfo));
+ if (pInitializeInfo) {
+ local_pInitializeInfo = (VkInitializePerformanceApiInfoINTEL*)pool->alloc(
+ sizeof(const VkInitializePerformanceApiInfoINTEL));
+ deepcopy_VkInitializePerformanceApiInfoINTEL(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInitializeInfo,
+ (VkInitializePerformanceApiInfoINTEL*)(local_pInitializeInfo));
}
- if (local_pInitializeInfo)
- {
- transform_tohost_VkInitializePerformanceApiInfoINTEL(sResourceTracker, (VkInitializePerformanceApiInfoINTEL*)(local_pInitializeInfo));
+ if (local_pInitializeInfo) {
+ transform_tohost_VkInitializePerformanceApiInfoINTEL(
+ sResourceTracker, (VkInitializePerformanceApiInfoINTEL*)(local_pInitializeInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkInitializePerformanceApiInfoINTEL(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkInitializePerformanceApiInfoINTEL*)(local_pInitializeInfo), countPtr);
+ count_VkInitializePerformanceApiInfoINTEL(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkInitializePerformanceApiInfoINTEL*)(local_pInitializeInfo), countPtr);
}
- uint32_t packetSize_vkInitializePerformanceApiINTEL = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkInitializePerformanceApiINTEL =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkInitializePerformanceApiINTEL);
uint8_t* streamPtr = stream->reserve(packetSize_vkInitializePerformanceApiINTEL);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkInitializePerformanceApiINTEL = OP_vkInitializePerformanceApiINTEL;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkInitializePerformanceApiINTEL, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkInitializePerformanceApiINTEL, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkInitializePerformanceApiINTEL, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkInitializePerformanceApiINTEL, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkInitializePerformanceApiInfoINTEL(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkInitializePerformanceApiInfoINTEL*)(local_pInitializeInfo), streamPtrPtr);
+ reservedmarshal_VkInitializePerformanceApiInfoINTEL(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkInitializePerformanceApiInfoINTEL*)(local_pInitializeInfo), streamPtrPtr);
VkResult vkInitializePerformanceApiINTEL_VkResult_return = (VkResult)0;
stream->read(&vkInitializePerformanceApiINTEL_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -32118,12 +45202,33 @@
return vkInitializePerformanceApiINTEL_VkResult_return;
}
-void VkEncoder::vkUninitializePerformanceApiINTEL(
- VkDevice device,
- uint32_t doLock)
-{
+void VkEncoder::vkUninitializePerformanceApiINTEL(VkDevice device, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkUninitializePerformanceApiINTEL in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkUninitializePerformanceApiINTEL(device:%p)", device);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -32135,35 +45240,68 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
}
- uint32_t packetSize_vkUninitializePerformanceApiINTEL = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkUninitializePerformanceApiINTEL =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkUninitializePerformanceApiINTEL);
uint8_t* streamPtr = stream->reserve(packetSize_vkUninitializePerformanceApiINTEL);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkUninitializePerformanceApiINTEL = OP_vkUninitializePerformanceApiINTEL;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkUninitializePerformanceApiINTEL, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkUninitializePerformanceApiINTEL, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkUninitializePerformanceApiINTEL, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkUninitializePerformanceApiINTEL, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkCmdSetPerformanceMarkerINTEL(
- VkCommandBuffer commandBuffer,
- const VkPerformanceMarkerInfoINTEL* pMarkerInfo,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer,
+ const VkPerformanceMarkerInfoINTEL* pMarkerInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetPerformanceMarkerINTEL in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetPerformanceMarkerINTEL(commandBuffer:%p, pMarkerInfo:%p)",
+ commandBuffer, pMarkerInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -32171,42 +45309,50 @@
VkPerformanceMarkerInfoINTEL* local_pMarkerInfo;
local_commandBuffer = commandBuffer;
local_pMarkerInfo = nullptr;
- if (pMarkerInfo)
- {
- local_pMarkerInfo = (VkPerformanceMarkerInfoINTEL*)pool->alloc(sizeof(const VkPerformanceMarkerInfoINTEL));
- deepcopy_VkPerformanceMarkerInfoINTEL(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMarkerInfo, (VkPerformanceMarkerInfoINTEL*)(local_pMarkerInfo));
+ if (pMarkerInfo) {
+ local_pMarkerInfo =
+ (VkPerformanceMarkerInfoINTEL*)pool->alloc(sizeof(const VkPerformanceMarkerInfoINTEL));
+ deepcopy_VkPerformanceMarkerInfoINTEL(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMarkerInfo,
+ (VkPerformanceMarkerInfoINTEL*)(local_pMarkerInfo));
}
- if (local_pMarkerInfo)
- {
- transform_tohost_VkPerformanceMarkerInfoINTEL(sResourceTracker, (VkPerformanceMarkerInfoINTEL*)(local_pMarkerInfo));
+ if (local_pMarkerInfo) {
+ transform_tohost_VkPerformanceMarkerInfoINTEL(
+ sResourceTracker, (VkPerformanceMarkerInfoINTEL*)(local_pMarkerInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPerformanceMarkerInfoINTEL(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceMarkerInfoINTEL*)(local_pMarkerInfo), countPtr);
+ count_VkPerformanceMarkerInfoINTEL(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPerformanceMarkerInfoINTEL*)(local_pMarkerInfo),
+ countPtr);
}
uint32_t packetSize_vkCmdSetPerformanceMarkerINTEL = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdSetPerformanceMarkerINTEL);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetPerformanceMarkerINTEL -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetPerformanceMarkerINTEL);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetPerformanceMarkerINTEL = OP_vkCmdSetPerformanceMarkerINTEL;
- memcpy(streamPtr, &opcode_vkCmdSetPerformanceMarkerINTEL, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetPerformanceMarkerINTEL, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetPerformanceMarkerINTEL, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetPerformanceMarkerINTEL, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkPerformanceMarkerInfoINTEL(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceMarkerInfoINTEL*)(local_pMarkerInfo), streamPtrPtr);
+ reservedmarshal_VkPerformanceMarkerInfoINTEL(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPerformanceMarkerInfoINTEL*)(local_pMarkerInfo),
+ streamPtrPtr);
VkResult vkCmdSetPerformanceMarkerINTEL_VkResult_return = (VkResult)0;
stream->read(&vkCmdSetPerformanceMarkerINTEL_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -32215,12 +45361,35 @@
}
VkResult VkEncoder::vkCmdSetPerformanceStreamMarkerINTEL(
- VkCommandBuffer commandBuffer,
- const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo,
- uint32_t doLock)
-{
+ VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetPerformanceStreamMarkerINTEL in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer:%p, pMarkerInfo:%p)",
+ commandBuffer, pMarkerInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -32228,42 +45397,51 @@
VkPerformanceStreamMarkerInfoINTEL* local_pMarkerInfo;
local_commandBuffer = commandBuffer;
local_pMarkerInfo = nullptr;
- if (pMarkerInfo)
- {
- local_pMarkerInfo = (VkPerformanceStreamMarkerInfoINTEL*)pool->alloc(sizeof(const VkPerformanceStreamMarkerInfoINTEL));
- deepcopy_VkPerformanceStreamMarkerInfoINTEL(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMarkerInfo, (VkPerformanceStreamMarkerInfoINTEL*)(local_pMarkerInfo));
+ if (pMarkerInfo) {
+ local_pMarkerInfo = (VkPerformanceStreamMarkerInfoINTEL*)pool->alloc(
+ sizeof(const VkPerformanceStreamMarkerInfoINTEL));
+ deepcopy_VkPerformanceStreamMarkerInfoINTEL(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMarkerInfo,
+ (VkPerformanceStreamMarkerInfoINTEL*)(local_pMarkerInfo));
}
- if (local_pMarkerInfo)
- {
- transform_tohost_VkPerformanceStreamMarkerInfoINTEL(sResourceTracker, (VkPerformanceStreamMarkerInfoINTEL*)(local_pMarkerInfo));
+ if (local_pMarkerInfo) {
+ transform_tohost_VkPerformanceStreamMarkerInfoINTEL(
+ sResourceTracker, (VkPerformanceStreamMarkerInfoINTEL*)(local_pMarkerInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPerformanceStreamMarkerInfoINTEL(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceStreamMarkerInfoINTEL*)(local_pMarkerInfo), countPtr);
+ count_VkPerformanceStreamMarkerInfoINTEL(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPerformanceStreamMarkerInfoINTEL*)(local_pMarkerInfo), countPtr);
}
uint32_t packetSize_vkCmdSetPerformanceStreamMarkerINTEL = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdSetPerformanceStreamMarkerINTEL);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetPerformanceStreamMarkerINTEL -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetPerformanceStreamMarkerINTEL);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetPerformanceStreamMarkerINTEL = OP_vkCmdSetPerformanceStreamMarkerINTEL;
- memcpy(streamPtr, &opcode_vkCmdSetPerformanceStreamMarkerINTEL, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetPerformanceStreamMarkerINTEL, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetPerformanceStreamMarkerINTEL, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetPerformanceStreamMarkerINTEL, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkPerformanceStreamMarkerInfoINTEL(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceStreamMarkerInfoINTEL*)(local_pMarkerInfo), streamPtrPtr);
+ reservedmarshal_VkPerformanceStreamMarkerInfoINTEL(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPerformanceStreamMarkerInfoINTEL*)(local_pMarkerInfo), streamPtrPtr);
VkResult vkCmdSetPerformanceStreamMarkerINTEL_VkResult_return = (VkResult)0;
stream->read(&vkCmdSetPerformanceStreamMarkerINTEL_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -32272,12 +45450,35 @@
}
VkResult VkEncoder::vkCmdSetPerformanceOverrideINTEL(
- VkCommandBuffer commandBuffer,
- const VkPerformanceOverrideInfoINTEL* pOverrideInfo,
- uint32_t doLock)
-{
+ VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetPerformanceOverrideINTEL in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetPerformanceOverrideINTEL(commandBuffer:%p, pOverrideInfo:%p)",
+ commandBuffer, pOverrideInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -32285,42 +45486,51 @@
VkPerformanceOverrideInfoINTEL* local_pOverrideInfo;
local_commandBuffer = commandBuffer;
local_pOverrideInfo = nullptr;
- if (pOverrideInfo)
- {
- local_pOverrideInfo = (VkPerformanceOverrideInfoINTEL*)pool->alloc(sizeof(const VkPerformanceOverrideInfoINTEL));
- deepcopy_VkPerformanceOverrideInfoINTEL(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pOverrideInfo, (VkPerformanceOverrideInfoINTEL*)(local_pOverrideInfo));
+ if (pOverrideInfo) {
+ local_pOverrideInfo = (VkPerformanceOverrideInfoINTEL*)pool->alloc(
+ sizeof(const VkPerformanceOverrideInfoINTEL));
+ deepcopy_VkPerformanceOverrideInfoINTEL(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pOverrideInfo,
+ (VkPerformanceOverrideInfoINTEL*)(local_pOverrideInfo));
}
- if (local_pOverrideInfo)
- {
- transform_tohost_VkPerformanceOverrideInfoINTEL(sResourceTracker, (VkPerformanceOverrideInfoINTEL*)(local_pOverrideInfo));
+ if (local_pOverrideInfo) {
+ transform_tohost_VkPerformanceOverrideInfoINTEL(
+ sResourceTracker, (VkPerformanceOverrideInfoINTEL*)(local_pOverrideInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPerformanceOverrideInfoINTEL(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceOverrideInfoINTEL*)(local_pOverrideInfo), countPtr);
+ count_VkPerformanceOverrideInfoINTEL(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPerformanceOverrideInfoINTEL*)(local_pOverrideInfo),
+ countPtr);
}
uint32_t packetSize_vkCmdSetPerformanceOverrideINTEL = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdSetPerformanceOverrideINTEL);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetPerformanceOverrideINTEL -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetPerformanceOverrideINTEL);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetPerformanceOverrideINTEL = OP_vkCmdSetPerformanceOverrideINTEL;
- memcpy(streamPtr, &opcode_vkCmdSetPerformanceOverrideINTEL, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetPerformanceOverrideINTEL, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetPerformanceOverrideINTEL, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetPerformanceOverrideINTEL, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkPerformanceOverrideInfoINTEL(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceOverrideInfoINTEL*)(local_pOverrideInfo), streamPtrPtr);
+ reservedmarshal_VkPerformanceOverrideInfoINTEL(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceOverrideInfoINTEL*)(local_pOverrideInfo),
+ streamPtrPtr);
VkResult vkCmdSetPerformanceOverrideINTEL_VkResult_return = (VkResult)0;
stream->read(&vkCmdSetPerformanceOverrideINTEL_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -32329,13 +45539,37 @@
}
VkResult VkEncoder::vkAcquirePerformanceConfigurationINTEL(
- VkDevice device,
- const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
- VkPerformanceConfigurationINTEL* pConfiguration,
- uint32_t doLock)
-{
+ VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
+ VkPerformanceConfigurationINTEL* pConfiguration, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkAcquirePerformanceConfigurationINTEL in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkAcquirePerformanceConfigurationINTEL(device:%p, pAcquireInfo:%p, pConfiguration:%p)",
+ device, pAcquireInfo, pConfiguration);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -32343,36 +45577,53 @@
VkPerformanceConfigurationAcquireInfoINTEL* local_pAcquireInfo;
local_device = device;
local_pAcquireInfo = nullptr;
- if (pAcquireInfo)
- {
- local_pAcquireInfo = (VkPerformanceConfigurationAcquireInfoINTEL*)pool->alloc(sizeof(const VkPerformanceConfigurationAcquireInfoINTEL));
- deepcopy_VkPerformanceConfigurationAcquireInfoINTEL(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAcquireInfo, (VkPerformanceConfigurationAcquireInfoINTEL*)(local_pAcquireInfo));
+ if (pAcquireInfo) {
+ local_pAcquireInfo = (VkPerformanceConfigurationAcquireInfoINTEL*)pool->alloc(
+ sizeof(const VkPerformanceConfigurationAcquireInfoINTEL));
+ deepcopy_VkPerformanceConfigurationAcquireInfoINTEL(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAcquireInfo,
+ (VkPerformanceConfigurationAcquireInfoINTEL*)(local_pAcquireInfo));
}
- if (local_pAcquireInfo)
- {
- transform_tohost_VkPerformanceConfigurationAcquireInfoINTEL(sResourceTracker, (VkPerformanceConfigurationAcquireInfoINTEL*)(local_pAcquireInfo));
+ if (local_pAcquireInfo) {
+ transform_tohost_VkPerformanceConfigurationAcquireInfoINTEL(
+ sResourceTracker, (VkPerformanceConfigurationAcquireInfoINTEL*)(local_pAcquireInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPerformanceConfigurationAcquireInfoINTEL(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceConfigurationAcquireInfoINTEL*)(local_pAcquireInfo), countPtr);
+ count_VkPerformanceConfigurationAcquireInfoINTEL(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPerformanceConfigurationAcquireInfoINTEL*)(local_pAcquireInfo), countPtr);
*countPtr += 8;
}
- uint32_t packetSize_vkAcquirePerformanceConfigurationINTEL = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkAcquirePerformanceConfigurationINTEL =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkAcquirePerformanceConfigurationINTEL);
uint8_t* streamPtr = stream->reserve(packetSize_vkAcquirePerformanceConfigurationINTEL);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkAcquirePerformanceConfigurationINTEL = OP_vkAcquirePerformanceConfigurationINTEL;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkAcquirePerformanceConfigurationINTEL, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkAcquirePerformanceConfigurationINTEL, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkAcquirePerformanceConfigurationINTEL =
+ OP_vkAcquirePerformanceConfigurationINTEL;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkAcquirePerformanceConfigurationINTEL, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkAcquirePerformanceConfigurationINTEL, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPerformanceConfigurationAcquireInfoINTEL(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceConfigurationAcquireInfoINTEL*)(local_pAcquireInfo), streamPtrPtr);
+ reservedmarshal_VkPerformanceConfigurationAcquireInfoINTEL(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPerformanceConfigurationAcquireInfoINTEL*)(local_pAcquireInfo), streamPtrPtr);
uint64_t cgen_var_1 = (uint64_t)(*pConfiguration);
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
@@ -32380,9 +45631,9 @@
(*pConfiguration) = (VkPerformanceConfigurationINTEL)stream->getBe64();
VkResult vkAcquirePerformanceConfigurationINTEL_VkResult_return = (VkResult)0;
stream->read(&vkAcquirePerformanceConfigurationINTEL_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -32391,12 +45642,34 @@
}
VkResult VkEncoder::vkReleasePerformanceConfigurationINTEL(
- VkDevice device,
- VkPerformanceConfigurationINTEL configuration,
- uint32_t doLock)
-{
+ VkDevice device, VkPerformanceConfigurationINTEL configuration, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkReleasePerformanceConfigurationINTEL in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkReleasePerformanceConfigurationINTEL(device:%p)", device);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -32411,14 +45684,25 @@
*countPtr += 1 * 8;
*countPtr += 8;
}
- uint32_t packetSize_vkReleasePerformanceConfigurationINTEL = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkReleasePerformanceConfigurationINTEL =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkReleasePerformanceConfigurationINTEL);
uint8_t* streamPtr = stream->reserve(packetSize_vkReleasePerformanceConfigurationINTEL);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkReleasePerformanceConfigurationINTEL = OP_vkReleasePerformanceConfigurationINTEL;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkReleasePerformanceConfigurationINTEL, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkReleasePerformanceConfigurationINTEL, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkReleasePerformanceConfigurationINTEL =
+ OP_vkReleasePerformanceConfigurationINTEL;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkReleasePerformanceConfigurationINTEL, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkReleasePerformanceConfigurationINTEL, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -32429,9 +45713,9 @@
*streamPtrPtr += 8;
VkResult vkReleasePerformanceConfigurationINTEL_VkResult_return = (VkResult)0;
stream->read(&vkReleasePerformanceConfigurationINTEL_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -32440,12 +45724,34 @@
}
VkResult VkEncoder::vkQueueSetPerformanceConfigurationINTEL(
- VkQueue queue,
- VkPerformanceConfigurationINTEL configuration,
- uint32_t doLock)
-{
+ VkQueue queue, VkPerformanceConfigurationINTEL configuration, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkQueueSetPerformanceConfigurationINTEL in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkQueueSetPerformanceConfigurationINTEL(queue:%p)", queue);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -32460,14 +45766,25 @@
*countPtr += 1 * 8;
*countPtr += 8;
}
- uint32_t packetSize_vkQueueSetPerformanceConfigurationINTEL = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkQueueSetPerformanceConfigurationINTEL =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkQueueSetPerformanceConfigurationINTEL);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueSetPerformanceConfigurationINTEL);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkQueueSetPerformanceConfigurationINTEL = OP_vkQueueSetPerformanceConfigurationINTEL;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkQueueSetPerformanceConfigurationINTEL, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkQueueSetPerformanceConfigurationINTEL, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkQueueSetPerformanceConfigurationINTEL =
+ OP_vkQueueSetPerformanceConfigurationINTEL;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkQueueSetPerformanceConfigurationINTEL, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkQueueSetPerformanceConfigurationINTEL, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -32478,9 +45795,9 @@
*streamPtrPtr += 8;
VkResult vkQueueSetPerformanceConfigurationINTEL_VkResult_return = (VkResult)0;
stream->read(&vkQueueSetPerformanceConfigurationINTEL_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -32488,14 +45805,36 @@
return vkQueueSetPerformanceConfigurationINTEL_VkResult_return;
}
-VkResult VkEncoder::vkGetPerformanceParameterINTEL(
- VkDevice device,
- VkPerformanceParameterTypeINTEL parameter,
- VkPerformanceValueINTEL* pValue,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetPerformanceParameterINTEL(VkDevice device,
+ VkPerformanceParameterTypeINTEL parameter,
+ VkPerformanceValueINTEL* pValue,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetPerformanceParameterINTEL in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetPerformanceParameterINTEL(device:%p, pValue:%p)", device, pValue);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -32509,33 +45848,47 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(VkPerformanceParameterTypeINTEL);
- count_VkPerformanceValueINTEL(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceValueINTEL*)(pValue), countPtr);
+ count_VkPerformanceValueINTEL(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPerformanceValueINTEL*)(pValue), countPtr);
}
- uint32_t packetSize_vkGetPerformanceParameterINTEL = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPerformanceParameterINTEL =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPerformanceParameterINTEL);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPerformanceParameterINTEL);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPerformanceParameterINTEL = OP_vkGetPerformanceParameterINTEL;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPerformanceParameterINTEL, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPerformanceParameterINTEL, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPerformanceParameterINTEL, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPerformanceParameterINTEL, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- memcpy(*streamPtrPtr, (VkPerformanceParameterTypeINTEL*)&local_parameter, sizeof(VkPerformanceParameterTypeINTEL));
+ memcpy(*streamPtrPtr, (VkPerformanceParameterTypeINTEL*)&local_parameter,
+ sizeof(VkPerformanceParameterTypeINTEL));
*streamPtrPtr += sizeof(VkPerformanceParameterTypeINTEL);
- reservedmarshal_VkPerformanceValueINTEL(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceValueINTEL*)(pValue), streamPtrPtr);
- unmarshal_VkPerformanceValueINTEL(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPerformanceValueINTEL*)(pValue));
- if (pValue)
- {
- transform_fromhost_VkPerformanceValueINTEL(sResourceTracker, (VkPerformanceValueINTEL*)(pValue));
+ reservedmarshal_VkPerformanceValueINTEL(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPerformanceValueINTEL*)(pValue), streamPtrPtr);
+ unmarshal_VkPerformanceValueINTEL(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPerformanceValueINTEL*)(pValue));
+ if (pValue) {
+ transform_fromhost_VkPerformanceValueINTEL(sResourceTracker,
+ (VkPerformanceValueINTEL*)(pValue));
}
VkResult vkGetPerformanceParameterINTEL_VkResult_return = (VkResult)0;
stream->read(&vkGetPerformanceParameterINTEL_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -32547,14 +45900,35 @@
#ifdef VK_EXT_pci_bus_info
#endif
#ifdef VK_AMD_display_native_hdr
-void VkEncoder::vkSetLocalDimmingAMD(
- VkDevice device,
- VkSwapchainKHR swapChain,
- VkBool32 localDimmingEnable,
- uint32_t doLock)
-{
+void VkEncoder::vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain,
+ VkBool32 localDimmingEnable, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkSetLocalDimmingAMD in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkSetLocalDimmingAMD(device:%p, swapChain:%p, localDimmingEnable:%d)",
+ device, swapChain, localDimmingEnable);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -32573,14 +45947,23 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkBool32);
}
- uint32_t packetSize_vkSetLocalDimmingAMD = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkSetLocalDimmingAMD =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkSetLocalDimmingAMD);
uint8_t* streamPtr = stream->reserve(packetSize_vkSetLocalDimmingAMD);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkSetLocalDimmingAMD = OP_vkSetLocalDimmingAMD;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkSetLocalDimmingAMD, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkSetLocalDimmingAMD, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkSetLocalDimmingAMD, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkSetLocalDimmingAMD, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -32592,9 +45975,9 @@
memcpy(*streamPtrPtr, (VkBool32*)&local_localDimmingEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -32604,14 +45987,36 @@
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
VkResult VkEncoder::vkCreateImagePipeSurfaceFUCHSIA(
- VkInstance instance,
- const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock)
-{
+ VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateImagePipeSurfaceFUCHSIA in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateImagePipeSurfaceFUCHSIA(instance:%p, pCreateInfo:%p, pAllocator:%p, pSurface:%p)",
+ instance, pCreateInfo, pAllocator, pSurface);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -32620,62 +46025,79 @@
VkAllocationCallbacks* local_pAllocator;
local_instance = instance;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkImagePipeSurfaceCreateInfoFUCHSIA*)pool->alloc(sizeof(const VkImagePipeSurfaceCreateInfoFUCHSIA));
- deepcopy_VkImagePipeSurfaceCreateInfoFUCHSIA(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkImagePipeSurfaceCreateInfoFUCHSIA*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkImagePipeSurfaceCreateInfoFUCHSIA*)pool->alloc(
+ sizeof(const VkImagePipeSurfaceCreateInfoFUCHSIA));
+ deepcopy_VkImagePipeSurfaceCreateInfoFUCHSIA(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkImagePipeSurfaceCreateInfoFUCHSIA*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkImagePipeSurfaceCreateInfoFUCHSIA(sResourceTracker, (VkImagePipeSurfaceCreateInfoFUCHSIA*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkImagePipeSurfaceCreateInfoFUCHSIA(
+ sResourceTracker, (VkImagePipeSurfaceCreateInfoFUCHSIA*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImagePipeSurfaceCreateInfoFUCHSIA(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImagePipeSurfaceCreateInfoFUCHSIA*)(local_pCreateInfo), countPtr);
+ count_VkImagePipeSurfaceCreateInfoFUCHSIA(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImagePipeSurfaceCreateInfoFUCHSIA*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateImagePipeSurfaceFUCHSIA = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateImagePipeSurfaceFUCHSIA =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCreateImagePipeSurfaceFUCHSIA);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateImagePipeSurfaceFUCHSIA);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateImagePipeSurfaceFUCHSIA = OP_vkCreateImagePipeSurfaceFUCHSIA;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateImagePipeSurfaceFUCHSIA, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateImagePipeSurfaceFUCHSIA, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateImagePipeSurfaceFUCHSIA, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateImagePipeSurfaceFUCHSIA, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImagePipeSurfaceCreateInfoFUCHSIA(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImagePipeSurfaceCreateInfoFUCHSIA*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkImagePipeSurfaceCreateInfoFUCHSIA(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImagePipeSurfaceCreateInfoFUCHSIA*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -32688,9 +46110,9 @@
stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_3, (VkSurfaceKHR*)pSurface, 1);
VkResult vkCreateImagePipeSurfaceFUCHSIA_VkResult_return = (VkResult)0;
stream->read(&vkCreateImagePipeSurfaceFUCHSIA_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -32700,15 +46122,38 @@
#endif
#ifdef VK_EXT_metal_surface
-VkResult VkEncoder::vkCreateMetalSurfaceEXT(
- VkInstance instance,
- const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateMetalSurfaceEXT(VkInstance instance,
+ const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateMetalSurfaceEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateMetalSurfaceEXT(instance:%p, pCreateInfo:%p, pAllocator:%p, pSurface:%p)",
+ instance, pCreateInfo, pAllocator, pSurface);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -32717,62 +46162,77 @@
VkAllocationCallbacks* local_pAllocator;
local_instance = instance;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkMetalSurfaceCreateInfoEXT*)pool->alloc(sizeof(const VkMetalSurfaceCreateInfoEXT));
- deepcopy_VkMetalSurfaceCreateInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkMetalSurfaceCreateInfoEXT*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkMetalSurfaceCreateInfoEXT*)pool->alloc(sizeof(const VkMetalSurfaceCreateInfoEXT));
+ deepcopy_VkMetalSurfaceCreateInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkMetalSurfaceCreateInfoEXT*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkMetalSurfaceCreateInfoEXT(sResourceTracker, (VkMetalSurfaceCreateInfoEXT*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkMetalSurfaceCreateInfoEXT(
+ sResourceTracker, (VkMetalSurfaceCreateInfoEXT*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkMetalSurfaceCreateInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMetalSurfaceCreateInfoEXT*)(local_pCreateInfo), countPtr);
+ count_VkMetalSurfaceCreateInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMetalSurfaceCreateInfoEXT*)(local_pCreateInfo),
+ countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateMetalSurfaceEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateMetalSurfaceEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateMetalSurfaceEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateMetalSurfaceEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateMetalSurfaceEXT = OP_vkCreateMetalSurfaceEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateMetalSurfaceEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateMetalSurfaceEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateMetalSurfaceEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateMetalSurfaceEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkMetalSurfaceCreateInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMetalSurfaceCreateInfoEXT*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkMetalSurfaceCreateInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMetalSurfaceCreateInfoEXT*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -32785,9 +46245,9 @@
stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_3, (VkSurfaceKHR*)pSurface, 1);
VkResult vkCreateMetalSurfaceEXT_VkResult_return = (VkResult)0;
stream->read(&vkCreateMetalSurfaceEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -32819,13 +46279,35 @@
#ifdef VK_NV_dedicated_allocation_image_aliasing
#endif
#ifdef VK_EXT_buffer_device_address
-VkDeviceAddress VkEncoder::vkGetBufferDeviceAddressEXT(
- VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo,
- uint32_t doLock)
-{
+VkDeviceAddress VkEncoder::vkGetBufferDeviceAddressEXT(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetBufferDeviceAddressEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetBufferDeviceAddressEXT(device:%p, pInfo:%p)", device, pInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -32833,40 +46315,53 @@
VkBufferDeviceAddressInfo* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkBufferDeviceAddressInfo*)pool->alloc(sizeof(const VkBufferDeviceAddressInfo));
- deepcopy_VkBufferDeviceAddressInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkBufferDeviceAddressInfo*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo =
+ (VkBufferDeviceAddressInfo*)pool->alloc(sizeof(const VkBufferDeviceAddressInfo));
+ deepcopy_VkBufferDeviceAddressInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkBufferDeviceAddressInfo*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkBufferDeviceAddressInfo(sResourceTracker, (VkBufferDeviceAddressInfo*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkBufferDeviceAddressInfo(sResourceTracker,
+ (VkBufferDeviceAddressInfo*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferDeviceAddressInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferDeviceAddressInfo*)(local_pInfo), countPtr);
+ count_VkBufferDeviceAddressInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferDeviceAddressInfo*)(local_pInfo), countPtr);
}
- uint32_t packetSize_vkGetBufferDeviceAddressEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetBufferDeviceAddressEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetBufferDeviceAddressEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferDeviceAddressEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetBufferDeviceAddressEXT = OP_vkGetBufferDeviceAddressEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetBufferDeviceAddressEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetBufferDeviceAddressEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetBufferDeviceAddressEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetBufferDeviceAddressEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferDeviceAddressInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferDeviceAddressInfo*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkBufferDeviceAddressInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferDeviceAddressInfo*)(local_pInfo),
+ streamPtrPtr);
VkDeviceAddress vkGetBufferDeviceAddressEXT_VkDeviceAddress_return = (VkDeviceAddress)0;
stream->read(&vkGetBufferDeviceAddressEXT_VkDeviceAddress_return, sizeof(VkDeviceAddress));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -32877,13 +46372,37 @@
#endif
#ifdef VK_EXT_tooling_info
VkResult VkEncoder::vkGetPhysicalDeviceToolPropertiesEXT(
- VkPhysicalDevice physicalDevice,
- uint32_t* pToolCount,
- VkPhysicalDeviceToolPropertiesEXT* pToolProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
+ VkPhysicalDeviceToolPropertiesEXT* pToolProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetPhysicalDeviceToolPropertiesEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice:%p, pToolCount:%p, "
+ "pToolProperties:%p)",
+ physicalDevice, pToolCount, pToolProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -32896,31 +46415,39 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pToolCount)
- {
+ if (pToolCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pToolProperties)
- {
- if (pToolCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i)
- {
- count_VkPhysicalDeviceToolPropertiesEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceToolPropertiesEXT*)(pToolProperties + i), countPtr);
+ if (pToolProperties) {
+ if (pToolCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i) {
+ count_VkPhysicalDeviceToolPropertiesEXT(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceToolPropertiesEXT*)(pToolProperties + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPhysicalDeviceToolPropertiesEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceToolPropertiesEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceToolPropertiesEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceToolPropertiesEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPhysicalDeviceToolPropertiesEXT = OP_vkGetPhysicalDeviceToolPropertiesEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceToolPropertiesEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceToolPropertiesEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceToolPropertiesEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceToolPropertiesEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -32930,8 +46457,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pToolCount)
- {
+ if (pToolCount) {
memcpy(*streamPtrPtr, (uint32_t*)pToolCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -32940,20 +46466,18 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pToolProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i)
- {
- reservedmarshal_VkPhysicalDeviceToolPropertiesEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceToolPropertiesEXT*)(pToolProperties + i), streamPtrPtr);
+ if (pToolProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i) {
+ reservedmarshal_VkPhysicalDeviceToolPropertiesEXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceToolPropertiesEXT*)(pToolProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pToolCount;
check_pToolCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pToolCount)
- {
- if (!(check_pToolCount))
- {
+ if (pToolCount) {
+ if (!(check_pToolCount)) {
fprintf(stderr, "fatal: pToolCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pToolCount, sizeof(uint32_t));
@@ -32961,35 +46485,31 @@
// WARNING PTR CHECK
VkPhysicalDeviceToolPropertiesEXT* check_pToolProperties;
check_pToolProperties = (VkPhysicalDeviceToolPropertiesEXT*)(uintptr_t)stream->getBe64();
- if (pToolProperties)
- {
- if (!(check_pToolProperties))
- {
+ if (pToolProperties) {
+ if (!(check_pToolProperties)) {
fprintf(stderr, "fatal: pToolProperties inconsistent between guest and host\n");
}
- if (pToolCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i)
- {
- unmarshal_VkPhysicalDeviceToolPropertiesEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceToolPropertiesEXT*)(pToolProperties + i));
+ if (pToolCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i) {
+ unmarshal_VkPhysicalDeviceToolPropertiesEXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceToolPropertiesEXT*)(pToolProperties + i));
}
}
}
- if (pToolCount)
- {
- if (pToolProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i)
- {
- transform_fromhost_VkPhysicalDeviceToolPropertiesEXT(sResourceTracker, (VkPhysicalDeviceToolPropertiesEXT*)(pToolProperties + i));
+ if (pToolCount) {
+ if (pToolProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i) {
+ transform_fromhost_VkPhysicalDeviceToolPropertiesEXT(
+ sResourceTracker, (VkPhysicalDeviceToolPropertiesEXT*)(pToolProperties + i));
}
}
}
VkResult vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -33004,13 +46524,38 @@
#endif
#ifdef VK_NV_cooperative_matrix
VkResult VkEncoder::vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
- VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkCooperativeMatrixPropertiesNV* pProperties,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount,
+ VkCooperativeMatrixPropertiesNV* pProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice:%p, pPropertyCount:%p, "
+ "pProperties:%p)",
+ physicalDevice, pPropertyCount, pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -33023,31 +46568,42 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pProperties)
- {
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- count_VkCooperativeMatrixPropertiesNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCooperativeMatrixPropertiesNV*)(pProperties + i), countPtr);
+ if (pProperties) {
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ count_VkCooperativeMatrixPropertiesNV(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCooperativeMatrixPropertiesNV*)(pProperties + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV);
+ uint32_t packetSize_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV);
+ uint8_t* streamPtr =
+ stream->reserve(packetSize_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = OP_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV =
+ OP_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
+ sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -33057,8 +46613,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPropertyCount)
- {
+ if (pPropertyCount) {
memcpy(*streamPtrPtr, (uint32_t*)pPropertyCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -33067,20 +46622,18 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- reservedmarshal_VkCooperativeMatrixPropertiesNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCooperativeMatrixPropertiesNV*)(pProperties + i), streamPtrPtr);
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ reservedmarshal_VkCooperativeMatrixPropertiesNV(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCooperativeMatrixPropertiesNV*)(pProperties + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pPropertyCount;
check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pPropertyCount)
- {
- if (!(check_pPropertyCount))
- {
+ if (pPropertyCount) {
+ if (!(check_pPropertyCount)) {
fprintf(stderr, "fatal: pPropertyCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pPropertyCount, sizeof(uint32_t));
@@ -33088,35 +46641,32 @@
// WARNING PTR CHECK
VkCooperativeMatrixPropertiesNV* check_pProperties;
check_pProperties = (VkCooperativeMatrixPropertiesNV*)(uintptr_t)stream->getBe64();
- if (pProperties)
- {
- if (!(check_pProperties))
- {
+ if (pProperties) {
+ if (!(check_pProperties)) {
fprintf(stderr, "fatal: pProperties inconsistent between guest and host\n");
}
- if (pPropertyCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- unmarshal_VkCooperativeMatrixPropertiesNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCooperativeMatrixPropertiesNV*)(pProperties + i));
+ if (pPropertyCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ unmarshal_VkCooperativeMatrixPropertiesNV(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCooperativeMatrixPropertiesNV*)(pProperties + i));
}
}
}
- if (pPropertyCount)
- {
- if (pProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i)
- {
- transform_fromhost_VkCooperativeMatrixPropertiesNV(sResourceTracker, (VkCooperativeMatrixPropertiesNV*)(pProperties + i));
+ if (pPropertyCount) {
+ if (pProperties) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pPropertyCount)); ++i) {
+ transform_fromhost_VkCooperativeMatrixPropertiesNV(
+ sResourceTracker, (VkCooperativeMatrixPropertiesNV*)(pProperties + i));
}
}
}
VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_VkResult_return = (VkResult)0;
- stream->read(&vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ stream->read(&vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_VkResult_return,
+ sizeof(VkResult));
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -33127,13 +46677,39 @@
#endif
#ifdef VK_NV_coverage_reduction_mode
VkResult VkEncoder::vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
- VkPhysicalDevice physicalDevice,
- uint32_t* pCombinationCount,
- VkFramebufferMixedSamplesCombinationNV* pCombinations,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount,
+ VkFramebufferMixedSamplesCombinationNV* pCombinations, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(
+ *mHealthMonitor,
+ "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice:%p, "
+ "pCombinationCount:%p, pCombinations:%p)",
+ physicalDevice, pCombinationCount, pCombinations);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -33146,31 +46722,43 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pCombinationCount)
- {
+ if (pCombinationCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pCombinations)
- {
- if (pCombinationCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pCombinationCount)); ++i)
- {
- count_VkFramebufferMixedSamplesCombinationNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFramebufferMixedSamplesCombinationNV*)(pCombinations + i), countPtr);
+ if (pCombinations) {
+ if (pCombinationCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCombinationCount)); ++i) {
+ count_VkFramebufferMixedSamplesCombinationNV(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkFramebufferMixedSamplesCombinationNV*)(pCombinations + i), countPtr);
}
}
}
}
- uint32_t packetSize_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV);
+ uint32_t packetSize_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(
+ packetSize_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV);
+ uint8_t* streamPtr = stream->reserve(
+ packetSize_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = OP_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV =
+ OP_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
+ sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
+ sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -33180,8 +46768,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pCombinationCount)
- {
+ if (pCombinationCount) {
memcpy(*streamPtrPtr, (uint32_t*)pCombinationCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -33190,20 +46777,18 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pCombinations)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pCombinationCount)); ++i)
- {
- reservedmarshal_VkFramebufferMixedSamplesCombinationNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFramebufferMixedSamplesCombinationNV*)(pCombinations + i), streamPtrPtr);
+ if (pCombinations) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCombinationCount)); ++i) {
+ reservedmarshal_VkFramebufferMixedSamplesCombinationNV(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkFramebufferMixedSamplesCombinationNV*)(pCombinations + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
uint32_t* check_pCombinationCount;
check_pCombinationCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pCombinationCount)
- {
- if (!(check_pCombinationCount))
- {
+ if (pCombinationCount) {
+ if (!(check_pCombinationCount)) {
fprintf(stderr, "fatal: pCombinationCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pCombinationCount, sizeof(uint32_t));
@@ -33211,35 +46796,33 @@
// WARNING PTR CHECK
VkFramebufferMixedSamplesCombinationNV* check_pCombinations;
check_pCombinations = (VkFramebufferMixedSamplesCombinationNV*)(uintptr_t)stream->getBe64();
- if (pCombinations)
- {
- if (!(check_pCombinations))
- {
+ if (pCombinations) {
+ if (!(check_pCombinations)) {
fprintf(stderr, "fatal: pCombinations inconsistent between guest and host\n");
}
- if (pCombinationCount)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pCombinationCount)); ++i)
- {
- unmarshal_VkFramebufferMixedSamplesCombinationNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkFramebufferMixedSamplesCombinationNV*)(pCombinations + i));
+ if (pCombinationCount) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCombinationCount)); ++i) {
+ unmarshal_VkFramebufferMixedSamplesCombinationNV(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkFramebufferMixedSamplesCombinationNV*)(pCombinations + i));
}
}
}
- if (pCombinationCount)
- {
- if (pCombinations)
- {
- for (uint32_t i = 0; i < (uint32_t)(*(pCombinationCount)); ++i)
- {
- transform_fromhost_VkFramebufferMixedSamplesCombinationNV(sResourceTracker, (VkFramebufferMixedSamplesCombinationNV*)(pCombinations + i));
+ if (pCombinationCount) {
+ if (pCombinations) {
+ for (uint32_t i = 0; i < (uint32_t)(*(pCombinationCount)); ++i) {
+ transform_fromhost_VkFramebufferMixedSamplesCombinationNV(
+ sResourceTracker, (VkFramebufferMixedSamplesCombinationNV*)(pCombinations + i));
}
}
}
- VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_VkResult_return = (VkResult)0;
- stream->read(&vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_VkResult_return =
+ (VkResult)0;
+ stream->read(&vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_VkResult_return,
+ sizeof(VkResult));
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -33256,14 +46839,38 @@
#endif
#ifdef VK_EXT_full_screen_exclusive
VkResult VkEncoder::vkGetPhysicalDeviceSurfacePresentModes2EXT(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
- uint32_t* pPresentModeCount,
- VkPresentModeKHR* pPresentModes,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceSurfacePresentModes2EXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceSurfacePresentModes2EXT(physicalDevice:%p, pSurfaceInfo:%p, "
+ "pPresentModeCount:%p, pPresentModes:%p)",
+ physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -33271,57 +46878,70 @@
VkPhysicalDeviceSurfaceInfo2KHR* local_pSurfaceInfo;
local_physicalDevice = physicalDevice;
local_pSurfaceInfo = nullptr;
- if (pSurfaceInfo)
- {
- local_pSurfaceInfo = (VkPhysicalDeviceSurfaceInfo2KHR*)pool->alloc(sizeof(const VkPhysicalDeviceSurfaceInfo2KHR));
- deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSurfaceInfo, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+ if (pSurfaceInfo) {
+ local_pSurfaceInfo = (VkPhysicalDeviceSurfaceInfo2KHR*)pool->alloc(
+ sizeof(const VkPhysicalDeviceSurfaceInfo2KHR));
+ deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSurfaceInfo,
+ (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
}
- if (local_pSurfaceInfo)
- {
- transform_tohost_VkPhysicalDeviceSurfaceInfo2KHR(sResourceTracker, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+ if (local_pSurfaceInfo) {
+ transform_tohost_VkPhysicalDeviceSurfaceInfo2KHR(
+ sResourceTracker, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceSurfaceInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo), countPtr);
+ count_VkPhysicalDeviceSurfaceInfo2KHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (pPresentModeCount)
- {
+ if (pPresentModeCount) {
*countPtr += sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pPresentModes)
- {
- if (pPresentModeCount)
- {
+ if (pPresentModes) {
+ if (pPresentModeCount) {
*countPtr += (*(pPresentModeCount)) * sizeof(VkPresentModeKHR);
}
}
}
- uint32_t packetSize_vkGetPhysicalDeviceSurfacePresentModes2EXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPhysicalDeviceSurfacePresentModes2EXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceSurfacePresentModes2EXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceSurfacePresentModes2EXT);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceSurfacePresentModes2EXT = OP_vkGetPhysicalDeviceSurfacePresentModes2EXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSurfacePresentModes2EXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSurfacePresentModes2EXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceSurfacePresentModes2EXT =
+ OP_vkGetPhysicalDeviceSurfacePresentModes2EXT;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceSurfacePresentModes2EXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceSurfacePresentModes2EXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceSurfaceInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo), streamPtrPtr);
+ reservedmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)pPresentModeCount;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPresentModeCount)
- {
+ if (pPresentModeCount) {
memcpy(*streamPtrPtr, (uint32_t*)pPresentModeCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
}
@@ -33330,18 +46950,16 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPresentModes)
- {
- memcpy(*streamPtrPtr, (VkPresentModeKHR*)pPresentModes, (*(pPresentModeCount)) * sizeof(VkPresentModeKHR));
+ if (pPresentModes) {
+ memcpy(*streamPtrPtr, (VkPresentModeKHR*)pPresentModes,
+ (*(pPresentModeCount)) * sizeof(VkPresentModeKHR));
*streamPtrPtr += (*(pPresentModeCount)) * sizeof(VkPresentModeKHR);
}
// WARNING PTR CHECK
uint32_t* check_pPresentModeCount;
check_pPresentModeCount = (uint32_t*)(uintptr_t)stream->getBe64();
- if (pPresentModeCount)
- {
- if (!(check_pPresentModeCount))
- {
+ if (pPresentModeCount) {
+ if (!(check_pPresentModeCount)) {
fprintf(stderr, "fatal: pPresentModeCount inconsistent between guest and host\n");
}
stream->read((uint32_t*)pPresentModeCount, sizeof(uint32_t));
@@ -33349,19 +46967,18 @@
// WARNING PTR CHECK
VkPresentModeKHR* check_pPresentModes;
check_pPresentModes = (VkPresentModeKHR*)(uintptr_t)stream->getBe64();
- if (pPresentModes)
- {
- if (!(check_pPresentModes))
- {
+ if (pPresentModes) {
+ if (!(check_pPresentModes)) {
fprintf(stderr, "fatal: pPresentModes inconsistent between guest and host\n");
}
- stream->read((VkPresentModeKHR*)pPresentModes, (*(pPresentModeCount)) * sizeof(VkPresentModeKHR));
+ stream->read((VkPresentModeKHR*)pPresentModes,
+ (*(pPresentModeCount)) * sizeof(VkPresentModeKHR));
}
VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT_VkResult_return = (VkResult)0;
stream->read(&vkGetPhysicalDeviceSurfacePresentModes2EXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -33369,13 +46986,35 @@
return vkGetPhysicalDeviceSurfacePresentModes2EXT_VkResult_return;
}
-VkResult VkEncoder::vkAcquireFullScreenExclusiveModeEXT(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkAcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkAcquireFullScreenExclusiveModeEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkAcquireFullScreenExclusiveModeEXT(device:%p, swapchain:%p)", device,
+ swapchain);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -33391,14 +47030,24 @@
uint64_t cgen_var_1;
*countPtr += 1 * 8;
}
- uint32_t packetSize_vkAcquireFullScreenExclusiveModeEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkAcquireFullScreenExclusiveModeEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkAcquireFullScreenExclusiveModeEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkAcquireFullScreenExclusiveModeEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkAcquireFullScreenExclusiveModeEXT = OP_vkAcquireFullScreenExclusiveModeEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkAcquireFullScreenExclusiveModeEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkAcquireFullScreenExclusiveModeEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkAcquireFullScreenExclusiveModeEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkAcquireFullScreenExclusiveModeEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -33409,9 +47058,9 @@
*streamPtrPtr += 1 * 8;
VkResult vkAcquireFullScreenExclusiveModeEXT_VkResult_return = (VkResult)0;
stream->read(&vkAcquireFullScreenExclusiveModeEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -33419,13 +47068,35 @@
return vkAcquireFullScreenExclusiveModeEXT_VkResult_return;
}
-VkResult VkEncoder::vkReleaseFullScreenExclusiveModeEXT(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkReleaseFullScreenExclusiveModeEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkReleaseFullScreenExclusiveModeEXT(device:%p, swapchain:%p)", device,
+ swapchain);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -33441,14 +47112,24 @@
uint64_t cgen_var_1;
*countPtr += 1 * 8;
}
- uint32_t packetSize_vkReleaseFullScreenExclusiveModeEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkReleaseFullScreenExclusiveModeEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkReleaseFullScreenExclusiveModeEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkReleaseFullScreenExclusiveModeEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkReleaseFullScreenExclusiveModeEXT = OP_vkReleaseFullScreenExclusiveModeEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkReleaseFullScreenExclusiveModeEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkReleaseFullScreenExclusiveModeEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkReleaseFullScreenExclusiveModeEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkReleaseFullScreenExclusiveModeEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -33459,9 +47140,9 @@
*streamPtrPtr += 1 * 8;
VkResult vkReleaseFullScreenExclusiveModeEXT_VkResult_return = (VkResult)0;
stream->read(&vkReleaseFullScreenExclusiveModeEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -33470,13 +47151,37 @@
}
VkResult VkEncoder::vkGetDeviceGroupSurfacePresentModes2EXT(
- VkDevice device,
- const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
- VkDeviceGroupPresentModeFlagsKHR* pModes,
- uint32_t doLock)
-{
+ VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ VkDeviceGroupPresentModeFlagsKHR* pModes, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetDeviceGroupSurfacePresentModes2EXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetDeviceGroupSurfacePresentModes2EXT(device:%p, pSurfaceInfo:%p, pModes:%p)", device,
+ pSurfaceInfo, pModes);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -33484,67 +47189,82 @@
VkPhysicalDeviceSurfaceInfo2KHR* local_pSurfaceInfo;
local_device = device;
local_pSurfaceInfo = nullptr;
- if (pSurfaceInfo)
- {
- local_pSurfaceInfo = (VkPhysicalDeviceSurfaceInfo2KHR*)pool->alloc(sizeof(const VkPhysicalDeviceSurfaceInfo2KHR));
- deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSurfaceInfo, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+ if (pSurfaceInfo) {
+ local_pSurfaceInfo = (VkPhysicalDeviceSurfaceInfo2KHR*)pool->alloc(
+ sizeof(const VkPhysicalDeviceSurfaceInfo2KHR));
+ deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSurfaceInfo,
+ (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
}
- if (local_pSurfaceInfo)
- {
- transform_tohost_VkPhysicalDeviceSurfaceInfo2KHR(sResourceTracker, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
+ if (local_pSurfaceInfo) {
+ transform_tohost_VkPhysicalDeviceSurfaceInfo2KHR(
+ sResourceTracker, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPhysicalDeviceSurfaceInfo2KHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo), countPtr);
+ count_VkPhysicalDeviceSurfaceInfo2KHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (pModes)
- {
+ if (pModes) {
*countPtr += sizeof(VkDeviceGroupPresentModeFlagsKHR);
}
}
- uint32_t packetSize_vkGetDeviceGroupSurfacePresentModes2EXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDeviceGroupSurfacePresentModes2EXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDeviceGroupSurfacePresentModes2EXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceGroupSurfacePresentModes2EXT);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetDeviceGroupSurfacePresentModes2EXT = OP_vkGetDeviceGroupSurfacePresentModes2EXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDeviceGroupSurfacePresentModes2EXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDeviceGroupSurfacePresentModes2EXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetDeviceGroupSurfacePresentModes2EXT =
+ OP_vkGetDeviceGroupSurfacePresentModes2EXT;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDeviceGroupSurfacePresentModes2EXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDeviceGroupSurfacePresentModes2EXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPhysicalDeviceSurfaceInfo2KHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo), streamPtrPtr);
+ reservedmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)pModes;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pModes)
- {
- memcpy(*streamPtrPtr, (VkDeviceGroupPresentModeFlagsKHR*)pModes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+ if (pModes) {
+ memcpy(*streamPtrPtr, (VkDeviceGroupPresentModeFlagsKHR*)pModes,
+ sizeof(VkDeviceGroupPresentModeFlagsKHR));
*streamPtrPtr += sizeof(VkDeviceGroupPresentModeFlagsKHR);
}
// WARNING PTR CHECK
VkDeviceGroupPresentModeFlagsKHR* check_pModes;
check_pModes = (VkDeviceGroupPresentModeFlagsKHR*)(uintptr_t)stream->getBe64();
- if (pModes)
- {
- if (!(check_pModes))
- {
+ if (pModes) {
+ if (!(check_pModes)) {
fprintf(stderr, "fatal: pModes inconsistent between guest and host\n");
}
- stream->read((VkDeviceGroupPresentModeFlagsKHR*)pModes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+ stream->read((VkDeviceGroupPresentModeFlagsKHR*)pModes,
+ sizeof(VkDeviceGroupPresentModeFlagsKHR));
}
VkResult vkGetDeviceGroupSurfacePresentModes2EXT_VkResult_return = (VkResult)0;
stream->read(&vkGetDeviceGroupSurfacePresentModes2EXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -33554,15 +47274,38 @@
#endif
#ifdef VK_EXT_headless_surface
-VkResult VkEncoder::vkCreateHeadlessSurfaceEXT(
- VkInstance instance,
- const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateHeadlessSurfaceEXT(VkInstance instance,
+ const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateHeadlessSurfaceEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateHeadlessSurfaceEXT(instance:%p, pCreateInfo:%p, pAllocator:%p, pSurface:%p)",
+ instance, pCreateInfo, pAllocator, pSurface);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -33571,62 +47314,78 @@
VkAllocationCallbacks* local_pAllocator;
local_instance = instance;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkHeadlessSurfaceCreateInfoEXT*)pool->alloc(sizeof(const VkHeadlessSurfaceCreateInfoEXT));
- deepcopy_VkHeadlessSurfaceCreateInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkHeadlessSurfaceCreateInfoEXT*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkHeadlessSurfaceCreateInfoEXT*)pool->alloc(
+ sizeof(const VkHeadlessSurfaceCreateInfoEXT));
+ deepcopy_VkHeadlessSurfaceCreateInfoEXT(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkHeadlessSurfaceCreateInfoEXT*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkHeadlessSurfaceCreateInfoEXT(sResourceTracker, (VkHeadlessSurfaceCreateInfoEXT*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkHeadlessSurfaceCreateInfoEXT(
+ sResourceTracker, (VkHeadlessSurfaceCreateInfoEXT*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkHeadlessSurfaceCreateInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkHeadlessSurfaceCreateInfoEXT*)(local_pCreateInfo), countPtr);
+ count_VkHeadlessSurfaceCreateInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkHeadlessSurfaceCreateInfoEXT*)(local_pCreateInfo),
+ countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateHeadlessSurfaceEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateHeadlessSurfaceEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateHeadlessSurfaceEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateHeadlessSurfaceEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateHeadlessSurfaceEXT = OP_vkCreateHeadlessSurfaceEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateHeadlessSurfaceEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateHeadlessSurfaceEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateHeadlessSurfaceEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateHeadlessSurfaceEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkHeadlessSurfaceCreateInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkHeadlessSurfaceCreateInfoEXT*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkHeadlessSurfaceCreateInfoEXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkHeadlessSurfaceCreateInfoEXT*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -33639,9 +47398,9 @@
stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_3, (VkSurfaceKHR*)pSurface, 1);
VkResult vkCreateHeadlessSurfaceEXT_VkResult_return = (VkResult)0;
stream->read(&vkCreateHeadlessSurfaceEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -33651,14 +47410,36 @@
#endif
#ifdef VK_EXT_line_rasterization
-void VkEncoder::vkCmdSetLineStippleEXT(
- VkCommandBuffer commandBuffer,
- uint32_t lineStippleFactor,
- uint16_t lineStipplePattern,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+ uint16_t lineStipplePattern, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetLineStippleEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdSetLineStippleEXT(commandBuffer:%p, lineStippleFactor:%d, lineStipplePattern:%d)",
+ commandBuffer, lineStippleFactor, lineStipplePattern);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -33677,14 +47458,16 @@
*countPtr += sizeof(uint16_t);
}
uint32_t packetSize_vkCmdSetLineStippleEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetLineStippleEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetLineStippleEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetLineStippleEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetLineStippleEXT = OP_vkCmdSetLineStippleEXT;
- memcpy(streamPtr, &opcode_vkCmdSetLineStippleEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetLineStippleEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetLineStippleEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetLineStippleEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -33694,9 +47477,9 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint16_t*)&local_lineStipplePattern, sizeof(uint16_t));
*streamPtrPtr += sizeof(uint16_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -33707,15 +47490,35 @@
#ifdef VK_EXT_shader_atomic_float
#endif
#ifdef VK_EXT_host_query_reset
-void VkEncoder::vkResetQueryPoolEXT(
- VkDevice device,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t queryCount,
- uint32_t doLock)
-{
+void VkEncoder::vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
+ uint32_t queryCount, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkResetQueryPoolEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkResetQueryPoolEXT(device:%p, queryPool:%p, firstQuery:%d, queryCount:%d)",
+ device, queryPool, firstQuery, queryCount);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -33737,14 +47540,23 @@
*countPtr += sizeof(uint32_t);
*countPtr += sizeof(uint32_t);
}
- uint32_t packetSize_vkResetQueryPoolEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkResetQueryPoolEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkResetQueryPoolEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkResetQueryPoolEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkResetQueryPoolEXT = OP_vkResetQueryPoolEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkResetQueryPoolEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkResetQueryPoolEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkResetQueryPoolEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkResetQueryPoolEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -33758,9 +47570,9 @@
memcpy(*streamPtrPtr, (uint32_t*)&local_queryCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -33771,13 +47583,35 @@
#ifdef VK_EXT_index_type_uint8
#endif
#ifdef VK_EXT_extended_dynamic_state
-void VkEncoder::vkCmdSetCullModeEXT(
- VkCommandBuffer commandBuffer,
- VkCullModeFlags cullMode,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetCullModeEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetCullModeEXT(commandBuffer:%p, cullMode:%d)", commandBuffer,
+ cullMode);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -33793,14 +47627,16 @@
*countPtr += sizeof(VkCullModeFlags);
}
uint32_t packetSize_vkCmdSetCullModeEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetCullModeEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetCullModeEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetCullModeEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetCullModeEXT = OP_vkCmdSetCullModeEXT;
- memcpy(streamPtr, &opcode_vkCmdSetCullModeEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetCullModeEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetCullModeEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetCullModeEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -33808,22 +47644,43 @@
}
memcpy(*streamPtrPtr, (VkCullModeFlags*)&local_cullMode, sizeof(VkCullModeFlags));
*streamPtrPtr += sizeof(VkCullModeFlags);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetFrontFaceEXT(
- VkCommandBuffer commandBuffer,
- VkFrontFace frontFace,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetFrontFaceEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetFrontFaceEXT(commandBuffer:%p)", commandBuffer);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -33839,14 +47696,16 @@
*countPtr += sizeof(VkFrontFace);
}
uint32_t packetSize_vkCmdSetFrontFaceEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetFrontFaceEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetFrontFaceEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetFrontFaceEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetFrontFaceEXT = OP_vkCmdSetFrontFaceEXT;
- memcpy(streamPtr, &opcode_vkCmdSetFrontFaceEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetFrontFaceEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetFrontFaceEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetFrontFaceEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -33854,22 +47713,44 @@
}
memcpy(*streamPtrPtr, (VkFrontFace*)&local_frontFace, sizeof(VkFrontFace));
*streamPtrPtr += sizeof(VkFrontFace);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetPrimitiveTopologyEXT(
- VkCommandBuffer commandBuffer,
- VkPrimitiveTopology primitiveTopology,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
+ VkPrimitiveTopology primitiveTopology,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetPrimitiveTopologyEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetPrimitiveTopologyEXT(commandBuffer:%p)", commandBuffer);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -33885,38 +47766,64 @@
*countPtr += sizeof(VkPrimitiveTopology);
}
uint32_t packetSize_vkCmdSetPrimitiveTopologyEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdSetPrimitiveTopologyEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetPrimitiveTopologyEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetPrimitiveTopologyEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetPrimitiveTopologyEXT = OP_vkCmdSetPrimitiveTopologyEXT;
- memcpy(streamPtr, &opcode_vkCmdSetPrimitiveTopologyEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetPrimitiveTopologyEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetPrimitiveTopologyEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetPrimitiveTopologyEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- memcpy(*streamPtrPtr, (VkPrimitiveTopology*)&local_primitiveTopology, sizeof(VkPrimitiveTopology));
+ memcpy(*streamPtrPtr, (VkPrimitiveTopology*)&local_primitiveTopology,
+ sizeof(VkPrimitiveTopology));
*streamPtrPtr += sizeof(VkPrimitiveTopology);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetViewportWithCountEXT(
- VkCommandBuffer commandBuffer,
- uint32_t viewportCount,
- const VkViewport* pViewports,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount,
+ const VkViewport* pViewports, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetViewportWithCountEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdSetViewportWithCountEXT(commandBuffer:%p, viewportCount:%d, pViewports:%p)",
+ commandBuffer, viewportCount, pViewports);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -33926,18 +47833,15 @@
local_commandBuffer = commandBuffer;
local_viewportCount = viewportCount;
local_pViewports = nullptr;
- if (pViewports)
- {
+ if (pViewports) {
local_pViewports = (VkViewport*)pool->alloc(((viewportCount)) * sizeof(const VkViewport));
- for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
- {
- deepcopy_VkViewport(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pViewports + i, (VkViewport*)(local_pViewports + i));
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+ deepcopy_VkViewport(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pViewports + i,
+ (VkViewport*)(local_pViewports + i));
}
}
- if (local_pViewports)
- {
- for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
- {
+ if (local_pViewports) {
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
transform_tohost_VkViewport(sResourceTracker, (VkViewport*)(local_pViewports + i));
}
}
@@ -33947,20 +47851,23 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
- {
- count_VkViewport(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkViewport*)(local_pViewports + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+ count_VkViewport(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkViewport*)(local_pViewports + i), countPtr);
}
}
uint32_t packetSize_vkCmdSetViewportWithCountEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdSetViewportWithCountEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetViewportWithCountEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetViewportWithCountEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetViewportWithCountEXT = OP_vkCmdSetViewportWithCountEXT;
- memcpy(streamPtr, &opcode_vkCmdSetViewportWithCountEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetViewportWithCountEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetViewportWithCountEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetViewportWithCountEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -33968,27 +47875,49 @@
}
memcpy(*streamPtrPtr, (uint32_t*)&local_viewportCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i)
- {
- reservedmarshal_VkViewport(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkViewport*)(local_pViewports + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+ reservedmarshal_VkViewport(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkViewport*)(local_pViewports + i), streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetScissorWithCountEXT(
- VkCommandBuffer commandBuffer,
- uint32_t scissorCount,
- const VkRect2D* pScissors,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount,
+ const VkRect2D* pScissors, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetScissorWithCountEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdSetScissorWithCountEXT(commandBuffer:%p, scissorCount:%d, pScissors:%p)",
+ commandBuffer, scissorCount, pScissors);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -33998,18 +47927,15 @@
local_commandBuffer = commandBuffer;
local_scissorCount = scissorCount;
local_pScissors = nullptr;
- if (pScissors)
- {
+ if (pScissors) {
local_pScissors = (VkRect2D*)pool->alloc(((scissorCount)) * sizeof(const VkRect2D));
- for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
- {
- deepcopy_VkRect2D(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pScissors + i, (VkRect2D*)(local_pScissors + i));
+ for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
+ deepcopy_VkRect2D(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pScissors + i,
+ (VkRect2D*)(local_pScissors + i));
}
}
- if (local_pScissors)
- {
- for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
- {
+ if (local_pScissors) {
+ for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
transform_tohost_VkRect2D(sResourceTracker, (VkRect2D*)(local_pScissors + i));
}
}
@@ -34019,20 +47945,22 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
- {
- count_VkRect2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(local_pScissors + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
+ count_VkRect2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRect2D*)(local_pScissors + i), countPtr);
}
}
uint32_t packetSize_vkCmdSetScissorWithCountEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetScissorWithCountEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetScissorWithCountEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetScissorWithCountEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetScissorWithCountEXT = OP_vkCmdSetScissorWithCountEXT;
- memcpy(streamPtr, &opcode_vkCmdSetScissorWithCountEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetScissorWithCountEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetScissorWithCountEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetScissorWithCountEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -34040,31 +47968,52 @@
}
memcpy(*streamPtrPtr, (uint32_t*)&local_scissorCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i)
- {
- reservedmarshal_VkRect2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRect2D*)(local_pScissors + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
+ reservedmarshal_VkRect2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRect2D*)(local_pScissors + i), streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdBindVertexBuffers2EXT(
- VkCommandBuffer commandBuffer,
- uint32_t firstBinding,
- uint32_t bindingCount,
- const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets,
- const VkDeviceSize* pSizes,
- const VkDeviceSize* pStrides,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+ uint32_t bindingCount, const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
+ const VkDeviceSize* pStrides, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBindVertexBuffers2EXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdBindVertexBuffers2EXT(commandBuffer:%p, firstBinding:%d, bindingCount:%d, "
+ "pBuffers:%p, pOffsets:%p, pSizes:%p, pStrides:%p)",
+ commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -34095,36 +48044,34 @@
*countPtr += sizeof(uint32_t);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pBuffers)
- {
- if (((bindingCount)))
- {
+ if (local_pBuffers) {
+ if (((bindingCount))) {
*countPtr += ((bindingCount)) * 8;
}
}
*countPtr += ((bindingCount)) * sizeof(VkDeviceSize);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pSizes)
- {
+ if (local_pSizes) {
*countPtr += ((bindingCount)) * sizeof(VkDeviceSize);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pStrides)
- {
+ if (local_pStrides) {
*countPtr += ((bindingCount)) * sizeof(VkDeviceSize);
}
}
uint32_t packetSize_vkCmdBindVertexBuffers2EXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdBindVertexBuffers2EXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBindVertexBuffers2EXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBindVertexBuffers2EXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBindVertexBuffers2EXT = OP_vkCmdBindVertexBuffers2EXT;
- memcpy(streamPtr, &opcode_vkCmdBindVertexBuffers2EXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBindVertexBuffers2EXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBindVertexBuffers2EXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBindVertexBuffers2EXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -34139,13 +48086,10 @@
memcpy((*streamPtrPtr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pBuffers)
- {
- if (((bindingCount)))
- {
+ if (local_pBuffers) {
+ if (((bindingCount))) {
uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((bindingCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((bindingCount)); ++k) {
uint64_t tmpval = get_host_u64_VkBuffer(local_pBuffers[k]);
memcpy(cgen_var_0_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -34159,8 +48103,7 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pSizes)
- {
+ if (local_pSizes) {
memcpy(*streamPtrPtr, (VkDeviceSize*)local_pSizes, ((bindingCount)) * sizeof(VkDeviceSize));
*streamPtrPtr += ((bindingCount)) * sizeof(VkDeviceSize);
}
@@ -34169,27 +48112,49 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pStrides)
- {
- memcpy(*streamPtrPtr, (VkDeviceSize*)local_pStrides, ((bindingCount)) * sizeof(VkDeviceSize));
+ if (local_pStrides) {
+ memcpy(*streamPtrPtr, (VkDeviceSize*)local_pStrides,
+ ((bindingCount)) * sizeof(VkDeviceSize));
*streamPtrPtr += ((bindingCount)) * sizeof(VkDeviceSize);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetDepthTestEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 depthTestEnable,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetDepthTestEnableEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetDepthTestEnableEXT(commandBuffer:%p, depthTestEnable:%d)",
+ commandBuffer, depthTestEnable);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -34205,14 +48170,16 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetDepthTestEnableEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetDepthTestEnableEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDepthTestEnableEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDepthTestEnableEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetDepthTestEnableEXT = OP_vkCmdSetDepthTestEnableEXT;
- memcpy(streamPtr, &opcode_vkCmdSetDepthTestEnableEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetDepthTestEnableEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetDepthTestEnableEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetDepthTestEnableEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -34220,22 +48187,44 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_depthTestEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetDepthWriteEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 depthWriteEnable,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 depthWriteEnable, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetDepthWriteEnableEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetDepthWriteEnableEXT(commandBuffer:%p, depthWriteEnable:%d)",
+ commandBuffer, depthWriteEnable);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -34251,14 +48240,16 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetDepthWriteEnableEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetDepthWriteEnableEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDepthWriteEnableEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDepthWriteEnableEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetDepthWriteEnableEXT = OP_vkCmdSetDepthWriteEnableEXT;
- memcpy(streamPtr, &opcode_vkCmdSetDepthWriteEnableEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetDepthWriteEnableEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetDepthWriteEnableEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetDepthWriteEnableEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -34266,22 +48257,43 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_depthWriteEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetDepthCompareOpEXT(
- VkCommandBuffer commandBuffer,
- VkCompareOp depthCompareOp,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetDepthCompareOpEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetDepthCompareOpEXT(commandBuffer:%p)", commandBuffer);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -34297,14 +48309,16 @@
*countPtr += sizeof(VkCompareOp);
}
uint32_t packetSize_vkCmdSetDepthCompareOpEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetDepthCompareOpEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDepthCompareOpEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDepthCompareOpEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetDepthCompareOpEXT = OP_vkCmdSetDepthCompareOpEXT;
- memcpy(streamPtr, &opcode_vkCmdSetDepthCompareOpEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetDepthCompareOpEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetDepthCompareOpEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetDepthCompareOpEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -34312,22 +48326,45 @@
}
memcpy(*streamPtrPtr, (VkCompareOp*)&local_depthCompareOp, sizeof(VkCompareOp));
*streamPtrPtr += sizeof(VkCompareOp);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetDepthBoundsTestEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 depthBoundsTestEnable,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 depthBoundsTestEnable, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetDepthBoundsTestEnableEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdSetDepthBoundsTestEnableEXT(commandBuffer:%p, depthBoundsTestEnable:%d)",
+ commandBuffer, depthBoundsTestEnable);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -34343,14 +48380,17 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetDepthBoundsTestEnableEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdSetDepthBoundsTestEnableEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDepthBoundsTestEnableEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDepthBoundsTestEnableEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetDepthBoundsTestEnableEXT = OP_vkCmdSetDepthBoundsTestEnableEXT;
- memcpy(streamPtr, &opcode_vkCmdSetDepthBoundsTestEnableEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetDepthBoundsTestEnableEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetDepthBoundsTestEnableEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetDepthBoundsTestEnableEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -34358,22 +48398,44 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_depthBoundsTestEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetStencilTestEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 stencilTestEnable,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 stencilTestEnable, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetStencilTestEnableEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetStencilTestEnableEXT(commandBuffer:%p, stencilTestEnable:%d)",
+ commandBuffer, stencilTestEnable);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -34389,14 +48451,17 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetStencilTestEnableEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdSetStencilTestEnableEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetStencilTestEnableEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetStencilTestEnableEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetStencilTestEnableEXT = OP_vkCmdSetStencilTestEnableEXT;
- memcpy(streamPtr, &opcode_vkCmdSetStencilTestEnableEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetStencilTestEnableEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetStencilTestEnableEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetStencilTestEnableEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -34404,26 +48469,46 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_stencilTestEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetStencilOpEXT(
- VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask,
- VkStencilOp failOp,
- VkStencilOp passOp,
- VkStencilOp depthFailOp,
- VkCompareOp compareOp,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+ VkStencilOp failOp, VkStencilOp passOp,
+ VkStencilOp depthFailOp, VkCompareOp compareOp,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetStencilOpEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetStencilOpEXT(commandBuffer:%p, faceMask:%d)", commandBuffer,
+ faceMask);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -34451,14 +48536,16 @@
*countPtr += sizeof(VkCompareOp);
}
uint32_t packetSize_vkCmdSetStencilOpEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetStencilOpEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetStencilOpEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetStencilOpEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetStencilOpEXT = OP_vkCmdSetStencilOpEXT;
- memcpy(streamPtr, &opcode_vkCmdSetStencilOpEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetStencilOpEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetStencilOpEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetStencilOpEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -34474,9 +48561,9 @@
*streamPtrPtr += sizeof(VkStencilOp);
memcpy(*streamPtrPtr, (VkCompareOp*)&local_compareOp, sizeof(VkCompareOp));
*streamPtrPtr += sizeof(VkCompareOp);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -34490,13 +48577,37 @@
#endif
#ifdef VK_NV_device_generated_commands
void VkEncoder::vkGetGeneratedCommandsMemoryRequirementsNV(
- VkDevice device,
- const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,
- VkMemoryRequirements2* pMemoryRequirements,
- uint32_t doLock)
-{
+ VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetGeneratedCommandsMemoryRequirementsNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetGeneratedCommandsMemoryRequirementsNV(device:%p, pInfo:%p, pMemoryRequirements:%p)",
+ device, pInfo, pMemoryRequirements);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -34504,45 +48615,66 @@
VkGeneratedCommandsMemoryRequirementsInfoNV* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkGeneratedCommandsMemoryRequirementsInfoNV*)pool->alloc(sizeof(const VkGeneratedCommandsMemoryRequirementsInfoNV));
- deepcopy_VkGeneratedCommandsMemoryRequirementsInfoNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkGeneratedCommandsMemoryRequirementsInfoNV*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkGeneratedCommandsMemoryRequirementsInfoNV*)pool->alloc(
+ sizeof(const VkGeneratedCommandsMemoryRequirementsInfoNV));
+ deepcopy_VkGeneratedCommandsMemoryRequirementsInfoNV(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkGeneratedCommandsMemoryRequirementsInfoNV*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkGeneratedCommandsMemoryRequirementsInfoNV(sResourceTracker, (VkGeneratedCommandsMemoryRequirementsInfoNV*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkGeneratedCommandsMemoryRequirementsInfoNV(
+ sResourceTracker, (VkGeneratedCommandsMemoryRequirementsInfoNV*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkGeneratedCommandsMemoryRequirementsInfoNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkGeneratedCommandsMemoryRequirementsInfoNV*)(local_pInfo), countPtr);
- count_VkMemoryRequirements2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements), countPtr);
+ count_VkGeneratedCommandsMemoryRequirementsInfoNV(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkGeneratedCommandsMemoryRequirementsInfoNV*)(local_pInfo), countPtr);
+ count_VkMemoryRequirements2(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements), countPtr);
}
- uint32_t packetSize_vkGetGeneratedCommandsMemoryRequirementsNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetGeneratedCommandsMemoryRequirementsNV =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetGeneratedCommandsMemoryRequirementsNV);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetGeneratedCommandsMemoryRequirementsNV);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetGeneratedCommandsMemoryRequirementsNV = OP_vkGetGeneratedCommandsMemoryRequirementsNV;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetGeneratedCommandsMemoryRequirementsNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetGeneratedCommandsMemoryRequirementsNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetGeneratedCommandsMemoryRequirementsNV =
+ OP_vkGetGeneratedCommandsMemoryRequirementsNV;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetGeneratedCommandsMemoryRequirementsNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetGeneratedCommandsMemoryRequirementsNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkGeneratedCommandsMemoryRequirementsInfoNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkGeneratedCommandsMemoryRequirementsInfoNV*)(local_pInfo), streamPtrPtr);
- reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements), streamPtrPtr);
- unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements2*)(pMemoryRequirements));
- if (pMemoryRequirements)
- {
- transform_fromhost_VkMemoryRequirements2(sResourceTracker, (VkMemoryRequirements2*)(pMemoryRequirements));
+ reservedmarshal_VkGeneratedCommandsMemoryRequirementsInfoNV(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkGeneratedCommandsMemoryRequirementsInfoNV*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements),
+ streamPtrPtr);
+ unmarshal_VkMemoryRequirements2(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements2*)(pMemoryRequirements));
+ if (pMemoryRequirements) {
+ transform_fromhost_VkMemoryRequirements2(sResourceTracker,
+ (VkMemoryRequirements2*)(pMemoryRequirements));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -34550,12 +48682,36 @@
}
void VkEncoder::vkCmdPreprocessGeneratedCommandsNV(
- VkCommandBuffer commandBuffer,
- const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo,
- uint32_t doLock)
-{
+ VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdPreprocessGeneratedCommandsNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdPreprocessGeneratedCommandsNV(commandBuffer:%p, pGeneratedCommandsInfo:%p)",
+ commandBuffer, pGeneratedCommandsInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -34563,40 +48719,49 @@
VkGeneratedCommandsInfoNV* local_pGeneratedCommandsInfo;
local_commandBuffer = commandBuffer;
local_pGeneratedCommandsInfo = nullptr;
- if (pGeneratedCommandsInfo)
- {
- local_pGeneratedCommandsInfo = (VkGeneratedCommandsInfoNV*)pool->alloc(sizeof(const VkGeneratedCommandsInfoNV));
- deepcopy_VkGeneratedCommandsInfoNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGeneratedCommandsInfo, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo));
+ if (pGeneratedCommandsInfo) {
+ local_pGeneratedCommandsInfo =
+ (VkGeneratedCommandsInfoNV*)pool->alloc(sizeof(const VkGeneratedCommandsInfoNV));
+ deepcopy_VkGeneratedCommandsInfoNV(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGeneratedCommandsInfo,
+ (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo));
}
- if (local_pGeneratedCommandsInfo)
- {
- transform_tohost_VkGeneratedCommandsInfoNV(sResourceTracker, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo));
+ if (local_pGeneratedCommandsInfo) {
+ transform_tohost_VkGeneratedCommandsInfoNV(
+ sResourceTracker, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkGeneratedCommandsInfoNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo), countPtr);
+ count_VkGeneratedCommandsInfoNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo),
+ countPtr);
}
uint32_t packetSize_vkCmdPreprocessGeneratedCommandsNV = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdPreprocessGeneratedCommandsNV);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdPreprocessGeneratedCommandsNV -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdPreprocessGeneratedCommandsNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdPreprocessGeneratedCommandsNV = OP_vkCmdPreprocessGeneratedCommandsNV;
- memcpy(streamPtr, &opcode_vkCmdPreprocessGeneratedCommandsNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdPreprocessGeneratedCommandsNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdPreprocessGeneratedCommandsNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdPreprocessGeneratedCommandsNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkGeneratedCommandsInfoNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkGeneratedCommandsInfoNV(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo), streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -34604,13 +48769,37 @@
}
void VkEncoder::vkCmdExecuteGeneratedCommandsNV(
- VkCommandBuffer commandBuffer,
- VkBool32 isPreprocessed,
- const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo,
- uint32_t doLock)
-{
+ VkCommandBuffer commandBuffer, VkBool32 isPreprocessed,
+ const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdExecuteGeneratedCommandsNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdExecuteGeneratedCommandsNV(commandBuffer:%p, isPreprocessed:%d, "
+ "pGeneratedCommandsInfo:%p)",
+ commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -34620,14 +48809,16 @@
local_commandBuffer = commandBuffer;
local_isPreprocessed = isPreprocessed;
local_pGeneratedCommandsInfo = nullptr;
- if (pGeneratedCommandsInfo)
- {
- local_pGeneratedCommandsInfo = (VkGeneratedCommandsInfoNV*)pool->alloc(sizeof(const VkGeneratedCommandsInfoNV));
- deepcopy_VkGeneratedCommandsInfoNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGeneratedCommandsInfo, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo));
+ if (pGeneratedCommandsInfo) {
+ local_pGeneratedCommandsInfo =
+ (VkGeneratedCommandsInfoNV*)pool->alloc(sizeof(const VkGeneratedCommandsInfoNV));
+ deepcopy_VkGeneratedCommandsInfoNV(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGeneratedCommandsInfo,
+ (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo));
}
- if (local_pGeneratedCommandsInfo)
- {
- transform_tohost_VkGeneratedCommandsInfoNV(sResourceTracker, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo));
+ if (local_pGeneratedCommandsInfo) {
+ transform_tohost_VkGeneratedCommandsInfoNV(
+ sResourceTracker, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -34635,17 +48826,22 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(VkBool32);
- count_VkGeneratedCommandsInfoNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo), countPtr);
+ count_VkGeneratedCommandsInfoNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo),
+ countPtr);
}
uint32_t packetSize_vkCmdExecuteGeneratedCommandsNV = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdExecuteGeneratedCommandsNV);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdExecuteGeneratedCommandsNV -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdExecuteGeneratedCommandsNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdExecuteGeneratedCommandsNV = OP_vkCmdExecuteGeneratedCommandsNV;
- memcpy(streamPtr, &opcode_vkCmdExecuteGeneratedCommandsNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdExecuteGeneratedCommandsNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdExecuteGeneratedCommandsNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdExecuteGeneratedCommandsNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -34653,25 +48849,50 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_isPreprocessed, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- reservedmarshal_VkGeneratedCommandsInfoNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkGeneratedCommandsInfoNV(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkGeneratedCommandsInfoNV*)(local_pGeneratedCommandsInfo), streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdBindPipelineShaderGroupNV(
- VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipeline pipeline,
- uint32_t groupIndex,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipeline pipeline, uint32_t groupIndex,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBindPipelineShaderGroupNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdBindPipelineShaderGroupNV(commandBuffer:%p, pipeline:%p, groupIndex:%d)",
+ commandBuffer, pipeline, groupIndex);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -34694,20 +48915,24 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdBindPipelineShaderGroupNV = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdBindPipelineShaderGroupNV);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBindPipelineShaderGroupNV -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBindPipelineShaderGroupNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBindPipelineShaderGroupNV = OP_vkCmdBindPipelineShaderGroupNV;
- memcpy(streamPtr, &opcode_vkCmdBindPipelineShaderGroupNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBindPipelineShaderGroupNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBindPipelineShaderGroupNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBindPipelineShaderGroupNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- memcpy(*streamPtrPtr, (VkPipelineBindPoint*)&local_pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ memcpy(*streamPtrPtr, (VkPipelineBindPoint*)&local_pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
*streamPtrPtr += sizeof(VkPipelineBindPoint);
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPipeline((*&local_pipeline));
@@ -34715,9 +48940,9 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_groupIndex, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -34725,14 +48950,38 @@
}
VkResult VkEncoder::vkCreateIndirectCommandsLayoutNV(
- VkDevice device,
- const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkIndirectCommandsLayoutNV* pIndirectCommandsLayout,
- uint32_t doLock)
-{
+ VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateIndirectCommandsLayoutNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateIndirectCommandsLayoutNV(device:%p, pCreateInfo:%p, pAllocator:%p, "
+ "pIndirectCommandsLayout:%p)",
+ device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -34741,62 +48990,79 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkIndirectCommandsLayoutCreateInfoNV*)pool->alloc(sizeof(const VkIndirectCommandsLayoutCreateInfoNV));
- deepcopy_VkIndirectCommandsLayoutCreateInfoNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkIndirectCommandsLayoutCreateInfoNV*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkIndirectCommandsLayoutCreateInfoNV*)pool->alloc(
+ sizeof(const VkIndirectCommandsLayoutCreateInfoNV));
+ deepcopy_VkIndirectCommandsLayoutCreateInfoNV(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkIndirectCommandsLayoutCreateInfoNV*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkIndirectCommandsLayoutCreateInfoNV(sResourceTracker, (VkIndirectCommandsLayoutCreateInfoNV*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkIndirectCommandsLayoutCreateInfoNV(
+ sResourceTracker, (VkIndirectCommandsLayoutCreateInfoNV*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkIndirectCommandsLayoutCreateInfoNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkIndirectCommandsLayoutCreateInfoNV*)(local_pCreateInfo), countPtr);
+ count_VkIndirectCommandsLayoutCreateInfoNV(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkIndirectCommandsLayoutCreateInfoNV*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateIndirectCommandsLayoutNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateIndirectCommandsLayoutNV =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCreateIndirectCommandsLayoutNV);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateIndirectCommandsLayoutNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateIndirectCommandsLayoutNV = OP_vkCreateIndirectCommandsLayoutNV;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateIndirectCommandsLayoutNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateIndirectCommandsLayoutNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateIndirectCommandsLayoutNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateIndirectCommandsLayoutNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkIndirectCommandsLayoutCreateInfoNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkIndirectCommandsLayoutCreateInfoNV*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkIndirectCommandsLayoutCreateInfoNV(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkIndirectCommandsLayoutCreateInfoNV*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -34807,13 +49073,14 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNV(&cgen_var_3, (VkIndirectCommandsLayoutNV*)pIndirectCommandsLayout, 1);
+ stream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNV(
+ &cgen_var_3, (VkIndirectCommandsLayoutNV*)pIndirectCommandsLayout, 1);
stream->unsetHandleMapping();
VkResult vkCreateIndirectCommandsLayoutNV_VkResult_return = (VkResult)0;
stream->read(&vkCreateIndirectCommandsLayoutNV_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -34821,14 +49088,38 @@
return vkCreateIndirectCommandsLayoutNV_VkResult_return;
}
-void VkEncoder::vkDestroyIndirectCommandsLayoutNV(
- VkDevice device,
- VkIndirectCommandsLayoutNV indirectCommandsLayout,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyIndirectCommandsLayoutNV(VkDevice device,
+ VkIndirectCommandsLayoutNV indirectCommandsLayout,
+ const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyIndirectCommandsLayoutNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkDestroyIndirectCommandsLayoutNV(device:%p, indirectCommandsLayout:%p, pAllocator:%p)",
+ device, indirectCommandsLayout, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -34838,15 +49129,15 @@
local_device = device;
local_indirectCommandsLayout = indirectCommandsLayout;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -34857,19 +49148,29 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyIndirectCommandsLayoutNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyIndirectCommandsLayoutNV =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkDestroyIndirectCommandsLayoutNV);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyIndirectCommandsLayoutNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyIndirectCommandsLayoutNV = OP_vkDestroyIndirectCommandsLayoutNV;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyIndirectCommandsLayoutNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyIndirectCommandsLayoutNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyIndirectCommandsLayoutNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyIndirectCommandsLayoutNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -34883,15 +49184,17 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
- sResourceTracker->destroyMapping()->mapHandles_VkIndirectCommandsLayoutNV((VkIndirectCommandsLayoutNV*)&indirectCommandsLayout);
+ sResourceTracker->destroyMapping()->mapHandles_VkIndirectCommandsLayoutNV(
+ (VkIndirectCommandsLayoutNV*)&indirectCommandsLayout);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -34908,14 +49211,35 @@
#ifdef VK_EXT_device_memory_report
#endif
#ifdef VK_EXT_acquire_drm_display
-VkResult VkEncoder::vkAcquireDrmDisplayEXT(
- VkPhysicalDevice physicalDevice,
- int32_t drmFd,
- VkDisplayKHR display,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd,
+ VkDisplayKHR display, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkAcquireDrmDisplayEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkAcquireDrmDisplayEXT(physicalDevice:%p, drmFd:%d, display:%p)",
+ physicalDevice, drmFd, display);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -34934,14 +49258,23 @@
uint64_t cgen_var_1;
*countPtr += 1 * 8;
}
- uint32_t packetSize_vkAcquireDrmDisplayEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkAcquireDrmDisplayEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkAcquireDrmDisplayEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkAcquireDrmDisplayEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkAcquireDrmDisplayEXT = OP_vkAcquireDrmDisplayEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkAcquireDrmDisplayEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkAcquireDrmDisplayEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkAcquireDrmDisplayEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkAcquireDrmDisplayEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -34954,9 +49287,9 @@
*streamPtrPtr += 1 * 8;
VkResult vkAcquireDrmDisplayEXT_VkResult_return = (VkResult)0;
stream->read(&vkAcquireDrmDisplayEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -34964,15 +49297,36 @@
return vkAcquireDrmDisplayEXT_VkResult_return;
}
-VkResult VkEncoder::vkGetDrmDisplayEXT(
- VkPhysicalDevice physicalDevice,
- int32_t drmFd,
- uint32_t connectorId,
- VkDisplayKHR* display,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd,
+ uint32_t connectorId, VkDisplayKHR* display,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetDrmDisplayEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetDrmDisplayEXT(physicalDevice:%p, drmFd:%d, connectorId:%d, display:%p)",
+ physicalDevice, drmFd, connectorId, display);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -34992,14 +49346,23 @@
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkGetDrmDisplayEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetDrmDisplayEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetDrmDisplayEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetDrmDisplayEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetDrmDisplayEXT = OP_vkGetDrmDisplayEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDrmDisplayEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDrmDisplayEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDrmDisplayEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDrmDisplayEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -35019,9 +49382,9 @@
stream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_2, (VkDisplayKHR*)display, 1);
VkResult vkGetDrmDisplayEXT_VkResult_return = (VkResult)0;
stream->read(&vkGetDrmDisplayEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -35037,15 +49400,39 @@
#ifdef VK_GOOGLE_user_type
#endif
#ifdef VK_EXT_private_data
-VkResult VkEncoder::vkCreatePrivateDataSlotEXT(
- VkDevice device,
- const VkPrivateDataSlotCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPrivateDataSlotEXT* pPrivateDataSlot,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreatePrivateDataSlotEXT(VkDevice device,
+ const VkPrivateDataSlotCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPrivateDataSlotEXT* pPrivateDataSlot,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreatePrivateDataSlotEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreatePrivateDataSlotEXT(device:%p, pCreateInfo:%p, pAllocator:%p, pPrivateDataSlot:%p)",
+ device, pCreateInfo, pAllocator, pPrivateDataSlot);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -35054,61 +49441,77 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkPrivateDataSlotCreateInfoEXT*)pool->alloc(sizeof(const VkPrivateDataSlotCreateInfoEXT));
- deepcopy_VkPrivateDataSlotCreateInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkPrivateDataSlotCreateInfoEXT*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkPrivateDataSlotCreateInfoEXT*)pool->alloc(
+ sizeof(const VkPrivateDataSlotCreateInfoEXT));
+ deepcopy_VkPrivateDataSlotCreateInfoEXT(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkPrivateDataSlotCreateInfoEXT*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkPrivateDataSlotCreateInfoEXT(sResourceTracker, (VkPrivateDataSlotCreateInfoEXT*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkPrivateDataSlotCreateInfoEXT(
+ sResourceTracker, (VkPrivateDataSlotCreateInfoEXT*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkPrivateDataSlotCreateInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPrivateDataSlotCreateInfoEXT*)(local_pCreateInfo), countPtr);
+ count_VkPrivateDataSlotCreateInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkPrivateDataSlotCreateInfoEXT*)(local_pCreateInfo),
+ countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
*countPtr += 8;
}
- uint32_t packetSize_vkCreatePrivateDataSlotEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreatePrivateDataSlotEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreatePrivateDataSlotEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreatePrivateDataSlotEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreatePrivateDataSlotEXT = OP_vkCreatePrivateDataSlotEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreatePrivateDataSlotEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreatePrivateDataSlotEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreatePrivateDataSlotEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreatePrivateDataSlotEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkPrivateDataSlotCreateInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPrivateDataSlotCreateInfoEXT*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkPrivateDataSlotCreateInfoEXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkPrivateDataSlotCreateInfoEXT*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
uint64_t cgen_var_2 = (uint64_t)(*pPrivateDataSlot);
memcpy((*streamPtrPtr), &cgen_var_2, 8);
@@ -35117,9 +49520,9 @@
(*pPrivateDataSlot) = (VkPrivateDataSlotEXT)stream->getBe64();
VkResult vkCreatePrivateDataSlotEXT_VkResult_return = (VkResult)0;
stream->read(&vkCreatePrivateDataSlotEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -35127,14 +49530,35 @@
return vkCreatePrivateDataSlotEXT_VkResult_return;
}
-void VkEncoder::vkDestroyPrivateDataSlotEXT(
- VkDevice device,
- VkPrivateDataSlotEXT privateDataSlot,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlotEXT privateDataSlot,
+ const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyPrivateDataSlotEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyPrivateDataSlotEXT(device:%p, pAllocator:%p)", device, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -35144,15 +49568,15 @@
local_device = device;
local_privateDataSlot = privateDataSlot;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -35162,19 +49586,28 @@
*countPtr += 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyPrivateDataSlotEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyPrivateDataSlotEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkDestroyPrivateDataSlotEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyPrivateDataSlotEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyPrivateDataSlotEXT = OP_vkDestroyPrivateDataSlotEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyPrivateDataSlotEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyPrivateDataSlotEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyPrivateDataSlotEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyPrivateDataSlotEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -35188,30 +49621,51 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkResult VkEncoder::vkSetPrivateDataEXT(
- VkDevice device,
- VkObjectType objectType,
- uint64_t objectHandle,
- VkPrivateDataSlotEXT privateDataSlot,
- uint64_t data,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType,
+ uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot,
+ uint64_t data, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkSetPrivateDataEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkSetPrivateDataEXT(device:%p, objectHandle:%ld, data:%ld)", device,
+ objectHandle, data);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -35235,14 +49689,23 @@
*countPtr += 8;
*countPtr += sizeof(uint64_t);
}
- uint32_t packetSize_vkSetPrivateDataEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkSetPrivateDataEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkSetPrivateDataEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkSetPrivateDataEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkSetPrivateDataEXT = OP_vkSetPrivateDataEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkSetPrivateDataEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkSetPrivateDataEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkSetPrivateDataEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkSetPrivateDataEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -35259,9 +49722,9 @@
*streamPtrPtr += sizeof(uint64_t);
VkResult vkSetPrivateDataEXT_VkResult_return = (VkResult)0;
stream->read(&vkSetPrivateDataEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -35269,16 +49732,36 @@
return vkSetPrivateDataEXT_VkResult_return;
}
-void VkEncoder::vkGetPrivateDataEXT(
- VkDevice device,
- VkObjectType objectType,
- uint64_t objectHandle,
- VkPrivateDataSlotEXT privateDataSlot,
- uint64_t* pData,
- uint32_t doLock)
-{
+void VkEncoder::vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
+ VkPrivateDataSlotEXT privateDataSlot, uint64_t* pData,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetPrivateDataEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetPrivateDataEXT(device:%p, objectHandle:%ld, pData:%p)", device,
+ objectHandle, pData);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -35300,14 +49783,23 @@
*countPtr += 8;
*countPtr += sizeof(uint64_t);
}
- uint32_t packetSize_vkGetPrivateDataEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetPrivateDataEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetPrivateDataEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetPrivateDataEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetPrivateDataEXT = OP_vkGetPrivateDataEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPrivateDataEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPrivateDataEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPrivateDataEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPrivateDataEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -35323,9 +49815,9 @@
memcpy(*streamPtrPtr, (uint64_t*)pData, sizeof(uint64_t));
*streamPtrPtr += sizeof(uint64_t);
stream->read((uint64_t*)pData, sizeof(uint64_t));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -35341,13 +49833,34 @@
#endif
#ifdef VK_NV_fragment_shading_rate_enums
void VkEncoder::vkCmdSetFragmentShadingRateEnumNV(
- VkCommandBuffer commandBuffer,
- VkFragmentShadingRateNV shadingRate,
- const VkFragmentShadingRateCombinerOpKHR combinerOps[2],
- uint32_t doLock)
-{
+ VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate,
+ const VkFragmentShadingRateCombinerOpKHR combinerOps[2], uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetFragmentShadingRateEnumNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetFragmentShadingRateEnumNV(commandBuffer:%p)", commandBuffer);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -35366,26 +49879,31 @@
*countPtr += 2 * sizeof(VkFragmentShadingRateCombinerOpKHR);
}
uint32_t packetSize_vkCmdSetFragmentShadingRateEnumNV = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdSetFragmentShadingRateEnumNV);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetFragmentShadingRateEnumNV -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetFragmentShadingRateEnumNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetFragmentShadingRateEnumNV = OP_vkCmdSetFragmentShadingRateEnumNV;
- memcpy(streamPtr, &opcode_vkCmdSetFragmentShadingRateEnumNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetFragmentShadingRateEnumNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetFragmentShadingRateEnumNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetFragmentShadingRateEnumNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- memcpy(*streamPtrPtr, (VkFragmentShadingRateNV*)&local_shadingRate, sizeof(VkFragmentShadingRateNV));
+ memcpy(*streamPtrPtr, (VkFragmentShadingRateNV*)&local_shadingRate,
+ sizeof(VkFragmentShadingRateNV));
*streamPtrPtr += sizeof(VkFragmentShadingRateNV);
- memcpy(*streamPtrPtr, (VkFragmentShadingRateCombinerOpKHR*)local_combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
+ memcpy(*streamPtrPtr, (VkFragmentShadingRateCombinerOpKHR*)local_combinerOps,
+ 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
*streamPtrPtr += 2 * sizeof(VkFragmentShadingRateCombinerOpKHR);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -35408,13 +49926,35 @@
#ifdef VK_EXT_rgba10x6_formats
#endif
#ifdef VK_NV_acquire_winrt_display
-VkResult VkEncoder::vkAcquireWinrtDisplayNV(
- VkPhysicalDevice physicalDevice,
- VkDisplayKHR display,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkAcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkAcquireWinrtDisplayNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkAcquireWinrtDisplayNV(physicalDevice:%p, display:%p)", physicalDevice,
+ display);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -35430,14 +49970,23 @@
uint64_t cgen_var_1;
*countPtr += 1 * 8;
}
- uint32_t packetSize_vkAcquireWinrtDisplayNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkAcquireWinrtDisplayNV =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkAcquireWinrtDisplayNV);
uint8_t* streamPtr = stream->reserve(packetSize_vkAcquireWinrtDisplayNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkAcquireWinrtDisplayNV = OP_vkAcquireWinrtDisplayNV;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkAcquireWinrtDisplayNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkAcquireWinrtDisplayNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkAcquireWinrtDisplayNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkAcquireWinrtDisplayNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -35448,9 +49997,9 @@
*streamPtrPtr += 1 * 8;
VkResult vkAcquireWinrtDisplayNV_VkResult_return = (VkResult)0;
stream->read(&vkAcquireWinrtDisplayNV_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -35458,14 +50007,35 @@
return vkAcquireWinrtDisplayNV_VkResult_return;
}
-VkResult VkEncoder::vkGetWinrtDisplayNV(
- VkPhysicalDevice physicalDevice,
- uint32_t deviceRelativeId,
- VkDisplayKHR* pDisplay,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetWinrtDisplayNV(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId,
+ VkDisplayKHR* pDisplay, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetWinrtDisplayNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetWinrtDisplayNV(physicalDevice:%p, deviceRelativeId:%d, pDisplay:%p)",
+ physicalDevice, deviceRelativeId, pDisplay);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -35482,14 +50052,23 @@
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkGetWinrtDisplayNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetWinrtDisplayNV =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetWinrtDisplayNV);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetWinrtDisplayNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetWinrtDisplayNV = OP_vkGetWinrtDisplayNV;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetWinrtDisplayNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetWinrtDisplayNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetWinrtDisplayNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetWinrtDisplayNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -35507,9 +50086,9 @@
stream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_2, (VkDisplayKHR*)pDisplay, 1);
VkResult vkGetWinrtDisplayNV_VkResult_return = (VkResult)0;
stream->read(&vkGetWinrtDisplayNV_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -35519,15 +50098,38 @@
#endif
#ifdef VK_EXT_directfb_surface
-VkResult VkEncoder::vkCreateDirectFBSurfaceEXT(
- VkInstance instance,
- const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateDirectFBSurfaceEXT(VkInstance instance,
+ const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateDirectFBSurfaceEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateDirectFBSurfaceEXT(instance:%p, pCreateInfo:%p, pAllocator:%p, pSurface:%p)",
+ instance, pCreateInfo, pAllocator, pSurface);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -35536,62 +50138,78 @@
VkAllocationCallbacks* local_pAllocator;
local_instance = instance;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkDirectFBSurfaceCreateInfoEXT*)pool->alloc(sizeof(const VkDirectFBSurfaceCreateInfoEXT));
- deepcopy_VkDirectFBSurfaceCreateInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkDirectFBSurfaceCreateInfoEXT*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkDirectFBSurfaceCreateInfoEXT*)pool->alloc(
+ sizeof(const VkDirectFBSurfaceCreateInfoEXT));
+ deepcopy_VkDirectFBSurfaceCreateInfoEXT(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkDirectFBSurfaceCreateInfoEXT*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkDirectFBSurfaceCreateInfoEXT(sResourceTracker, (VkDirectFBSurfaceCreateInfoEXT*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkDirectFBSurfaceCreateInfoEXT(
+ sResourceTracker, (VkDirectFBSurfaceCreateInfoEXT*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkDirectFBSurfaceCreateInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDirectFBSurfaceCreateInfoEXT*)(local_pCreateInfo), countPtr);
+ count_VkDirectFBSurfaceCreateInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDirectFBSurfaceCreateInfoEXT*)(local_pCreateInfo),
+ countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateDirectFBSurfaceEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateDirectFBSurfaceEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateDirectFBSurfaceEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateDirectFBSurfaceEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateDirectFBSurfaceEXT = OP_vkCreateDirectFBSurfaceEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateDirectFBSurfaceEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateDirectFBSurfaceEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateDirectFBSurfaceEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateDirectFBSurfaceEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkDirectFBSurfaceCreateInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDirectFBSurfaceCreateInfoEXT*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkDirectFBSurfaceCreateInfoEXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDirectFBSurfaceCreateInfoEXT*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -35604,9 +50222,9 @@
stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_3, (VkSurfaceKHR*)pSurface, 1);
VkResult vkCreateDirectFBSurfaceEXT_VkResult_return = (VkResult)0;
stream->read(&vkCreateDirectFBSurfaceEXT_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -35615,13 +50233,37 @@
}
VkBool32 VkEncoder::vkGetPhysicalDeviceDirectFBPresentationSupportEXT(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- IDirectFB* dfb,
- uint32_t doLock)
-{
+ VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceDirectFBPresentationSupportEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceDirectFBPresentationSupportEXT(physicalDevice:%p, queueFamilyIndex:%d, "
+ "dfb:%p)",
+ physicalDevice, queueFamilyIndex, dfb);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -35637,14 +50279,27 @@
*countPtr += sizeof(uint32_t);
*countPtr += sizeof(IDirectFB);
}
- uint32_t packetSize_vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceDirectFBPresentationSupportEXT);
+ uint32_t packetSize_vkGetPhysicalDeviceDirectFBPresentationSupportEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceDirectFBPresentationSupportEXT);
+ uint8_t* streamPtr =
+ stream->reserve(packetSize_vkGetPhysicalDeviceDirectFBPresentationSupportEXT);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceDirectFBPresentationSupportEXT = OP_vkGetPhysicalDeviceDirectFBPresentationSupportEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceDirectFBPresentationSupportEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceDirectFBPresentationSupportEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceDirectFBPresentationSupportEXT =
+ OP_vkGetPhysicalDeviceDirectFBPresentationSupportEXT;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceDirectFBPresentationSupportEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceDirectFBPresentationSupportEXT,
+ sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -35655,10 +50310,11 @@
*streamPtrPtr += sizeof(IDirectFB);
stream->read((IDirectFB*)dfb, sizeof(IDirectFB));
VkBool32 vkGetPhysicalDeviceDirectFBPresentationSupportEXT_VkBool32_return = (VkBool32)0;
- stream->read(&vkGetPhysicalDeviceDirectFBPresentationSupportEXT_VkBool32_return, sizeof(VkBool32));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ stream->read(&vkGetPhysicalDeviceDirectFBPresentationSupportEXT_VkBool32_return,
+ sizeof(VkBool32));
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -35671,15 +50327,41 @@
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
void VkEncoder::vkCmdSetVertexInputEXT(
- VkCommandBuffer commandBuffer,
- uint32_t vertexBindingDescriptionCount,
+ VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount,
const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions,
uint32_t vertexAttributeDescriptionCount,
- const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions,
- uint32_t doLock)
-{
+ const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetVertexInputEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdSetVertexInputEXT(commandBuffer:%p, vertexBindingDescriptionCount:%d, "
+ "pVertexBindingDescriptions:%p, vertexAttributeDescriptionCount:%d, "
+ "pVertexAttributeDescriptions:%p)",
+ commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions,
+ vertexAttributeDescriptionCount, pVertexAttributeDescriptions);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -35691,36 +50373,39 @@
local_commandBuffer = commandBuffer;
local_vertexBindingDescriptionCount = vertexBindingDescriptionCount;
local_pVertexBindingDescriptions = nullptr;
- if (pVertexBindingDescriptions)
- {
- local_pVertexBindingDescriptions = (VkVertexInputBindingDescription2EXT*)pool->alloc(((vertexBindingDescriptionCount)) * sizeof(const VkVertexInputBindingDescription2EXT));
- for (uint32_t i = 0; i < (uint32_t)((vertexBindingDescriptionCount)); ++i)
- {
- deepcopy_VkVertexInputBindingDescription2EXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pVertexBindingDescriptions + i, (VkVertexInputBindingDescription2EXT*)(local_pVertexBindingDescriptions + i));
+ if (pVertexBindingDescriptions) {
+ local_pVertexBindingDescriptions = (VkVertexInputBindingDescription2EXT*)pool->alloc(
+ ((vertexBindingDescriptionCount)) * sizeof(const VkVertexInputBindingDescription2EXT));
+ for (uint32_t i = 0; i < (uint32_t)((vertexBindingDescriptionCount)); ++i) {
+ deepcopy_VkVertexInputBindingDescription2EXT(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pVertexBindingDescriptions + i,
+ (VkVertexInputBindingDescription2EXT*)(local_pVertexBindingDescriptions + i));
}
}
local_vertexAttributeDescriptionCount = vertexAttributeDescriptionCount;
local_pVertexAttributeDescriptions = nullptr;
- if (pVertexAttributeDescriptions)
- {
- local_pVertexAttributeDescriptions = (VkVertexInputAttributeDescription2EXT*)pool->alloc(((vertexAttributeDescriptionCount)) * sizeof(const VkVertexInputAttributeDescription2EXT));
- for (uint32_t i = 0; i < (uint32_t)((vertexAttributeDescriptionCount)); ++i)
- {
- deepcopy_VkVertexInputAttributeDescription2EXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pVertexAttributeDescriptions + i, (VkVertexInputAttributeDescription2EXT*)(local_pVertexAttributeDescriptions + i));
+ if (pVertexAttributeDescriptions) {
+ local_pVertexAttributeDescriptions = (VkVertexInputAttributeDescription2EXT*)pool->alloc(
+ ((vertexAttributeDescriptionCount)) *
+ sizeof(const VkVertexInputAttributeDescription2EXT));
+ for (uint32_t i = 0; i < (uint32_t)((vertexAttributeDescriptionCount)); ++i) {
+ deepcopy_VkVertexInputAttributeDescription2EXT(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pVertexAttributeDescriptions + i,
+ (VkVertexInputAttributeDescription2EXT*)(local_pVertexAttributeDescriptions + i));
}
}
- if (local_pVertexBindingDescriptions)
- {
- for (uint32_t i = 0; i < (uint32_t)((vertexBindingDescriptionCount)); ++i)
- {
- transform_tohost_VkVertexInputBindingDescription2EXT(sResourceTracker, (VkVertexInputBindingDescription2EXT*)(local_pVertexBindingDescriptions + i));
+ if (local_pVertexBindingDescriptions) {
+ for (uint32_t i = 0; i < (uint32_t)((vertexBindingDescriptionCount)); ++i) {
+ transform_tohost_VkVertexInputBindingDescription2EXT(
+ sResourceTracker,
+ (VkVertexInputBindingDescription2EXT*)(local_pVertexBindingDescriptions + i));
}
}
- if (local_pVertexAttributeDescriptions)
- {
- for (uint32_t i = 0; i < (uint32_t)((vertexAttributeDescriptionCount)); ++i)
- {
- transform_tohost_VkVertexInputAttributeDescription2EXT(sResourceTracker, (VkVertexInputAttributeDescription2EXT*)(local_pVertexAttributeDescriptions + i));
+ if (local_pVertexAttributeDescriptions) {
+ for (uint32_t i = 0; i < (uint32_t)((vertexAttributeDescriptionCount)); ++i) {
+ transform_tohost_VkVertexInputAttributeDescription2EXT(
+ sResourceTracker,
+ (VkVertexInputAttributeDescription2EXT*)(local_pVertexAttributeDescriptions + i));
}
}
size_t count = 0;
@@ -35729,25 +50414,31 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((vertexBindingDescriptionCount)); ++i)
- {
- count_VkVertexInputBindingDescription2EXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVertexInputBindingDescription2EXT*)(local_pVertexBindingDescriptions + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((vertexBindingDescriptionCount)); ++i) {
+ count_VkVertexInputBindingDescription2EXT(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVertexInputBindingDescription2EXT*)(local_pVertexBindingDescriptions + i),
+ countPtr);
}
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((vertexAttributeDescriptionCount)); ++i)
- {
- count_VkVertexInputAttributeDescription2EXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVertexInputAttributeDescription2EXT*)(local_pVertexAttributeDescriptions + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((vertexAttributeDescriptionCount)); ++i) {
+ count_VkVertexInputAttributeDescription2EXT(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVertexInputAttributeDescription2EXT*)(local_pVertexAttributeDescriptions + i),
+ countPtr);
}
}
uint32_t packetSize_vkCmdSetVertexInputEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetVertexInputEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetVertexInputEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetVertexInputEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetVertexInputEXT = OP_vkCmdSetVertexInputEXT;
- memcpy(streamPtr, &opcode_vkCmdSetVertexInputEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetVertexInputEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetVertexInputEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetVertexInputEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -35755,19 +50446,23 @@
}
memcpy(*streamPtrPtr, (uint32_t*)&local_vertexBindingDescriptionCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((vertexBindingDescriptionCount)); ++i)
- {
- reservedmarshal_VkVertexInputBindingDescription2EXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVertexInputBindingDescription2EXT*)(local_pVertexBindingDescriptions + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((vertexBindingDescriptionCount)); ++i) {
+ reservedmarshal_VkVertexInputBindingDescription2EXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVertexInputBindingDescription2EXT*)(local_pVertexBindingDescriptions + i),
+ streamPtrPtr);
}
memcpy(*streamPtrPtr, (uint32_t*)&local_vertexAttributeDescriptionCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((vertexAttributeDescriptionCount)); ++i)
- {
- reservedmarshal_VkVertexInputAttributeDescription2EXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkVertexInputAttributeDescription2EXT*)(local_pVertexAttributeDescriptions + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((vertexAttributeDescriptionCount)); ++i) {
+ reservedmarshal_VkVertexInputAttributeDescription2EXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkVertexInputAttributeDescription2EXT*)(local_pVertexAttributeDescriptions + i),
+ streamPtrPtr);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -35781,13 +50476,36 @@
#endif
#ifdef VK_FUCHSIA_external_memory
VkResult VkEncoder::vkGetMemoryZirconHandleFUCHSIA(
- VkDevice device,
- const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
- zx_handle_t* pZirconHandle,
- uint32_t doLock)
-{
+ VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetMemoryZirconHandleFUCHSIA in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetMemoryZirconHandleFUCHSIA(device:%p, pGetZirconHandleInfo:%p, pZirconHandle:%p)",
+ device, pGetZirconHandleInfo, pZirconHandle);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -35795,44 +50513,60 @@
VkMemoryGetZirconHandleInfoFUCHSIA* local_pGetZirconHandleInfo;
local_device = device;
local_pGetZirconHandleInfo = nullptr;
- if (pGetZirconHandleInfo)
- {
- local_pGetZirconHandleInfo = (VkMemoryGetZirconHandleInfoFUCHSIA*)pool->alloc(sizeof(const VkMemoryGetZirconHandleInfoFUCHSIA));
- deepcopy_VkMemoryGetZirconHandleInfoFUCHSIA(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetZirconHandleInfo, (VkMemoryGetZirconHandleInfoFUCHSIA*)(local_pGetZirconHandleInfo));
+ if (pGetZirconHandleInfo) {
+ local_pGetZirconHandleInfo = (VkMemoryGetZirconHandleInfoFUCHSIA*)pool->alloc(
+ sizeof(const VkMemoryGetZirconHandleInfoFUCHSIA));
+ deepcopy_VkMemoryGetZirconHandleInfoFUCHSIA(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetZirconHandleInfo,
+ (VkMemoryGetZirconHandleInfoFUCHSIA*)(local_pGetZirconHandleInfo));
}
- if (local_pGetZirconHandleInfo)
- {
- transform_tohost_VkMemoryGetZirconHandleInfoFUCHSIA(sResourceTracker, (VkMemoryGetZirconHandleInfoFUCHSIA*)(local_pGetZirconHandleInfo));
+ if (local_pGetZirconHandleInfo) {
+ transform_tohost_VkMemoryGetZirconHandleInfoFUCHSIA(
+ sResourceTracker, (VkMemoryGetZirconHandleInfoFUCHSIA*)(local_pGetZirconHandleInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkMemoryGetZirconHandleInfoFUCHSIA(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryGetZirconHandleInfoFUCHSIA*)(local_pGetZirconHandleInfo), countPtr);
+ count_VkMemoryGetZirconHandleInfoFUCHSIA(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryGetZirconHandleInfoFUCHSIA*)(local_pGetZirconHandleInfo), countPtr);
*countPtr += sizeof(zx_handle_t);
}
- uint32_t packetSize_vkGetMemoryZirconHandleFUCHSIA = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetMemoryZirconHandleFUCHSIA =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetMemoryZirconHandleFUCHSIA);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetMemoryZirconHandleFUCHSIA);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetMemoryZirconHandleFUCHSIA = OP_vkGetMemoryZirconHandleFUCHSIA;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetMemoryZirconHandleFUCHSIA, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetMemoryZirconHandleFUCHSIA, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetMemoryZirconHandleFUCHSIA, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetMemoryZirconHandleFUCHSIA, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkMemoryGetZirconHandleInfoFUCHSIA(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryGetZirconHandleInfoFUCHSIA*)(local_pGetZirconHandleInfo), streamPtrPtr);
+ reservedmarshal_VkMemoryGetZirconHandleInfoFUCHSIA(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryGetZirconHandleInfoFUCHSIA*)(local_pGetZirconHandleInfo), streamPtrPtr);
memcpy(*streamPtrPtr, (zx_handle_t*)pZirconHandle, sizeof(zx_handle_t));
*streamPtrPtr += sizeof(zx_handle_t);
stream->read((zx_handle_t*)pZirconHandle, sizeof(zx_handle_t));
VkResult vkGetMemoryZirconHandleFUCHSIA_VkResult_return = (VkResult)0;
stream->read(&vkGetMemoryZirconHandleFUCHSIA_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -35841,14 +50575,37 @@
}
VkResult VkEncoder::vkGetMemoryZirconHandlePropertiesFUCHSIA(
- VkDevice device,
- VkExternalMemoryHandleTypeFlagBits handleType,
- zx_handle_t zirconHandle,
- VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties,
- uint32_t doLock)
-{
+ VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle,
+ VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetMemoryZirconHandlePropertiesFUCHSIA in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetMemoryZirconHandlePropertiesFUCHSIA(device:%p, pMemoryZirconHandleProperties:%p)",
+ device, pMemoryZirconHandleProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -35865,35 +50622,54 @@
*countPtr += 1 * 8;
*countPtr += sizeof(VkExternalMemoryHandleTypeFlagBits);
*countPtr += sizeof(zx_handle_t);
- count_VkMemoryZirconHandlePropertiesFUCHSIA(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryZirconHandlePropertiesFUCHSIA*)(pMemoryZirconHandleProperties), countPtr);
+ count_VkMemoryZirconHandlePropertiesFUCHSIA(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryZirconHandlePropertiesFUCHSIA*)(pMemoryZirconHandleProperties), countPtr);
}
- uint32_t packetSize_vkGetMemoryZirconHandlePropertiesFUCHSIA = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetMemoryZirconHandlePropertiesFUCHSIA =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetMemoryZirconHandlePropertiesFUCHSIA);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetMemoryZirconHandlePropertiesFUCHSIA);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetMemoryZirconHandlePropertiesFUCHSIA = OP_vkGetMemoryZirconHandlePropertiesFUCHSIA;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetMemoryZirconHandlePropertiesFUCHSIA, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetMemoryZirconHandlePropertiesFUCHSIA, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetMemoryZirconHandlePropertiesFUCHSIA =
+ OP_vkGetMemoryZirconHandlePropertiesFUCHSIA;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetMemoryZirconHandlePropertiesFUCHSIA, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetMemoryZirconHandlePropertiesFUCHSIA, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- memcpy(*streamPtrPtr, (VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ memcpy(*streamPtrPtr, (VkExternalMemoryHandleTypeFlagBits*)&local_handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
*streamPtrPtr += sizeof(VkExternalMemoryHandleTypeFlagBits);
memcpy(*streamPtrPtr, (zx_handle_t*)&local_zirconHandle, sizeof(zx_handle_t));
*streamPtrPtr += sizeof(zx_handle_t);
- reservedmarshal_VkMemoryZirconHandlePropertiesFUCHSIA(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryZirconHandlePropertiesFUCHSIA*)(pMemoryZirconHandleProperties), streamPtrPtr);
- unmarshal_VkMemoryZirconHandlePropertiesFUCHSIA(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryZirconHandlePropertiesFUCHSIA*)(pMemoryZirconHandleProperties));
- if (pMemoryZirconHandleProperties)
- {
- transform_fromhost_VkMemoryZirconHandlePropertiesFUCHSIA(sResourceTracker, (VkMemoryZirconHandlePropertiesFUCHSIA*)(pMemoryZirconHandleProperties));
+ reservedmarshal_VkMemoryZirconHandlePropertiesFUCHSIA(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryZirconHandlePropertiesFUCHSIA*)(pMemoryZirconHandleProperties), streamPtrPtr);
+ unmarshal_VkMemoryZirconHandlePropertiesFUCHSIA(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryZirconHandlePropertiesFUCHSIA*)(pMemoryZirconHandleProperties));
+ if (pMemoryZirconHandleProperties) {
+ transform_fromhost_VkMemoryZirconHandlePropertiesFUCHSIA(
+ sResourceTracker,
+ (VkMemoryZirconHandlePropertiesFUCHSIA*)(pMemoryZirconHandleProperties));
}
VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA_VkResult_return = (VkResult)0;
stream->read(&vkGetMemoryZirconHandlePropertiesFUCHSIA_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -35906,10 +50682,35 @@
VkResult VkEncoder::vkImportSemaphoreZirconHandleFUCHSIA(
VkDevice device,
const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo,
- uint32_t doLock)
-{
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkImportSemaphoreZirconHandleFUCHSIA in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkImportSemaphoreZirconHandleFUCHSIA(device:%p, pImportSemaphoreZirconHandleInfo:%p)",
+ device, pImportSemaphoreZirconHandleInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -35917,40 +50718,60 @@
VkImportSemaphoreZirconHandleInfoFUCHSIA* local_pImportSemaphoreZirconHandleInfo;
local_device = device;
local_pImportSemaphoreZirconHandleInfo = nullptr;
- if (pImportSemaphoreZirconHandleInfo)
- {
- local_pImportSemaphoreZirconHandleInfo = (VkImportSemaphoreZirconHandleInfoFUCHSIA*)pool->alloc(sizeof(const VkImportSemaphoreZirconHandleInfoFUCHSIA));
- deepcopy_VkImportSemaphoreZirconHandleInfoFUCHSIA(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImportSemaphoreZirconHandleInfo, (VkImportSemaphoreZirconHandleInfoFUCHSIA*)(local_pImportSemaphoreZirconHandleInfo));
+ if (pImportSemaphoreZirconHandleInfo) {
+ local_pImportSemaphoreZirconHandleInfo =
+ (VkImportSemaphoreZirconHandleInfoFUCHSIA*)pool->alloc(
+ sizeof(const VkImportSemaphoreZirconHandleInfoFUCHSIA));
+ deepcopy_VkImportSemaphoreZirconHandleInfoFUCHSIA(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImportSemaphoreZirconHandleInfo,
+ (VkImportSemaphoreZirconHandleInfoFUCHSIA*)(local_pImportSemaphoreZirconHandleInfo));
}
- if (local_pImportSemaphoreZirconHandleInfo)
- {
- transform_tohost_VkImportSemaphoreZirconHandleInfoFUCHSIA(sResourceTracker, (VkImportSemaphoreZirconHandleInfoFUCHSIA*)(local_pImportSemaphoreZirconHandleInfo));
+ if (local_pImportSemaphoreZirconHandleInfo) {
+ transform_tohost_VkImportSemaphoreZirconHandleInfoFUCHSIA(
+ sResourceTracker,
+ (VkImportSemaphoreZirconHandleInfoFUCHSIA*)(local_pImportSemaphoreZirconHandleInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImportSemaphoreZirconHandleInfoFUCHSIA(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImportSemaphoreZirconHandleInfoFUCHSIA*)(local_pImportSemaphoreZirconHandleInfo), countPtr);
+ count_VkImportSemaphoreZirconHandleInfoFUCHSIA(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImportSemaphoreZirconHandleInfoFUCHSIA*)(local_pImportSemaphoreZirconHandleInfo),
+ countPtr);
}
- uint32_t packetSize_vkImportSemaphoreZirconHandleFUCHSIA = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkImportSemaphoreZirconHandleFUCHSIA =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkImportSemaphoreZirconHandleFUCHSIA);
uint8_t* streamPtr = stream->reserve(packetSize_vkImportSemaphoreZirconHandleFUCHSIA);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkImportSemaphoreZirconHandleFUCHSIA = OP_vkImportSemaphoreZirconHandleFUCHSIA;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkImportSemaphoreZirconHandleFUCHSIA, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkImportSemaphoreZirconHandleFUCHSIA, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkImportSemaphoreZirconHandleFUCHSIA, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkImportSemaphoreZirconHandleFUCHSIA, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImportSemaphoreZirconHandleInfoFUCHSIA(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImportSemaphoreZirconHandleInfoFUCHSIA*)(local_pImportSemaphoreZirconHandleInfo), streamPtrPtr);
+ reservedmarshal_VkImportSemaphoreZirconHandleInfoFUCHSIA(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImportSemaphoreZirconHandleInfoFUCHSIA*)(local_pImportSemaphoreZirconHandleInfo),
+ streamPtrPtr);
VkResult vkImportSemaphoreZirconHandleFUCHSIA_VkResult_return = (VkResult)0;
stream->read(&vkImportSemaphoreZirconHandleFUCHSIA_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -35959,13 +50780,36 @@
}
VkResult VkEncoder::vkGetSemaphoreZirconHandleFUCHSIA(
- VkDevice device,
- const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
- zx_handle_t* pZirconHandle,
- uint32_t doLock)
-{
+ VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetSemaphoreZirconHandleFUCHSIA in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetSemaphoreZirconHandleFUCHSIA(device:%p, pGetZirconHandleInfo:%p, pZirconHandle:%p)",
+ device, pGetZirconHandleInfo, pZirconHandle);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -35973,44 +50817,60 @@
VkSemaphoreGetZirconHandleInfoFUCHSIA* local_pGetZirconHandleInfo;
local_device = device;
local_pGetZirconHandleInfo = nullptr;
- if (pGetZirconHandleInfo)
- {
- local_pGetZirconHandleInfo = (VkSemaphoreGetZirconHandleInfoFUCHSIA*)pool->alloc(sizeof(const VkSemaphoreGetZirconHandleInfoFUCHSIA));
- deepcopy_VkSemaphoreGetZirconHandleInfoFUCHSIA(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetZirconHandleInfo, (VkSemaphoreGetZirconHandleInfoFUCHSIA*)(local_pGetZirconHandleInfo));
+ if (pGetZirconHandleInfo) {
+ local_pGetZirconHandleInfo = (VkSemaphoreGetZirconHandleInfoFUCHSIA*)pool->alloc(
+ sizeof(const VkSemaphoreGetZirconHandleInfoFUCHSIA));
+ deepcopy_VkSemaphoreGetZirconHandleInfoFUCHSIA(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pGetZirconHandleInfo,
+ (VkSemaphoreGetZirconHandleInfoFUCHSIA*)(local_pGetZirconHandleInfo));
}
- if (local_pGetZirconHandleInfo)
- {
- transform_tohost_VkSemaphoreGetZirconHandleInfoFUCHSIA(sResourceTracker, (VkSemaphoreGetZirconHandleInfoFUCHSIA*)(local_pGetZirconHandleInfo));
+ if (local_pGetZirconHandleInfo) {
+ transform_tohost_VkSemaphoreGetZirconHandleInfoFUCHSIA(
+ sResourceTracker, (VkSemaphoreGetZirconHandleInfoFUCHSIA*)(local_pGetZirconHandleInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkSemaphoreGetZirconHandleInfoFUCHSIA(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSemaphoreGetZirconHandleInfoFUCHSIA*)(local_pGetZirconHandleInfo), countPtr);
+ count_VkSemaphoreGetZirconHandleInfoFUCHSIA(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSemaphoreGetZirconHandleInfoFUCHSIA*)(local_pGetZirconHandleInfo), countPtr);
*countPtr += sizeof(zx_handle_t);
}
- uint32_t packetSize_vkGetSemaphoreZirconHandleFUCHSIA = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetSemaphoreZirconHandleFUCHSIA =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetSemaphoreZirconHandleFUCHSIA);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetSemaphoreZirconHandleFUCHSIA);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetSemaphoreZirconHandleFUCHSIA = OP_vkGetSemaphoreZirconHandleFUCHSIA;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetSemaphoreZirconHandleFUCHSIA, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetSemaphoreZirconHandleFUCHSIA, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetSemaphoreZirconHandleFUCHSIA, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetSemaphoreZirconHandleFUCHSIA, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkSemaphoreGetZirconHandleInfoFUCHSIA(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSemaphoreGetZirconHandleInfoFUCHSIA*)(local_pGetZirconHandleInfo), streamPtrPtr);
+ reservedmarshal_VkSemaphoreGetZirconHandleInfoFUCHSIA(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSemaphoreGetZirconHandleInfoFUCHSIA*)(local_pGetZirconHandleInfo), streamPtrPtr);
memcpy(*streamPtrPtr, (zx_handle_t*)pZirconHandle, sizeof(zx_handle_t));
*streamPtrPtr += sizeof(zx_handle_t);
stream->read((zx_handle_t*)pZirconHandle, sizeof(zx_handle_t));
VkResult vkGetSemaphoreZirconHandleFUCHSIA_VkResult_return = (VkResult)0;
stream->read(&vkGetSemaphoreZirconHandleFUCHSIA_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -36021,14 +50881,37 @@
#endif
#ifdef VK_FUCHSIA_buffer_collection
VkResult VkEncoder::vkCreateBufferCollectionFUCHSIA(
- VkDevice device,
- const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkBufferCollectionFUCHSIA* pCollection,
- uint32_t doLock)
-{
+ VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateBufferCollectionFUCHSIA in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateBufferCollectionFUCHSIA(device:%p, pCreateInfo:%p, pAllocator:%p, pCollection:%p)",
+ device, pCreateInfo, pAllocator, pCollection);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -36037,61 +50920,78 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkBufferCollectionCreateInfoFUCHSIA*)pool->alloc(sizeof(const VkBufferCollectionCreateInfoFUCHSIA));
- deepcopy_VkBufferCollectionCreateInfoFUCHSIA(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkBufferCollectionCreateInfoFUCHSIA*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkBufferCollectionCreateInfoFUCHSIA*)pool->alloc(
+ sizeof(const VkBufferCollectionCreateInfoFUCHSIA));
+ deepcopy_VkBufferCollectionCreateInfoFUCHSIA(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkBufferCollectionCreateInfoFUCHSIA*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkBufferCollectionCreateInfoFUCHSIA(sResourceTracker, (VkBufferCollectionCreateInfoFUCHSIA*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkBufferCollectionCreateInfoFUCHSIA(
+ sResourceTracker, (VkBufferCollectionCreateInfoFUCHSIA*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferCollectionCreateInfoFUCHSIA(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferCollectionCreateInfoFUCHSIA*)(local_pCreateInfo), countPtr);
+ count_VkBufferCollectionCreateInfoFUCHSIA(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferCollectionCreateInfoFUCHSIA*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
*countPtr += 8;
}
- uint32_t packetSize_vkCreateBufferCollectionFUCHSIA = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateBufferCollectionFUCHSIA =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCreateBufferCollectionFUCHSIA);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateBufferCollectionFUCHSIA);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateBufferCollectionFUCHSIA = OP_vkCreateBufferCollectionFUCHSIA;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateBufferCollectionFUCHSIA, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateBufferCollectionFUCHSIA, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateBufferCollectionFUCHSIA, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateBufferCollectionFUCHSIA, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferCollectionCreateInfoFUCHSIA(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferCollectionCreateInfoFUCHSIA*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkBufferCollectionCreateInfoFUCHSIA(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferCollectionCreateInfoFUCHSIA*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
uint64_t cgen_var_2 = (uint64_t)(*pCollection);
memcpy((*streamPtrPtr), &cgen_var_2, 8);
@@ -36100,9 +51000,9 @@
(*pCollection) = (VkBufferCollectionFUCHSIA)stream->getBe64();
VkResult vkCreateBufferCollectionFUCHSIA_VkResult_return = (VkResult)0;
stream->read(&vkCreateBufferCollectionFUCHSIA_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -36111,13 +51011,37 @@
}
VkResult VkEncoder::vkSetBufferCollectionImageConstraintsFUCHSIA(
- VkDevice device,
- VkBufferCollectionFUCHSIA collection,
- const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo,
- uint32_t doLock)
-{
+ VkDevice device, VkBufferCollectionFUCHSIA collection,
+ const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkSetBufferCollectionImageConstraintsFUCHSIA in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkSetBufferCollectionImageConstraintsFUCHSIA(device:%p, pImageConstraintsInfo:%p)", device,
+ pImageConstraintsInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -36127,14 +51051,16 @@
local_device = device;
local_collection = collection;
local_pImageConstraintsInfo = nullptr;
- if (pImageConstraintsInfo)
- {
- local_pImageConstraintsInfo = (VkImageConstraintsInfoFUCHSIA*)pool->alloc(sizeof(const VkImageConstraintsInfoFUCHSIA));
- deepcopy_VkImageConstraintsInfoFUCHSIA(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImageConstraintsInfo, (VkImageConstraintsInfoFUCHSIA*)(local_pImageConstraintsInfo));
+ if (pImageConstraintsInfo) {
+ local_pImageConstraintsInfo = (VkImageConstraintsInfoFUCHSIA*)pool->alloc(
+ sizeof(const VkImageConstraintsInfoFUCHSIA));
+ deepcopy_VkImageConstraintsInfoFUCHSIA(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImageConstraintsInfo,
+ (VkImageConstraintsInfoFUCHSIA*)(local_pImageConstraintsInfo));
}
- if (local_pImageConstraintsInfo)
- {
- transform_tohost_VkImageConstraintsInfoFUCHSIA(sResourceTracker, (VkImageConstraintsInfoFUCHSIA*)(local_pImageConstraintsInfo));
+ if (local_pImageConstraintsInfo) {
+ transform_tohost_VkImageConstraintsInfoFUCHSIA(
+ sResourceTracker, (VkImageConstraintsInfoFUCHSIA*)(local_pImageConstraintsInfo));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -36142,16 +51068,29 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += 8;
- count_VkImageConstraintsInfoFUCHSIA(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageConstraintsInfoFUCHSIA*)(local_pImageConstraintsInfo), countPtr);
+ count_VkImageConstraintsInfoFUCHSIA(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageConstraintsInfoFUCHSIA*)(local_pImageConstraintsInfo), countPtr);
}
- uint32_t packetSize_vkSetBufferCollectionImageConstraintsFUCHSIA = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkSetBufferCollectionImageConstraintsFUCHSIA =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkSetBufferCollectionImageConstraintsFUCHSIA);
uint8_t* streamPtr = stream->reserve(packetSize_vkSetBufferCollectionImageConstraintsFUCHSIA);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkSetBufferCollectionImageConstraintsFUCHSIA = OP_vkSetBufferCollectionImageConstraintsFUCHSIA;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkSetBufferCollectionImageConstraintsFUCHSIA, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkSetBufferCollectionImageConstraintsFUCHSIA, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkSetBufferCollectionImageConstraintsFUCHSIA =
+ OP_vkSetBufferCollectionImageConstraintsFUCHSIA;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkSetBufferCollectionImageConstraintsFUCHSIA, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkSetBufferCollectionImageConstraintsFUCHSIA, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -36160,12 +51099,14 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- reservedmarshal_VkImageConstraintsInfoFUCHSIA(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageConstraintsInfoFUCHSIA*)(local_pImageConstraintsInfo), streamPtrPtr);
+ reservedmarshal_VkImageConstraintsInfoFUCHSIA(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageConstraintsInfoFUCHSIA*)(local_pImageConstraintsInfo), streamPtrPtr);
VkResult vkSetBufferCollectionImageConstraintsFUCHSIA_VkResult_return = (VkResult)0;
stream->read(&vkSetBufferCollectionImageConstraintsFUCHSIA_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -36174,13 +51115,37 @@
}
VkResult VkEncoder::vkSetBufferCollectionBufferConstraintsFUCHSIA(
- VkDevice device,
- VkBufferCollectionFUCHSIA collection,
- const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo,
- uint32_t doLock)
-{
+ VkDevice device, VkBufferCollectionFUCHSIA collection,
+ const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkSetBufferCollectionBufferConstraintsFUCHSIA in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkSetBufferCollectionBufferConstraintsFUCHSIA(device:%p, pBufferConstraintsInfo:%p)",
+ device, pBufferConstraintsInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -36190,14 +51155,16 @@
local_device = device;
local_collection = collection;
local_pBufferConstraintsInfo = nullptr;
- if (pBufferConstraintsInfo)
- {
- local_pBufferConstraintsInfo = (VkBufferConstraintsInfoFUCHSIA*)pool->alloc(sizeof(const VkBufferConstraintsInfoFUCHSIA));
- deepcopy_VkBufferConstraintsInfoFUCHSIA(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBufferConstraintsInfo, (VkBufferConstraintsInfoFUCHSIA*)(local_pBufferConstraintsInfo));
+ if (pBufferConstraintsInfo) {
+ local_pBufferConstraintsInfo = (VkBufferConstraintsInfoFUCHSIA*)pool->alloc(
+ sizeof(const VkBufferConstraintsInfoFUCHSIA));
+ deepcopy_VkBufferConstraintsInfoFUCHSIA(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBufferConstraintsInfo,
+ (VkBufferConstraintsInfoFUCHSIA*)(local_pBufferConstraintsInfo));
}
- if (local_pBufferConstraintsInfo)
- {
- transform_tohost_VkBufferConstraintsInfoFUCHSIA(sResourceTracker, (VkBufferConstraintsInfoFUCHSIA*)(local_pBufferConstraintsInfo));
+ if (local_pBufferConstraintsInfo) {
+ transform_tohost_VkBufferConstraintsInfoFUCHSIA(
+ sResourceTracker, (VkBufferConstraintsInfoFUCHSIA*)(local_pBufferConstraintsInfo));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -36205,16 +51172,29 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += 8;
- count_VkBufferConstraintsInfoFUCHSIA(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferConstraintsInfoFUCHSIA*)(local_pBufferConstraintsInfo), countPtr);
+ count_VkBufferConstraintsInfoFUCHSIA(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferConstraintsInfoFUCHSIA*)(local_pBufferConstraintsInfo), countPtr);
}
- uint32_t packetSize_vkSetBufferCollectionBufferConstraintsFUCHSIA = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkSetBufferCollectionBufferConstraintsFUCHSIA =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkSetBufferCollectionBufferConstraintsFUCHSIA);
uint8_t* streamPtr = stream->reserve(packetSize_vkSetBufferCollectionBufferConstraintsFUCHSIA);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkSetBufferCollectionBufferConstraintsFUCHSIA = OP_vkSetBufferCollectionBufferConstraintsFUCHSIA;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkSetBufferCollectionBufferConstraintsFUCHSIA, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkSetBufferCollectionBufferConstraintsFUCHSIA, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkSetBufferCollectionBufferConstraintsFUCHSIA =
+ OP_vkSetBufferCollectionBufferConstraintsFUCHSIA;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkSetBufferCollectionBufferConstraintsFUCHSIA, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkSetBufferCollectionBufferConstraintsFUCHSIA, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -36223,12 +51203,14 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- reservedmarshal_VkBufferConstraintsInfoFUCHSIA(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferConstraintsInfoFUCHSIA*)(local_pBufferConstraintsInfo), streamPtrPtr);
+ reservedmarshal_VkBufferConstraintsInfoFUCHSIA(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferConstraintsInfoFUCHSIA*)(local_pBufferConstraintsInfo), streamPtrPtr);
VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA_VkResult_return = (VkResult)0;
stream->read(&vkSetBufferCollectionBufferConstraintsFUCHSIA_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -36236,14 +51218,37 @@
return vkSetBufferCollectionBufferConstraintsFUCHSIA_VkResult_return;
}
-void VkEncoder::vkDestroyBufferCollectionFUCHSIA(
- VkDevice device,
- VkBufferCollectionFUCHSIA collection,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyBufferCollectionFUCHSIA(VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyBufferCollectionFUCHSIA in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkDestroyBufferCollectionFUCHSIA(device:%p, pAllocator:%p)", device,
+ pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -36253,15 +51258,15 @@
local_device = device;
local_collection = collection;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -36271,19 +51276,29 @@
*countPtr += 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyBufferCollectionFUCHSIA = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyBufferCollectionFUCHSIA =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkDestroyBufferCollectionFUCHSIA);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyBufferCollectionFUCHSIA);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyBufferCollectionFUCHSIA = OP_vkDestroyBufferCollectionFUCHSIA;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyBufferCollectionFUCHSIA, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyBufferCollectionFUCHSIA, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyBufferCollectionFUCHSIA, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyBufferCollectionFUCHSIA, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -36297,14 +51312,15 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -36312,13 +51328,36 @@
}
VkResult VkEncoder::vkGetBufferCollectionPropertiesFUCHSIA(
- VkDevice device,
- VkBufferCollectionFUCHSIA collection,
- VkBufferCollectionPropertiesFUCHSIA* pProperties,
- uint32_t doLock)
-{
+ VkDevice device, VkBufferCollectionFUCHSIA collection,
+ VkBufferCollectionPropertiesFUCHSIA* pProperties, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetBufferCollectionPropertiesFUCHSIA in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetBufferCollectionPropertiesFUCHSIA(device:%p, pProperties:%p)", device,
+ pProperties);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -36332,16 +51371,29 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += 8;
- count_VkBufferCollectionPropertiesFUCHSIA(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferCollectionPropertiesFUCHSIA*)(pProperties), countPtr);
+ count_VkBufferCollectionPropertiesFUCHSIA(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferCollectionPropertiesFUCHSIA*)(pProperties), countPtr);
}
- uint32_t packetSize_vkGetBufferCollectionPropertiesFUCHSIA = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetBufferCollectionPropertiesFUCHSIA =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetBufferCollectionPropertiesFUCHSIA);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetBufferCollectionPropertiesFUCHSIA);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetBufferCollectionPropertiesFUCHSIA = OP_vkGetBufferCollectionPropertiesFUCHSIA;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetBufferCollectionPropertiesFUCHSIA, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetBufferCollectionPropertiesFUCHSIA, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetBufferCollectionPropertiesFUCHSIA =
+ OP_vkGetBufferCollectionPropertiesFUCHSIA;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetBufferCollectionPropertiesFUCHSIA, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetBufferCollectionPropertiesFUCHSIA, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -36350,17 +51402,20 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- reservedmarshal_VkBufferCollectionPropertiesFUCHSIA(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferCollectionPropertiesFUCHSIA*)(pProperties), streamPtrPtr);
- unmarshal_VkBufferCollectionPropertiesFUCHSIA(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferCollectionPropertiesFUCHSIA*)(pProperties));
- if (pProperties)
- {
- transform_fromhost_VkBufferCollectionPropertiesFUCHSIA(sResourceTracker, (VkBufferCollectionPropertiesFUCHSIA*)(pProperties));
+ reservedmarshal_VkBufferCollectionPropertiesFUCHSIA(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferCollectionPropertiesFUCHSIA*)(pProperties),
+ streamPtrPtr);
+ unmarshal_VkBufferCollectionPropertiesFUCHSIA(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferCollectionPropertiesFUCHSIA*)(pProperties));
+ if (pProperties) {
+ transform_fromhost_VkBufferCollectionPropertiesFUCHSIA(
+ sResourceTracker, (VkBufferCollectionPropertiesFUCHSIA*)(pProperties));
}
VkResult vkGetBufferCollectionPropertiesFUCHSIA_VkResult_return = (VkResult)0;
stream->read(&vkGetBufferCollectionPropertiesFUCHSIA_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -36370,14 +51425,40 @@
#endif
#ifdef VK_HUAWEI_subpass_shading
-VkResult VkEncoder::vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
- VkDevice device,
- VkRenderPass renderpass,
- VkExtent2D* pMaxWorkgroupSize,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device,
+ VkRenderPass renderpass,
+ VkExtent2D* pMaxWorkgroupSize,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device:%p, renderpass:%p, "
+ "pMaxWorkgroupSize:%p)",
+ device, renderpass, pMaxWorkgroupSize);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -36392,16 +51473,30 @@
*countPtr += 1 * 8;
uint64_t cgen_var_1;
*countPtr += 1 * 8;
- count_VkExtent2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pMaxWorkgroupSize), countPtr);
+ count_VkExtent2D(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pMaxWorkgroupSize),
+ countPtr);
}
- uint32_t packetSize_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI);
+ uint32_t packetSize_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI);
+ uint8_t* streamPtr =
+ stream->reserve(packetSize_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = OP_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI =
+ OP_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
+ sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -36410,17 +51505,18 @@
*&cgen_var_1 = get_host_u64_VkRenderPass((*&local_renderpass));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkExtent2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pMaxWorkgroupSize), streamPtrPtr);
+ reservedmarshal_VkExtent2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pMaxWorkgroupSize),
+ streamPtrPtr);
unmarshal_VkExtent2D(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkExtent2D*)(pMaxWorkgroupSize));
- if (pMaxWorkgroupSize)
- {
+ if (pMaxWorkgroupSize) {
transform_fromhost_VkExtent2D(sResourceTracker, (VkExtent2D*)(pMaxWorkgroupSize));
}
VkResult vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_VkResult_return = (VkResult)0;
- stream->read(&vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ stream->read(&vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_VkResult_return,
+ sizeof(VkResult));
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -36428,12 +51524,33 @@
return vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_VkResult_return;
}
-void VkEncoder::vkCmdSubpassShadingHUAWEI(
- VkCommandBuffer commandBuffer,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSubpassShadingHUAWEI in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSubpassShadingHUAWEI(commandBuffer:%p)", commandBuffer);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -36446,22 +51563,24 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkCmdSubpassShadingHUAWEI = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSubpassShadingHUAWEI);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSubpassShadingHUAWEI -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSubpassShadingHUAWEI);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSubpassShadingHUAWEI = OP_vkCmdSubpassShadingHUAWEI;
- memcpy(streamPtr, &opcode_vkCmdSubpassShadingHUAWEI, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSubpassShadingHUAWEI, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSubpassShadingHUAWEI, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSubpassShadingHUAWEI, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -36470,14 +51589,36 @@
#endif
#ifdef VK_HUAWEI_invocation_mask
-void VkEncoder::vkCmdBindInvocationMaskHUAWEI(
- VkCommandBuffer commandBuffer,
- VkImageView imageView,
- VkImageLayout imageLayout,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView,
+ VkImageLayout imageLayout, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBindInvocationMaskHUAWEI in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdBindInvocationMaskHUAWEI(commandBuffer:%p, imageView:%p, imageLayout:%d)",
+ commandBuffer, imageView, imageLayout);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -36497,14 +51638,17 @@
*countPtr += sizeof(VkImageLayout);
}
uint32_t packetSize_vkCmdBindInvocationMaskHUAWEI = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdBindInvocationMaskHUAWEI);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBindInvocationMaskHUAWEI -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBindInvocationMaskHUAWEI);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBindInvocationMaskHUAWEI = OP_vkCmdBindInvocationMaskHUAWEI;
- memcpy(streamPtr, &opcode_vkCmdBindInvocationMaskHUAWEI, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBindInvocationMaskHUAWEI, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBindInvocationMaskHUAWEI, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBindInvocationMaskHUAWEI, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -36516,9 +51660,9 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (VkImageLayout*)&local_imageLayout, sizeof(VkImageLayout));
*streamPtrPtr += sizeof(VkImageLayout);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -36528,13 +51672,36 @@
#endif
#ifdef VK_NV_external_memory_rdma
VkResult VkEncoder::vkGetMemoryRemoteAddressNV(
- VkDevice device,
- const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo,
- VkRemoteAddressNV* pAddress,
- uint32_t doLock)
-{
+ VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo,
+ VkRemoteAddressNV* pAddress, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetMemoryRemoteAddressNV in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetMemoryRemoteAddressNV(device:%p, pMemoryGetRemoteAddressInfo:%p, pAddress:%p)",
+ device, pMemoryGetRemoteAddressInfo, pAddress);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -36542,44 +51709,59 @@
VkMemoryGetRemoteAddressInfoNV* local_pMemoryGetRemoteAddressInfo;
local_device = device;
local_pMemoryGetRemoteAddressInfo = nullptr;
- if (pMemoryGetRemoteAddressInfo)
- {
- local_pMemoryGetRemoteAddressInfo = (VkMemoryGetRemoteAddressInfoNV*)pool->alloc(sizeof(const VkMemoryGetRemoteAddressInfoNV));
- deepcopy_VkMemoryGetRemoteAddressInfoNV(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMemoryGetRemoteAddressInfo, (VkMemoryGetRemoteAddressInfoNV*)(local_pMemoryGetRemoteAddressInfo));
+ if (pMemoryGetRemoteAddressInfo) {
+ local_pMemoryGetRemoteAddressInfo = (VkMemoryGetRemoteAddressInfoNV*)pool->alloc(
+ sizeof(const VkMemoryGetRemoteAddressInfoNV));
+ deepcopy_VkMemoryGetRemoteAddressInfoNV(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMemoryGetRemoteAddressInfo,
+ (VkMemoryGetRemoteAddressInfoNV*)(local_pMemoryGetRemoteAddressInfo));
}
- if (local_pMemoryGetRemoteAddressInfo)
- {
- transform_tohost_VkMemoryGetRemoteAddressInfoNV(sResourceTracker, (VkMemoryGetRemoteAddressInfoNV*)(local_pMemoryGetRemoteAddressInfo));
+ if (local_pMemoryGetRemoteAddressInfo) {
+ transform_tohost_VkMemoryGetRemoteAddressInfoNV(
+ sResourceTracker, (VkMemoryGetRemoteAddressInfoNV*)(local_pMemoryGetRemoteAddressInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkMemoryGetRemoteAddressInfoNV(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryGetRemoteAddressInfoNV*)(local_pMemoryGetRemoteAddressInfo), countPtr);
+ count_VkMemoryGetRemoteAddressInfoNV(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryGetRemoteAddressInfoNV*)(local_pMemoryGetRemoteAddressInfo), countPtr);
*countPtr += sizeof(VkRemoteAddressNV);
}
- uint32_t packetSize_vkGetMemoryRemoteAddressNV = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetMemoryRemoteAddressNV =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkGetMemoryRemoteAddressNV);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetMemoryRemoteAddressNV);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetMemoryRemoteAddressNV = OP_vkGetMemoryRemoteAddressNV;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetMemoryRemoteAddressNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetMemoryRemoteAddressNV, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetMemoryRemoteAddressNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetMemoryRemoteAddressNV, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkMemoryGetRemoteAddressInfoNV(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryGetRemoteAddressInfoNV*)(local_pMemoryGetRemoteAddressInfo), streamPtrPtr);
+ reservedmarshal_VkMemoryGetRemoteAddressInfoNV(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryGetRemoteAddressInfoNV*)(local_pMemoryGetRemoteAddressInfo), streamPtrPtr);
memcpy(*streamPtrPtr, (VkRemoteAddressNV*)pAddress, sizeof(VkRemoteAddressNV));
*streamPtrPtr += sizeof(VkRemoteAddressNV);
stream->read((VkRemoteAddressNV*)pAddress, sizeof(VkRemoteAddressNV));
VkResult vkGetMemoryRemoteAddressNV_VkResult_return = (VkResult)0;
stream->read(&vkGetMemoryRemoteAddressNV_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -36589,13 +51771,35 @@
#endif
#ifdef VK_EXT_extended_dynamic_state2
-void VkEncoder::vkCmdSetPatchControlPointsEXT(
- VkCommandBuffer commandBuffer,
- uint32_t patchControlPoints,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer,
+ uint32_t patchControlPoints, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetPatchControlPointsEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetPatchControlPointsEXT(commandBuffer:%p, patchControlPoints:%d)",
+ commandBuffer, patchControlPoints);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -36611,14 +51815,17 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdSetPatchControlPointsEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdSetPatchControlPointsEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetPatchControlPointsEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetPatchControlPointsEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetPatchControlPointsEXT = OP_vkCmdSetPatchControlPointsEXT;
- memcpy(streamPtr, &opcode_vkCmdSetPatchControlPointsEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetPatchControlPointsEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetPatchControlPointsEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetPatchControlPointsEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -36626,22 +51833,46 @@
}
memcpy(*streamPtrPtr, (uint32_t*)&local_patchControlPoints, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetRasterizerDiscardEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 rasterizerDiscardEnable,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 rasterizerDiscardEnable,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetRasterizerDiscardEnableEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdSetRasterizerDiscardEnableEXT(commandBuffer:%p, rasterizerDiscardEnable:%d)",
+ commandBuffer, rasterizerDiscardEnable);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -36657,14 +51888,17 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetRasterizerDiscardEnableEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdSetRasterizerDiscardEnableEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetRasterizerDiscardEnableEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetRasterizerDiscardEnableEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetRasterizerDiscardEnableEXT = OP_vkCmdSetRasterizerDiscardEnableEXT;
- memcpy(streamPtr, &opcode_vkCmdSetRasterizerDiscardEnableEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetRasterizerDiscardEnableEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetRasterizerDiscardEnableEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetRasterizerDiscardEnableEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -36672,22 +51906,44 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_rasterizerDiscardEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetDepthBiasEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 depthBiasEnable,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetDepthBiasEnableEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetDepthBiasEnableEXT(commandBuffer:%p, depthBiasEnable:%d)",
+ commandBuffer, depthBiasEnable);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -36703,14 +51959,16 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetDepthBiasEnableEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetDepthBiasEnableEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetDepthBiasEnableEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetDepthBiasEnableEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetDepthBiasEnableEXT = OP_vkCmdSetDepthBiasEnableEXT;
- memcpy(streamPtr, &opcode_vkCmdSetDepthBiasEnableEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetDepthBiasEnableEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetDepthBiasEnableEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetDepthBiasEnableEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -36718,22 +51976,43 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_depthBiasEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetLogicOpEXT(
- VkCommandBuffer commandBuffer,
- VkLogicOp logicOp,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetLogicOpEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdSetLogicOpEXT(commandBuffer:%p)", commandBuffer);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -36749,14 +52028,16 @@
*countPtr += sizeof(VkLogicOp);
}
uint32_t packetSize_vkCmdSetLogicOpEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetLogicOpEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetLogicOpEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetLogicOpEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetLogicOpEXT = OP_vkCmdSetLogicOpEXT;
- memcpy(streamPtr, &opcode_vkCmdSetLogicOpEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetLogicOpEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetLogicOpEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetLogicOpEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -36764,22 +52045,46 @@
}
memcpy(*streamPtrPtr, (VkLogicOp*)&local_logicOp, sizeof(VkLogicOp));
*streamPtrPtr += sizeof(VkLogicOp);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdSetPrimitiveRestartEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 primitiveRestartEnable,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 primitiveRestartEnable,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetPrimitiveRestartEnableEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdSetPrimitiveRestartEnableEXT(commandBuffer:%p, primitiveRestartEnable:%d)",
+ commandBuffer, primitiveRestartEnable);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -36795,14 +52100,17 @@
*countPtr += sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetPrimitiveRestartEnableEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdSetPrimitiveRestartEnableEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetPrimitiveRestartEnableEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetPrimitiveRestartEnableEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetPrimitiveRestartEnableEXT = OP_vkCmdSetPrimitiveRestartEnableEXT;
- memcpy(streamPtr, &opcode_vkCmdSetPrimitiveRestartEnableEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetPrimitiveRestartEnableEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetPrimitiveRestartEnableEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetPrimitiveRestartEnableEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -36810,9 +52118,9 @@
}
memcpy(*streamPtrPtr, (VkBool32*)&local_primitiveRestartEnable, sizeof(VkBool32));
*streamPtrPtr += sizeof(VkBool32);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -36821,15 +52129,38 @@
#endif
#ifdef VK_QNX_screen_surface
-VkResult VkEncoder::vkCreateScreenSurfaceQNX(
- VkInstance instance,
- const VkScreenSurfaceCreateInfoQNX* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCreateScreenSurfaceQNX(VkInstance instance,
+ const VkScreenSurfaceCreateInfoQNX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateScreenSurfaceQNX in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateScreenSurfaceQNX(instance:%p, pCreateInfo:%p, pAllocator:%p, pSurface:%p)",
+ instance, pCreateInfo, pAllocator, pSurface);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -36838,62 +52169,77 @@
VkAllocationCallbacks* local_pAllocator;
local_instance = instance;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkScreenSurfaceCreateInfoQNX*)pool->alloc(sizeof(const VkScreenSurfaceCreateInfoQNX));
- deepcopy_VkScreenSurfaceCreateInfoQNX(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkScreenSurfaceCreateInfoQNX*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo =
+ (VkScreenSurfaceCreateInfoQNX*)pool->alloc(sizeof(const VkScreenSurfaceCreateInfoQNX));
+ deepcopy_VkScreenSurfaceCreateInfoQNX(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkScreenSurfaceCreateInfoQNX*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkScreenSurfaceCreateInfoQNX(sResourceTracker, (VkScreenSurfaceCreateInfoQNX*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkScreenSurfaceCreateInfoQNX(
+ sResourceTracker, (VkScreenSurfaceCreateInfoQNX*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkScreenSurfaceCreateInfoQNX(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkScreenSurfaceCreateInfoQNX*)(local_pCreateInfo), countPtr);
+ count_VkScreenSurfaceCreateInfoQNX(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkScreenSurfaceCreateInfoQNX*)(local_pCreateInfo),
+ countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateScreenSurfaceQNX = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateScreenSurfaceQNX =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCreateScreenSurfaceQNX);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateScreenSurfaceQNX);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateScreenSurfaceQNX = OP_vkCreateScreenSurfaceQNX;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateScreenSurfaceQNX, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateScreenSurfaceQNX, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateScreenSurfaceQNX, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateScreenSurfaceQNX, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkInstance((*&local_instance));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkScreenSurfaceCreateInfoQNX(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkScreenSurfaceCreateInfoQNX*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkScreenSurfaceCreateInfoQNX(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkScreenSurfaceCreateInfoQNX*)(local_pCreateInfo),
+ streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -36906,9 +52252,9 @@
stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_3, (VkSurfaceKHR*)pSurface, 1);
VkResult vkCreateScreenSurfaceQNX_VkResult_return = (VkResult)0;
stream->read(&vkCreateScreenSurfaceQNX_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -36916,14 +52262,40 @@
return vkCreateScreenSurfaceQNX_VkResult_return;
}
-VkBool32 VkEncoder::vkGetPhysicalDeviceScreenPresentationSupportQNX(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- _screen_window* window,
- uint32_t doLock)
-{
+VkBool32 VkEncoder::vkGetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ _screen_window* window,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetPhysicalDeviceScreenPresentationSupportQNX in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetPhysicalDeviceScreenPresentationSupportQNX(physicalDevice:%p, queueFamilyIndex:%d, "
+ "window:%p)",
+ physicalDevice, queueFamilyIndex, window);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -36939,14 +52311,27 @@
*countPtr += sizeof(uint32_t);
*countPtr += sizeof(_screen_window);
}
- uint32_t packetSize_vkGetPhysicalDeviceScreenPresentationSupportQNX = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- uint8_t* streamPtr = stream->reserve(packetSize_vkGetPhysicalDeviceScreenPresentationSupportQNX);
+ uint32_t packetSize_vkGetPhysicalDeviceScreenPresentationSupportQNX =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetPhysicalDeviceScreenPresentationSupportQNX);
+ uint8_t* streamPtr =
+ stream->reserve(packetSize_vkGetPhysicalDeviceScreenPresentationSupportQNX);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetPhysicalDeviceScreenPresentationSupportQNX = OP_vkGetPhysicalDeviceScreenPresentationSupportQNX;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetPhysicalDeviceScreenPresentationSupportQNX, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceScreenPresentationSupportQNX, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetPhysicalDeviceScreenPresentationSupportQNX =
+ OP_vkGetPhysicalDeviceScreenPresentationSupportQNX;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetPhysicalDeviceScreenPresentationSupportQNX, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetPhysicalDeviceScreenPresentationSupportQNX,
+ sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPhysicalDevice((*&local_physicalDevice));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -36957,10 +52342,11 @@
*streamPtrPtr += sizeof(_screen_window);
stream->read((_screen_window*)window, sizeof(_screen_window));
VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX_VkBool32_return = (VkBool32)0;
- stream->read(&vkGetPhysicalDeviceScreenPresentationSupportQNX_VkBool32_return, sizeof(VkBool32));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ stream->read(&vkGetPhysicalDeviceScreenPresentationSupportQNX_VkBool32_return,
+ sizeof(VkBool32));
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -36970,14 +52356,36 @@
#endif
#ifdef VK_EXT_color_write_enable
-void VkEncoder::vkCmdSetColorWriteEnableEXT(
- VkCommandBuffer commandBuffer,
- uint32_t attachmentCount,
- const VkBool32* pColorWriteEnables,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
+ const VkBool32* pColorWriteEnables, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdSetColorWriteEnableEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdSetColorWriteEnableEXT(commandBuffer:%p, attachmentCount:%d, pColorWriteEnables:%p)",
+ commandBuffer, attachmentCount, pColorWriteEnables);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -36997,14 +52405,16 @@
*countPtr += ((attachmentCount)) * sizeof(VkBool32);
}
uint32_t packetSize_vkCmdSetColorWriteEnableEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdSetColorWriteEnableEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetColorWriteEnableEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetColorWriteEnableEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdSetColorWriteEnableEXT = OP_vkCmdSetColorWriteEnableEXT;
- memcpy(streamPtr, &opcode_vkCmdSetColorWriteEnableEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetColorWriteEnableEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdSetColorWriteEnableEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetColorWriteEnableEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -37012,11 +52422,12 @@
}
memcpy(*streamPtrPtr, (uint32_t*)&local_attachmentCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- memcpy(*streamPtrPtr, (VkBool32*)local_pColorWriteEnables, ((attachmentCount)) * sizeof(VkBool32));
+ memcpy(*streamPtrPtr, (VkBool32*)local_pColorWriteEnables,
+ ((attachmentCount)) * sizeof(VkBool32));
*streamPtrPtr += ((attachmentCount)) * sizeof(VkBool32);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -37025,14 +52436,35 @@
#endif
#ifdef VK_GOOGLE_gfxstream
-VkResult VkEncoder::vkRegisterImageColorBufferGOOGLE(
- VkDevice device,
- VkImage image,
- uint32_t colorBuffer,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkRegisterImageColorBufferGOOGLE(VkDevice device, VkImage image,
+ uint32_t colorBuffer, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkRegisterImageColorBufferGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkRegisterImageColorBufferGOOGLE(device:%p, image:%p, colorBuffer:%d)",
+ device, image, colorBuffer);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -37051,14 +52483,24 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
}
- uint32_t packetSize_vkRegisterImageColorBufferGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkRegisterImageColorBufferGOOGLE =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkRegisterImageColorBufferGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkRegisterImageColorBufferGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkRegisterImageColorBufferGOOGLE = OP_vkRegisterImageColorBufferGOOGLE;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkRegisterImageColorBufferGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkRegisterImageColorBufferGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkRegisterImageColorBufferGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkRegisterImageColorBufferGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -37071,9 +52513,9 @@
*streamPtrPtr += sizeof(uint32_t);
VkResult vkRegisterImageColorBufferGOOGLE_VkResult_return = (VkResult)0;
stream->read(&vkRegisterImageColorBufferGOOGLE_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -37081,14 +52523,35 @@
return vkRegisterImageColorBufferGOOGLE_VkResult_return;
}
-VkResult VkEncoder::vkRegisterBufferColorBufferGOOGLE(
- VkDevice device,
- VkBuffer buffer,
- uint32_t colorBuffer,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkRegisterBufferColorBufferGOOGLE(VkDevice device, VkBuffer buffer,
+ uint32_t colorBuffer, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkRegisterBufferColorBufferGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkRegisterBufferColorBufferGOOGLE(device:%p, buffer:%p, colorBuffer:%d)",
+ device, buffer, colorBuffer);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -37107,14 +52570,24 @@
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
}
- uint32_t packetSize_vkRegisterBufferColorBufferGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkRegisterBufferColorBufferGOOGLE =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkRegisterBufferColorBufferGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkRegisterBufferColorBufferGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkRegisterBufferColorBufferGOOGLE = OP_vkRegisterBufferColorBufferGOOGLE;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkRegisterBufferColorBufferGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkRegisterBufferColorBufferGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkRegisterBufferColorBufferGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkRegisterBufferColorBufferGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -37127,9 +52600,9 @@
*streamPtrPtr += sizeof(uint32_t);
VkResult vkRegisterBufferColorBufferGOOGLE_VkResult_return = (VkResult)0;
stream->read(&vkRegisterBufferColorBufferGOOGLE_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -37137,23 +52610,47 @@
return vkRegisterBufferColorBufferGOOGLE_VkResult_return;
}
-VkResult VkEncoder::vkMapMemoryIntoAddressSpaceGOOGLE(
- VkDevice device,
- VkDeviceMemory memory,
- uint64_t* pAddress,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkMapMemoryIntoAddressSpaceGOOGLE(VkDevice device, VkDeviceMemory memory,
+ uint64_t* pAddress, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkMapMemoryIntoAddressSpaceGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkMapMemoryIntoAddressSpaceGOOGLE(device:%p, memory:%p, pAddress:%p)",
+ device, memory, pAddress);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
- sResourceTracker->on_vkMapMemoryIntoAddressSpaceGOOGLE_pre(this, VK_SUCCESS, device, memory, pAddress);
+ sResourceTracker->on_vkMapMemoryIntoAddressSpaceGOOGLE_pre(this, VK_SUCCESS, device, memory,
+ pAddress);
auto stream = mImpl->stream();
auto pool = mImpl->pool();
VkDevice local_device;
VkDeviceMemory local_memory;
local_device = device;
local_memory = memory;
- sResourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ sResourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0,
+ (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
size_t count = 0;
size_t* countPtr = &count;
{
@@ -37163,19 +52660,28 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pAddress)
- {
+ if (pAddress) {
*countPtr += sizeof(uint64_t);
}
}
- uint32_t packetSize_vkMapMemoryIntoAddressSpaceGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkMapMemoryIntoAddressSpaceGOOGLE =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkMapMemoryIntoAddressSpaceGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkMapMemoryIntoAddressSpaceGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkMapMemoryIntoAddressSpaceGOOGLE = OP_vkMapMemoryIntoAddressSpaceGOOGLE;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkMapMemoryIntoAddressSpaceGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkMapMemoryIntoAddressSpaceGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkMapMemoryIntoAddressSpaceGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkMapMemoryIntoAddressSpaceGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -37189,28 +52695,26 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pAddress)
- {
+ if (pAddress) {
memcpy(*streamPtrPtr, (uint64_t*)pAddress, sizeof(uint64_t));
*streamPtrPtr += sizeof(uint64_t);
}
// WARNING PTR CHECK
uint64_t* check_pAddress;
check_pAddress = (uint64_t*)(uintptr_t)stream->getBe64();
- if (pAddress)
- {
- if (!(check_pAddress))
- {
+ if (pAddress) {
+ if (!(check_pAddress)) {
fprintf(stderr, "fatal: pAddress inconsistent between guest and host\n");
}
stream->read((uint64_t*)pAddress, sizeof(uint64_t));
}
VkResult vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = (VkResult)0;
stream->read(&vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return, sizeof(VkResult));
- sResourceTracker->on_vkMapMemoryIntoAddressSpaceGOOGLE(this, vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return, device, memory, pAddress);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ sResourceTracker->on_vkMapMemoryIntoAddressSpaceGOOGLE(
+ this, vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return, device, memory, pAddress);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -37219,22 +52723,46 @@
}
void VkEncoder::vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
- VkDevice device,
- VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- uint32_t imageInfoCount,
- uint32_t bufferInfoCount,
- uint32_t bufferViewCount,
- const uint32_t* pImageInfoEntryIndices,
- const uint32_t* pBufferInfoEntryIndices,
- const uint32_t* pBufferViewEntryIndices,
- const VkDescriptorImageInfo* pImageInfos,
- const VkDescriptorBufferInfo* pBufferInfos,
- const VkBufferView* pBufferViews,
- uint32_t doLock)
-{
+ VkDevice device, VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
+ uint32_t bufferInfoCount, uint32_t bufferViewCount, const uint32_t* pImageInfoEntryIndices,
+ const uint32_t* pBufferInfoEntryIndices, const uint32_t* pBufferViewEntryIndices,
+ const VkDescriptorImageInfo* pImageInfos, const VkDescriptorBufferInfo* pBufferInfos,
+ const VkBufferView* pBufferViews, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkUpdateDescriptorSetWithTemplateSizedGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkUpdateDescriptorSetWithTemplateSizedGOOGLE(device:%p, descriptorSet:%p, "
+ "descriptorUpdateTemplate:%p, imageInfoCount:%d, bufferInfoCount:%d, bufferViewCount:%d, "
+ "pImageInfoEntryIndices:%p, pBufferInfoEntryIndices:%p, pBufferViewEntryIndices:%p, "
+ "pImageInfos:%p, pBufferInfos:%p, pBufferViews:%p)",
+ device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount,
+ bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices,
+ pImageInfos, pBufferInfos, pBufferViews);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -37263,37 +52791,35 @@
// Avoiding deepcopy for pBufferViewEntryIndices
local_pBufferViewEntryIndices = (uint32_t*)pBufferViewEntryIndices;
local_pImageInfos = nullptr;
- if (pImageInfos)
- {
- local_pImageInfos = (VkDescriptorImageInfo*)pool->alloc(((imageInfoCount)) * sizeof(const VkDescriptorImageInfo));
- for (uint32_t i = 0; i < (uint32_t)((imageInfoCount)); ++i)
- {
- deepcopy_VkDescriptorImageInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImageInfos + i, (VkDescriptorImageInfo*)(local_pImageInfos + i));
+ if (pImageInfos) {
+ local_pImageInfos = (VkDescriptorImageInfo*)pool->alloc(
+ ((imageInfoCount)) * sizeof(const VkDescriptorImageInfo));
+ for (uint32_t i = 0; i < (uint32_t)((imageInfoCount)); ++i) {
+ deepcopy_VkDescriptorImageInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pImageInfos + i,
+ (VkDescriptorImageInfo*)(local_pImageInfos + i));
}
}
local_pBufferInfos = nullptr;
- if (pBufferInfos)
- {
- local_pBufferInfos = (VkDescriptorBufferInfo*)pool->alloc(((bufferInfoCount)) * sizeof(const VkDescriptorBufferInfo));
- for (uint32_t i = 0; i < (uint32_t)((bufferInfoCount)); ++i)
- {
- deepcopy_VkDescriptorBufferInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBufferInfos + i, (VkDescriptorBufferInfo*)(local_pBufferInfos + i));
+ if (pBufferInfos) {
+ local_pBufferInfos = (VkDescriptorBufferInfo*)pool->alloc(
+ ((bufferInfoCount)) * sizeof(const VkDescriptorBufferInfo));
+ for (uint32_t i = 0; i < (uint32_t)((bufferInfoCount)); ++i) {
+ deepcopy_VkDescriptorBufferInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBufferInfos + i,
+ (VkDescriptorBufferInfo*)(local_pBufferInfos + i));
}
}
// Avoiding deepcopy for pBufferViews
local_pBufferViews = (VkBufferView*)pBufferViews;
- if (local_pImageInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((imageInfoCount)); ++i)
- {
- transform_tohost_VkDescriptorImageInfo(sResourceTracker, (VkDescriptorImageInfo*)(local_pImageInfos + i));
+ if (local_pImageInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((imageInfoCount)); ++i) {
+ transform_tohost_VkDescriptorImageInfo(sResourceTracker,
+ (VkDescriptorImageInfo*)(local_pImageInfos + i));
}
}
- if (local_pBufferInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((bufferInfoCount)); ++i)
- {
- transform_tohost_VkDescriptorBufferInfo(sResourceTracker, (VkDescriptorBufferInfo*)(local_pBufferInfos + i));
+ if (local_pBufferInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((bufferInfoCount)); ++i) {
+ transform_tohost_VkDescriptorBufferInfo(
+ sResourceTracker, (VkDescriptorBufferInfo*)(local_pBufferInfos + i));
}
}
size_t count = 0;
@@ -37310,58 +52836,64 @@
*countPtr += sizeof(uint32_t);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pImageInfoEntryIndices)
- {
+ if (local_pImageInfoEntryIndices) {
*countPtr += ((imageInfoCount)) * sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pBufferInfoEntryIndices)
- {
+ if (local_pBufferInfoEntryIndices) {
*countPtr += ((bufferInfoCount)) * sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pBufferViewEntryIndices)
- {
+ if (local_pBufferViewEntryIndices) {
*countPtr += ((bufferViewCount)) * sizeof(uint32_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pImageInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((imageInfoCount)); ++i)
- {
- count_VkDescriptorImageInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorImageInfo*)(local_pImageInfos + i), countPtr);
+ if (local_pImageInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((imageInfoCount)); ++i) {
+ count_VkDescriptorImageInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorImageInfo*)(local_pImageInfos + i),
+ countPtr);
}
}
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pBufferInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((bufferInfoCount)); ++i)
- {
- count_VkDescriptorBufferInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorBufferInfo*)(local_pBufferInfos + i), countPtr);
+ if (local_pBufferInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((bufferInfoCount)); ++i) {
+ count_VkDescriptorBufferInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorBufferInfo*)(local_pBufferInfos + i),
+ countPtr);
}
}
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pBufferViews)
- {
- if (((bufferViewCount)))
- {
+ if (local_pBufferViews) {
+ if (((bufferViewCount))) {
*countPtr += ((bufferViewCount)) * 8;
}
}
}
- uint32_t packetSize_vkUpdateDescriptorSetWithTemplateSizedGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkUpdateDescriptorSetWithTemplateSizedGOOGLE =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkUpdateDescriptorSetWithTemplateSizedGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkUpdateDescriptorSetWithTemplateSizedGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkUpdateDescriptorSetWithTemplateSizedGOOGLE = OP_vkUpdateDescriptorSetWithTemplateSizedGOOGLE;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkUpdateDescriptorSetWithTemplateSizedGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkUpdateDescriptorSetWithTemplateSizedGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkUpdateDescriptorSetWithTemplateSizedGOOGLE =
+ OP_vkUpdateDescriptorSetWithTemplateSizedGOOGLE;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkUpdateDescriptorSetWithTemplateSizedGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkUpdateDescriptorSetWithTemplateSizedGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -37385,9 +52917,9 @@
memcpy((*streamPtrPtr), &cgen_var_3, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pImageInfoEntryIndices)
- {
- memcpy(*streamPtrPtr, (uint32_t*)local_pImageInfoEntryIndices, ((imageInfoCount)) * sizeof(uint32_t));
+ if (local_pImageInfoEntryIndices) {
+ memcpy(*streamPtrPtr, (uint32_t*)local_pImageInfoEntryIndices,
+ ((imageInfoCount)) * sizeof(uint32_t));
*streamPtrPtr += ((imageInfoCount)) * sizeof(uint32_t);
}
// WARNING PTR CHECK
@@ -37395,9 +52927,9 @@
memcpy((*streamPtrPtr), &cgen_var_4, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pBufferInfoEntryIndices)
- {
- memcpy(*streamPtrPtr, (uint32_t*)local_pBufferInfoEntryIndices, ((bufferInfoCount)) * sizeof(uint32_t));
+ if (local_pBufferInfoEntryIndices) {
+ memcpy(*streamPtrPtr, (uint32_t*)local_pBufferInfoEntryIndices,
+ ((bufferInfoCount)) * sizeof(uint32_t));
*streamPtrPtr += ((bufferInfoCount)) * sizeof(uint32_t);
}
// WARNING PTR CHECK
@@ -37405,9 +52937,9 @@
memcpy((*streamPtrPtr), &cgen_var_5, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pBufferViewEntryIndices)
- {
- memcpy(*streamPtrPtr, (uint32_t*)local_pBufferViewEntryIndices, ((bufferViewCount)) * sizeof(uint32_t));
+ if (local_pBufferViewEntryIndices) {
+ memcpy(*streamPtrPtr, (uint32_t*)local_pBufferViewEntryIndices,
+ ((bufferViewCount)) * sizeof(uint32_t));
*streamPtrPtr += ((bufferViewCount)) * sizeof(uint32_t);
}
// WARNING PTR CHECK
@@ -37415,11 +52947,11 @@
memcpy((*streamPtrPtr), &cgen_var_6, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pImageInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((imageInfoCount)); ++i)
- {
- reservedmarshal_VkDescriptorImageInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorImageInfo*)(local_pImageInfos + i), streamPtrPtr);
+ if (local_pImageInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((imageInfoCount)); ++i) {
+ reservedmarshal_VkDescriptorImageInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorImageInfo*)(local_pImageInfos + i),
+ streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -37427,11 +52959,11 @@
memcpy((*streamPtrPtr), &cgen_var_7, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pBufferInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((bufferInfoCount)); ++i)
- {
- reservedmarshal_VkDescriptorBufferInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkDescriptorBufferInfo*)(local_pBufferInfos + i), streamPtrPtr);
+ if (local_pBufferInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((bufferInfoCount)); ++i) {
+ reservedmarshal_VkDescriptorBufferInfo(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDescriptorBufferInfo*)(local_pBufferInfos + i), streamPtrPtr);
}
}
// WARNING PTR CHECK
@@ -37439,13 +52971,10 @@
memcpy((*streamPtrPtr), &cgen_var_8, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pBufferViews)
- {
- if (((bufferViewCount)))
- {
+ if (local_pBufferViews) {
+ if (((bufferViewCount))) {
uint8_t* cgen_var_8_0_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((bufferViewCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((bufferViewCount)); ++k) {
uint64_t tmpval = get_host_u64_VkBufferView(local_pBufferViews[k]);
memcpy(cgen_var_8_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -37453,22 +52982,45 @@
}
}
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkBeginCommandBufferAsyncGOOGLE(
- VkCommandBuffer commandBuffer,
- const VkCommandBufferBeginInfo* pBeginInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkBeginCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkBeginCommandBufferAsyncGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkBeginCommandBufferAsyncGOOGLE(commandBuffer:%p, pBeginInfo:%p)",
+ commandBuffer, pBeginInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -37476,52 +53028,80 @@
VkCommandBufferBeginInfo* local_pBeginInfo;
local_commandBuffer = commandBuffer;
local_pBeginInfo = nullptr;
- if (pBeginInfo)
- {
- local_pBeginInfo = (VkCommandBufferBeginInfo*)pool->alloc(sizeof(const VkCommandBufferBeginInfo));
- deepcopy_VkCommandBufferBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBeginInfo, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
+ if (pBeginInfo) {
+ local_pBeginInfo =
+ (VkCommandBufferBeginInfo*)pool->alloc(sizeof(const VkCommandBufferBeginInfo));
+ deepcopy_VkCommandBufferBeginInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBeginInfo,
+ (VkCommandBufferBeginInfo*)(local_pBeginInfo));
}
- if (local_pBeginInfo)
- {
- transform_tohost_VkCommandBufferBeginInfo(sResourceTracker, (VkCommandBufferBeginInfo*)(local_pBeginInfo));
+ if (local_pBeginInfo) {
+ transform_tohost_VkCommandBufferBeginInfo(sResourceTracker,
+ (VkCommandBufferBeginInfo*)(local_pBeginInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCommandBufferBeginInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCommandBufferBeginInfo*)(local_pBeginInfo), countPtr);
+ count_VkCommandBufferBeginInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCommandBufferBeginInfo*)(local_pBeginInfo), countPtr);
}
uint32_t packetSize_vkBeginCommandBufferAsyncGOOGLE = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkBeginCommandBufferAsyncGOOGLE);
if (queueSubmitWithCommandsEnabled) packetSize_vkBeginCommandBufferAsyncGOOGLE -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkBeginCommandBufferAsyncGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkBeginCommandBufferAsyncGOOGLE = OP_vkBeginCommandBufferAsyncGOOGLE;
- memcpy(streamPtr, &opcode_vkBeginCommandBufferAsyncGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkBeginCommandBufferAsyncGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkBeginCommandBufferAsyncGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkBeginCommandBufferAsyncGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkCommandBufferBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCommandBufferBeginInfo*)(local_pBeginInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkCommandBufferBeginInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCommandBufferBeginInfo*)(local_pBeginInfo),
+ streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkEndCommandBufferAsyncGOOGLE(
- VkCommandBuffer commandBuffer,
- uint32_t doLock)
-{
+void VkEncoder::vkEndCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkEndCommandBufferAsyncGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkEndCommandBufferAsyncGOOGLE(commandBuffer:%p)", commandBuffer);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -37534,36 +53114,61 @@
*countPtr += 1 * 8;
}
uint32_t packetSize_vkEndCommandBufferAsyncGOOGLE = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkEndCommandBufferAsyncGOOGLE);
if (queueSubmitWithCommandsEnabled) packetSize_vkEndCommandBufferAsyncGOOGLE -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkEndCommandBufferAsyncGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkEndCommandBufferAsyncGOOGLE = OP_vkEndCommandBufferAsyncGOOGLE;
- memcpy(streamPtr, &opcode_vkEndCommandBufferAsyncGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkEndCommandBufferAsyncGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkEndCommandBufferAsyncGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkEndCommandBufferAsyncGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkResetCommandBufferAsyncGOOGLE(
- VkCommandBuffer commandBuffer,
- VkCommandBufferResetFlags flags,
- uint32_t doLock)
-{
+void VkEncoder::vkResetCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkResetCommandBufferAsyncGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkResetCommandBufferAsyncGOOGLE(commandBuffer:%p, flags:%d)", commandBuffer,
+ flags);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -37579,38 +53184,64 @@
*countPtr += sizeof(VkCommandBufferResetFlags);
}
uint32_t packetSize_vkResetCommandBufferAsyncGOOGLE = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkResetCommandBufferAsyncGOOGLE);
if (queueSubmitWithCommandsEnabled) packetSize_vkResetCommandBufferAsyncGOOGLE -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkResetCommandBufferAsyncGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkResetCommandBufferAsyncGOOGLE = OP_vkResetCommandBufferAsyncGOOGLE;
- memcpy(streamPtr, &opcode_vkResetCommandBufferAsyncGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkResetCommandBufferAsyncGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkResetCommandBufferAsyncGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkResetCommandBufferAsyncGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- memcpy(*streamPtrPtr, (VkCommandBufferResetFlags*)&local_flags, sizeof(VkCommandBufferResetFlags));
+ memcpy(*streamPtrPtr, (VkCommandBufferResetFlags*)&local_flags,
+ sizeof(VkCommandBufferResetFlags));
*streamPtrPtr += sizeof(VkCommandBufferResetFlags);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCommandBufferHostSyncGOOGLE(
- VkCommandBuffer commandBuffer,
- uint32_t needHostSync,
- uint32_t sequenceNumber,
- uint32_t doLock)
-{
+void VkEncoder::vkCommandBufferHostSyncGOOGLE(VkCommandBuffer commandBuffer, uint32_t needHostSync,
+ uint32_t sequenceNumber, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCommandBufferHostSyncGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCommandBufferHostSyncGOOGLE(commandBuffer:%p, needHostSync:%d, sequenceNumber:%d)",
+ commandBuffer, needHostSync, sequenceNumber);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -37629,14 +53260,17 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCommandBufferHostSyncGOOGLE = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCommandBufferHostSyncGOOGLE);
if (queueSubmitWithCommandsEnabled) packetSize_vkCommandBufferHostSyncGOOGLE -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCommandBufferHostSyncGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCommandBufferHostSyncGOOGLE = OP_vkCommandBufferHostSyncGOOGLE;
- memcpy(streamPtr, &opcode_vkCommandBufferHostSyncGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCommandBufferHostSyncGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCommandBufferHostSyncGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCommandBufferHostSyncGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -37646,9 +53280,9 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_sequenceNumber, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -37656,15 +53290,33 @@
}
VkResult VkEncoder::vkCreateImageWithRequirementsGOOGLE(
- VkDevice device,
- const VkImageCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkImage* pImage,
- VkMemoryRequirements* pMemoryRequirements,
- uint32_t doLock)
-{
+ VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage, VkMemoryRequirements* pMemoryRequirements, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateImageWithRequirementsGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -37673,64 +53325,79 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
+ if (pCreateInfo) {
local_pCreateInfo = (VkImageCreateInfo*)pool->alloc(sizeof(const VkImageCreateInfo));
- deepcopy_VkImageCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkImageCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkImageCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkImageCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
sResourceTracker->unwrap_VkNativeBufferANDROID(pCreateInfo, local_pCreateInfo);
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkImageCreateInfo(sResourceTracker, (VkImageCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ sResourceTracker->transformImpl_VkImageCreateInfo_tohost(local_pCreateInfo, 1);
+ transform_tohost_VkImageCreateInfo(sResourceTracker,
+ (VkImageCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImageCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkImageCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
- count_VkMemoryRequirements(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements*)(pMemoryRequirements), countPtr);
+ count_VkMemoryRequirements(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements*)(pMemoryRequirements), countPtr);
}
- uint32_t packetSize_vkCreateImageWithRequirementsGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateImageWithRequirementsGOOGLE =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCreateImageWithRequirementsGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateImageWithRequirementsGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateImageWithRequirementsGOOGLE = OP_vkCreateImageWithRequirementsGOOGLE;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateImageWithRequirementsGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateImageWithRequirementsGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateImageWithRequirementsGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateImageWithRequirementsGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkImageCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageCreateInfo*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -37738,22 +53405,25 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- reservedmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements*)(pMemoryRequirements), streamPtrPtr);
+ reservedmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements*)(pMemoryRequirements),
+ streamPtrPtr);
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
stream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_3, (VkImage*)pImage, 1);
stream->unsetHandleMapping();
- unmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements*)(pMemoryRequirements));
- if (pMemoryRequirements)
- {
- transform_fromhost_VkMemoryRequirements(sResourceTracker, (VkMemoryRequirements*)(pMemoryRequirements));
+ unmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements*)(pMemoryRequirements));
+ if (pMemoryRequirements) {
+ transform_fromhost_VkMemoryRequirements(sResourceTracker,
+ (VkMemoryRequirements*)(pMemoryRequirements));
}
VkResult vkCreateImageWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
stream->read(&vkCreateImageWithRequirementsGOOGLE_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -37762,15 +53432,37 @@
}
VkResult VkEncoder::vkCreateBufferWithRequirementsGOOGLE(
- VkDevice device,
- const VkBufferCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkBuffer* pBuffer,
- VkMemoryRequirements* pMemoryRequirements,
- uint32_t doLock)
-{
+ VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer, VkMemoryRequirements* pMemoryRequirements, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateBufferWithRequirementsGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateBufferWithRequirementsGOOGLE(device:%p, pCreateInfo:%p, pAllocator:%p, "
+ "pBuffer:%p, pMemoryRequirements:%p)",
+ device, pCreateInfo, pAllocator, pBuffer, pMemoryRequirements);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -37779,63 +53471,77 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
+ if (pCreateInfo) {
local_pCreateInfo = (VkBufferCreateInfo*)pool->alloc(sizeof(const VkBufferCreateInfo));
- deepcopy_VkBufferCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkBufferCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkBufferCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkBufferCreateInfo*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkBufferCreateInfo(sResourceTracker, (VkBufferCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkBufferCreateInfo(sResourceTracker,
+ (VkBufferCreateInfo*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkBufferCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkBufferCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferCreateInfo*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
- count_VkMemoryRequirements(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements*)(pMemoryRequirements), countPtr);
+ count_VkMemoryRequirements(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements*)(pMemoryRequirements), countPtr);
}
- uint32_t packetSize_vkCreateBufferWithRequirementsGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateBufferWithRequirementsGOOGLE =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCreateBufferWithRequirementsGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateBufferWithRequirementsGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateBufferWithRequirementsGOOGLE = OP_vkCreateBufferWithRequirementsGOOGLE;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateBufferWithRequirementsGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateBufferWithRequirementsGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateBufferWithRequirementsGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateBufferWithRequirementsGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkBufferCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBufferCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkBufferCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBufferCreateInfo*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -37843,22 +53549,25 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 8);
*streamPtrPtr += 8;
/* is handle, possibly out */;
- reservedmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements*)(pMemoryRequirements), streamPtrPtr);
+ reservedmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements*)(pMemoryRequirements),
+ streamPtrPtr);
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
stream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_3, (VkBuffer*)pBuffer, 1);
stream->unsetHandleMapping();
- unmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMemoryRequirements*)(pMemoryRequirements));
- if (pMemoryRequirements)
- {
- transform_fromhost_VkMemoryRequirements(sResourceTracker, (VkMemoryRequirements*)(pMemoryRequirements));
+ unmarshal_VkMemoryRequirements(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryRequirements*)(pMemoryRequirements));
+ if (pMemoryRequirements) {
+ transform_fromhost_VkMemoryRequirements(sResourceTracker,
+ (VkMemoryRequirements*)(pMemoryRequirements));
}
VkResult vkCreateBufferWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
stream->read(&vkCreateBufferWithRequirementsGOOGLE_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -37866,16 +53575,38 @@
return vkCreateBufferWithRequirementsGOOGLE_VkResult_return;
}
-VkResult VkEncoder::vkGetMemoryHostAddressInfoGOOGLE(
- VkDevice device,
- VkDeviceMemory memory,
- uint64_t* pAddress,
- uint64_t* pSize,
- uint64_t* pHostmemId,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkGetMemoryHostAddressInfoGOOGLE(VkDevice device, VkDeviceMemory memory,
+ uint64_t* pAddress, uint64_t* pSize,
+ uint64_t* pHostmemId, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetMemoryHostAddressInfoGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetMemoryHostAddressInfoGOOGLE(device:%p, memory:%p, pAddress:%p, pSize:%p, "
+ "pHostmemId:%p)",
+ device, memory, pAddress, pSize, pHostmemId);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -37883,7 +53614,9 @@
VkDeviceMemory local_memory;
local_device = device;
local_memory = memory;
- sResourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ sResourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0,
+ (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
size_t count = 0;
size_t* countPtr = &count;
{
@@ -37893,31 +53626,38 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (pAddress)
- {
+ if (pAddress) {
*countPtr += sizeof(uint64_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pSize)
- {
+ if (pSize) {
*countPtr += sizeof(uint64_t);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (pHostmemId)
- {
+ if (pHostmemId) {
*countPtr += sizeof(uint64_t);
}
}
- uint32_t packetSize_vkGetMemoryHostAddressInfoGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetMemoryHostAddressInfoGOOGLE =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetMemoryHostAddressInfoGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetMemoryHostAddressInfoGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetMemoryHostAddressInfoGOOGLE = OP_vkGetMemoryHostAddressInfoGOOGLE;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetMemoryHostAddressInfoGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetMemoryHostAddressInfoGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetMemoryHostAddressInfoGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetMemoryHostAddressInfoGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -37931,8 +53671,7 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pAddress)
- {
+ if (pAddress) {
memcpy(*streamPtrPtr, (uint64_t*)pAddress, sizeof(uint64_t));
*streamPtrPtr += sizeof(uint64_t);
}
@@ -37941,8 +53680,7 @@
memcpy((*streamPtrPtr), &cgen_var_3, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pSize)
- {
+ if (pSize) {
memcpy(*streamPtrPtr, (uint64_t*)pSize, sizeof(uint64_t));
*streamPtrPtr += sizeof(uint64_t);
}
@@ -37951,18 +53689,15 @@
memcpy((*streamPtrPtr), &cgen_var_4, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pHostmemId)
- {
+ if (pHostmemId) {
memcpy(*streamPtrPtr, (uint64_t*)pHostmemId, sizeof(uint64_t));
*streamPtrPtr += sizeof(uint64_t);
}
// WARNING PTR CHECK
uint64_t* check_pAddress;
check_pAddress = (uint64_t*)(uintptr_t)stream->getBe64();
- if (pAddress)
- {
- if (!(check_pAddress))
- {
+ if (pAddress) {
+ if (!(check_pAddress)) {
fprintf(stderr, "fatal: pAddress inconsistent between guest and host\n");
}
stream->read((uint64_t*)pAddress, sizeof(uint64_t));
@@ -37970,10 +53705,8 @@
// WARNING PTR CHECK
uint64_t* check_pSize;
check_pSize = (uint64_t*)(uintptr_t)stream->getBe64();
- if (pSize)
- {
- if (!(check_pSize))
- {
+ if (pSize) {
+ if (!(check_pSize)) {
fprintf(stderr, "fatal: pSize inconsistent between guest and host\n");
}
stream->read((uint64_t*)pSize, sizeof(uint64_t));
@@ -37981,19 +53714,17 @@
// WARNING PTR CHECK
uint64_t* check_pHostmemId;
check_pHostmemId = (uint64_t*)(uintptr_t)stream->getBe64();
- if (pHostmemId)
- {
- if (!(check_pHostmemId))
- {
+ if (pHostmemId) {
+ if (!(check_pHostmemId)) {
fprintf(stderr, "fatal: pHostmemId inconsistent between guest and host\n");
}
stream->read((uint64_t*)pHostmemId, sizeof(uint64_t));
}
VkResult vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = (VkResult)0;
stream->read(&vkGetMemoryHostAddressInfoGOOGLE_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -38001,14 +53732,36 @@
return vkGetMemoryHostAddressInfoGOOGLE_VkResult_return;
}
-VkResult VkEncoder::vkFreeMemorySyncGOOGLE(
- VkDevice device,
- VkDeviceMemory memory,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkFreeMemorySyncGOOGLE(VkDevice device, VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkFreeMemorySyncGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkFreeMemorySyncGOOGLE(device:%p, memory:%p, pAllocator:%p)", device, memory,
+ pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -38018,13 +53771,15 @@
local_device = device;
local_memory = memory;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- sResourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ sResourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)&local_memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0,
+ (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
size_t count = 0;
size_t* countPtr = &count;
{
@@ -38034,19 +53789,28 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkFreeMemorySyncGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkFreeMemorySyncGOOGLE =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkFreeMemorySyncGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkFreeMemorySyncGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkFreeMemorySyncGOOGLE = OP_vkFreeMemorySyncGOOGLE;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkFreeMemorySyncGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkFreeMemorySyncGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkFreeMemorySyncGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkFreeMemorySyncGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -38060,16 +53824,17 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
VkResult vkFreeMemorySyncGOOGLE_VkResult_return = (VkResult)0;
stream->read(&vkFreeMemorySyncGOOGLE_VkResult_return, sizeof(VkResult));
sResourceTracker->destroyMapping()->mapHandles_VkDeviceMemory((VkDeviceMemory*)&memory);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -38077,14 +53842,35 @@
return vkFreeMemorySyncGOOGLE_VkResult_return;
}
-void VkEncoder::vkQueueHostSyncGOOGLE(
- VkQueue queue,
- uint32_t needHostSync,
- uint32_t sequenceNumber,
- uint32_t doLock)
-{
+void VkEncoder::vkQueueHostSyncGOOGLE(VkQueue queue, uint32_t needHostSync, uint32_t sequenceNumber,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkQueueHostSyncGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkQueueHostSyncGOOGLE(queue:%p, needHostSync:%d, sequenceNumber:%d)", queue,
+ needHostSync, sequenceNumber);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -38102,14 +53888,23 @@
*countPtr += sizeof(uint32_t);
*countPtr += sizeof(uint32_t);
}
- uint32_t packetSize_vkQueueHostSyncGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkQueueHostSyncGOOGLE =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkQueueHostSyncGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueHostSyncGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueHostSyncGOOGLE = OP_vkQueueHostSyncGOOGLE;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkQueueHostSyncGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkQueueHostSyncGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkQueueHostSyncGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkQueueHostSyncGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -38119,24 +53914,45 @@
memcpy(*streamPtrPtr, (uint32_t*)&local_sequenceNumber, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkQueueSubmitAsyncGOOGLE(
- VkQueue queue,
- uint32_t submitCount,
- const VkSubmitInfo* pSubmits,
- VkFence fence,
- uint32_t doLock)
-{
+void VkEncoder::vkQueueSubmitAsyncGOOGLE(VkQueue queue, uint32_t submitCount,
+ const VkSubmitInfo* pSubmits, VkFence fence,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkQueueSubmitAsyncGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkQueueSubmitAsyncGOOGLE(queue:%p, submitCount:%d, pSubmits:%p, fence:%p)",
+ queue, submitCount, pSubmits, fence);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -38147,19 +53963,16 @@
local_queue = queue;
local_submitCount = submitCount;
local_pSubmits = nullptr;
- if (pSubmits)
- {
+ if (pSubmits) {
local_pSubmits = (VkSubmitInfo*)pool->alloc(((submitCount)) * sizeof(const VkSubmitInfo));
- for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
- {
- deepcopy_VkSubmitInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubmits + i, (VkSubmitInfo*)(local_pSubmits + i));
+ for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
+ deepcopy_VkSubmitInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pSubmits + i,
+ (VkSubmitInfo*)(local_pSubmits + i));
}
}
local_fence = fence;
- if (local_pSubmits)
- {
- for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
- {
+ if (local_pSubmits) {
+ for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
transform_tohost_VkSubmitInfo(sResourceTracker, (VkSubmitInfo*)(local_pSubmits + i));
}
}
@@ -38169,51 +53982,81 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
- {
- count_VkSubmitInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubmitInfo*)(local_pSubmits + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
+ count_VkSubmitInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubmitInfo*)(local_pSubmits + i), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 1 * 8;
}
- uint32_t packetSize_vkQueueSubmitAsyncGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkQueueSubmitAsyncGOOGLE =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkQueueSubmitAsyncGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueSubmitAsyncGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueSubmitAsyncGOOGLE = OP_vkQueueSubmitAsyncGOOGLE;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkQueueSubmitAsyncGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkQueueSubmitAsyncGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkQueueSubmitAsyncGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkQueueSubmitAsyncGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_submitCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i)
- {
- reservedmarshal_VkSubmitInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkSubmitInfo*)(local_pSubmits + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
+ reservedmarshal_VkSubmitInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkSubmitInfo*)(local_pSubmits + i), streamPtrPtr);
}
uint64_t cgen_var_1;
*&cgen_var_1 = get_host_u64_VkFence((*&local_fence));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkQueueWaitIdleAsyncGOOGLE(
- VkQueue queue,
- uint32_t doLock)
-{
+void VkEncoder::vkQueueWaitIdleAsyncGOOGLE(VkQueue queue, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkQueueWaitIdleAsyncGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkQueueWaitIdleAsyncGOOGLE(queue:%p)", queue);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -38225,37 +54068,68 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
}
- uint32_t packetSize_vkQueueWaitIdleAsyncGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkQueueWaitIdleAsyncGOOGLE =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkQueueWaitIdleAsyncGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueWaitIdleAsyncGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueWaitIdleAsyncGOOGLE = OP_vkQueueWaitIdleAsyncGOOGLE;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkQueueWaitIdleAsyncGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkQueueWaitIdleAsyncGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkQueueWaitIdleAsyncGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkQueueWaitIdleAsyncGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkQueueBindSparseAsyncGOOGLE(
- VkQueue queue,
- uint32_t bindInfoCount,
- const VkBindSparseInfo* pBindInfo,
- VkFence fence,
- uint32_t doLock)
-{
+void VkEncoder::vkQueueBindSparseAsyncGOOGLE(VkQueue queue, uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo, VkFence fence,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkQueueBindSparseAsyncGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkQueueBindSparseAsyncGOOGLE(queue:%p, bindInfoCount:%d, pBindInfo:%p, fence:%p)", queue,
+ bindInfoCount, pBindInfo, fence);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -38266,20 +54140,19 @@
local_queue = queue;
local_bindInfoCount = bindInfoCount;
local_pBindInfo = nullptr;
- if (pBindInfo)
- {
- local_pBindInfo = (VkBindSparseInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindSparseInfo));
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- deepcopy_VkBindSparseInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfo + i, (VkBindSparseInfo*)(local_pBindInfo + i));
+ if (pBindInfo) {
+ local_pBindInfo =
+ (VkBindSparseInfo*)pool->alloc(((bindInfoCount)) * sizeof(const VkBindSparseInfo));
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ deepcopy_VkBindSparseInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBindInfo + i,
+ (VkBindSparseInfo*)(local_pBindInfo + i));
}
}
local_fence = fence;
- if (local_pBindInfo)
- {
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- transform_tohost_VkBindSparseInfo(sResourceTracker, (VkBindSparseInfo*)(local_pBindInfo + i));
+ if (local_pBindInfo) {
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ transform_tohost_VkBindSparseInfo(sResourceTracker,
+ (VkBindSparseInfo*)(local_pBindInfo + i));
}
}
size_t count = 0;
@@ -38288,54 +54161,86 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- count_VkBindSparseInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindSparseInfo*)(local_pBindInfo + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ count_VkBindSparseInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBindSparseInfo*)(local_pBindInfo + i), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 1 * 8;
}
- uint32_t packetSize_vkQueueBindSparseAsyncGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkQueueBindSparseAsyncGOOGLE =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkQueueBindSparseAsyncGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueBindSparseAsyncGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkQueueBindSparseAsyncGOOGLE = OP_vkQueueBindSparseAsyncGOOGLE;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkQueueBindSparseAsyncGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkQueueBindSparseAsyncGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkQueueBindSparseAsyncGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkQueueBindSparseAsyncGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_bindInfoCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i)
- {
- reservedmarshal_VkBindSparseInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkBindSparseInfo*)(local_pBindInfo + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((bindInfoCount)); ++i) {
+ reservedmarshal_VkBindSparseInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkBindSparseInfo*)(local_pBindInfo + i), streamPtrPtr);
}
uint64_t cgen_var_1;
*&cgen_var_1 = get_host_u64_VkFence((*&local_fence));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_1, 1 * 8);
*streamPtrPtr += 1 * 8;
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkGetLinearImageLayoutGOOGLE(
- VkDevice device,
- VkFormat format,
- VkDeviceSize* pOffset,
- VkDeviceSize* pRowPitchAlignment,
- uint32_t doLock)
-{
+void VkEncoder::vkGetLinearImageLayoutGOOGLE(VkDevice device, VkFormat format,
+ VkDeviceSize* pOffset,
+ VkDeviceSize* pRowPitchAlignment, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetLinearImageLayoutGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetLinearImageLayoutGOOGLE(device:%p, format:%d, pOffset:%p, pRowPitchAlignment:%p)",
+ device, format, pOffset, pRowPitchAlignment);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -38352,14 +54257,24 @@
*countPtr += sizeof(VkDeviceSize);
*countPtr += sizeof(VkDeviceSize);
}
- uint32_t packetSize_vkGetLinearImageLayoutGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetLinearImageLayoutGOOGLE =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetLinearImageLayoutGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetLinearImageLayoutGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetLinearImageLayoutGOOGLE = OP_vkGetLinearImageLayoutGOOGLE;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetLinearImageLayoutGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetLinearImageLayoutGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetLinearImageLayoutGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetLinearImageLayoutGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -38372,24 +54287,47 @@
*streamPtrPtr += sizeof(VkDeviceSize);
stream->read((VkDeviceSize*)pOffset, sizeof(VkDeviceSize));
stream->read((VkDeviceSize*)pRowPitchAlignment, sizeof(VkDeviceSize));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkGetLinearImageLayout2GOOGLE(
- VkDevice device,
- const VkImageCreateInfo* pCreateInfo,
- VkDeviceSize* pOffset,
- VkDeviceSize* pRowPitchAlignment,
- uint32_t doLock)
-{
+void VkEncoder::vkGetLinearImageLayout2GOOGLE(VkDevice device, const VkImageCreateInfo* pCreateInfo,
+ VkDeviceSize* pOffset,
+ VkDeviceSize* pRowPitchAlignment, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkGetLinearImageLayout2GOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetLinearImageLayout2GOOGLE(device:%p, pCreateInfo:%p, pOffset:%p, "
+ "pRowPitchAlignment:%p)",
+ device, pCreateInfo, pOffset, pRowPitchAlignment);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -38397,78 +54335,135 @@
VkImageCreateInfo* local_pCreateInfo;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
+ if (pCreateInfo) {
local_pCreateInfo = (VkImageCreateInfo*)pool->alloc(sizeof(const VkImageCreateInfo));
- deepcopy_VkImageCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkImageCreateInfo*)(local_pCreateInfo));
+ deepcopy_VkImageCreateInfo(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkImageCreateInfo*)(local_pCreateInfo));
}
- if (local_pCreateInfo)
- {
- transform_tohost_VkImageCreateInfo(sResourceTracker, (VkImageCreateInfo*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ sResourceTracker->transformImpl_VkImageCreateInfo_tohost(local_pCreateInfo, 1);
+ transform_tohost_VkImageCreateInfo(sResourceTracker,
+ (VkImageCreateInfo*)(local_pCreateInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkImageCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageCreateInfo*)(local_pCreateInfo), countPtr);
+ count_VkImageCreateInfo(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageCreateInfo*)(local_pCreateInfo), countPtr);
*countPtr += sizeof(VkDeviceSize);
*countPtr += sizeof(VkDeviceSize);
}
- uint32_t packetSize_vkGetLinearImageLayout2GOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetLinearImageLayout2GOOGLE =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetLinearImageLayout2GOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetLinearImageLayout2GOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkGetLinearImageLayout2GOOGLE = OP_vkGetLinearImageLayout2GOOGLE;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetLinearImageLayout2GOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetLinearImageLayout2GOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetLinearImageLayout2GOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetLinearImageLayout2GOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkImageCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkImageCreateInfo*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkImageCreateInfo(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkImageCreateInfo*)(local_pCreateInfo), streamPtrPtr);
memcpy(*streamPtrPtr, (VkDeviceSize*)pOffset, sizeof(VkDeviceSize));
*streamPtrPtr += sizeof(VkDeviceSize);
memcpy(*streamPtrPtr, (VkDeviceSize*)pRowPitchAlignment, sizeof(VkDeviceSize));
*streamPtrPtr += sizeof(VkDeviceSize);
stream->read((VkDeviceSize*)pOffset, sizeof(VkDeviceSize));
stream->read((VkDeviceSize*)pRowPitchAlignment, sizeof(VkDeviceSize));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkQueueFlushCommandsGOOGLE(
- VkQueue queue,
- VkCommandBuffer commandBuffer,
- VkDeviceSize dataSize,
- const void* pData,
- uint32_t doLock)
-{
- #include "vkQueueFlushCommandsGOOGLE_encode_impl.cpp.inl"
+void VkEncoder::vkQueueFlushCommandsGOOGLE(VkQueue queue, VkCommandBuffer commandBuffer,
+ VkDeviceSize dataSize, const void* pData,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkQueueFlushCommandsGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+#include "vkQueueFlushCommandsGOOGLE_encode_impl.cpp.inl"
}
void VkEncoder::vkQueueCommitDescriptorSetUpdatesGOOGLE(
- VkQueue queue,
- uint32_t descriptorPoolCount,
- const VkDescriptorPool* pDescriptorPools,
- uint32_t descriptorSetCount,
- const VkDescriptorSetLayout* pSetLayouts,
- const uint64_t* pDescriptorSetPoolIds,
- const uint32_t* pDescriptorSetWhichPool,
+ VkQueue queue, uint32_t descriptorPoolCount, const VkDescriptorPool* pDescriptorPools,
+ uint32_t descriptorSetCount, const VkDescriptorSetLayout* pSetLayouts,
+ const uint64_t* pDescriptorSetPoolIds, const uint32_t* pDescriptorSetWhichPool,
const uint32_t* pDescriptorSetPendingAllocation,
- const uint32_t* pDescriptorWriteStartingIndices,
- uint32_t pendingDescriptorWriteCount,
- const VkWriteDescriptorSet* pPendingDescriptorWrites,
- uint32_t doLock)
-{
+ const uint32_t* pDescriptorWriteStartingIndices, uint32_t pendingDescriptorWriteCount,
+ const VkWriteDescriptorSet* pPendingDescriptorWrites, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkQueueCommitDescriptorSetUpdatesGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkQueueCommitDescriptorSetUpdatesGOOGLE(queue:%p, descriptorPoolCount:%d, "
+ "pDescriptorPools:%p, descriptorSetCount:%d, pSetLayouts:%p, pDescriptorSetPoolIds:%p, "
+ "pDescriptorSetWhichPool:%p, pDescriptorSetPendingAllocation:%p, "
+ "pDescriptorWriteStartingIndices:%p, pendingDescriptorWriteCount:%d, "
+ "pPendingDescriptorWrites:%p)",
+ queue, descriptorPoolCount, pDescriptorPools, descriptorSetCount, pSetLayouts,
+ pDescriptorSetPoolIds, pDescriptorSetWhichPool, pDescriptorSetPendingAllocation,
+ pDescriptorWriteStartingIndices, pendingDescriptorWriteCount, pPendingDescriptorWrites);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -38500,19 +54495,19 @@
local_pDescriptorWriteStartingIndices = (uint32_t*)pDescriptorWriteStartingIndices;
local_pendingDescriptorWriteCount = pendingDescriptorWriteCount;
local_pPendingDescriptorWrites = nullptr;
- if (pPendingDescriptorWrites)
- {
- local_pPendingDescriptorWrites = (VkWriteDescriptorSet*)pool->alloc(((pendingDescriptorWriteCount)) * sizeof(const VkWriteDescriptorSet));
- for (uint32_t i = 0; i < (uint32_t)((pendingDescriptorWriteCount)); ++i)
- {
- deepcopy_VkWriteDescriptorSet(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pPendingDescriptorWrites + i, (VkWriteDescriptorSet*)(local_pPendingDescriptorWrites + i));
+ if (pPendingDescriptorWrites) {
+ local_pPendingDescriptorWrites = (VkWriteDescriptorSet*)pool->alloc(
+ ((pendingDescriptorWriteCount)) * sizeof(const VkWriteDescriptorSet));
+ for (uint32_t i = 0; i < (uint32_t)((pendingDescriptorWriteCount)); ++i) {
+ deepcopy_VkWriteDescriptorSet(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pPendingDescriptorWrites + i,
+ (VkWriteDescriptorSet*)(local_pPendingDescriptorWrites + i));
}
}
- if (local_pPendingDescriptorWrites)
- {
- for (uint32_t i = 0; i < (uint32_t)((pendingDescriptorWriteCount)); ++i)
- {
- transform_tohost_VkWriteDescriptorSet(sResourceTracker, (VkWriteDescriptorSet*)(local_pPendingDescriptorWrites + i));
+ if (local_pPendingDescriptorWrites) {
+ for (uint32_t i = 0; i < (uint32_t)((pendingDescriptorWriteCount)); ++i) {
+ transform_tohost_VkWriteDescriptorSet(
+ sResourceTracker, (VkWriteDescriptorSet*)(local_pPendingDescriptorWrites + i));
}
}
size_t count = 0;
@@ -38521,13 +54516,11 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- if (((descriptorPoolCount)))
- {
+ if (((descriptorPoolCount))) {
*countPtr += ((descriptorPoolCount)) * 8;
}
*countPtr += sizeof(uint32_t);
- if (((descriptorSetCount)))
- {
+ if (((descriptorSetCount))) {
*countPtr += ((descriptorSetCount)) * 8;
}
*countPtr += ((descriptorSetCount)) * sizeof(uint64_t);
@@ -38535,30 +54528,40 @@
*countPtr += ((descriptorSetCount)) * sizeof(uint32_t);
*countPtr += ((descriptorSetCount)) * sizeof(uint32_t);
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((pendingDescriptorWriteCount)); ++i)
- {
- count_VkWriteDescriptorSet(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkWriteDescriptorSet*)(local_pPendingDescriptorWrites + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((pendingDescriptorWriteCount)); ++i) {
+ count_VkWriteDescriptorSet(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkWriteDescriptorSet*)(local_pPendingDescriptorWrites + i),
+ countPtr);
}
}
- uint32_t packetSize_vkQueueCommitDescriptorSetUpdatesGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkQueueCommitDescriptorSetUpdatesGOOGLE =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkQueueCommitDescriptorSetUpdatesGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueCommitDescriptorSetUpdatesGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkQueueCommitDescriptorSetUpdatesGOOGLE = OP_vkQueueCommitDescriptorSetUpdatesGOOGLE;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkQueueCommitDescriptorSetUpdatesGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkQueueCommitDescriptorSetUpdatesGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkQueueCommitDescriptorSetUpdatesGOOGLE =
+ OP_vkQueueCommitDescriptorSetUpdatesGOOGLE;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkQueueCommitDescriptorSetUpdatesGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkQueueCommitDescriptorSetUpdatesGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_descriptorPoolCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (((descriptorPoolCount)))
- {
+ if (((descriptorPoolCount))) {
uint8_t* cgen_var_1_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((descriptorPoolCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((descriptorPoolCount)); ++k) {
uint64_t tmpval = get_host_u64_VkDescriptorPool(local_pDescriptorPools[k]);
memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -38566,49 +54569,75 @@
}
memcpy(*streamPtrPtr, (uint32_t*)&local_descriptorSetCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (((descriptorSetCount)))
- {
+ if (((descriptorSetCount))) {
uint8_t* cgen_var_2_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((descriptorSetCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((descriptorSetCount)); ++k) {
uint64_t tmpval = get_host_u64_VkDescriptorSetLayout(local_pSetLayouts[k]);
memcpy(cgen_var_2_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
*streamPtrPtr += 8 * ((descriptorSetCount));
}
- memcpy(*streamPtrPtr, (uint64_t*)local_pDescriptorSetPoolIds, ((descriptorSetCount)) * sizeof(uint64_t));
+ memcpy(*streamPtrPtr, (uint64_t*)local_pDescriptorSetPoolIds,
+ ((descriptorSetCount)) * sizeof(uint64_t));
*streamPtrPtr += ((descriptorSetCount)) * sizeof(uint64_t);
- memcpy(*streamPtrPtr, (uint32_t*)local_pDescriptorSetWhichPool, ((descriptorSetCount)) * sizeof(uint32_t));
+ memcpy(*streamPtrPtr, (uint32_t*)local_pDescriptorSetWhichPool,
+ ((descriptorSetCount)) * sizeof(uint32_t));
*streamPtrPtr += ((descriptorSetCount)) * sizeof(uint32_t);
- memcpy(*streamPtrPtr, (uint32_t*)local_pDescriptorSetPendingAllocation, ((descriptorSetCount)) * sizeof(uint32_t));
+ memcpy(*streamPtrPtr, (uint32_t*)local_pDescriptorSetPendingAllocation,
+ ((descriptorSetCount)) * sizeof(uint32_t));
*streamPtrPtr += ((descriptorSetCount)) * sizeof(uint32_t);
- memcpy(*streamPtrPtr, (uint32_t*)local_pDescriptorWriteStartingIndices, ((descriptorSetCount)) * sizeof(uint32_t));
+ memcpy(*streamPtrPtr, (uint32_t*)local_pDescriptorWriteStartingIndices,
+ ((descriptorSetCount)) * sizeof(uint32_t));
*streamPtrPtr += ((descriptorSetCount)) * sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_pendingDescriptorWriteCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((pendingDescriptorWriteCount)); ++i)
- {
- reservedmarshal_VkWriteDescriptorSet(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkWriteDescriptorSet*)(local_pPendingDescriptorWrites + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((pendingDescriptorWriteCount)); ++i) {
+ reservedmarshal_VkWriteDescriptorSet(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkWriteDescriptorSet*)(local_pPendingDescriptorWrites + i), streamPtrPtr);
}
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCollectDescriptorPoolIdsGOOGLE(
- VkDevice device,
- VkDescriptorPool descriptorPool,
- uint32_t* pPoolIdCount,
- uint64_t* pPoolIds,
- uint32_t doLock)
-{
+void VkEncoder::vkCollectDescriptorPoolIdsGOOGLE(VkDevice device, VkDescriptorPool descriptorPool,
+ uint32_t* pPoolIdCount, uint64_t* pPoolIds,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCollectDescriptorPoolIdsGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCollectDescriptorPoolIdsGOOGLE(device:%p, descriptorPool:%p, pPoolIdCount:%p, "
+ "pPoolIds:%p)",
+ device, descriptorPool, pPoolIdCount, pPoolIds);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -38626,22 +54655,30 @@
*countPtr += sizeof(uint32_t);
// WARNING PTR CHECK
*countPtr += 8;
- if (pPoolIds)
- {
- if (pPoolIdCount)
- {
+ if (pPoolIds) {
+ if (pPoolIdCount) {
*countPtr += (*(pPoolIdCount)) * sizeof(uint64_t);
}
}
}
- uint32_t packetSize_vkCollectDescriptorPoolIdsGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCollectDescriptorPoolIdsGOOGLE =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCollectDescriptorPoolIdsGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkCollectDescriptorPoolIdsGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCollectDescriptorPoolIdsGOOGLE = OP_vkCollectDescriptorPoolIdsGOOGLE;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCollectDescriptorPoolIdsGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCollectDescriptorPoolIdsGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCollectDescriptorPoolIdsGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCollectDescriptorPoolIdsGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -38657,8 +54694,7 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (pPoolIds)
- {
+ if (pPoolIds) {
memcpy(*streamPtrPtr, (uint64_t*)pPoolIds, (*(pPoolIdCount)) * sizeof(uint64_t));
*streamPtrPtr += (*(pPoolIdCount)) * sizeof(uint64_t);
}
@@ -38666,32 +54702,55 @@
// WARNING PTR CHECK
uint64_t* check_pPoolIds;
check_pPoolIds = (uint64_t*)(uintptr_t)stream->getBe64();
- if (pPoolIds)
- {
- if (!(check_pPoolIds))
- {
+ if (pPoolIds) {
+ if (!(check_pPoolIds)) {
fprintf(stderr, "fatal: pPoolIds inconsistent between guest and host\n");
}
stream->read((uint64_t*)pPoolIds, (*(pPoolIdCount)) * sizeof(uint64_t));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(
- VkQueue queue,
- uint32_t waitSemaphoreCount,
- const VkSemaphore* pWaitSemaphores,
- VkImage image,
- uint32_t doLock)
-{
+void VkEncoder::vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(VkQueue queue,
+ uint32_t waitSemaphoreCount,
+ const VkSemaphore* pWaitSemaphores,
+ VkImage image, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(queue:%p, waitSemaphoreCount:%d, "
+ "pWaitSemaphores:%p, image:%p)",
+ queue, waitSemaphoreCount, pWaitSemaphores, image);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -38712,24 +54771,33 @@
*countPtr += sizeof(uint32_t);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pWaitSemaphores)
- {
- if (((waitSemaphoreCount)))
- {
+ if (local_pWaitSemaphores) {
+ if (((waitSemaphoreCount))) {
*countPtr += ((waitSemaphoreCount)) * 8;
}
}
uint64_t cgen_var_1;
*countPtr += 1 * 8;
}
- uint32_t packetSize_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE);
uint8_t* streamPtr = stream->reserve(packetSize_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE = OP_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE =
+ OP_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkQueue((*&local_queue));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -38741,13 +54809,10 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pWaitSemaphores)
- {
- if (((waitSemaphoreCount)))
- {
+ if (local_pWaitSemaphores) {
+ if (((waitSemaphoreCount))) {
uint8_t* cgen_var_1_0_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((waitSemaphoreCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((waitSemaphoreCount)); ++k) {
uint64_t tmpval = get_host_u64_VkSemaphore(local_pWaitSemaphores[k]);
memcpy(cgen_var_1_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -38759,9 +54824,9 @@
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_2, 1 * 8);
*streamPtrPtr += 1 * 8;
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -38772,17 +54837,38 @@
#ifdef VK_EXT_global_priority_query
#endif
#ifdef VK_EXT_multi_draw
-void VkEncoder::vkCmdDrawMultiEXT(
- VkCommandBuffer commandBuffer,
- uint32_t drawCount,
- const VkMultiDrawInfoEXT* pVertexInfo,
- uint32_t instanceCount,
- uint32_t firstInstance,
- uint32_t stride,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount,
+ const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount,
+ uint32_t firstInstance, uint32_t stride, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDrawMultiEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdDrawMultiEXT(commandBuffer:%p, drawCount:%d, pVertexInfo:%p, instanceCount:%d, "
+ "firstInstance:%d, stride:%d)",
+ commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -38795,22 +54881,21 @@
local_commandBuffer = commandBuffer;
local_drawCount = drawCount;
local_pVertexInfo = nullptr;
- if (pVertexInfo)
- {
- local_pVertexInfo = (VkMultiDrawInfoEXT*)pool->alloc(((drawCount)) * sizeof(const VkMultiDrawInfoEXT));
- for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i)
- {
- deepcopy_VkMultiDrawInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pVertexInfo + i, (VkMultiDrawInfoEXT*)(local_pVertexInfo + i));
+ if (pVertexInfo) {
+ local_pVertexInfo =
+ (VkMultiDrawInfoEXT*)pool->alloc(((drawCount)) * sizeof(const VkMultiDrawInfoEXT));
+ for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i) {
+ deepcopy_VkMultiDrawInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pVertexInfo + i,
+ (VkMultiDrawInfoEXT*)(local_pVertexInfo + i));
}
}
local_instanceCount = instanceCount;
local_firstInstance = firstInstance;
local_stride = stride;
- if (local_pVertexInfo)
- {
- for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i)
- {
- transform_tohost_VkMultiDrawInfoEXT(sResourceTracker, (VkMultiDrawInfoEXT*)(local_pVertexInfo + i));
+ if (local_pVertexInfo) {
+ for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i) {
+ transform_tohost_VkMultiDrawInfoEXT(sResourceTracker,
+ (VkMultiDrawInfoEXT*)(local_pVertexInfo + i));
}
}
size_t count = 0;
@@ -38821,11 +54906,10 @@
*countPtr += sizeof(uint32_t);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pVertexInfo)
- {
- for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i)
- {
- count_VkMultiDrawInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMultiDrawInfoEXT*)(local_pVertexInfo + i), countPtr);
+ if (local_pVertexInfo) {
+ for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i) {
+ count_VkMultiDrawInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMultiDrawInfoEXT*)(local_pVertexInfo + i), countPtr);
}
}
*countPtr += sizeof(uint32_t);
@@ -38833,14 +54917,16 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdDrawMultiEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDrawMultiEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawMultiEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawMultiEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDrawMultiEXT = OP_vkCmdDrawMultiEXT;
- memcpy(streamPtr, &opcode_vkCmdDrawMultiEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDrawMultiEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDrawMultiEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDrawMultiEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -38853,11 +54939,11 @@
memcpy((*streamPtrPtr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pVertexInfo)
- {
- for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i)
- {
- reservedmarshal_VkMultiDrawInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMultiDrawInfoEXT*)(local_pVertexInfo + i), streamPtrPtr);
+ if (local_pVertexInfo) {
+ for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i) {
+ reservedmarshal_VkMultiDrawInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMultiDrawInfoEXT*)(local_pVertexInfo + i),
+ streamPtrPtr);
}
}
memcpy(*streamPtrPtr, (uint32_t*)&local_instanceCount, sizeof(uint32_t));
@@ -38866,27 +54952,49 @@
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_stride, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-void VkEncoder::vkCmdDrawMultiIndexedEXT(
- VkCommandBuffer commandBuffer,
- uint32_t drawCount,
- const VkMultiDrawIndexedInfoEXT* pIndexInfo,
- uint32_t instanceCount,
- uint32_t firstInstance,
- uint32_t stride,
- const int32_t* pVertexOffset,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount,
+ const VkMultiDrawIndexedInfoEXT* pIndexInfo,
+ uint32_t instanceCount, uint32_t firstInstance,
+ uint32_t stride, const int32_t* pVertexOffset,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdDrawMultiIndexedEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdDrawMultiIndexedEXT(commandBuffer:%p, drawCount:%d, pIndexInfo:%p, instanceCount:%d, "
+ "firstInstance:%d, stride:%d, pVertexOffset:%p)",
+ commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -38900,12 +55008,12 @@
local_commandBuffer = commandBuffer;
local_drawCount = drawCount;
local_pIndexInfo = nullptr;
- if (pIndexInfo)
- {
- local_pIndexInfo = (VkMultiDrawIndexedInfoEXT*)pool->alloc(((drawCount)) * sizeof(const VkMultiDrawIndexedInfoEXT));
- for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i)
- {
- deepcopy_VkMultiDrawIndexedInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pIndexInfo + i, (VkMultiDrawIndexedInfoEXT*)(local_pIndexInfo + i));
+ if (pIndexInfo) {
+ local_pIndexInfo = (VkMultiDrawIndexedInfoEXT*)pool->alloc(
+ ((drawCount)) * sizeof(const VkMultiDrawIndexedInfoEXT));
+ for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i) {
+ deepcopy_VkMultiDrawIndexedInfoEXT(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pIndexInfo + i,
+ (VkMultiDrawIndexedInfoEXT*)(local_pIndexInfo + i));
}
}
local_instanceCount = instanceCount;
@@ -38913,11 +55021,10 @@
local_stride = stride;
// Avoiding deepcopy for pVertexOffset
local_pVertexOffset = (int32_t*)pVertexOffset;
- if (local_pIndexInfo)
- {
- for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i)
- {
- transform_tohost_VkMultiDrawIndexedInfoEXT(sResourceTracker, (VkMultiDrawIndexedInfoEXT*)(local_pIndexInfo + i));
+ if (local_pIndexInfo) {
+ for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i) {
+ transform_tohost_VkMultiDrawIndexedInfoEXT(
+ sResourceTracker, (VkMultiDrawIndexedInfoEXT*)(local_pIndexInfo + i));
}
}
size_t count = 0;
@@ -38928,11 +55035,11 @@
*countPtr += sizeof(uint32_t);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pIndexInfo)
- {
- for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i)
- {
- count_VkMultiDrawIndexedInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMultiDrawIndexedInfoEXT*)(local_pIndexInfo + i), countPtr);
+ if (local_pIndexInfo) {
+ for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i) {
+ count_VkMultiDrawIndexedInfoEXT(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMultiDrawIndexedInfoEXT*)(local_pIndexInfo + i),
+ countPtr);
}
}
*countPtr += sizeof(uint32_t);
@@ -38940,20 +55047,21 @@
*countPtr += sizeof(uint32_t);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pVertexOffset)
- {
+ if (local_pVertexOffset) {
*countPtr += sizeof(int32_t);
}
}
uint32_t packetSize_vkCmdDrawMultiIndexedEXT = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdDrawMultiIndexedEXT);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdDrawMultiIndexedEXT -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdDrawMultiIndexedEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdDrawMultiIndexedEXT = OP_vkCmdDrawMultiIndexedEXT;
- memcpy(streamPtr, &opcode_vkCmdDrawMultiIndexedEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdDrawMultiIndexedEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdDrawMultiIndexedEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdDrawMultiIndexedEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -38966,11 +55074,11 @@
memcpy((*streamPtrPtr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pIndexInfo)
- {
- for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i)
- {
- reservedmarshal_VkMultiDrawIndexedInfoEXT(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkMultiDrawIndexedInfoEXT*)(local_pIndexInfo + i), streamPtrPtr);
+ if (local_pIndexInfo) {
+ for (uint32_t i = 0; i < (uint32_t)((drawCount)); ++i) {
+ reservedmarshal_VkMultiDrawIndexedInfoEXT(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMultiDrawIndexedInfoEXT*)(local_pIndexInfo + i), streamPtrPtr);
}
}
memcpy(*streamPtrPtr, (uint32_t*)&local_instanceCount, sizeof(uint32_t));
@@ -38984,14 +55092,13 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pVertexOffset)
- {
+ if (local_pVertexOffset) {
memcpy(*streamPtrPtr, (int32_t*)local_pVertexOffset, sizeof(int32_t));
*streamPtrPtr += sizeof(int32_t);
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -39004,14 +55111,35 @@
#ifdef VK_EXT_border_color_swizzle
#endif
#ifdef VK_EXT_pageable_device_local_memory
-void VkEncoder::vkSetDeviceMemoryPriorityEXT(
- VkDevice device,
- VkDeviceMemory memory,
- float priority,
- uint32_t doLock)
-{
+void VkEncoder::vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkSetDeviceMemoryPriorityEXT in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkSetDeviceMemoryPriorityEXT(device:%p, memory:%p, priority:%f)", device,
+ memory, priority);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -39030,14 +55158,24 @@
*countPtr += 1 * 8;
*countPtr += sizeof(float);
}
- uint32_t packetSize_vkSetDeviceMemoryPriorityEXT = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkSetDeviceMemoryPriorityEXT =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkSetDeviceMemoryPriorityEXT);
uint8_t* streamPtr = stream->reserve(packetSize_vkSetDeviceMemoryPriorityEXT);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkSetDeviceMemoryPriorityEXT = OP_vkSetDeviceMemoryPriorityEXT;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkSetDeviceMemoryPriorityEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkSetDeviceMemoryPriorityEXT, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkSetDeviceMemoryPriorityEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkSetDeviceMemoryPriorityEXT, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -39049,9 +55187,9 @@
memcpy(*streamPtrPtr, (float*)&local_priority, sizeof(float));
*streamPtrPtr += sizeof(float);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -39061,14 +55199,38 @@
#endif
#ifdef VK_KHR_acceleration_structure
VkResult VkEncoder::vkCreateAccelerationStructureKHR(
- VkDevice device,
- const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkAccelerationStructureKHR* pAccelerationStructure,
- uint32_t doLock)
-{
+ VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateAccelerationStructureKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateAccelerationStructureKHR(device:%p, pCreateInfo:%p, pAllocator:%p, "
+ "pAccelerationStructure:%p)",
+ device, pCreateInfo, pAllocator, pAccelerationStructure);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -39077,62 +55239,79 @@
VkAllocationCallbacks* local_pAllocator;
local_device = device;
local_pCreateInfo = nullptr;
- if (pCreateInfo)
- {
- local_pCreateInfo = (VkAccelerationStructureCreateInfoKHR*)pool->alloc(sizeof(const VkAccelerationStructureCreateInfoKHR));
- deepcopy_VkAccelerationStructureCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo, (VkAccelerationStructureCreateInfoKHR*)(local_pCreateInfo));
+ if (pCreateInfo) {
+ local_pCreateInfo = (VkAccelerationStructureCreateInfoKHR*)pool->alloc(
+ sizeof(const VkAccelerationStructureCreateInfoKHR));
+ deepcopy_VkAccelerationStructureCreateInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfo,
+ (VkAccelerationStructureCreateInfoKHR*)(local_pCreateInfo));
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfo)
- {
- transform_tohost_VkAccelerationStructureCreateInfoKHR(sResourceTracker, (VkAccelerationStructureCreateInfoKHR*)(local_pCreateInfo));
+ if (local_pCreateInfo) {
+ transform_tohost_VkAccelerationStructureCreateInfoKHR(
+ sResourceTracker, (VkAccelerationStructureCreateInfoKHR*)(local_pCreateInfo));
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkAccelerationStructureCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureCreateInfoKHR*)(local_pCreateInfo), countPtr);
+ count_VkAccelerationStructureCreateInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureCreateInfoKHR*)(local_pCreateInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
uint64_t cgen_var_1;
*countPtr += 8;
}
- uint32_t packetSize_vkCreateAccelerationStructureKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateAccelerationStructureKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCreateAccelerationStructureKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateAccelerationStructureKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateAccelerationStructureKHR = OP_vkCreateAccelerationStructureKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateAccelerationStructureKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateAccelerationStructureKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateAccelerationStructureKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateAccelerationStructureKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkAccelerationStructureCreateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureCreateInfoKHR*)(local_pCreateInfo), streamPtrPtr);
+ reservedmarshal_VkAccelerationStructureCreateInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureCreateInfoKHR*)(local_pCreateInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
uint64_t cgen_var_2;
@@ -39143,13 +55322,14 @@
stream->setHandleMapping(sResourceTracker->createMapping());
uint64_t cgen_var_3;
stream->read((uint64_t*)&cgen_var_3, 8);
- stream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(&cgen_var_3, (VkAccelerationStructureKHR*)pAccelerationStructure, 1);
+ stream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(
+ &cgen_var_3, (VkAccelerationStructureKHR*)pAccelerationStructure, 1);
stream->unsetHandleMapping();
VkResult vkCreateAccelerationStructureKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateAccelerationStructureKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -39157,14 +55337,38 @@
return vkCreateAccelerationStructureKHR_VkResult_return;
}
-void VkEncoder::vkDestroyAccelerationStructureKHR(
- VkDevice device,
- VkAccelerationStructureKHR accelerationStructure,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock)
-{
+void VkEncoder::vkDestroyAccelerationStructureKHR(VkDevice device,
+ VkAccelerationStructureKHR accelerationStructure,
+ const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkDestroyAccelerationStructureKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkDestroyAccelerationStructureKHR(device:%p, accelerationStructure:%p, pAllocator:%p)",
+ device, accelerationStructure, pAllocator);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -39174,15 +55378,15 @@
local_device = device;
local_accelerationStructure = accelerationStructure;
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -39193,19 +55397,29 @@
*countPtr += 1 * 8;
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
}
- uint32_t packetSize_vkDestroyAccelerationStructureKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkDestroyAccelerationStructureKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkDestroyAccelerationStructureKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkDestroyAccelerationStructureKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkDestroyAccelerationStructureKHR = OP_vkDestroyAccelerationStructureKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkDestroyAccelerationStructureKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkDestroyAccelerationStructureKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkDestroyAccelerationStructureKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkDestroyAccelerationStructureKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -39219,15 +55433,17 @@
memcpy((*streamPtrPtr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
- sResourceTracker->destroyMapping()->mapHandles_VkAccelerationStructureKHR((VkAccelerationStructureKHR*)&accelerationStructure);
+ sResourceTracker->destroyMapping()->mapHandles_VkAccelerationStructureKHR(
+ (VkAccelerationStructureKHR*)&accelerationStructure);
stream->flush();
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -39235,14 +55451,38 @@
}
void VkEncoder::vkCmdBuildAccelerationStructuresKHR(
- VkCommandBuffer commandBuffer,
- uint32_t infoCount,
+ VkCommandBuffer commandBuffer, uint32_t infoCount,
const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
- const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos,
- uint32_t doLock)
-{
+ const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdBuildAccelerationStructuresKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdBuildAccelerationStructuresKHR(commandBuffer:%p, infoCount:%d, pInfos:%p, "
+ "ppBuildRangeInfos:%p)",
+ commandBuffer, infoCount, pInfos, ppBuildRangeInfos);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -39253,20 +55493,20 @@
local_commandBuffer = commandBuffer;
local_infoCount = infoCount;
local_pInfos = nullptr;
- if (pInfos)
- {
- local_pInfos = (VkAccelerationStructureBuildGeometryInfoKHR*)pool->alloc(((infoCount)) * sizeof(const VkAccelerationStructureBuildGeometryInfoKHR));
- for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
- {
- deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfos + i, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i));
+ if (pInfos) {
+ local_pInfos = (VkAccelerationStructureBuildGeometryInfoKHR*)pool->alloc(
+ ((infoCount)) * sizeof(const VkAccelerationStructureBuildGeometryInfoKHR));
+ for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+ deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfos + i,
+ (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i));
}
}
(void)ppBuildRangeInfos;
- if (local_pInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
- {
- transform_tohost_VkAccelerationStructureBuildGeometryInfoKHR(sResourceTracker, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i));
+ if (local_pInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+ transform_tohost_VkAccelerationStructureBuildGeometryInfoKHR(
+ sResourceTracker, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i));
}
}
(void)local_ppBuildRangeInfos;
@@ -39276,21 +55516,25 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
- {
- count_VkAccelerationStructureBuildGeometryInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+ count_VkAccelerationStructureBuildGeometryInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), countPtr);
}
(void)local_ppBuildRangeInfos;
}
uint32_t packetSize_vkCmdBuildAccelerationStructuresKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdBuildAccelerationStructuresKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBuildAccelerationStructuresKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBuildAccelerationStructuresKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdBuildAccelerationStructuresKHR = OP_vkCmdBuildAccelerationStructuresKHR;
- memcpy(streamPtr, &opcode_vkCmdBuildAccelerationStructuresKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBuildAccelerationStructuresKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdBuildAccelerationStructuresKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBuildAccelerationStructuresKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -39298,14 +55542,15 @@
}
memcpy(*streamPtrPtr, (uint32_t*)&local_infoCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
- {
- reservedmarshal_VkAccelerationStructureBuildGeometryInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+ reservedmarshal_VkAccelerationStructureBuildGeometryInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), streamPtrPtr);
}
(void)local_ppBuildRangeInfos;
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -39313,16 +55558,41 @@
}
void VkEncoder::vkCmdBuildAccelerationStructuresIndirectKHR(
- VkCommandBuffer commandBuffer,
- uint32_t infoCount,
+ VkCommandBuffer commandBuffer, uint32_t infoCount,
const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
- const VkDeviceAddress* pIndirectDeviceAddresses,
- const uint32_t* pIndirectStrides,
- const uint32_t* const* ppMaxPrimitiveCounts,
- uint32_t doLock)
-{
+ const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides,
+ const uint32_t* const* ppMaxPrimitiveCounts, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkCmdBuildAccelerationStructuresIndirectKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdBuildAccelerationStructuresIndirectKHR(commandBuffer:%p, infoCount:%d, pInfos:%p, "
+ "pIndirectDeviceAddresses:%p, pIndirectStrides:%p, ppMaxPrimitiveCounts:%p)",
+ commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides,
+ ppMaxPrimitiveCounts);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -39335,12 +55605,13 @@
local_commandBuffer = commandBuffer;
local_infoCount = infoCount;
local_pInfos = nullptr;
- if (pInfos)
- {
- local_pInfos = (VkAccelerationStructureBuildGeometryInfoKHR*)pool->alloc(((infoCount)) * sizeof(const VkAccelerationStructureBuildGeometryInfoKHR));
- for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
- {
- deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfos + i, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i));
+ if (pInfos) {
+ local_pInfos = (VkAccelerationStructureBuildGeometryInfoKHR*)pool->alloc(
+ ((infoCount)) * sizeof(const VkAccelerationStructureBuildGeometryInfoKHR));
+ for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+ deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfos + i,
+ (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i));
}
}
// Avoiding deepcopy for pIndirectDeviceAddresses
@@ -39348,11 +55619,10 @@
// Avoiding deepcopy for pIndirectStrides
local_pIndirectStrides = (uint32_t*)pIndirectStrides;
(void)ppMaxPrimitiveCounts;
- if (local_pInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
- {
- transform_tohost_VkAccelerationStructureBuildGeometryInfoKHR(sResourceTracker, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i));
+ if (local_pInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+ transform_tohost_VkAccelerationStructureBuildGeometryInfoKHR(
+ sResourceTracker, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i));
}
}
(void)local_ppMaxPrimitiveCounts;
@@ -39362,23 +55632,28 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
- {
- count_VkAccelerationStructureBuildGeometryInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+ count_VkAccelerationStructureBuildGeometryInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), countPtr);
}
*countPtr += ((infoCount)) * sizeof(VkDeviceAddress);
*countPtr += ((infoCount)) * sizeof(uint32_t);
(void)local_ppMaxPrimitiveCounts;
}
uint32_t packetSize_vkCmdBuildAccelerationStructuresIndirectKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdBuildAccelerationStructuresIndirectKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdBuildAccelerationStructuresIndirectKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdBuildAccelerationStructuresIndirectKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkCmdBuildAccelerationStructuresIndirectKHR = OP_vkCmdBuildAccelerationStructuresIndirectKHR;
- memcpy(streamPtr, &opcode_vkCmdBuildAccelerationStructuresIndirectKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdBuildAccelerationStructuresIndirectKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ uint32_t opcode_vkCmdBuildAccelerationStructuresIndirectKHR =
+ OP_vkCmdBuildAccelerationStructuresIndirectKHR;
+ memcpy(streamPtr, &opcode_vkCmdBuildAccelerationStructuresIndirectKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdBuildAccelerationStructuresIndirectKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -39386,18 +55661,20 @@
}
memcpy(*streamPtrPtr, (uint32_t*)&local_infoCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
- {
- reservedmarshal_VkAccelerationStructureBuildGeometryInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+ reservedmarshal_VkAccelerationStructureBuildGeometryInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), streamPtrPtr);
}
- memcpy(*streamPtrPtr, (VkDeviceAddress*)local_pIndirectDeviceAddresses, ((infoCount)) * sizeof(VkDeviceAddress));
+ memcpy(*streamPtrPtr, (VkDeviceAddress*)local_pIndirectDeviceAddresses,
+ ((infoCount)) * sizeof(VkDeviceAddress));
*streamPtrPtr += ((infoCount)) * sizeof(VkDeviceAddress);
memcpy(*streamPtrPtr, (uint32_t*)local_pIndirectStrides, ((infoCount)) * sizeof(uint32_t));
*streamPtrPtr += ((infoCount)) * sizeof(uint32_t);
(void)local_ppMaxPrimitiveCounts;
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -39405,15 +55682,38 @@
}
VkResult VkEncoder::vkBuildAccelerationStructuresKHR(
- VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- uint32_t infoCount,
+ VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount,
const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
- const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos,
- uint32_t doLock)
-{
+ const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkBuildAccelerationStructuresKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkBuildAccelerationStructuresKHR(device:%p, infoCount:%d, pInfos:%p, "
+ "ppBuildRangeInfos:%p)",
+ device, infoCount, pInfos, ppBuildRangeInfos);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -39426,20 +55726,20 @@
local_deferredOperation = deferredOperation;
local_infoCount = infoCount;
local_pInfos = nullptr;
- if (pInfos)
- {
- local_pInfos = (VkAccelerationStructureBuildGeometryInfoKHR*)pool->alloc(((infoCount)) * sizeof(const VkAccelerationStructureBuildGeometryInfoKHR));
- for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
- {
- deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfos + i, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i));
+ if (pInfos) {
+ local_pInfos = (VkAccelerationStructureBuildGeometryInfoKHR*)pool->alloc(
+ ((infoCount)) * sizeof(const VkAccelerationStructureBuildGeometryInfoKHR));
+ for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+ deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfos + i,
+ (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i));
}
}
(void)ppBuildRangeInfos;
- if (local_pInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
- {
- transform_tohost_VkAccelerationStructureBuildGeometryInfoKHR(sResourceTracker, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i));
+ if (local_pInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+ transform_tohost_VkAccelerationStructureBuildGeometryInfoKHR(
+ sResourceTracker, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i));
}
}
(void)local_ppBuildRangeInfos;
@@ -39450,20 +55750,31 @@
*countPtr += 1 * 8;
*countPtr += 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
- {
- count_VkAccelerationStructureBuildGeometryInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+ count_VkAccelerationStructureBuildGeometryInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), countPtr);
}
(void)local_ppBuildRangeInfos;
}
- uint32_t packetSize_vkBuildAccelerationStructuresKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkBuildAccelerationStructuresKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkBuildAccelerationStructuresKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkBuildAccelerationStructuresKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkBuildAccelerationStructuresKHR = OP_vkBuildAccelerationStructuresKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkBuildAccelerationStructuresKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkBuildAccelerationStructuresKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkBuildAccelerationStructuresKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkBuildAccelerationStructuresKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -39474,16 +55785,17 @@
*streamPtrPtr += 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_infoCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i)
- {
- reservedmarshal_VkAccelerationStructureBuildGeometryInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+ reservedmarshal_VkAccelerationStructureBuildGeometryInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pInfos + i), streamPtrPtr);
}
(void)local_ppBuildRangeInfos;
VkResult vkBuildAccelerationStructuresKHR_VkResult_return = (VkResult)0;
stream->read(&vkBuildAccelerationStructuresKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -39491,14 +55803,36 @@
return vkBuildAccelerationStructuresKHR_VkResult_return;
}
-VkResult VkEncoder::vkCopyAccelerationStructureKHR(
- VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- const VkCopyAccelerationStructureInfoKHR* pInfo,
- uint32_t doLock)
-{
+VkResult VkEncoder::vkCopyAccelerationStructureKHR(VkDevice device,
+ VkDeferredOperationKHR deferredOperation,
+ const VkCopyAccelerationStructureInfoKHR* pInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCopyAccelerationStructureKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCopyAccelerationStructureKHR(device:%p, pInfo:%p)", device, pInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -39508,14 +55842,16 @@
local_device = device;
local_deferredOperation = deferredOperation;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkCopyAccelerationStructureInfoKHR*)pool->alloc(sizeof(const VkCopyAccelerationStructureInfoKHR));
- deepcopy_VkCopyAccelerationStructureInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkCopyAccelerationStructureInfoKHR*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkCopyAccelerationStructureInfoKHR*)pool->alloc(
+ sizeof(const VkCopyAccelerationStructureInfoKHR));
+ deepcopy_VkCopyAccelerationStructureInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkCopyAccelerationStructureInfoKHR*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkCopyAccelerationStructureInfoKHR(sResourceTracker, (VkCopyAccelerationStructureInfoKHR*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkCopyAccelerationStructureInfoKHR(
+ sResourceTracker, (VkCopyAccelerationStructureInfoKHR*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -39523,16 +55859,28 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += 8;
- count_VkCopyAccelerationStructureInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyAccelerationStructureInfoKHR*)(local_pInfo), countPtr);
+ count_VkCopyAccelerationStructureInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyAccelerationStructureInfoKHR*)(local_pInfo),
+ countPtr);
}
- uint32_t packetSize_vkCopyAccelerationStructureKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCopyAccelerationStructureKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCopyAccelerationStructureKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCopyAccelerationStructureKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCopyAccelerationStructureKHR = OP_vkCopyAccelerationStructureKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCopyAccelerationStructureKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCopyAccelerationStructureKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCopyAccelerationStructureKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCopyAccelerationStructureKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -39541,12 +55889,14 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- reservedmarshal_VkCopyAccelerationStructureInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyAccelerationStructureInfoKHR*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkCopyAccelerationStructureInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyAccelerationStructureInfoKHR*)(local_pInfo),
+ streamPtrPtr);
VkResult vkCopyAccelerationStructureKHR_VkResult_return = (VkResult)0;
stream->read(&vkCopyAccelerationStructureKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -39555,13 +55905,35 @@
}
VkResult VkEncoder::vkCopyAccelerationStructureToMemoryKHR(
- VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo,
- uint32_t doLock)
-{
+ VkDevice device, VkDeferredOperationKHR deferredOperation,
+ const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkCopyAccelerationStructureToMemoryKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCopyAccelerationStructureToMemoryKHR(device:%p, pInfo:%p)", device, pInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -39571,14 +55943,16 @@
local_device = device;
local_deferredOperation = deferredOperation;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkCopyAccelerationStructureToMemoryInfoKHR*)pool->alloc(sizeof(const VkCopyAccelerationStructureToMemoryInfoKHR));
- deepcopy_VkCopyAccelerationStructureToMemoryInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkCopyAccelerationStructureToMemoryInfoKHR*)pool->alloc(
+ sizeof(const VkCopyAccelerationStructureToMemoryInfoKHR));
+ deepcopy_VkCopyAccelerationStructureToMemoryInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkCopyAccelerationStructureToMemoryInfoKHR(sResourceTracker, (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkCopyAccelerationStructureToMemoryInfoKHR(
+ sResourceTracker, (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -39586,16 +55960,29 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += 8;
- count_VkCopyAccelerationStructureToMemoryInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo), countPtr);
+ count_VkCopyAccelerationStructureToMemoryInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo), countPtr);
}
- uint32_t packetSize_vkCopyAccelerationStructureToMemoryKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCopyAccelerationStructureToMemoryKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCopyAccelerationStructureToMemoryKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCopyAccelerationStructureToMemoryKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkCopyAccelerationStructureToMemoryKHR = OP_vkCopyAccelerationStructureToMemoryKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCopyAccelerationStructureToMemoryKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCopyAccelerationStructureToMemoryKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkCopyAccelerationStructureToMemoryKHR =
+ OP_vkCopyAccelerationStructureToMemoryKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCopyAccelerationStructureToMemoryKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCopyAccelerationStructureToMemoryKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -39604,12 +55991,14 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- reservedmarshal_VkCopyAccelerationStructureToMemoryInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkCopyAccelerationStructureToMemoryInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo), streamPtrPtr);
VkResult vkCopyAccelerationStructureToMemoryKHR_VkResult_return = (VkResult)0;
stream->read(&vkCopyAccelerationStructureToMemoryKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -39618,13 +56007,35 @@
}
VkResult VkEncoder::vkCopyMemoryToAccelerationStructureKHR(
- VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo,
- uint32_t doLock)
-{
+ VkDevice device, VkDeferredOperationKHR deferredOperation,
+ const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkCopyMemoryToAccelerationStructureKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCopyMemoryToAccelerationStructureKHR(device:%p, pInfo:%p)", device, pInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -39634,14 +56045,16 @@
local_device = device;
local_deferredOperation = deferredOperation;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkCopyMemoryToAccelerationStructureInfoKHR*)pool->alloc(sizeof(const VkCopyMemoryToAccelerationStructureInfoKHR));
- deepcopy_VkCopyMemoryToAccelerationStructureInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkCopyMemoryToAccelerationStructureInfoKHR*)pool->alloc(
+ sizeof(const VkCopyMemoryToAccelerationStructureInfoKHR));
+ deepcopy_VkCopyMemoryToAccelerationStructureInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkCopyMemoryToAccelerationStructureInfoKHR(sResourceTracker, (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkCopyMemoryToAccelerationStructureInfoKHR(
+ sResourceTracker, (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -39649,16 +56062,29 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += 8;
- count_VkCopyMemoryToAccelerationStructureInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo), countPtr);
+ count_VkCopyMemoryToAccelerationStructureInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo), countPtr);
}
- uint32_t packetSize_vkCopyMemoryToAccelerationStructureKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCopyMemoryToAccelerationStructureKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCopyMemoryToAccelerationStructureKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCopyMemoryToAccelerationStructureKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkCopyMemoryToAccelerationStructureKHR = OP_vkCopyMemoryToAccelerationStructureKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCopyMemoryToAccelerationStructureKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCopyMemoryToAccelerationStructureKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkCopyMemoryToAccelerationStructureKHR =
+ OP_vkCopyMemoryToAccelerationStructureKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCopyMemoryToAccelerationStructureKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCopyMemoryToAccelerationStructureKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -39667,12 +56093,14 @@
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- reservedmarshal_VkCopyMemoryToAccelerationStructureInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo), streamPtrPtr);
+ reservedmarshal_VkCopyMemoryToAccelerationStructureInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo), streamPtrPtr);
VkResult vkCopyMemoryToAccelerationStructureKHR_VkResult_return = (VkResult)0;
stream->read(&vkCopyMemoryToAccelerationStructureKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -39681,17 +56109,39 @@
}
VkResult VkEncoder::vkWriteAccelerationStructuresPropertiesKHR(
- VkDevice device,
- uint32_t accelerationStructureCount,
- const VkAccelerationStructureKHR* pAccelerationStructures,
- VkQueryType queryType,
- size_t dataSize,
- void* pData,
- size_t stride,
- uint32_t doLock)
-{
+ VkDevice device, uint32_t accelerationStructureCount,
+ const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType,
+ size_t dataSize, void* pData, size_t stride, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkWriteAccelerationStructuresPropertiesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkWriteAccelerationStructuresPropertiesKHR(device:%p, accelerationStructureCount:%d, "
+ "pAccelerationStructures:%p, dataSize:%ld, pData:%p, stride:%ld)",
+ device, accelerationStructureCount, pAccelerationStructures, dataSize, pData, stride);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -39714,8 +56164,7 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- if (((accelerationStructureCount)))
- {
+ if (((accelerationStructureCount))) {
*countPtr += ((accelerationStructureCount)) * 8;
}
*countPtr += sizeof(VkQueryType);
@@ -39723,26 +56172,36 @@
*countPtr += ((dataSize)) * sizeof(uint8_t);
*countPtr += 8;
}
- uint32_t packetSize_vkWriteAccelerationStructuresPropertiesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkWriteAccelerationStructuresPropertiesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkWriteAccelerationStructuresPropertiesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkWriteAccelerationStructuresPropertiesKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkWriteAccelerationStructuresPropertiesKHR = OP_vkWriteAccelerationStructuresPropertiesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkWriteAccelerationStructuresPropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkWriteAccelerationStructuresPropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkWriteAccelerationStructuresPropertiesKHR =
+ OP_vkWriteAccelerationStructuresPropertiesKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkWriteAccelerationStructuresPropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkWriteAccelerationStructuresPropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_accelerationStructureCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (((accelerationStructureCount)))
- {
+ if (((accelerationStructureCount))) {
uint8_t* cgen_var_1_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((accelerationStructureCount)); ++k)
- {
- uint64_t tmpval = get_host_u64_VkAccelerationStructureKHR(local_pAccelerationStructures[k]);
+ for (uint32_t k = 0; k < ((accelerationStructureCount)); ++k) {
+ uint64_t tmpval =
+ get_host_u64_VkAccelerationStructureKHR(local_pAccelerationStructures[k]);
memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
*streamPtrPtr += 8 * ((accelerationStructureCount));
@@ -39762,9 +56221,9 @@
stream->read((void*)pData, ((dataSize)) * sizeof(uint8_t));
VkResult vkWriteAccelerationStructuresPropertiesKHR_VkResult_return = (VkResult)0;
stream->read(&vkWriteAccelerationStructuresPropertiesKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -39772,13 +56231,36 @@
return vkWriteAccelerationStructuresPropertiesKHR_VkResult_return;
}
-void VkEncoder::vkCmdCopyAccelerationStructureKHR(
- VkCommandBuffer commandBuffer,
- const VkCopyAccelerationStructureInfoKHR* pInfo,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer,
+ const VkCopyAccelerationStructureInfoKHR* pInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdCopyAccelerationStructureKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdCopyAccelerationStructureKHR(commandBuffer:%p, pInfo:%p)",
+ commandBuffer, pInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -39786,40 +56268,49 @@
VkCopyAccelerationStructureInfoKHR* local_pInfo;
local_commandBuffer = commandBuffer;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkCopyAccelerationStructureInfoKHR*)pool->alloc(sizeof(const VkCopyAccelerationStructureInfoKHR));
- deepcopy_VkCopyAccelerationStructureInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkCopyAccelerationStructureInfoKHR*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkCopyAccelerationStructureInfoKHR*)pool->alloc(
+ sizeof(const VkCopyAccelerationStructureInfoKHR));
+ deepcopy_VkCopyAccelerationStructureInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkCopyAccelerationStructureInfoKHR*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkCopyAccelerationStructureInfoKHR(sResourceTracker, (VkCopyAccelerationStructureInfoKHR*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkCopyAccelerationStructureInfoKHR(
+ sResourceTracker, (VkCopyAccelerationStructureInfoKHR*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCopyAccelerationStructureInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyAccelerationStructureInfoKHR*)(local_pInfo), countPtr);
+ count_VkCopyAccelerationStructureInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyAccelerationStructureInfoKHR*)(local_pInfo),
+ countPtr);
}
uint32_t packetSize_vkCmdCopyAccelerationStructureKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdCopyAccelerationStructureKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyAccelerationStructureKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyAccelerationStructureKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdCopyAccelerationStructureKHR = OP_vkCmdCopyAccelerationStructureKHR;
- memcpy(streamPtr, &opcode_vkCmdCopyAccelerationStructureKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdCopyAccelerationStructureKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdCopyAccelerationStructureKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdCopyAccelerationStructureKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkCopyAccelerationStructureInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyAccelerationStructureInfoKHR*)(local_pInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkCopyAccelerationStructureInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyAccelerationStructureInfoKHR*)(local_pInfo),
+ streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -39827,12 +56318,36 @@
}
void VkEncoder::vkCmdCopyAccelerationStructureToMemoryKHR(
- VkCommandBuffer commandBuffer,
- const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo,
- uint32_t doLock)
-{
+ VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkCmdCopyAccelerationStructureToMemoryKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdCopyAccelerationStructureToMemoryKHR(commandBuffer:%p, pInfo:%p)",
+ commandBuffer, pInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -39840,40 +56355,50 @@
VkCopyAccelerationStructureToMemoryInfoKHR* local_pInfo;
local_commandBuffer = commandBuffer;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkCopyAccelerationStructureToMemoryInfoKHR*)pool->alloc(sizeof(const VkCopyAccelerationStructureToMemoryInfoKHR));
- deepcopy_VkCopyAccelerationStructureToMemoryInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkCopyAccelerationStructureToMemoryInfoKHR*)pool->alloc(
+ sizeof(const VkCopyAccelerationStructureToMemoryInfoKHR));
+ deepcopy_VkCopyAccelerationStructureToMemoryInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkCopyAccelerationStructureToMemoryInfoKHR(sResourceTracker, (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkCopyAccelerationStructureToMemoryInfoKHR(
+ sResourceTracker, (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCopyAccelerationStructureToMemoryInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo), countPtr);
+ count_VkCopyAccelerationStructureToMemoryInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo), countPtr);
}
uint32_t packetSize_vkCmdCopyAccelerationStructureToMemoryKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdCopyAccelerationStructureToMemoryKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyAccelerationStructureToMemoryKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyAccelerationStructureToMemoryKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkCmdCopyAccelerationStructureToMemoryKHR = OP_vkCmdCopyAccelerationStructureToMemoryKHR;
- memcpy(streamPtr, &opcode_vkCmdCopyAccelerationStructureToMemoryKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdCopyAccelerationStructureToMemoryKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ uint32_t opcode_vkCmdCopyAccelerationStructureToMemoryKHR =
+ OP_vkCmdCopyAccelerationStructureToMemoryKHR;
+ memcpy(streamPtr, &opcode_vkCmdCopyAccelerationStructureToMemoryKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdCopyAccelerationStructureToMemoryKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkCopyAccelerationStructureToMemoryInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkCopyAccelerationStructureToMemoryInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyAccelerationStructureToMemoryInfoKHR*)(local_pInfo), streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -39881,12 +56406,36 @@
}
void VkEncoder::vkCmdCopyMemoryToAccelerationStructureKHR(
- VkCommandBuffer commandBuffer,
- const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo,
- uint32_t doLock)
-{
+ VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkCmdCopyMemoryToAccelerationStructureKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkCmdCopyMemoryToAccelerationStructureKHR(commandBuffer:%p, pInfo:%p)",
+ commandBuffer, pInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -39894,40 +56443,50 @@
VkCopyMemoryToAccelerationStructureInfoKHR* local_pInfo;
local_commandBuffer = commandBuffer;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkCopyMemoryToAccelerationStructureInfoKHR*)pool->alloc(sizeof(const VkCopyMemoryToAccelerationStructureInfoKHR));
- deepcopy_VkCopyMemoryToAccelerationStructureInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkCopyMemoryToAccelerationStructureInfoKHR*)pool->alloc(
+ sizeof(const VkCopyMemoryToAccelerationStructureInfoKHR));
+ deepcopy_VkCopyMemoryToAccelerationStructureInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkCopyMemoryToAccelerationStructureInfoKHR(sResourceTracker, (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkCopyMemoryToAccelerationStructureInfoKHR(
+ sResourceTracker, (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkCopyMemoryToAccelerationStructureInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo), countPtr);
+ count_VkCopyMemoryToAccelerationStructureInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo), countPtr);
}
uint32_t packetSize_vkCmdCopyMemoryToAccelerationStructureKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdCopyMemoryToAccelerationStructureKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdCopyMemoryToAccelerationStructureKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdCopyMemoryToAccelerationStructureKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkCmdCopyMemoryToAccelerationStructureKHR = OP_vkCmdCopyMemoryToAccelerationStructureKHR;
- memcpy(streamPtr, &opcode_vkCmdCopyMemoryToAccelerationStructureKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdCopyMemoryToAccelerationStructureKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ uint32_t opcode_vkCmdCopyMemoryToAccelerationStructureKHR =
+ OP_vkCmdCopyMemoryToAccelerationStructureKHR;
+ memcpy(streamPtr, &opcode_vkCmdCopyMemoryToAccelerationStructureKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdCopyMemoryToAccelerationStructureKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkCopyMemoryToAccelerationStructureInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo), streamPtrPtr);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkCopyMemoryToAccelerationStructureInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkCopyMemoryToAccelerationStructureInfoKHR*)(local_pInfo), streamPtrPtr);
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -39935,12 +56494,35 @@
}
VkDeviceAddress VkEncoder::vkGetAccelerationStructureDeviceAddressKHR(
- VkDevice device,
- const VkAccelerationStructureDeviceAddressInfoKHR* pInfo,
- uint32_t doLock)
-{
+ VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetAccelerationStructureDeviceAddressKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetAccelerationStructureDeviceAddressKHR(device:%p, pInfo:%p)", device,
+ pInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -39948,40 +56530,59 @@
VkAccelerationStructureDeviceAddressInfoKHR* local_pInfo;
local_device = device;
local_pInfo = nullptr;
- if (pInfo)
- {
- local_pInfo = (VkAccelerationStructureDeviceAddressInfoKHR*)pool->alloc(sizeof(const VkAccelerationStructureDeviceAddressInfoKHR));
- deepcopy_VkAccelerationStructureDeviceAddressInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo, (VkAccelerationStructureDeviceAddressInfoKHR*)(local_pInfo));
+ if (pInfo) {
+ local_pInfo = (VkAccelerationStructureDeviceAddressInfoKHR*)pool->alloc(
+ sizeof(const VkAccelerationStructureDeviceAddressInfoKHR));
+ deepcopy_VkAccelerationStructureDeviceAddressInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pInfo,
+ (VkAccelerationStructureDeviceAddressInfoKHR*)(local_pInfo));
}
- if (local_pInfo)
- {
- transform_tohost_VkAccelerationStructureDeviceAddressInfoKHR(sResourceTracker, (VkAccelerationStructureDeviceAddressInfoKHR*)(local_pInfo));
+ if (local_pInfo) {
+ transform_tohost_VkAccelerationStructureDeviceAddressInfoKHR(
+ sResourceTracker, (VkAccelerationStructureDeviceAddressInfoKHR*)(local_pInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkAccelerationStructureDeviceAddressInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureDeviceAddressInfoKHR*)(local_pInfo), countPtr);
+ count_VkAccelerationStructureDeviceAddressInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureDeviceAddressInfoKHR*)(local_pInfo), countPtr);
}
- uint32_t packetSize_vkGetAccelerationStructureDeviceAddressKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetAccelerationStructureDeviceAddressKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetAccelerationStructureDeviceAddressKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetAccelerationStructureDeviceAddressKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetAccelerationStructureDeviceAddressKHR = OP_vkGetAccelerationStructureDeviceAddressKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetAccelerationStructureDeviceAddressKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetAccelerationStructureDeviceAddressKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetAccelerationStructureDeviceAddressKHR =
+ OP_vkGetAccelerationStructureDeviceAddressKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetAccelerationStructureDeviceAddressKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetAccelerationStructureDeviceAddressKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkAccelerationStructureDeviceAddressInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureDeviceAddressInfoKHR*)(local_pInfo), streamPtrPtr);
- VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR_VkDeviceAddress_return = (VkDeviceAddress)0;
- stream->read(&vkGetAccelerationStructureDeviceAddressKHR_VkDeviceAddress_return, sizeof(VkDeviceAddress));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ reservedmarshal_VkAccelerationStructureDeviceAddressInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureDeviceAddressInfoKHR*)(local_pInfo), streamPtrPtr);
+ VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR_VkDeviceAddress_return =
+ (VkDeviceAddress)0;
+ stream->read(&vkGetAccelerationStructureDeviceAddressKHR_VkDeviceAddress_return,
+ sizeof(VkDeviceAddress));
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -39990,16 +56591,39 @@
}
void VkEncoder::vkCmdWriteAccelerationStructuresPropertiesKHR(
- VkCommandBuffer commandBuffer,
- uint32_t accelerationStructureCount,
- const VkAccelerationStructureKHR* pAccelerationStructures,
- VkQueryType queryType,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t doLock)
-{
+ VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount,
+ const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType,
+ VkQueryPool queryPool, uint32_t firstQuery, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkCmdWriteAccelerationStructuresPropertiesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdWriteAccelerationStructuresPropertiesKHR(commandBuffer:%p, "
+ "accelerationStructureCount:%d, pAccelerationStructures:%p, queryPool:%p, firstQuery:%d)",
+ commandBuffer, accelerationStructureCount, pAccelerationStructures, queryPool, firstQuery);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -40022,8 +56646,7 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- if (((accelerationStructureCount)))
- {
+ if (((accelerationStructureCount))) {
*countPtr += ((accelerationStructureCount)) * 8;
}
*countPtr += sizeof(VkQueryType);
@@ -40032,14 +56655,19 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdWriteAccelerationStructuresPropertiesKHR = 4 + 4 + count;
- if (queueSubmitWithCommandsEnabled) packetSize_vkCmdWriteAccelerationStructuresPropertiesKHR -= 8;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdWriteAccelerationStructuresPropertiesKHR);
+ if (queueSubmitWithCommandsEnabled)
+ packetSize_vkCmdWriteAccelerationStructuresPropertiesKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdWriteAccelerationStructuresPropertiesKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkCmdWriteAccelerationStructuresPropertiesKHR = OP_vkCmdWriteAccelerationStructuresPropertiesKHR;
- memcpy(streamPtr, &opcode_vkCmdWriteAccelerationStructuresPropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdWriteAccelerationStructuresPropertiesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ uint32_t opcode_vkCmdWriteAccelerationStructuresPropertiesKHR =
+ OP_vkCmdWriteAccelerationStructuresPropertiesKHR;
+ memcpy(streamPtr, &opcode_vkCmdWriteAccelerationStructuresPropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdWriteAccelerationStructuresPropertiesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -40047,12 +56675,11 @@
}
memcpy(*streamPtrPtr, (uint32_t*)&local_accelerationStructureCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- if (((accelerationStructureCount)))
- {
+ if (((accelerationStructureCount))) {
uint8_t* cgen_var_0_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((accelerationStructureCount)); ++k)
- {
- uint64_t tmpval = get_host_u64_VkAccelerationStructureKHR(local_pAccelerationStructures[k]);
+ for (uint32_t k = 0; k < ((accelerationStructureCount)); ++k) {
+ uint64_t tmpval =
+ get_host_u64_VkAccelerationStructureKHR(local_pAccelerationStructures[k]);
memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
*streamPtrPtr += 8 * ((accelerationStructureCount));
@@ -40065,9 +56692,9 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_firstQuery, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -40075,13 +56702,38 @@
}
void VkEncoder::vkGetDeviceAccelerationStructureCompatibilityKHR(
- VkDevice device,
- const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
- VkAccelerationStructureCompatibilityKHR* pCompatibility,
- uint32_t doLock)
-{
+ VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
+ VkAccelerationStructureCompatibilityKHR* pCompatibility, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetDeviceAccelerationStructureCompatibilityKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetDeviceAccelerationStructureCompatibilityKHR(device:%p, pVersionInfo:%p, "
+ "pCompatibility:%p)",
+ device, pVersionInfo, pCompatibility);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -40089,42 +56741,63 @@
VkAccelerationStructureVersionInfoKHR* local_pVersionInfo;
local_device = device;
local_pVersionInfo = nullptr;
- if (pVersionInfo)
- {
- local_pVersionInfo = (VkAccelerationStructureVersionInfoKHR*)pool->alloc(sizeof(const VkAccelerationStructureVersionInfoKHR));
- deepcopy_VkAccelerationStructureVersionInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pVersionInfo, (VkAccelerationStructureVersionInfoKHR*)(local_pVersionInfo));
+ if (pVersionInfo) {
+ local_pVersionInfo = (VkAccelerationStructureVersionInfoKHR*)pool->alloc(
+ sizeof(const VkAccelerationStructureVersionInfoKHR));
+ deepcopy_VkAccelerationStructureVersionInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pVersionInfo,
+ (VkAccelerationStructureVersionInfoKHR*)(local_pVersionInfo));
}
- if (local_pVersionInfo)
- {
- transform_tohost_VkAccelerationStructureVersionInfoKHR(sResourceTracker, (VkAccelerationStructureVersionInfoKHR*)(local_pVersionInfo));
+ if (local_pVersionInfo) {
+ transform_tohost_VkAccelerationStructureVersionInfoKHR(
+ sResourceTracker, (VkAccelerationStructureVersionInfoKHR*)(local_pVersionInfo));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkAccelerationStructureVersionInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureVersionInfoKHR*)(local_pVersionInfo), countPtr);
+ count_VkAccelerationStructureVersionInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureVersionInfoKHR*)(local_pVersionInfo), countPtr);
*countPtr += sizeof(VkAccelerationStructureCompatibilityKHR);
}
- uint32_t packetSize_vkGetDeviceAccelerationStructureCompatibilityKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- uint8_t* streamPtr = stream->reserve(packetSize_vkGetDeviceAccelerationStructureCompatibilityKHR);
+ uint32_t packetSize_vkGetDeviceAccelerationStructureCompatibilityKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetDeviceAccelerationStructureCompatibilityKHR);
+ uint8_t* streamPtr =
+ stream->reserve(packetSize_vkGetDeviceAccelerationStructureCompatibilityKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetDeviceAccelerationStructureCompatibilityKHR = OP_vkGetDeviceAccelerationStructureCompatibilityKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetDeviceAccelerationStructureCompatibilityKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetDeviceAccelerationStructureCompatibilityKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetDeviceAccelerationStructureCompatibilityKHR =
+ OP_vkGetDeviceAccelerationStructureCompatibilityKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetDeviceAccelerationStructureCompatibilityKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetDeviceAccelerationStructureCompatibilityKHR,
+ sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- reservedmarshal_VkAccelerationStructureVersionInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureVersionInfoKHR*)(local_pVersionInfo), streamPtrPtr);
- memcpy(*streamPtrPtr, (VkAccelerationStructureCompatibilityKHR*)pCompatibility, sizeof(VkAccelerationStructureCompatibilityKHR));
+ reservedmarshal_VkAccelerationStructureVersionInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureVersionInfoKHR*)(local_pVersionInfo), streamPtrPtr);
+ memcpy(*streamPtrPtr, (VkAccelerationStructureCompatibilityKHR*)pCompatibility,
+ sizeof(VkAccelerationStructureCompatibilityKHR));
*streamPtrPtr += sizeof(VkAccelerationStructureCompatibilityKHR);
- stream->read((VkAccelerationStructureCompatibilityKHR*)pCompatibility, sizeof(VkAccelerationStructureCompatibilityKHR));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ stream->read((VkAccelerationStructureCompatibilityKHR*)pCompatibility,
+ sizeof(VkAccelerationStructureCompatibilityKHR));
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -40132,15 +56805,40 @@
}
void VkEncoder::vkGetAccelerationStructureBuildSizesKHR(
- VkDevice device,
- VkAccelerationStructureBuildTypeKHR buildType,
+ VkDevice device, VkAccelerationStructureBuildTypeKHR buildType,
const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo,
- const uint32_t* pMaxPrimitiveCounts,
- VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo,
- uint32_t doLock)
-{
+ const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetAccelerationStructureBuildSizesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetAccelerationStructureBuildSizesKHR(device:%p, pBuildInfo:%p, pMaxPrimitiveCounts:%p, "
+ "pSizeInfo:%p)",
+ device, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -40151,16 +56849,18 @@
local_device = device;
local_buildType = buildType;
local_pBuildInfo = nullptr;
- if (pBuildInfo)
- {
- local_pBuildInfo = (VkAccelerationStructureBuildGeometryInfoKHR*)pool->alloc(sizeof(const VkAccelerationStructureBuildGeometryInfoKHR));
- deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBuildInfo, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pBuildInfo));
+ if (pBuildInfo) {
+ local_pBuildInfo = (VkAccelerationStructureBuildGeometryInfoKHR*)pool->alloc(
+ sizeof(const VkAccelerationStructureBuildGeometryInfoKHR));
+ deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pBuildInfo,
+ (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pBuildInfo));
}
// Avoiding deepcopy for pMaxPrimitiveCounts
local_pMaxPrimitiveCounts = (uint32_t*)pMaxPrimitiveCounts;
- if (local_pBuildInfo)
- {
- transform_tohost_VkAccelerationStructureBuildGeometryInfoKHR(sResourceTracker, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pBuildInfo));
+ if (local_pBuildInfo) {
+ transform_tohost_VkAccelerationStructureBuildGeometryInfoKHR(
+ sResourceTracker, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pBuildInfo));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -40168,49 +56868,69 @@
uint64_t cgen_var_0;
*countPtr += 1 * 8;
*countPtr += sizeof(VkAccelerationStructureBuildTypeKHR);
- count_VkAccelerationStructureBuildGeometryInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pBuildInfo), countPtr);
+ count_VkAccelerationStructureBuildGeometryInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pBuildInfo), countPtr);
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pMaxPrimitiveCounts)
- {
+ if (local_pMaxPrimitiveCounts) {
*countPtr += pBuildInfo->geometryCount * sizeof(uint32_t);
}
- count_VkAccelerationStructureBuildSizesInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildSizesInfoKHR*)(pSizeInfo), countPtr);
+ count_VkAccelerationStructureBuildSizesInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureBuildSizesInfoKHR*)(pSizeInfo), countPtr);
}
- uint32_t packetSize_vkGetAccelerationStructureBuildSizesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetAccelerationStructureBuildSizesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetAccelerationStructureBuildSizesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetAccelerationStructureBuildSizesKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetAccelerationStructureBuildSizesKHR = OP_vkGetAccelerationStructureBuildSizesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetAccelerationStructureBuildSizesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetAccelerationStructureBuildSizesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetAccelerationStructureBuildSizesKHR =
+ OP_vkGetAccelerationStructureBuildSizesKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetAccelerationStructureBuildSizesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetAccelerationStructureBuildSizesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
- memcpy(*streamPtrPtr, (VkAccelerationStructureBuildTypeKHR*)&local_buildType, sizeof(VkAccelerationStructureBuildTypeKHR));
+ memcpy(*streamPtrPtr, (VkAccelerationStructureBuildTypeKHR*)&local_buildType,
+ sizeof(VkAccelerationStructureBuildTypeKHR));
*streamPtrPtr += sizeof(VkAccelerationStructureBuildTypeKHR);
- reservedmarshal_VkAccelerationStructureBuildGeometryInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pBuildInfo), streamPtrPtr);
+ reservedmarshal_VkAccelerationStructureBuildGeometryInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAccelerationStructureBuildGeometryInfoKHR*)(local_pBuildInfo), streamPtrPtr);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)local_pMaxPrimitiveCounts;
memcpy((*streamPtrPtr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pMaxPrimitiveCounts)
- {
- memcpy(*streamPtrPtr, (uint32_t*)local_pMaxPrimitiveCounts, pBuildInfo->geometryCount * sizeof(uint32_t));
+ if (local_pMaxPrimitiveCounts) {
+ memcpy(*streamPtrPtr, (uint32_t*)local_pMaxPrimitiveCounts,
+ pBuildInfo->geometryCount * sizeof(uint32_t));
*streamPtrPtr += pBuildInfo->geometryCount * sizeof(uint32_t);
}
- reservedmarshal_VkAccelerationStructureBuildSizesInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildSizesInfoKHR*)(pSizeInfo), streamPtrPtr);
- unmarshal_VkAccelerationStructureBuildSizesInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildSizesInfoKHR*)(pSizeInfo));
- if (pSizeInfo)
- {
- transform_fromhost_VkAccelerationStructureBuildSizesInfoKHR(sResourceTracker, (VkAccelerationStructureBuildSizesInfoKHR*)(pSizeInfo));
+ reservedmarshal_VkAccelerationStructureBuildSizesInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildSizesInfoKHR*)(pSizeInfo),
+ streamPtrPtr);
+ unmarshal_VkAccelerationStructureBuildSizesInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAccelerationStructureBuildSizesInfoKHR*)(pSizeInfo));
+ if (pSizeInfo) {
+ transform_fromhost_VkAccelerationStructureBuildSizesInfoKHR(
+ sResourceTracker, (VkAccelerationStructureBuildSizesInfoKHR*)(pSizeInfo));
}
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -40220,18 +56940,42 @@
#endif
#ifdef VK_KHR_ray_tracing_pipeline
void VkEncoder::vkCmdTraceRaysKHR(
- VkCommandBuffer commandBuffer,
- const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
+ VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
- const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
- uint32_t width,
- uint32_t height,
- uint32_t depth,
- uint32_t doLock)
-{
+ const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width,
+ uint32_t height, uint32_t depth, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdTraceRaysKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdTraceRaysKHR(commandBuffer:%p, pRaygenShaderBindingTable:%p, "
+ "pMissShaderBindingTable:%p, pHitShaderBindingTable:%p, pCallableShaderBindingTable:%p, "
+ "width:%d, height:%d, depth:%d)",
+ commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable,
+ pCallableShaderBindingTable, width, height, depth);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -40245,88 +56989,115 @@
uint32_t local_depth;
local_commandBuffer = commandBuffer;
local_pRaygenShaderBindingTable = nullptr;
- if (pRaygenShaderBindingTable)
- {
- local_pRaygenShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)pool->alloc(sizeof(const VkStridedDeviceAddressRegionKHR));
- deepcopy_VkStridedDeviceAddressRegionKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRaygenShaderBindingTable, (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable));
+ if (pRaygenShaderBindingTable) {
+ local_pRaygenShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)pool->alloc(
+ sizeof(const VkStridedDeviceAddressRegionKHR));
+ deepcopy_VkStridedDeviceAddressRegionKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRaygenShaderBindingTable,
+ (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable));
}
local_pMissShaderBindingTable = nullptr;
- if (pMissShaderBindingTable)
- {
- local_pMissShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)pool->alloc(sizeof(const VkStridedDeviceAddressRegionKHR));
- deepcopy_VkStridedDeviceAddressRegionKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMissShaderBindingTable, (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable));
+ if (pMissShaderBindingTable) {
+ local_pMissShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)pool->alloc(
+ sizeof(const VkStridedDeviceAddressRegionKHR));
+ deepcopy_VkStridedDeviceAddressRegionKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMissShaderBindingTable,
+ (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable));
}
local_pHitShaderBindingTable = nullptr;
- if (pHitShaderBindingTable)
- {
- local_pHitShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)pool->alloc(sizeof(const VkStridedDeviceAddressRegionKHR));
- deepcopy_VkStridedDeviceAddressRegionKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pHitShaderBindingTable, (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable));
+ if (pHitShaderBindingTable) {
+ local_pHitShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)pool->alloc(
+ sizeof(const VkStridedDeviceAddressRegionKHR));
+ deepcopy_VkStridedDeviceAddressRegionKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pHitShaderBindingTable,
+ (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable));
}
local_pCallableShaderBindingTable = nullptr;
- if (pCallableShaderBindingTable)
- {
- local_pCallableShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)pool->alloc(sizeof(const VkStridedDeviceAddressRegionKHR));
- deepcopy_VkStridedDeviceAddressRegionKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCallableShaderBindingTable, (VkStridedDeviceAddressRegionKHR*)(local_pCallableShaderBindingTable));
+ if (pCallableShaderBindingTable) {
+ local_pCallableShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)pool->alloc(
+ sizeof(const VkStridedDeviceAddressRegionKHR));
+ deepcopy_VkStridedDeviceAddressRegionKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCallableShaderBindingTable,
+ (VkStridedDeviceAddressRegionKHR*)(local_pCallableShaderBindingTable));
}
local_width = width;
local_height = height;
local_depth = depth;
- if (local_pRaygenShaderBindingTable)
- {
- transform_tohost_VkStridedDeviceAddressRegionKHR(sResourceTracker, (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable));
+ if (local_pRaygenShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ sResourceTracker, (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable));
}
- if (local_pMissShaderBindingTable)
- {
- transform_tohost_VkStridedDeviceAddressRegionKHR(sResourceTracker, (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable));
+ if (local_pMissShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ sResourceTracker, (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable));
}
- if (local_pHitShaderBindingTable)
- {
- transform_tohost_VkStridedDeviceAddressRegionKHR(sResourceTracker, (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable));
+ if (local_pHitShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ sResourceTracker, (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable));
}
- if (local_pCallableShaderBindingTable)
- {
- transform_tohost_VkStridedDeviceAddressRegionKHR(sResourceTracker, (VkStridedDeviceAddressRegionKHR*)(local_pCallableShaderBindingTable));
+ if (local_pCallableShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ sResourceTracker,
+ (VkStridedDeviceAddressRegionKHR*)(local_pCallableShaderBindingTable));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkStridedDeviceAddressRegionKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable), countPtr);
- count_VkStridedDeviceAddressRegionKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable), countPtr);
- count_VkStridedDeviceAddressRegionKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable), countPtr);
- count_VkStridedDeviceAddressRegionKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(local_pCallableShaderBindingTable), countPtr);
+ count_VkStridedDeviceAddressRegionKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable), countPtr);
+ count_VkStridedDeviceAddressRegionKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable), countPtr);
+ count_VkStridedDeviceAddressRegionKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable), countPtr);
+ count_VkStridedDeviceAddressRegionKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(local_pCallableShaderBindingTable), countPtr);
*countPtr += sizeof(uint32_t);
*countPtr += sizeof(uint32_t);
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdTraceRaysKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdTraceRaysKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdTraceRaysKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdTraceRaysKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdTraceRaysKHR = OP_vkCmdTraceRaysKHR;
- memcpy(streamPtr, &opcode_vkCmdTraceRaysKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdTraceRaysKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdTraceRaysKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdTraceRaysKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkStridedDeviceAddressRegionKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable), streamPtrPtr);
- reservedmarshal_VkStridedDeviceAddressRegionKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable), streamPtrPtr);
- reservedmarshal_VkStridedDeviceAddressRegionKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable), streamPtrPtr);
- reservedmarshal_VkStridedDeviceAddressRegionKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(local_pCallableShaderBindingTable), streamPtrPtr);
+ reservedmarshal_VkStridedDeviceAddressRegionKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable), streamPtrPtr);
+ reservedmarshal_VkStridedDeviceAddressRegionKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable), streamPtrPtr);
+ reservedmarshal_VkStridedDeviceAddressRegionKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable), streamPtrPtr);
+ reservedmarshal_VkStridedDeviceAddressRegionKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(local_pCallableShaderBindingTable), streamPtrPtr);
memcpy(*streamPtrPtr, (uint32_t*)&local_width, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_height, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
memcpy(*streamPtrPtr, (uint32_t*)&local_depth, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -40334,17 +57105,38 @@
}
VkResult VkEncoder::vkCreateRayTracingPipelinesKHR(
- VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines,
- uint32_t doLock)
-{
+ VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache,
+ uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCreateRayTracingPipelinesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCreateRayTracingPipelinesKHR(device:%p, pipelineCache:%p, createInfoCount:%d, "
+ "pCreateInfos:%p, pAllocator:%p, pPipelines:%p)",
+ device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -40359,31 +57151,31 @@
local_pipelineCache = pipelineCache;
local_createInfoCount = createInfoCount;
local_pCreateInfos = nullptr;
- if (pCreateInfos)
- {
- local_pCreateInfos = (VkRayTracingPipelineCreateInfoKHR*)pool->alloc(((createInfoCount)) * sizeof(const VkRayTracingPipelineCreateInfoKHR));
- for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
- {
- deepcopy_VkRayTracingPipelineCreateInfoKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfos + i, (VkRayTracingPipelineCreateInfoKHR*)(local_pCreateInfos + i));
+ if (pCreateInfos) {
+ local_pCreateInfos = (VkRayTracingPipelineCreateInfoKHR*)pool->alloc(
+ ((createInfoCount)) * sizeof(const VkRayTracingPipelineCreateInfoKHR));
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+ deepcopy_VkRayTracingPipelineCreateInfoKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCreateInfos + i,
+ (VkRayTracingPipelineCreateInfoKHR*)(local_pCreateInfos + i));
}
}
local_pAllocator = nullptr;
- if (pAllocator)
- {
+ if (pAllocator) {
local_pAllocator = (VkAllocationCallbacks*)pool->alloc(sizeof(const VkAllocationCallbacks));
- deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator, (VkAllocationCallbacks*)(local_pAllocator));
+ deepcopy_VkAllocationCallbacks(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pAllocator,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
local_pAllocator = nullptr;
- if (local_pCreateInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
- {
- transform_tohost_VkRayTracingPipelineCreateInfoKHR(sResourceTracker, (VkRayTracingPipelineCreateInfoKHR*)(local_pCreateInfos + i));
+ if (local_pCreateInfos) {
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+ transform_tohost_VkRayTracingPipelineCreateInfoKHR(
+ sResourceTracker, (VkRayTracingPipelineCreateInfoKHR*)(local_pCreateInfos + i));
}
}
- if (local_pAllocator)
- {
- transform_tohost_VkAllocationCallbacks(sResourceTracker, (VkAllocationCallbacks*)(local_pAllocator));
+ if (local_pAllocator) {
+ transform_tohost_VkAllocationCallbacks(sResourceTracker,
+ (VkAllocationCallbacks*)(local_pAllocator));
}
size_t count = 0;
size_t* countPtr = &count;
@@ -40394,29 +57186,39 @@
uint64_t cgen_var_1;
*countPtr += 1 * 8;
*countPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
- {
- count_VkRayTracingPipelineCreateInfoKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRayTracingPipelineCreateInfoKHR*)(local_pCreateInfos + i), countPtr);
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+ count_VkRayTracingPipelineCreateInfoKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRayTracingPipelineCreateInfoKHR*)(local_pCreateInfos + i), countPtr);
}
// WARNING PTR CHECK
*countPtr += 8;
- if (local_pAllocator)
- {
- count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), countPtr);
+ if (local_pAllocator) {
+ count_VkAllocationCallbacks(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator), countPtr);
}
- if (((createInfoCount)))
- {
+ if (((createInfoCount))) {
*countPtr += ((createInfoCount)) * 8;
}
}
- uint32_t packetSize_vkCreateRayTracingPipelinesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkCreateRayTracingPipelinesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCreateRayTracingPipelinesKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkCreateRayTracingPipelinesKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCreateRayTracingPipelinesKHR = OP_vkCreateRayTracingPipelinesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkCreateRayTracingPipelinesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCreateRayTracingPipelinesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkCreateRayTracingPipelinesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCreateRayTracingPipelinesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -40431,43 +57233,43 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_createInfoCount, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i)
- {
- reservedmarshal_VkRayTracingPipelineCreateInfoKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkRayTracingPipelineCreateInfoKHR*)(local_pCreateInfos + i), streamPtrPtr);
+ for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+ reservedmarshal_VkRayTracingPipelineCreateInfoKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkRayTracingPipelineCreateInfoKHR*)(local_pCreateInfos + i), streamPtrPtr);
}
// WARNING PTR CHECK
uint64_t cgen_var_3 = (uint64_t)(uintptr_t)local_pAllocator;
memcpy((*streamPtrPtr), &cgen_var_3, 8);
android::base::Stream::toBe64((uint8_t*)(*streamPtrPtr));
*streamPtrPtr += 8;
- if (local_pAllocator)
- {
- reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkAllocationCallbacks*)(local_pAllocator), streamPtrPtr);
+ if (local_pAllocator) {
+ reservedmarshal_VkAllocationCallbacks(stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(local_pAllocator),
+ streamPtrPtr);
}
/* is handle, possibly out */;
- if (((createInfoCount)))
- {
+ if (((createInfoCount))) {
uint8_t* cgen_var_4_ptr = (uint8_t*)(*streamPtrPtr);
- for (uint32_t k = 0; k < ((createInfoCount)); ++k)
- {
+ for (uint32_t k = 0; k < ((createInfoCount)); ++k) {
uint64_t tmpval = (uint64_t)(pPipelines[k]);
memcpy(cgen_var_4_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
*streamPtrPtr += 8 * ((createInfoCount));
}
/* is handle, possibly out */;
- if (((createInfoCount)))
- {
+ if (((createInfoCount))) {
uint64_t* cgen_var_5;
stream->alloc((void**)&cgen_var_5, ((createInfoCount)) * 8);
stream->read((uint64_t*)cgen_var_5, ((createInfoCount)) * 8);
- stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_5, (VkPipeline*)pPipelines, ((createInfoCount)));
+ stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_5, (VkPipeline*)pPipelines,
+ ((createInfoCount)));
}
VkResult vkCreateRayTracingPipelinesKHR_VkResult_return = (VkResult)0;
stream->read(&vkCreateRayTracingPipelinesKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -40476,16 +57278,38 @@
}
VkResult VkEncoder::vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
- VkDevice device,
- VkPipeline pipeline,
- uint32_t firstGroup,
- uint32_t groupCount,
- size_t dataSize,
- void* pData,
- uint32_t doLock)
-{
+ VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize,
+ void* pData, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(device:%p, pipeline:%p, firstGroup:%d, "
+ "groupCount:%d, dataSize:%ld, pData:%p)",
+ device, pipeline, firstGroup, groupCount, dataSize, pData);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -40511,14 +57335,27 @@
*countPtr += 8;
*countPtr += ((dataSize)) * sizeof(uint8_t);
}
- uint32_t packetSize_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
- uint8_t* streamPtr = stream->reserve(packetSize_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR);
+ uint32_t packetSize_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR);
+ uint8_t* streamPtr =
+ stream->reserve(packetSize_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = OP_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR =
+ OP_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
+ sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -40539,10 +57376,11 @@
*streamPtrPtr += ((dataSize)) * sizeof(uint8_t);
stream->read((void*)pData, ((dataSize)) * sizeof(uint8_t));
VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return = (VkResult)0;
- stream->read(&vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return, sizeof(VkResult));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ stream->read(&vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return,
+ sizeof(VkResult));
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -40551,16 +57389,41 @@
}
void VkEncoder::vkCmdTraceRaysIndirectKHR(
- VkCommandBuffer commandBuffer,
- const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
+ VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
- VkDeviceAddress indirectDeviceAddress,
- uint32_t doLock)
-{
+ VkDeviceAddress indirectDeviceAddress, uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor, "vkCmdTraceRaysIndirectKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdTraceRaysIndirectKHR(commandBuffer:%p, pRaygenShaderBindingTable:%p, "
+ "pMissShaderBindingTable:%p, pHitShaderBindingTable:%p, pCallableShaderBindingTable:%p)",
+ commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable,
+ pCallableShaderBindingTable);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -40572,95 +57435,145 @@
VkDeviceAddress local_indirectDeviceAddress;
local_commandBuffer = commandBuffer;
local_pRaygenShaderBindingTable = nullptr;
- if (pRaygenShaderBindingTable)
- {
- local_pRaygenShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)pool->alloc(sizeof(const VkStridedDeviceAddressRegionKHR));
- deepcopy_VkStridedDeviceAddressRegionKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRaygenShaderBindingTable, (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable));
+ if (pRaygenShaderBindingTable) {
+ local_pRaygenShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)pool->alloc(
+ sizeof(const VkStridedDeviceAddressRegionKHR));
+ deepcopy_VkStridedDeviceAddressRegionKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pRaygenShaderBindingTable,
+ (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable));
}
local_pMissShaderBindingTable = nullptr;
- if (pMissShaderBindingTable)
- {
- local_pMissShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)pool->alloc(sizeof(const VkStridedDeviceAddressRegionKHR));
- deepcopy_VkStridedDeviceAddressRegionKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMissShaderBindingTable, (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable));
+ if (pMissShaderBindingTable) {
+ local_pMissShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)pool->alloc(
+ sizeof(const VkStridedDeviceAddressRegionKHR));
+ deepcopy_VkStridedDeviceAddressRegionKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pMissShaderBindingTable,
+ (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable));
}
local_pHitShaderBindingTable = nullptr;
- if (pHitShaderBindingTable)
- {
- local_pHitShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)pool->alloc(sizeof(const VkStridedDeviceAddressRegionKHR));
- deepcopy_VkStridedDeviceAddressRegionKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pHitShaderBindingTable, (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable));
+ if (pHitShaderBindingTable) {
+ local_pHitShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)pool->alloc(
+ sizeof(const VkStridedDeviceAddressRegionKHR));
+ deepcopy_VkStridedDeviceAddressRegionKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pHitShaderBindingTable,
+ (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable));
}
local_pCallableShaderBindingTable = nullptr;
- if (pCallableShaderBindingTable)
- {
- local_pCallableShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)pool->alloc(sizeof(const VkStridedDeviceAddressRegionKHR));
- deepcopy_VkStridedDeviceAddressRegionKHR(pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCallableShaderBindingTable, (VkStridedDeviceAddressRegionKHR*)(local_pCallableShaderBindingTable));
+ if (pCallableShaderBindingTable) {
+ local_pCallableShaderBindingTable = (VkStridedDeviceAddressRegionKHR*)pool->alloc(
+ sizeof(const VkStridedDeviceAddressRegionKHR));
+ deepcopy_VkStridedDeviceAddressRegionKHR(
+ pool, VK_STRUCTURE_TYPE_MAX_ENUM, pCallableShaderBindingTable,
+ (VkStridedDeviceAddressRegionKHR*)(local_pCallableShaderBindingTable));
}
local_indirectDeviceAddress = indirectDeviceAddress;
- if (local_pRaygenShaderBindingTable)
- {
- transform_tohost_VkStridedDeviceAddressRegionKHR(sResourceTracker, (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable));
+ if (local_pRaygenShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ sResourceTracker, (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable));
}
- if (local_pMissShaderBindingTable)
- {
- transform_tohost_VkStridedDeviceAddressRegionKHR(sResourceTracker, (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable));
+ if (local_pMissShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ sResourceTracker, (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable));
}
- if (local_pHitShaderBindingTable)
- {
- transform_tohost_VkStridedDeviceAddressRegionKHR(sResourceTracker, (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable));
+ if (local_pHitShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ sResourceTracker, (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable));
}
- if (local_pCallableShaderBindingTable)
- {
- transform_tohost_VkStridedDeviceAddressRegionKHR(sResourceTracker, (VkStridedDeviceAddressRegionKHR*)(local_pCallableShaderBindingTable));
+ if (local_pCallableShaderBindingTable) {
+ transform_tohost_VkStridedDeviceAddressRegionKHR(
+ sResourceTracker,
+ (VkStridedDeviceAddressRegionKHR*)(local_pCallableShaderBindingTable));
}
size_t count = 0;
size_t* countPtr = &count;
{
uint64_t cgen_var_0;
*countPtr += 1 * 8;
- count_VkStridedDeviceAddressRegionKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable), countPtr);
- count_VkStridedDeviceAddressRegionKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable), countPtr);
- count_VkStridedDeviceAddressRegionKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable), countPtr);
- count_VkStridedDeviceAddressRegionKHR(sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(local_pCallableShaderBindingTable), countPtr);
+ count_VkStridedDeviceAddressRegionKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable), countPtr);
+ count_VkStridedDeviceAddressRegionKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable), countPtr);
+ count_VkStridedDeviceAddressRegionKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable), countPtr);
+ count_VkStridedDeviceAddressRegionKHR(
+ sFeatureBits, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(local_pCallableShaderBindingTable), countPtr);
*countPtr += sizeof(VkDeviceAddress);
}
uint32_t packetSize_vkCmdTraceRaysIndirectKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize = std::make_optional(packetSize_vkCmdTraceRaysIndirectKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdTraceRaysIndirectKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdTraceRaysIndirectKHR);
uint8_t** streamPtrPtr = &streamPtr;
uint32_t opcode_vkCmdTraceRaysIndirectKHR = OP_vkCmdTraceRaysIndirectKHR;
- memcpy(streamPtr, &opcode_vkCmdTraceRaysIndirectKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdTraceRaysIndirectKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ memcpy(streamPtr, &opcode_vkCmdTraceRaysIndirectKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdTraceRaysIndirectKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
*streamPtrPtr += 1 * 8;
}
- reservedmarshal_VkStridedDeviceAddressRegionKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable), streamPtrPtr);
- reservedmarshal_VkStridedDeviceAddressRegionKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable), streamPtrPtr);
- reservedmarshal_VkStridedDeviceAddressRegionKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable), streamPtrPtr);
- reservedmarshal_VkStridedDeviceAddressRegionKHR(stream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkStridedDeviceAddressRegionKHR*)(local_pCallableShaderBindingTable), streamPtrPtr);
+ reservedmarshal_VkStridedDeviceAddressRegionKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(local_pRaygenShaderBindingTable), streamPtrPtr);
+ reservedmarshal_VkStridedDeviceAddressRegionKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(local_pMissShaderBindingTable), streamPtrPtr);
+ reservedmarshal_VkStridedDeviceAddressRegionKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(local_pHitShaderBindingTable), streamPtrPtr);
+ reservedmarshal_VkStridedDeviceAddressRegionKHR(
+ stream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkStridedDeviceAddressRegionKHR*)(local_pCallableShaderBindingTable), streamPtrPtr);
memcpy(*streamPtrPtr, (VkDeviceAddress*)&local_indirectDeviceAddress, sizeof(VkDeviceAddress));
*streamPtrPtr += sizeof(VkDeviceAddress);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
if (!queueSubmitWithCommandsEnabled && doLock) this->unlock();
}
-VkDeviceSize VkEncoder::vkGetRayTracingShaderGroupStackSizeKHR(
- VkDevice device,
- VkPipeline pipeline,
- uint32_t group,
- VkShaderGroupShaderKHR groupShader,
- uint32_t doLock)
-{
+VkDeviceSize VkEncoder::vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline,
+ uint32_t group,
+ VkShaderGroupShaderKHR groupShader,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkGetRayTracingShaderGroupStackSizeKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG("vkGetRayTracingShaderGroupStackSizeKHR(device:%p, pipeline:%p, group:%d)",
+ device, pipeline, group);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -40682,14 +57595,25 @@
*countPtr += sizeof(uint32_t);
*countPtr += sizeof(VkShaderGroupShaderKHR);
}
- uint32_t packetSize_vkGetRayTracingShaderGroupStackSizeKHR = 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ uint32_t packetSize_vkGetRayTracingShaderGroupStackSizeKHR =
+ 4 + 4 + (queueSubmitWithCommandsEnabled ? 4 : 0) + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkGetRayTracingShaderGroupStackSizeKHR);
uint8_t* streamPtr = stream->reserve(packetSize_vkGetRayTracingShaderGroupStackSizeKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkGetRayTracingShaderGroupStackSizeKHR = OP_vkGetRayTracingShaderGroupStackSizeKHR;
- uint32_t seqno; if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
- memcpy(streamPtr, &opcode_vkGetRayTracingShaderGroupStackSizeKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkGetRayTracingShaderGroupStackSizeKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (queueSubmitWithCommandsEnabled) { memcpy(streamPtr, &seqno, sizeof(uint32_t)); streamPtr += sizeof(uint32_t); }
+ uint32_t opcode_vkGetRayTracingShaderGroupStackSizeKHR =
+ OP_vkGetRayTracingShaderGroupStackSizeKHR;
+ uint32_t seqno;
+ if (queueSubmitWithCommandsEnabled) seqno = ResourceTracker::nextSeqno();
+ healthMonitorAnnotation_seqno = std::make_optional(seqno);
+ memcpy(streamPtr, &opcode_vkGetRayTracingShaderGroupStackSizeKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkGetRayTracingShaderGroupStackSizeKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (queueSubmitWithCommandsEnabled) {
+ memcpy(streamPtr, &seqno, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ }
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDevice((*&local_device));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -40700,13 +57624,14 @@
*streamPtrPtr += 1 * 8;
memcpy(*streamPtrPtr, (uint32_t*)&local_group, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- memcpy(*streamPtrPtr, (VkShaderGroupShaderKHR*)&local_groupShader, sizeof(VkShaderGroupShaderKHR));
+ memcpy(*streamPtrPtr, (VkShaderGroupShaderKHR*)&local_groupShader,
+ sizeof(VkShaderGroupShaderKHR));
*streamPtrPtr += sizeof(VkShaderGroupShaderKHR);
VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR_VkDeviceSize_return = (VkDeviceSize)0;
stream->read(&vkGetRayTracingShaderGroupStackSizeKHR_VkDeviceSize_return, sizeof(VkDeviceSize));
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -40714,13 +57639,38 @@
return vkGetRayTracingShaderGroupStackSizeKHR_VkDeviceSize_return;
}
-void VkEncoder::vkCmdSetRayTracingPipelineStackSizeKHR(
- VkCommandBuffer commandBuffer,
- uint32_t pipelineStackSize,
- uint32_t doLock)
-{
+void VkEncoder::vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer,
+ uint32_t pipelineStackSize,
+ uint32_t doLock) {
+ std::optional<uint32_t> healthMonitorAnnotation_seqno = std::nullopt;
+ std::optional<uint32_t> healthMonitorAnnotation_packetSize = std::nullopt;
+
+ auto watchdog =
+ mHealthMonitor
+ ? WATCHDOG_BUILDER(*mHealthMonitor,
+ "vkCmdSetRayTracingPipelineStackSizeKHR in VkEncoder")
+ .setOnHangCallback([&]() {
+ auto annotations = std::make_unique<EventHangMetadata::HangAnnotations>();
+ if (healthMonitorAnnotation_seqno) {
+ annotations->insert(
+ {{"seqno", std::to_string(healthMonitorAnnotation_seqno.value())}});
+ }
+ if (healthMonitorAnnotation_packetSize) {
+ annotations->insert(
+ {{"packetSize",
+ std::to_string(healthMonitorAnnotation_packetSize.value())}});
+ }
+ return std::move(annotations);
+ })
+ .build()
+ : nullptr;
+
+ ENCODER_DEBUG_LOG(
+ "vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer:%p, pipelineStackSize:%d)",
+ commandBuffer, pipelineStackSize);
(void)doLock;
- bool queueSubmitWithCommandsEnabled = sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
+ bool queueSubmitWithCommandsEnabled =
+ sFeatureBits & VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT;
if (!queueSubmitWithCommandsEnabled && doLock) this->lock();
auto stream = mImpl->stream();
auto pool = mImpl->pool();
@@ -40736,14 +57686,18 @@
*countPtr += sizeof(uint32_t);
}
uint32_t packetSize_vkCmdSetRayTracingPipelineStackSizeKHR = 4 + 4 + count;
+ healthMonitorAnnotation_packetSize =
+ std::make_optional(packetSize_vkCmdSetRayTracingPipelineStackSizeKHR);
if (queueSubmitWithCommandsEnabled) packetSize_vkCmdSetRayTracingPipelineStackSizeKHR -= 8;
uint8_t* streamPtr = stream->reserve(packetSize_vkCmdSetRayTracingPipelineStackSizeKHR);
uint8_t** streamPtrPtr = &streamPtr;
- uint32_t opcode_vkCmdSetRayTracingPipelineStackSizeKHR = OP_vkCmdSetRayTracingPipelineStackSizeKHR;
- memcpy(streamPtr, &opcode_vkCmdSetRayTracingPipelineStackSizeKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- memcpy(streamPtr, &packetSize_vkCmdSetRayTracingPipelineStackSizeKHR, sizeof(uint32_t)); streamPtr += sizeof(uint32_t);
- if (!queueSubmitWithCommandsEnabled)
- {
+ uint32_t opcode_vkCmdSetRayTracingPipelineStackSizeKHR =
+ OP_vkCmdSetRayTracingPipelineStackSizeKHR;
+ memcpy(streamPtr, &opcode_vkCmdSetRayTracingPipelineStackSizeKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ memcpy(streamPtr, &packetSize_vkCmdSetRayTracingPipelineStackSizeKHR, sizeof(uint32_t));
+ streamPtr += sizeof(uint32_t);
+ if (!queueSubmitWithCommandsEnabled) {
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkCommandBuffer((*&local_commandBuffer));
memcpy(*streamPtrPtr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -40751,9 +57705,9 @@
}
memcpy(*streamPtrPtr, (uint32_t*)&local_pipelineStackSize, sizeof(uint32_t));
*streamPtrPtr += sizeof(uint32_t);
- ++encodeCount;;
- if (0 == encodeCount % POOL_CLEAR_INTERVAL)
- {
+ ++encodeCount;
+ ;
+ if (0 == encodeCount % POOL_CLEAR_INTERVAL) {
pool->freeAll();
stream->clearPool();
}
@@ -40764,4 +57718,4 @@
#ifdef VK_KHR_ray_query
#endif
-} // namespace goldfish_vk
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/VkEncoder.cpp.inl b/system/vulkan_enc/VkEncoder.cpp.inl
index dae61b5..6351a6e 100644
--- a/system/vulkan_enc/VkEncoder.cpp.inl
+++ b/system/vulkan_enc/VkEncoder.cpp.inl
@@ -2,7 +2,7 @@
static uint32_t sFeatureBits = 0;
class VkEncoder::Impl {
-public:
+ public:
Impl(IOStream* stream) : m_stream(stream), m_logEncodes(false) {
if (!sResourceTracker) sResourceTracker = ResourceTracker::get();
m_stream.incStreamRef();
@@ -14,9 +14,7 @@
sFeatureBits = m_stream.getFeatureBits();
}
- ~Impl() {
- m_stream.decStreamRef();
- }
+ ~Impl() { m_stream.decStreamRef(); }
VulkanCountingStream* countingStream() { return &m_countingStream; }
VulkanStreamGuest* stream() { return &m_stream; }
@@ -37,14 +35,13 @@
// can be recursive
void lock() {
- while (mLock.test_and_set(std::memory_order_acquire));
+ while (mLock.test_and_set(std::memory_order_acquire))
+ ;
}
- void unlock() {
- mLock.clear(std::memory_order_release);
- }
+ void unlock() { mLock.clear(std::memory_order_release); }
-private:
+ private:
VulkanCountingStream m_countingStream;
VulkanStreamGuest m_stream;
BumpPool m_pool;
@@ -54,36 +51,24 @@
std::atomic_flag mLock = ATOMIC_FLAG_INIT;
};
-VkEncoder::~VkEncoder() { }
+VkEncoder::~VkEncoder() {}
struct EncoderAutoLock {
- EncoderAutoLock(VkEncoder* enc) : mEnc(enc) {
- mEnc->lock();
- }
- ~EncoderAutoLock() {
- mEnc->unlock();
- }
+ EncoderAutoLock(VkEncoder* enc) : mEnc(enc) { mEnc->lock(); }
+ ~EncoderAutoLock() { mEnc->unlock(); }
VkEncoder* mEnc;
};
-VkEncoder::VkEncoder(IOStream *stream) :
- mImpl(new VkEncoder::Impl(stream)) { }
+VkEncoder::VkEncoder(IOStream* stream, android::base::guest::HealthMonitor<>* healthMonitor)
+ : mImpl(new VkEncoder::Impl(stream)), mHealthMonitor(healthMonitor) {}
-void VkEncoder::flush() {
- mImpl->flush();
-}
+void VkEncoder::flush() { mImpl->flush(); }
-void VkEncoder::lock() {
- mImpl->lock();
-}
+void VkEncoder::lock() { mImpl->lock(); }
-void VkEncoder::unlock() {
- mImpl->unlock();
-}
+void VkEncoder::unlock() { mImpl->unlock(); }
-void VkEncoder::incRef() {
- __atomic_add_fetch(&refCount, 1, __ATOMIC_SEQ_CST);
-}
+void VkEncoder::incRef() { __atomic_add_fetch(&refCount, 1, __ATOMIC_SEQ_CST); }
bool VkEncoder::decRef() {
if (0 == __atomic_sub_fetch(&refCount, 1, __ATOMIC_SEQ_CST)) {
diff --git a/system/vulkan_enc/VkEncoder.h b/system/vulkan_enc/VkEncoder.h
index c42704b..1283d35 100644
--- a/system/vulkan_enc/VkEncoder.h
+++ b/system/vulkan_enc/VkEncoder.h
@@ -14,1486 +14,795 @@
// limitations under the License.
// Autogenerated module VkEncoder
-// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal -o ../qemu/android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+//
+// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
+// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
-// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
-
+//
+// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
+// $CEREAL_OUTPUT_DIR
+//
#pragma once
-
#include <vulkan/vulkan.h>
-
-#include "goldfish_vk_private_defs.h"
#include <memory>
-class IOStream;
+#include "android/base/AndroidHealthMonitor.h"
+#include "goldfish_vk_private_defs.h"
+#include "vulkan_gfxstream.h"
+class IOStream;
namespace goldfish_vk {
+using android::base::guest::HealthMonitor;
class VkEncoder {
-public:
- VkEncoder(IOStream* stream);
+ public:
+ VkEncoder(IOStream* stream, HealthMonitor<>* healthMonitor = nullptr);
~VkEncoder();
#include "VkEncoder.h.inl"
#ifdef VK_VERSION_1_0
- VkResult vkCreateInstance(
- const VkInstanceCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkInstance* pInstance,
- uint32_t doLock);
- void vkDestroyInstance(
- VkInstance instance,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkEnumeratePhysicalDevices(
- VkInstance instance,
- uint32_t* pPhysicalDeviceCount,
- VkPhysicalDevice* pPhysicalDevices,
- uint32_t doLock);
- void vkGetPhysicalDeviceFeatures(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures* pFeatures,
- uint32_t doLock);
- void vkGetPhysicalDeviceFormatProperties(
- VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties* pFormatProperties,
- uint32_t doLock);
+ VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkInstance* pInstance,
+ uint32_t doLock);
+ void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock);
+ VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount,
+ VkPhysicalDevice* pPhysicalDevices, uint32_t doLock);
+ void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures* pFeatures, uint32_t doLock);
+ void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
+ VkFormatProperties* pFormatProperties,
+ uint32_t doLock);
VkResult vkGetPhysicalDeviceImageFormatProperties(
- VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkImageType type,
- VkImageTiling tiling,
- VkImageUsageFlags usage,
- VkImageCreateFlags flags,
- VkImageFormatProperties* pImageFormatProperties,
- uint32_t doLock);
- void vkGetPhysicalDeviceProperties(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties* pProperties,
- uint32_t doLock);
- void vkGetPhysicalDeviceQueueFamilyProperties(
- VkPhysicalDevice physicalDevice,
- uint32_t* pQueueFamilyPropertyCount,
- VkQueueFamilyProperties* pQueueFamilyProperties,
- uint32_t doLock);
- void vkGetPhysicalDeviceMemoryProperties(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceMemoryProperties* pMemoryProperties,
- uint32_t doLock);
- PFN_vkVoidFunction vkGetInstanceProcAddr(
- VkInstance instance,
- const char* pName,
- uint32_t doLock);
- PFN_vkVoidFunction vkGetDeviceProcAddr(
- VkDevice device,
- const char* pName,
- uint32_t doLock);
- VkResult vkCreateDevice(
- VkPhysicalDevice physicalDevice,
- const VkDeviceCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDevice* pDevice,
- uint32_t doLock);
- void vkDestroyDevice(
- VkDevice device,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkEnumerateInstanceExtensionProperties(
- const char* pLayerName,
- uint32_t* pPropertyCount,
- VkExtensionProperties* pProperties,
- uint32_t doLock);
- VkResult vkEnumerateDeviceExtensionProperties(
- VkPhysicalDevice physicalDevice,
- const char* pLayerName,
- uint32_t* pPropertyCount,
- VkExtensionProperties* pProperties,
- uint32_t doLock);
- VkResult vkEnumerateInstanceLayerProperties(
- uint32_t* pPropertyCount,
- VkLayerProperties* pProperties,
- uint32_t doLock);
- VkResult vkEnumerateDeviceLayerProperties(
- VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkLayerProperties* pProperties,
- uint32_t doLock);
- void vkGetDeviceQueue(
- VkDevice device,
- uint32_t queueFamilyIndex,
- uint32_t queueIndex,
- VkQueue* pQueue,
- uint32_t doLock);
- VkResult vkQueueSubmit(
- VkQueue queue,
- uint32_t submitCount,
- const VkSubmitInfo* pSubmits,
- VkFence fence,
- uint32_t doLock);
- VkResult vkQueueWaitIdle(
- VkQueue queue,
- uint32_t doLock);
- VkResult vkDeviceWaitIdle(
- VkDevice device,
- uint32_t doLock);
- VkResult vkAllocateMemory(
- VkDevice device,
- const VkMemoryAllocateInfo* pAllocateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDeviceMemory* pMemory,
- uint32_t doLock);
- void vkFreeMemory(
- VkDevice device,
- VkDeviceMemory memory,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkMapMemory(
- VkDevice device,
- VkDeviceMemory memory,
- VkDeviceSize offset,
- VkDeviceSize size,
- VkMemoryMapFlags flags,
- void** ppData,
- uint32_t doLock);
- void vkUnmapMemory(
- VkDevice device,
- VkDeviceMemory memory,
- uint32_t doLock);
- VkResult vkFlushMappedMemoryRanges(
- VkDevice device,
- uint32_t memoryRangeCount,
- const VkMappedMemoryRange* pMemoryRanges,
- uint32_t doLock);
- VkResult vkInvalidateMappedMemoryRanges(
- VkDevice device,
- uint32_t memoryRangeCount,
- const VkMappedMemoryRange* pMemoryRanges,
- uint32_t doLock);
- void vkGetDeviceMemoryCommitment(
- VkDevice device,
- VkDeviceMemory memory,
- VkDeviceSize* pCommittedMemoryInBytes,
- uint32_t doLock);
- VkResult vkBindBufferMemory(
- VkDevice device,
- VkBuffer buffer,
- VkDeviceMemory memory,
- VkDeviceSize memoryOffset,
- uint32_t doLock);
- VkResult vkBindImageMemory(
- VkDevice device,
- VkImage image,
- VkDeviceMemory memory,
- VkDeviceSize memoryOffset,
- uint32_t doLock);
- void vkGetBufferMemoryRequirements(
- VkDevice device,
- VkBuffer buffer,
- VkMemoryRequirements* pMemoryRequirements,
- uint32_t doLock);
- void vkGetImageMemoryRequirements(
- VkDevice device,
- VkImage image,
- VkMemoryRequirements* pMemoryRequirements,
- uint32_t doLock);
+ VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling,
+ VkImageUsageFlags usage, VkImageCreateFlags flags,
+ VkImageFormatProperties* pImageFormatProperties, uint32_t doLock);
+ void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties* pProperties, uint32_t doLock);
+ void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties* pQueueFamilyProperties,
+ uint32_t doLock);
+ void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties* pMemoryProperties,
+ uint32_t doLock);
+ PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* pName,
+ uint32_t doLock);
+ PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char* pName, uint32_t doLock);
+ VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkDevice* pDevice,
+ uint32_t doLock);
+ void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties,
+ uint32_t doLock);
+ VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
+ const char* pLayerName, uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties,
+ uint32_t doLock);
+ VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties, uint32_t doLock);
+ VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties, uint32_t doLock);
+ void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex,
+ VkQueue* pQueue, uint32_t doLock);
+ VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits,
+ VkFence fence, uint32_t doLock);
+ VkResult vkQueueWaitIdle(VkQueue queue, uint32_t doLock);
+ VkResult vkDeviceWaitIdle(VkDevice device, uint32_t doLock);
+ VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory,
+ uint32_t doLock);
+ void vkFreeMemory(VkDevice device, VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset,
+ VkDeviceSize size, VkMemoryMapFlags flags, void** ppData, uint32_t doLock);
+ void vkUnmapMemory(VkDevice device, VkDeviceMemory memory, uint32_t doLock);
+ VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges, uint32_t doLock);
+ VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges,
+ uint32_t doLock);
+ void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
+ VkDeviceSize* pCommittedMemoryInBytes, uint32_t doLock);
+ VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
+ VkDeviceSize memoryOffset, uint32_t doLock);
+ VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory,
+ VkDeviceSize memoryOffset, uint32_t doLock);
+ void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
+ VkMemoryRequirements* pMemoryRequirements, uint32_t doLock);
+ void vkGetImageMemoryRequirements(VkDevice device, VkImage image,
+ VkMemoryRequirements* pMemoryRequirements, uint32_t doLock);
void vkGetImageSparseMemoryRequirements(
- VkDevice device,
- VkImage image,
- uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements* pSparseMemoryRequirements,
- uint32_t doLock);
+ VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements* pSparseMemoryRequirements, uint32_t doLock);
void vkGetPhysicalDeviceSparseImageFormatProperties(
- VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkImageType type,
- VkSampleCountFlagBits samples,
- VkImageUsageFlags usage,
- VkImageTiling tiling,
- uint32_t* pPropertyCount,
- VkSparseImageFormatProperties* pProperties,
- uint32_t doLock);
- VkResult vkQueueBindSparse(
- VkQueue queue,
- uint32_t bindInfoCount,
- const VkBindSparseInfo* pBindInfo,
- VkFence fence,
- uint32_t doLock);
- VkResult vkCreateFence(
- VkDevice device,
- const VkFenceCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkFence* pFence,
- uint32_t doLock);
- void vkDestroyFence(
- VkDevice device,
- VkFence fence,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkResetFences(
- VkDevice device,
- uint32_t fenceCount,
- const VkFence* pFences,
- uint32_t doLock);
- VkResult vkGetFenceStatus(
- VkDevice device,
- VkFence fence,
- uint32_t doLock);
- VkResult vkWaitForFences(
- VkDevice device,
- uint32_t fenceCount,
- const VkFence* pFences,
- VkBool32 waitAll,
- uint64_t timeout,
- uint32_t doLock);
- VkResult vkCreateSemaphore(
- VkDevice device,
- const VkSemaphoreCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSemaphore* pSemaphore,
- uint32_t doLock);
- void vkDestroySemaphore(
- VkDevice device,
- VkSemaphore semaphore,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkCreateEvent(
- VkDevice device,
- const VkEventCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkEvent* pEvent,
- uint32_t doLock);
- void vkDestroyEvent(
- VkDevice device,
- VkEvent event,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkGetEventStatus(
- VkDevice device,
- VkEvent event,
- uint32_t doLock);
- VkResult vkSetEvent(
- VkDevice device,
- VkEvent event,
- uint32_t doLock);
- VkResult vkResetEvent(
- VkDevice device,
- VkEvent event,
- uint32_t doLock);
- VkResult vkCreateQueryPool(
- VkDevice device,
- const VkQueryPoolCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkQueryPool* pQueryPool,
- uint32_t doLock);
- void vkDestroyQueryPool(
- VkDevice device,
- VkQueryPool queryPool,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkGetQueryPoolResults(
- VkDevice device,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t queryCount,
- size_t dataSize,
- void* pData,
- VkDeviceSize stride,
- VkQueryResultFlags flags,
- uint32_t doLock);
- VkResult vkCreateBuffer(
- VkDevice device,
- const VkBufferCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkBuffer* pBuffer,
- uint32_t doLock);
- void vkDestroyBuffer(
- VkDevice device,
- VkBuffer buffer,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkCreateBufferView(
- VkDevice device,
- const VkBufferViewCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkBufferView* pView,
- uint32_t doLock);
- void vkDestroyBufferView(
- VkDevice device,
- VkBufferView bufferView,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkCreateImage(
- VkDevice device,
- const VkImageCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkImage* pImage,
- uint32_t doLock);
- void vkDestroyImage(
- VkDevice device,
- VkImage image,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- void vkGetImageSubresourceLayout(
- VkDevice device,
- VkImage image,
- const VkImageSubresource* pSubresource,
- VkSubresourceLayout* pLayout,
- uint32_t doLock);
- VkResult vkCreateImageView(
- VkDevice device,
- const VkImageViewCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkImageView* pView,
- uint32_t doLock);
- void vkDestroyImageView(
- VkDevice device,
- VkImageView imageView,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkCreateShaderModule(
- VkDevice device,
- const VkShaderModuleCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkShaderModule* pShaderModule,
- uint32_t doLock);
- void vkDestroyShaderModule(
- VkDevice device,
- VkShaderModule shaderModule,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkCreatePipelineCache(
- VkDevice device,
- const VkPipelineCacheCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPipelineCache* pPipelineCache,
- uint32_t doLock);
- void vkDestroyPipelineCache(
- VkDevice device,
- VkPipelineCache pipelineCache,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkGetPipelineCacheData(
- VkDevice device,
- VkPipelineCache pipelineCache,
- size_t* pDataSize,
- void* pData,
- uint32_t doLock);
- VkResult vkMergePipelineCaches(
- VkDevice device,
- VkPipelineCache dstCache,
- uint32_t srcCacheCount,
- const VkPipelineCache* pSrcCaches,
- uint32_t doLock);
- VkResult vkCreateGraphicsPipelines(
- VkDevice device,
- VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkGraphicsPipelineCreateInfo* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines,
- uint32_t doLock);
- VkResult vkCreateComputePipelines(
- VkDevice device,
- VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkComputePipelineCreateInfo* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines,
- uint32_t doLock);
- void vkDestroyPipeline(
- VkDevice device,
- VkPipeline pipeline,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkCreatePipelineLayout(
- VkDevice device,
- const VkPipelineLayoutCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPipelineLayout* pPipelineLayout,
- uint32_t doLock);
- void vkDestroyPipelineLayout(
- VkDevice device,
- VkPipelineLayout pipelineLayout,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkCreateSampler(
- VkDevice device,
- const VkSamplerCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSampler* pSampler,
- uint32_t doLock);
- void vkDestroySampler(
- VkDevice device,
- VkSampler sampler,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkCreateDescriptorSetLayout(
- VkDevice device,
- const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDescriptorSetLayout* pSetLayout,
- uint32_t doLock);
- void vkDestroyDescriptorSetLayout(
- VkDevice device,
- VkDescriptorSetLayout descriptorSetLayout,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkCreateDescriptorPool(
- VkDevice device,
- const VkDescriptorPoolCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDescriptorPool* pDescriptorPool,
- uint32_t doLock);
- void vkDestroyDescriptorPool(
- VkDevice device,
- VkDescriptorPool descriptorPool,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkResetDescriptorPool(
- VkDevice device,
- VkDescriptorPool descriptorPool,
- VkDescriptorPoolResetFlags flags,
- uint32_t doLock);
- VkResult vkAllocateDescriptorSets(
- VkDevice device,
- const VkDescriptorSetAllocateInfo* pAllocateInfo,
- VkDescriptorSet* pDescriptorSets,
- uint32_t doLock);
- VkResult vkFreeDescriptorSets(
- VkDevice device,
- VkDescriptorPool descriptorPool,
- uint32_t descriptorSetCount,
- const VkDescriptorSet* pDescriptorSets,
- uint32_t doLock);
- void vkUpdateDescriptorSets(
- VkDevice device,
- uint32_t descriptorWriteCount,
- const VkWriteDescriptorSet* pDescriptorWrites,
- uint32_t descriptorCopyCount,
- const VkCopyDescriptorSet* pDescriptorCopies,
- uint32_t doLock);
- VkResult vkCreateFramebuffer(
- VkDevice device,
- const VkFramebufferCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkFramebuffer* pFramebuffer,
- uint32_t doLock);
- void vkDestroyFramebuffer(
- VkDevice device,
- VkFramebuffer framebuffer,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkCreateRenderPass(
- VkDevice device,
- const VkRenderPassCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass,
- uint32_t doLock);
- void vkDestroyRenderPass(
- VkDevice device,
- VkRenderPass renderPass,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- void vkGetRenderAreaGranularity(
- VkDevice device,
- VkRenderPass renderPass,
- VkExtent2D* pGranularity,
- uint32_t doLock);
- VkResult vkCreateCommandPool(
- VkDevice device,
- const VkCommandPoolCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkCommandPool* pCommandPool,
- uint32_t doLock);
- void vkDestroyCommandPool(
- VkDevice device,
- VkCommandPool commandPool,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkResetCommandPool(
- VkDevice device,
- VkCommandPool commandPool,
- VkCommandPoolResetFlags flags,
- uint32_t doLock);
- VkResult vkAllocateCommandBuffers(
- VkDevice device,
- const VkCommandBufferAllocateInfo* pAllocateInfo,
- VkCommandBuffer* pCommandBuffers,
- uint32_t doLock);
- void vkFreeCommandBuffers(
- VkDevice device,
- VkCommandPool commandPool,
- uint32_t commandBufferCount,
- const VkCommandBuffer* pCommandBuffers,
- uint32_t doLock);
- VkResult vkBeginCommandBuffer(
- VkCommandBuffer commandBuffer,
- const VkCommandBufferBeginInfo* pBeginInfo,
- uint32_t doLock);
- VkResult vkEndCommandBuffer(
- VkCommandBuffer commandBuffer,
- uint32_t doLock);
- VkResult vkResetCommandBuffer(
- VkCommandBuffer commandBuffer,
- VkCommandBufferResetFlags flags,
- uint32_t doLock);
- void vkCmdBindPipeline(
- VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipeline pipeline,
- uint32_t doLock);
- void vkCmdSetViewport(
- VkCommandBuffer commandBuffer,
- uint32_t firstViewport,
- uint32_t viewportCount,
- const VkViewport* pViewports,
- uint32_t doLock);
- void vkCmdSetScissor(
- VkCommandBuffer commandBuffer,
- uint32_t firstScissor,
- uint32_t scissorCount,
- const VkRect2D* pScissors,
- uint32_t doLock);
- void vkCmdSetLineWidth(
- VkCommandBuffer commandBuffer,
- float lineWidth,
- uint32_t doLock);
- void vkCmdSetDepthBias(
- VkCommandBuffer commandBuffer,
- float depthBiasConstantFactor,
- float depthBiasClamp,
- float depthBiasSlopeFactor,
- uint32_t doLock);
- void vkCmdSetBlendConstants(
- VkCommandBuffer commandBuffer,
- const float blendConstants[4],
- uint32_t doLock);
- void vkCmdSetDepthBounds(
- VkCommandBuffer commandBuffer,
- float minDepthBounds,
- float maxDepthBounds,
- uint32_t doLock);
- void vkCmdSetStencilCompareMask(
- VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask,
- uint32_t compareMask,
- uint32_t doLock);
- void vkCmdSetStencilWriteMask(
- VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask,
- uint32_t writeMask,
- uint32_t doLock);
- void vkCmdSetStencilReference(
- VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask,
- uint32_t reference,
- uint32_t doLock);
- void vkCmdBindDescriptorSets(
- VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipelineLayout layout,
- uint32_t firstSet,
- uint32_t descriptorSetCount,
- const VkDescriptorSet* pDescriptorSets,
- uint32_t dynamicOffsetCount,
- const uint32_t* pDynamicOffsets,
- uint32_t doLock);
- void vkCmdBindIndexBuffer(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkIndexType indexType,
- uint32_t doLock);
- void vkCmdBindVertexBuffers(
- VkCommandBuffer commandBuffer,
- uint32_t firstBinding,
- uint32_t bindingCount,
- const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets,
- uint32_t doLock);
- void vkCmdDraw(
- VkCommandBuffer commandBuffer,
- uint32_t vertexCount,
- uint32_t instanceCount,
- uint32_t firstVertex,
- uint32_t firstInstance,
- uint32_t doLock);
- void vkCmdDrawIndexed(
- VkCommandBuffer commandBuffer,
- uint32_t indexCount,
- uint32_t instanceCount,
- uint32_t firstIndex,
- int32_t vertexOffset,
- uint32_t firstInstance,
- uint32_t doLock);
- void vkCmdDrawIndirect(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- uint32_t drawCount,
- uint32_t stride,
- uint32_t doLock);
- void vkCmdDrawIndexedIndirect(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- uint32_t drawCount,
- uint32_t stride,
- uint32_t doLock);
- void vkCmdDispatch(
- VkCommandBuffer commandBuffer,
- uint32_t groupCountX,
- uint32_t groupCountY,
- uint32_t groupCountZ,
- uint32_t doLock);
- void vkCmdDispatchIndirect(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- uint32_t doLock);
- void vkCmdCopyBuffer(
- VkCommandBuffer commandBuffer,
- VkBuffer srcBuffer,
- VkBuffer dstBuffer,
- uint32_t regionCount,
- const VkBufferCopy* pRegions,
- uint32_t doLock);
- void vkCmdCopyImage(
- VkCommandBuffer commandBuffer,
- VkImage srcImage,
- VkImageLayout srcImageLayout,
- VkImage dstImage,
- VkImageLayout dstImageLayout,
- uint32_t regionCount,
- const VkImageCopy* pRegions,
- uint32_t doLock);
- void vkCmdBlitImage(
- VkCommandBuffer commandBuffer,
- VkImage srcImage,
- VkImageLayout srcImageLayout,
- VkImage dstImage,
- VkImageLayout dstImageLayout,
- uint32_t regionCount,
- const VkImageBlit* pRegions,
- VkFilter filter,
- uint32_t doLock);
- void vkCmdCopyBufferToImage(
- VkCommandBuffer commandBuffer,
- VkBuffer srcBuffer,
- VkImage dstImage,
- VkImageLayout dstImageLayout,
- uint32_t regionCount,
- const VkBufferImageCopy* pRegions,
- uint32_t doLock);
- void vkCmdCopyImageToBuffer(
- VkCommandBuffer commandBuffer,
- VkImage srcImage,
- VkImageLayout srcImageLayout,
- VkBuffer dstBuffer,
- uint32_t regionCount,
- const VkBufferImageCopy* pRegions,
- uint32_t doLock);
- void vkCmdUpdateBuffer(
- VkCommandBuffer commandBuffer,
- VkBuffer dstBuffer,
- VkDeviceSize dstOffset,
- VkDeviceSize dataSize,
- const void* pData,
- uint32_t doLock);
- void vkCmdFillBuffer(
- VkCommandBuffer commandBuffer,
- VkBuffer dstBuffer,
- VkDeviceSize dstOffset,
- VkDeviceSize size,
- uint32_t data,
- uint32_t doLock);
- void vkCmdClearColorImage(
- VkCommandBuffer commandBuffer,
- VkImage image,
- VkImageLayout imageLayout,
- const VkClearColorValue* pColor,
- uint32_t rangeCount,
- const VkImageSubresourceRange* pRanges,
- uint32_t doLock);
- void vkCmdClearDepthStencilImage(
- VkCommandBuffer commandBuffer,
- VkImage image,
- VkImageLayout imageLayout,
- const VkClearDepthStencilValue* pDepthStencil,
- uint32_t rangeCount,
- const VkImageSubresourceRange* pRanges,
- uint32_t doLock);
- void vkCmdClearAttachments(
- VkCommandBuffer commandBuffer,
- uint32_t attachmentCount,
- const VkClearAttachment* pAttachments,
- uint32_t rectCount,
- const VkClearRect* pRects,
- uint32_t doLock);
- void vkCmdResolveImage(
- VkCommandBuffer commandBuffer,
- VkImage srcImage,
- VkImageLayout srcImageLayout,
- VkImage dstImage,
- VkImageLayout dstImageLayout,
- uint32_t regionCount,
- const VkImageResolve* pRegions,
- uint32_t doLock);
- void vkCmdSetEvent(
- VkCommandBuffer commandBuffer,
- VkEvent event,
- VkPipelineStageFlags stageMask,
- uint32_t doLock);
- void vkCmdResetEvent(
- VkCommandBuffer commandBuffer,
- VkEvent event,
- VkPipelineStageFlags stageMask,
- uint32_t doLock);
- void 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,
- uint32_t doLock);
- void 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,
- uint32_t doLock);
- void vkCmdBeginQuery(
- VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t query,
- VkQueryControlFlags flags,
- uint32_t doLock);
- void vkCmdEndQuery(
- VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t query,
- uint32_t doLock);
- void vkCmdResetQueryPool(
- VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t queryCount,
- uint32_t doLock);
- void vkCmdWriteTimestamp(
- VkCommandBuffer commandBuffer,
- VkPipelineStageFlagBits pipelineStage,
- VkQueryPool queryPool,
- uint32_t query,
- uint32_t doLock);
- void vkCmdCopyQueryPoolResults(
- VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t queryCount,
- VkBuffer dstBuffer,
- VkDeviceSize dstOffset,
- VkDeviceSize stride,
- VkQueryResultFlags flags,
- uint32_t doLock);
- void vkCmdPushConstants(
- VkCommandBuffer commandBuffer,
- VkPipelineLayout layout,
- VkShaderStageFlags stageFlags,
- uint32_t offset,
- uint32_t size,
- const void* pValues,
- uint32_t doLock);
- void vkCmdBeginRenderPass(
- VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo* pRenderPassBegin,
- VkSubpassContents contents,
- uint32_t doLock);
- void vkCmdNextSubpass(
- VkCommandBuffer commandBuffer,
- VkSubpassContents contents,
- uint32_t doLock);
- void vkCmdEndRenderPass(
- VkCommandBuffer commandBuffer,
- uint32_t doLock);
- void vkCmdExecuteCommands(
- VkCommandBuffer commandBuffer,
- uint32_t commandBufferCount,
- const VkCommandBuffer* pCommandBuffers,
- uint32_t doLock);
+ VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
+ VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling,
+ uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties, uint32_t doLock);
+ VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo, VkFence fence, uint32_t doLock);
+ VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkFence* pFence,
+ uint32_t doLock);
+ void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock);
+ VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences,
+ uint32_t doLock);
+ VkResult vkGetFenceStatus(VkDevice device, VkFence fence, uint32_t doLock);
+ VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences,
+ VkBool32 waitAll, uint64_t timeout, uint32_t doLock);
+ VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore,
+ uint32_t doLock);
+ void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkEvent* pEvent,
+ uint32_t doLock);
+ void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock);
+ VkResult vkGetEventStatus(VkDevice device, VkEvent event, uint32_t doLock);
+ VkResult vkSetEvent(VkDevice device, VkEvent event, uint32_t doLock);
+ VkResult vkResetEvent(VkDevice device, VkEvent event, uint32_t doLock);
+ VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool,
+ uint32_t doLock);
+ void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
+ uint32_t queryCount, size_t dataSize, void* pData,
+ VkDeviceSize stride, VkQueryResultFlags flags, uint32_t doLock);
+ VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer,
+ uint32_t doLock);
+ void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock);
+ VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkBufferView* pView,
+ uint32_t doLock);
+ void vkDestroyBufferView(VkDevice device, VkBufferView bufferView,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkImage* pImage,
+ uint32_t doLock);
+ void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock);
+ void vkGetImageSubresourceLayout(VkDevice device, VkImage image,
+ const VkImageSubresource* pSubresource,
+ VkSubresourceLayout* pLayout, uint32_t doLock);
+ VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkImageView* pView,
+ uint32_t doLock);
+ void vkDestroyImageView(VkDevice device, VkImageView imageView,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkShaderModule* pShaderModule, uint32_t doLock);
+ void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineCache* pPipelineCache, uint32_t doLock);
+ void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
+ size_t* pDataSize, void* pData, uint32_t doLock);
+ VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
+ uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches,
+ uint32_t doLock);
+ VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines, uint32_t doLock);
+ VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkComputePipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines, uint32_t doLock);
+ void vkDestroyPipeline(VkDevice device, VkPipeline pipeline,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineLayout* pPipelineLayout, uint32_t doLock);
+ void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSampler* pSampler,
+ uint32_t doLock);
+ void vkDestroySampler(VkDevice device, VkSampler sampler,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ VkResult vkCreateDescriptorSetLayout(VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorSetLayout* pSetLayout, uint32_t doLock);
+ void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorPool* pDescriptorPool, uint32_t doLock);
+ void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+ VkDescriptorPoolResetFlags flags, uint32_t doLock);
+ VkResult vkAllocateDescriptorSets(VkDevice device,
+ const VkDescriptorSetAllocateInfo* pAllocateInfo,
+ VkDescriptorSet* pDescriptorSets, uint32_t doLock);
+ VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets, uint32_t doLock);
+ void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites,
+ uint32_t descriptorCopyCount,
+ const VkCopyDescriptorSet* pDescriptorCopies, uint32_t doLock);
+ VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFramebuffer* pFramebuffer, uint32_t doLock);
+ void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass,
+ uint32_t doLock);
+ void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
+ VkExtent2D* pGranularity, uint32_t doLock);
+ VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCommandPool* pCommandPool, uint32_t doLock);
+ void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool,
+ VkCommandPoolResetFlags flags, uint32_t doLock);
+ VkResult vkAllocateCommandBuffers(VkDevice device,
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers, uint32_t doLock);
+ void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool,
+ uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers,
+ uint32_t doLock);
+ VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo, uint32_t doLock);
+ VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer, uint32_t doLock);
+ VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags,
+ uint32_t doLock);
+ void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
+ VkPipeline pipeline, uint32_t doLock);
+ void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
+ uint32_t viewportCount, const VkViewport* pViewports, uint32_t doLock);
+ void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
+ uint32_t scissorCount, const VkRect2D* pScissors, uint32_t doLock);
+ void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth, uint32_t doLock);
+ void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
+ float depthBiasClamp, float depthBiasSlopeFactor, uint32_t doLock);
+ void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4],
+ uint32_t doLock);
+ void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
+ float maxDepthBounds, uint32_t doLock);
+ void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+ uint32_t compareMask, uint32_t doLock);
+ void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+ uint32_t writeMask, uint32_t doLock);
+ void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+ uint32_t reference, uint32_t doLock);
+ void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
+ uint32_t firstSet, uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets,
+ uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets,
+ uint32_t doLock);
+ void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+ VkIndexType indexType, uint32_t doLock);
+ void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+ uint32_t bindingCount, const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets, uint32_t doLock);
+ void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount,
+ uint32_t firstVertex, uint32_t firstInstance, uint32_t doLock);
+ void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
+ uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset,
+ uint32_t firstInstance, uint32_t doLock);
+ void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+ uint32_t drawCount, uint32_t stride, uint32_t doLock);
+ void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, uint32_t drawCount, uint32_t stride,
+ uint32_t doLock);
+ void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY,
+ uint32_t groupCountZ, uint32_t doLock);
+ void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+ uint32_t doLock);
+ void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer,
+ uint32_t regionCount, const VkBufferCopy* pRegions, uint32_t doLock);
+ void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+ VkImageLayout srcImageLayout, VkImage dstImage,
+ VkImageLayout dstImageLayout, uint32_t regionCount,
+ const VkImageCopy* pRegions, uint32_t doLock);
+ void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+ VkImageLayout srcImageLayout, VkImage dstImage,
+ VkImageLayout dstImageLayout, uint32_t regionCount,
+ const VkImageBlit* pRegions, VkFilter filter, uint32_t doLock);
+ void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
+ VkImageLayout dstImageLayout, uint32_t regionCount,
+ const VkBufferImageCopy* pRegions, uint32_t doLock);
+ void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
+ VkImageLayout srcImageLayout, VkBuffer dstBuffer,
+ uint32_t regionCount, const VkBufferImageCopy* pRegions,
+ uint32_t doLock);
+ void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
+ VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData,
+ uint32_t doLock);
+ void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
+ VkDeviceSize size, uint32_t data, uint32_t doLock);
+ void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
+ VkImageLayout imageLayout, const VkClearColorValue* pColor,
+ uint32_t rangeCount, const VkImageSubresourceRange* pRanges,
+ uint32_t doLock);
+ void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearDepthStencilValue* pDepthStencil,
+ uint32_t rangeCount, const VkImageSubresourceRange* pRanges,
+ uint32_t doLock);
+ void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
+ const VkClearAttachment* pAttachments, uint32_t rectCount,
+ const VkClearRect* pRects, uint32_t doLock);
+ void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+ VkImageLayout srcImageLayout, VkImage dstImage,
+ VkImageLayout dstImageLayout, uint32_t regionCount,
+ const VkImageResolve* pRegions, uint32_t doLock);
+ void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask,
+ uint32_t doLock);
+ void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
+ VkPipelineStageFlags stageMask, uint32_t doLock);
+ void 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, uint32_t doLock);
+ void 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, uint32_t doLock);
+ void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
+ VkQueryControlFlags flags, uint32_t doLock);
+ void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
+ uint32_t doLock);
+ void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t firstQuery, uint32_t queryCount, uint32_t doLock);
+ void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
+ VkQueryPool queryPool, uint32_t query, uint32_t doLock);
+ void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer,
+ VkDeviceSize dstOffset, VkDeviceSize stride,
+ VkQueryResultFlags flags, uint32_t doLock);
+ void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
+ const void* pValues, uint32_t doLock);
+ void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ VkSubpassContents contents, uint32_t doLock);
+ void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents,
+ uint32_t doLock);
+ void vkCmdEndRenderPass(VkCommandBuffer commandBuffer, uint32_t doLock);
+ void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers, uint32_t doLock);
#endif
#ifdef VK_VERSION_1_1
- VkResult vkEnumerateInstanceVersion(
- uint32_t* pApiVersion,
- uint32_t doLock);
- VkResult vkBindBufferMemory2(
- VkDevice device,
- uint32_t bindInfoCount,
- const VkBindBufferMemoryInfo* pBindInfos,
- uint32_t doLock);
- VkResult vkBindImageMemory2(
- VkDevice device,
- uint32_t bindInfoCount,
- const VkBindImageMemoryInfo* pBindInfos,
- uint32_t doLock);
- void vkGetDeviceGroupPeerMemoryFeatures(
- VkDevice device,
- uint32_t heapIndex,
- uint32_t localDeviceIndex,
- uint32_t remoteDeviceIndex,
- VkPeerMemoryFeatureFlags* pPeerMemoryFeatures,
- uint32_t doLock);
- void vkCmdSetDeviceMask(
- VkCommandBuffer commandBuffer,
- uint32_t deviceMask,
- uint32_t doLock);
- void vkCmdDispatchBase(
- VkCommandBuffer commandBuffer,
- uint32_t baseGroupX,
- uint32_t baseGroupY,
- uint32_t baseGroupZ,
- uint32_t groupCountX,
- uint32_t groupCountY,
- uint32_t groupCountZ,
- uint32_t doLock);
+ VkResult vkEnumerateInstanceVersion(uint32_t* pApiVersion, uint32_t doLock);
+ VkResult vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos, uint32_t doLock);
+ VkResult vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos, uint32_t doLock);
+ void vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex,
+ uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures,
+ uint32_t doLock);
+ void vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask, uint32_t doLock);
+ void vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY,
+ uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY,
+ uint32_t groupCountZ, uint32_t doLock);
VkResult vkEnumeratePhysicalDeviceGroups(
- VkInstance instance,
- uint32_t* pPhysicalDeviceGroupCount,
- VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties,
- uint32_t doLock);
- void vkGetImageMemoryRequirements2(
- VkDevice device,
- const VkImageMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements,
- uint32_t doLock);
- void vkGetBufferMemoryRequirements2(
- VkDevice device,
- const VkBufferMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements,
- uint32_t doLock);
+ VkInstance instance, uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, uint32_t doLock);
+ void vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements, uint32_t doLock);
+ void vkGetBufferMemoryRequirements2(VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements,
+ uint32_t doLock);
void vkGetImageSparseMemoryRequirements2(
- VkDevice device,
- const VkImageSparseMemoryRequirementsInfo2* pInfo,
+ VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements,
- uint32_t doLock);
- void vkGetPhysicalDeviceFeatures2(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures2* pFeatures,
- uint32_t doLock);
- void vkGetPhysicalDeviceProperties2(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties2* pProperties,
- uint32_t doLock);
- void vkGetPhysicalDeviceFormatProperties2(
- VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties2* pFormatProperties,
- uint32_t doLock);
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, uint32_t doLock);
+ void vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures, uint32_t doLock);
+ void vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties, uint32_t doLock);
+ void vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format,
+ VkFormatProperties2* pFormatProperties,
+ uint32_t doLock);
VkResult vkGetPhysicalDeviceImageFormatProperties2(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
- VkImageFormatProperties2* pImageFormatProperties,
- uint32_t doLock);
- void vkGetPhysicalDeviceQueueFamilyProperties2(
- VkPhysicalDevice physicalDevice,
- uint32_t* pQueueFamilyPropertyCount,
- VkQueueFamilyProperties2* pQueueFamilyProperties,
- uint32_t doLock);
- void vkGetPhysicalDeviceMemoryProperties2(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceMemoryProperties2* pMemoryProperties,
- uint32_t doLock);
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+ VkImageFormatProperties2* pImageFormatProperties, uint32_t doLock);
+ void vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,
+ uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2* pQueueFamilyProperties,
+ uint32_t doLock);
+ void vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties2* pMemoryProperties,
+ uint32_t doLock);
void vkGetPhysicalDeviceSparseImageFormatProperties2(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
- uint32_t* pPropertyCount,
- VkSparseImageFormatProperties2* pProperties,
- uint32_t doLock);
- void vkTrimCommandPool(
- VkDevice device,
- VkCommandPool commandPool,
- VkCommandPoolTrimFlags flags,
- uint32_t doLock);
- void vkGetDeviceQueue2(
- VkDevice device,
- const VkDeviceQueueInfo2* pQueueInfo,
- VkQueue* pQueue,
- uint32_t doLock);
- VkResult vkCreateSamplerYcbcrConversion(
- VkDevice device,
- const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSamplerYcbcrConversion* pYcbcrConversion,
- uint32_t doLock);
- void vkDestroySamplerYcbcrConversion(
- VkDevice device,
- VkSamplerYcbcrConversion ycbcrConversion,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+ uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties, uint32_t doLock);
+ void vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags,
+ uint32_t doLock);
+ void vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue,
+ uint32_t doLock);
+ VkResult vkCreateSamplerYcbcrConversion(VkDevice device,
+ const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSamplerYcbcrConversion* pYcbcrConversion,
+ uint32_t doLock);
+ void vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
VkResult vkCreateDescriptorUpdateTemplate(
- VkDevice device,
- const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+ VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate,
- uint32_t doLock);
- void vkDestroyDescriptorUpdateTemplate(
- VkDevice device,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- void vkUpdateDescriptorSetWithTemplate(
- VkDevice device,
- VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const void* pData,
- uint32_t doLock);
+ VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, uint32_t doLock);
+ void vkDestroyDescriptorUpdateTemplate(VkDevice device,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock);
+ void vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const void* pData, uint32_t doLock);
void vkGetPhysicalDeviceExternalBufferProperties(
- VkPhysicalDevice physicalDevice,
+ VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
- VkExternalBufferProperties* pExternalBufferProperties,
- uint32_t doLock);
+ VkExternalBufferProperties* pExternalBufferProperties, uint32_t doLock);
void vkGetPhysicalDeviceExternalFenceProperties(
- VkPhysicalDevice physicalDevice,
+ VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
- VkExternalFenceProperties* pExternalFenceProperties,
- uint32_t doLock);
+ VkExternalFenceProperties* pExternalFenceProperties, uint32_t doLock);
void vkGetPhysicalDeviceExternalSemaphoreProperties(
- VkPhysicalDevice physicalDevice,
+ VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
- VkExternalSemaphoreProperties* pExternalSemaphoreProperties,
- uint32_t doLock);
- void vkGetDescriptorSetLayoutSupport(
- VkDevice device,
- const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- VkDescriptorSetLayoutSupport* pSupport,
- uint32_t doLock);
+ VkExternalSemaphoreProperties* pExternalSemaphoreProperties, uint32_t doLock);
+ void vkGetDescriptorSetLayoutSupport(VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport, uint32_t doLock);
#endif
#ifdef VK_VERSION_1_2
- void vkCmdDrawIndirectCount(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride,
- uint32_t doLock);
- void vkCmdDrawIndexedIndirectCount(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride,
- uint32_t doLock);
- VkResult vkCreateRenderPass2(
- VkDevice device,
- const VkRenderPassCreateInfo2* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass,
- uint32_t doLock);
- void vkCmdBeginRenderPass2(
- VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo* pRenderPassBegin,
- const VkSubpassBeginInfo* pSubpassBeginInfo,
- uint32_t doLock);
- void vkCmdNextSubpass2(
- VkCommandBuffer commandBuffer,
- const VkSubpassBeginInfo* pSubpassBeginInfo,
- const VkSubpassEndInfo* pSubpassEndInfo,
- uint32_t doLock);
- void vkCmdEndRenderPass2(
- VkCommandBuffer commandBuffer,
- const VkSubpassEndInfo* pSubpassEndInfo,
- uint32_t doLock);
- void vkResetQueryPool(
- VkDevice device,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t queryCount,
- uint32_t doLock);
- VkResult vkGetSemaphoreCounterValue(
- VkDevice device,
- VkSemaphore semaphore,
- uint64_t* pValue,
- uint32_t doLock);
- VkResult vkWaitSemaphores(
- VkDevice device,
- const VkSemaphoreWaitInfo* pWaitInfo,
- uint64_t timeout,
- uint32_t doLock);
- VkResult vkSignalSemaphore(
- VkDevice device,
- const VkSemaphoreSignalInfo* pSignalInfo,
- uint32_t doLock);
- VkDeviceAddress vkGetBufferDeviceAddress(
- VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo,
- uint32_t doLock);
- uint64_t vkGetBufferOpaqueCaptureAddress(
- VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo,
- uint32_t doLock);
+ void vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+ VkBuffer countBuffer, VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount, uint32_t stride, uint32_t doLock);
+ void vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+ uint32_t stride, uint32_t doLock);
+ VkResult vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass,
+ uint32_t doLock);
+ void vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ const VkSubpassBeginInfo* pSubpassBeginInfo, uint32_t doLock);
+ void vkCmdNextSubpass2(VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfo* pSubpassBeginInfo,
+ const VkSubpassEndInfo* pSubpassEndInfo, uint32_t doLock);
+ void vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo,
+ uint32_t doLock);
+ void vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
+ uint32_t queryCount, uint32_t doLock);
+ VkResult vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue,
+ uint32_t doLock);
+ VkResult vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo,
+ uint64_t timeout, uint32_t doLock);
+ VkResult vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo,
+ uint32_t doLock);
+ VkDeviceAddress vkGetBufferDeviceAddress(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo,
+ uint32_t doLock);
+ uint64_t vkGetBufferOpaqueCaptureAddress(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo,
+ uint32_t doLock);
uint64_t vkGetDeviceMemoryOpaqueCaptureAddress(
- VkDevice device,
- const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo,
- uint32_t doLock);
+ VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo, uint32_t doLock);
#endif
#ifdef VK_KHR_surface
- void vkDestroySurfaceKHR(
- VkInstance instance,
- VkSurfaceKHR surface,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkGetPhysicalDeviceSurfaceSupportKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- VkSurfaceKHR surface,
- VkBool32* pSupported,
- uint32_t doLock);
+ void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex, VkSurfaceKHR surface,
+ VkBool32* pSupported, uint32_t doLock);
VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
- VkPhysicalDevice physicalDevice,
- VkSurfaceKHR surface,
- VkSurfaceCapabilitiesKHR* pSurfaceCapabilities,
- uint32_t doLock);
- VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(
- VkPhysicalDevice physicalDevice,
- VkSurfaceKHR surface,
- uint32_t* pSurfaceFormatCount,
- VkSurfaceFormatKHR* pSurfaceFormats,
- uint32_t doLock);
- VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(
- VkPhysicalDevice physicalDevice,
- VkSurfaceKHR surface,
- uint32_t* pPresentModeCount,
- VkPresentModeKHR* pPresentModes,
- uint32_t doLock);
+ VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+ VkSurfaceCapabilitiesKHR* pSurfaceCapabilities, uint32_t doLock);
+ VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormatKHR* pSurfaceFormats,
+ uint32_t doLock);
+ VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pPresentModeCount,
+ VkPresentModeKHR* pPresentModes,
+ uint32_t doLock);
#endif
#ifdef VK_KHR_swapchain
- VkResult vkCreateSwapchainKHR(
- VkDevice device,
- const VkSwapchainCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSwapchainKHR* pSwapchain,
- uint32_t doLock);
- void vkDestroySwapchainKHR(
- VkDevice device,
- VkSwapchainKHR swapchain,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkGetSwapchainImagesKHR(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint32_t* pSwapchainImageCount,
- VkImage* pSwapchainImages,
- uint32_t doLock);
- VkResult vkAcquireNextImageKHR(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint64_t timeout,
- VkSemaphore semaphore,
- VkFence fence,
- uint32_t* pImageIndex,
- uint32_t doLock);
- VkResult vkQueuePresentKHR(
- VkQueue queue,
- const VkPresentInfoKHR* pPresentInfo,
- uint32_t doLock);
+ VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchain, uint32_t doLock);
+ void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain,
+ uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages,
+ uint32_t doLock);
+ VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout,
+ VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex,
+ uint32_t doLock);
+ VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo,
+ uint32_t doLock);
VkResult vkGetDeviceGroupPresentCapabilitiesKHR(
- VkDevice device,
- VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities,
+ VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities,
uint32_t doLock);
- VkResult vkGetDeviceGroupSurfacePresentModesKHR(
- VkDevice device,
- VkSurfaceKHR surface,
- VkDeviceGroupPresentModeFlagsKHR* pModes,
- uint32_t doLock);
- VkResult vkGetPhysicalDevicePresentRectanglesKHR(
- VkPhysicalDevice physicalDevice,
- VkSurfaceKHR surface,
- uint32_t* pRectCount,
- VkRect2D* pRects,
- uint32_t doLock);
- VkResult vkAcquireNextImage2KHR(
- VkDevice device,
- const VkAcquireNextImageInfoKHR* pAcquireInfo,
- uint32_t* pImageIndex,
- uint32_t doLock);
+ VkResult vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface,
+ VkDeviceGroupPresentModeFlagsKHR* pModes,
+ uint32_t doLock);
+ VkResult vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface, uint32_t* pRectCount,
+ VkRect2D* pRects, uint32_t doLock);
+ VkResult vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo,
+ uint32_t* pImageIndex, uint32_t doLock);
#endif
#ifdef VK_KHR_display
- VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkDisplayPropertiesKHR* pProperties,
- uint32_t doLock);
- VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkDisplayPlanePropertiesKHR* pProperties,
- uint32_t doLock);
- VkResult vkGetDisplayPlaneSupportedDisplaysKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t planeIndex,
- uint32_t* pDisplayCount,
- VkDisplayKHR* pDisplays,
- uint32_t doLock);
- VkResult vkGetDisplayModePropertiesKHR(
- VkPhysicalDevice physicalDevice,
- VkDisplayKHR display,
- uint32_t* pPropertyCount,
- VkDisplayModePropertiesKHR* pProperties,
- uint32_t doLock);
- VkResult vkCreateDisplayModeKHR(
- VkPhysicalDevice physicalDevice,
- VkDisplayKHR display,
- const VkDisplayModeCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDisplayModeKHR* pMode,
- uint32_t doLock);
- VkResult vkGetDisplayPlaneCapabilitiesKHR(
- VkPhysicalDevice physicalDevice,
- VkDisplayModeKHR mode,
- uint32_t planeIndex,
- VkDisplayPlaneCapabilitiesKHR* pCapabilities,
- uint32_t doLock);
- VkResult vkCreateDisplayPlaneSurfaceKHR(
- VkInstance instance,
- const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock);
+ VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPropertiesKHR* pProperties,
+ uint32_t doLock);
+ VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPlanePropertiesKHR* pProperties,
+ uint32_t doLock);
+ VkResult vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice,
+ uint32_t planeIndex, uint32_t* pDisplayCount,
+ VkDisplayKHR* pDisplays, uint32_t doLock);
+ VkResult vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+ uint32_t* pPropertyCount,
+ VkDisplayModePropertiesKHR* pProperties,
+ uint32_t doLock);
+ VkResult vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+ const VkDisplayModeCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDisplayModeKHR* pMode, uint32_t doLock);
+ VkResult vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice,
+ VkDisplayModeKHR mode, uint32_t planeIndex,
+ VkDisplayPlaneCapabilitiesKHR* pCapabilities,
+ uint32_t doLock);
+ VkResult vkCreateDisplayPlaneSurfaceKHR(VkInstance instance,
+ const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock);
#endif
#ifdef VK_KHR_display_swapchain
- VkResult vkCreateSharedSwapchainsKHR(
- VkDevice device,
- uint32_t swapchainCount,
- const VkSwapchainCreateInfoKHR* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkSwapchainKHR* pSwapchains,
- uint32_t doLock);
+ VkResult vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
+ const VkSwapchainCreateInfoKHR* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchains, uint32_t doLock);
#endif
#ifdef VK_KHR_xlib_surface
- VkResult vkCreateXlibSurfaceKHR(
- VkInstance instance,
- const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock);
- VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- Display* dpy,
- VisualID visualID,
- uint32_t doLock);
+ VkResult vkCreateXlibSurfaceKHR(VkInstance instance,
+ const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface,
+ uint32_t doLock);
+ VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex, Display* dpy,
+ VisualID visualID, uint32_t doLock);
#endif
#ifdef VK_KHR_xcb_surface
- VkResult vkCreateXcbSurfaceKHR(
- VkInstance instance,
- const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock);
- VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- xcb_connection_t* connection,
- xcb_visualid_t visual_id,
- uint32_t doLock);
+ VkResult vkCreateXcbSurfaceKHR(VkInstance instance,
+ const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface,
+ uint32_t doLock);
+ VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ xcb_connection_t* connection,
+ xcb_visualid_t visual_id,
+ uint32_t doLock);
#endif
#ifdef VK_KHR_wayland_surface
- VkResult vkCreateWaylandSurfaceKHR(
- VkInstance instance,
- const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock);
- VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- wl_display* display,
- uint32_t doLock);
+ VkResult vkCreateWaylandSurfaceKHR(VkInstance instance,
+ const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock);
+ VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ wl_display* display, uint32_t doLock);
#endif
#ifdef VK_KHR_android_surface
- VkResult vkCreateAndroidSurfaceKHR(
- VkInstance instance,
- const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock);
+ VkResult vkCreateAndroidSurfaceKHR(VkInstance instance,
+ const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock);
#endif
#ifdef VK_KHR_win32_surface
- VkResult vkCreateWin32SurfaceKHR(
- VkInstance instance,
- const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock);
- VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- uint32_t doLock);
+ VkResult vkCreateWin32SurfaceKHR(VkInstance instance,
+ const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock);
+ VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ uint32_t doLock);
#endif
#ifdef VK_KHR_sampler_mirror_clamp_to_edge
#endif
#ifdef VK_KHR_video_queue
- VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR(
- VkPhysicalDevice physicalDevice,
- const VkVideoProfileKHR* pVideoProfile,
- VkVideoCapabilitiesKHR* pCapabilities,
- uint32_t doLock);
+ VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice,
+ const VkVideoProfileKHR* pVideoProfile,
+ VkVideoCapabilitiesKHR* pCapabilities,
+ uint32_t doLock);
VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo,
- uint32_t* pVideoFormatPropertyCount,
- VkVideoFormatPropertiesKHR* pVideoFormatProperties,
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo,
+ uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties,
uint32_t doLock);
- VkResult vkCreateVideoSessionKHR(
- VkDevice device,
- const VkVideoSessionCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkVideoSessionKHR* pVideoSession,
- uint32_t doLock);
- void vkDestroyVideoSessionKHR(
- VkDevice device,
- VkVideoSessionKHR videoSession,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
+ VkResult vkCreateVideoSessionKHR(VkDevice device,
+ const VkVideoSessionCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkVideoSessionKHR* pVideoSession, uint32_t doLock);
+ void vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
VkResult vkGetVideoSessionMemoryRequirementsKHR(
- VkDevice device,
- VkVideoSessionKHR videoSession,
+ VkDevice device, VkVideoSessionKHR videoSession,
uint32_t* pVideoSessionMemoryRequirementsCount,
- VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements,
- uint32_t doLock);
- VkResult vkBindVideoSessionMemoryKHR(
- VkDevice device,
- VkVideoSessionKHR videoSession,
- uint32_t videoSessionBindMemoryCount,
- const VkVideoBindMemoryKHR* pVideoSessionBindMemories,
- uint32_t doLock);
+ VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements, uint32_t doLock);
+ VkResult vkBindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession,
+ uint32_t videoSessionBindMemoryCount,
+ const VkVideoBindMemoryKHR* pVideoSessionBindMemories,
+ uint32_t doLock);
VkResult vkCreateVideoSessionParametersKHR(
- VkDevice device,
- const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,
+ VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkVideoSessionParametersKHR* pVideoSessionParameters,
- uint32_t doLock);
+ VkVideoSessionParametersKHR* pVideoSessionParameters, uint32_t doLock);
VkResult vkUpdateVideoSessionParametersKHR(
- VkDevice device,
- VkVideoSessionParametersKHR videoSessionParameters,
- const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo,
- uint32_t doLock);
- void vkDestroyVideoSessionParametersKHR(
- VkDevice device,
- VkVideoSessionParametersKHR videoSessionParameters,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- void vkCmdBeginVideoCodingKHR(
- VkCommandBuffer commandBuffer,
- const VkVideoBeginCodingInfoKHR* pBeginInfo,
- uint32_t doLock);
- void vkCmdEndVideoCodingKHR(
- VkCommandBuffer commandBuffer,
- const VkVideoEndCodingInfoKHR* pEndCodingInfo,
- uint32_t doLock);
- void vkCmdControlVideoCodingKHR(
- VkCommandBuffer commandBuffer,
- const VkVideoCodingControlInfoKHR* pCodingControlInfo,
- uint32_t doLock);
+ VkDevice device, VkVideoSessionParametersKHR videoSessionParameters,
+ const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo, uint32_t doLock);
+ void vkDestroyVideoSessionParametersKHR(VkDevice device,
+ VkVideoSessionParametersKHR videoSessionParameters,
+ const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock);
+ void vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer,
+ const VkVideoBeginCodingInfoKHR* pBeginInfo, uint32_t doLock);
+ void vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer,
+ const VkVideoEndCodingInfoKHR* pEndCodingInfo, uint32_t doLock);
+ void vkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer,
+ const VkVideoCodingControlInfoKHR* pCodingControlInfo,
+ uint32_t doLock);
#endif
#ifdef VK_KHR_video_decode_queue
- void vkCmdDecodeVideoKHR(
- VkCommandBuffer commandBuffer,
- const VkVideoDecodeInfoKHR* pFrameInfo,
- uint32_t doLock);
+ void vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pFrameInfo,
+ uint32_t doLock);
#endif
#ifdef VK_KHR_dynamic_rendering
- void vkCmdBeginRenderingKHR(
- VkCommandBuffer commandBuffer,
- const VkRenderingInfoKHR* pRenderingInfo,
- uint32_t doLock);
- void vkCmdEndRenderingKHR(
- VkCommandBuffer commandBuffer,
- uint32_t doLock);
+ void vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer,
+ const VkRenderingInfoKHR* pRenderingInfo, uint32_t doLock);
+ void vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer, uint32_t doLock);
#endif
#ifdef VK_KHR_multiview
#endif
#ifdef VK_KHR_get_physical_device_properties2
- void vkGetPhysicalDeviceFeatures2KHR(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures2* pFeatures,
- uint32_t doLock);
- void vkGetPhysicalDeviceProperties2KHR(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties2* pProperties,
- uint32_t doLock);
- void vkGetPhysicalDeviceFormatProperties2KHR(
- VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties2* pFormatProperties,
- uint32_t doLock);
+ void vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures, uint32_t doLock);
+ void vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties,
+ uint32_t doLock);
+ void vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format,
+ VkFormatProperties2* pFormatProperties,
+ uint32_t doLock);
VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
- VkImageFormatProperties2* pImageFormatProperties,
- uint32_t doLock);
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+ VkImageFormatProperties2* pImageFormatProperties, uint32_t doLock);
void vkGetPhysicalDeviceQueueFamilyProperties2KHR(
- VkPhysicalDevice physicalDevice,
- uint32_t* pQueueFamilyPropertyCount,
- VkQueueFamilyProperties2* pQueueFamilyProperties,
- uint32_t doLock);
+ VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2* pQueueFamilyProperties, uint32_t doLock);
void vkGetPhysicalDeviceMemoryProperties2KHR(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceMemoryProperties2* pMemoryProperties,
+ VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties,
uint32_t doLock);
void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
- uint32_t* pPropertyCount,
- VkSparseImageFormatProperties2* pProperties,
- uint32_t doLock);
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+ uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties, uint32_t doLock);
#endif
#ifdef VK_KHR_device_group
- void vkGetDeviceGroupPeerMemoryFeaturesKHR(
- VkDevice device,
- uint32_t heapIndex,
- uint32_t localDeviceIndex,
- uint32_t remoteDeviceIndex,
- VkPeerMemoryFeatureFlags* pPeerMemoryFeatures,
- uint32_t doLock);
- void vkCmdSetDeviceMaskKHR(
- VkCommandBuffer commandBuffer,
- uint32_t deviceMask,
- uint32_t doLock);
- void vkCmdDispatchBaseKHR(
- VkCommandBuffer commandBuffer,
- uint32_t baseGroupX,
- uint32_t baseGroupY,
- uint32_t baseGroupZ,
- uint32_t groupCountX,
- uint32_t groupCountY,
- uint32_t groupCountZ,
- uint32_t doLock);
+ void vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures,
+ uint32_t doLock);
+ void vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask, uint32_t doLock);
+ void vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX,
+ uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX,
+ uint32_t groupCountY, uint32_t groupCountZ, uint32_t doLock);
#endif
#ifdef VK_KHR_shader_draw_parameters
#endif
#ifdef VK_KHR_maintenance1
- void vkTrimCommandPoolKHR(
- VkDevice device,
- VkCommandPool commandPool,
- VkCommandPoolTrimFlags flags,
- uint32_t doLock);
+ void vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags, uint32_t doLock);
#endif
#ifdef VK_KHR_device_group_creation
VkResult vkEnumeratePhysicalDeviceGroupsKHR(
- VkInstance instance,
- uint32_t* pPhysicalDeviceGroupCount,
- VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties,
- uint32_t doLock);
+ VkInstance instance, uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, uint32_t doLock);
#endif
#ifdef VK_KHR_external_memory_capabilities
void vkGetPhysicalDeviceExternalBufferPropertiesKHR(
- VkPhysicalDevice physicalDevice,
+ VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
- VkExternalBufferProperties* pExternalBufferProperties,
- uint32_t doLock);
+ VkExternalBufferProperties* pExternalBufferProperties, uint32_t doLock);
#endif
#ifdef VK_KHR_external_memory
#endif
#ifdef VK_KHR_external_memory_win32
- VkResult vkGetMemoryWin32HandleKHR(
- VkDevice device,
- const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
- HANDLE* pHandle,
- uint32_t doLock);
+ VkResult vkGetMemoryWin32HandleKHR(VkDevice device,
+ const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle, uint32_t doLock);
VkResult vkGetMemoryWin32HandlePropertiesKHR(
- VkDevice device,
- VkExternalMemoryHandleTypeFlagBits handleType,
- HANDLE handle,
- VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties,
- uint32_t doLock);
+ VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle,
+ VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, uint32_t doLock);
#endif
#ifdef VK_KHR_external_memory_fd
- VkResult vkGetMemoryFdKHR(
- VkDevice device,
- const VkMemoryGetFdInfoKHR* pGetFdInfo,
- int* pFd,
- uint32_t doLock);
- VkResult vkGetMemoryFdPropertiesKHR(
- VkDevice device,
- VkExternalMemoryHandleTypeFlagBits handleType,
- int fd,
- VkMemoryFdPropertiesKHR* pMemoryFdProperties,
- uint32_t doLock);
+ VkResult vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd,
+ uint32_t doLock);
+ VkResult vkGetMemoryFdPropertiesKHR(VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType, int fd,
+ VkMemoryFdPropertiesKHR* pMemoryFdProperties,
+ uint32_t doLock);
#endif
#ifdef VK_KHR_win32_keyed_mutex
#endif
#ifdef VK_KHR_external_semaphore_capabilities
void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
- VkPhysicalDevice physicalDevice,
+ VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
- VkExternalSemaphoreProperties* pExternalSemaphoreProperties,
- uint32_t doLock);
+ VkExternalSemaphoreProperties* pExternalSemaphoreProperties, uint32_t doLock);
#endif
#ifdef VK_KHR_external_semaphore
#endif
#ifdef VK_KHR_external_semaphore_win32
VkResult vkImportSemaphoreWin32HandleKHR(
- VkDevice device,
- const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo,
+ VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo,
uint32_t doLock);
VkResult vkGetSemaphoreWin32HandleKHR(
- VkDevice device,
- const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
- HANDLE* pHandle,
- uint32_t doLock);
+ VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle, uint32_t doLock);
#endif
#ifdef VK_KHR_external_semaphore_fd
- VkResult vkImportSemaphoreFdKHR(
- VkDevice device,
- const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo,
- uint32_t doLock);
- VkResult vkGetSemaphoreFdKHR(
- VkDevice device,
- const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
- int* pFd,
- uint32_t doLock);
+ VkResult vkImportSemaphoreFdKHR(VkDevice device,
+ const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo,
+ uint32_t doLock);
+ VkResult vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+ int* pFd, uint32_t doLock);
#endif
#ifdef VK_KHR_push_descriptor
- void vkCmdPushDescriptorSetKHR(
- VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipelineLayout layout,
- uint32_t set,
- uint32_t descriptorWriteCount,
- const VkWriteDescriptorSet* pDescriptorWrites,
- uint32_t doLock);
- void vkCmdPushDescriptorSetWithTemplateKHR(
- VkCommandBuffer commandBuffer,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- VkPipelineLayout layout,
- uint32_t set,
- const void* pData,
- uint32_t doLock);
+ void vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
+ uint32_t set, uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites, uint32_t doLock);
+ void vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ VkPipelineLayout layout, uint32_t set,
+ const void* pData, uint32_t doLock);
#endif
#ifdef VK_KHR_shader_float16_int8
#endif
@@ -1503,144 +812,98 @@
#endif
#ifdef VK_KHR_descriptor_update_template
VkResult vkCreateDescriptorUpdateTemplateKHR(
- VkDevice device,
- const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+ VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate,
- uint32_t doLock);
- void vkDestroyDescriptorUpdateTemplateKHR(
- VkDevice device,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- void vkUpdateDescriptorSetWithTemplateKHR(
- VkDevice device,
- VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const void* pData,
- uint32_t doLock);
+ VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, uint32_t doLock);
+ void vkDestroyDescriptorUpdateTemplateKHR(VkDevice device,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock);
+ void vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const void* pData, uint32_t doLock);
#endif
#ifdef VK_KHR_imageless_framebuffer
#endif
#ifdef VK_KHR_create_renderpass2
- VkResult vkCreateRenderPass2KHR(
- VkDevice device,
- const VkRenderPassCreateInfo2* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass,
- uint32_t doLock);
- void vkCmdBeginRenderPass2KHR(
- VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo* pRenderPassBegin,
- const VkSubpassBeginInfo* pSubpassBeginInfo,
- uint32_t doLock);
- void vkCmdNextSubpass2KHR(
- VkCommandBuffer commandBuffer,
- const VkSubpassBeginInfo* pSubpassBeginInfo,
- const VkSubpassEndInfo* pSubpassEndInfo,
- uint32_t doLock);
- void vkCmdEndRenderPass2KHR(
- VkCommandBuffer commandBuffer,
- const VkSubpassEndInfo* pSubpassEndInfo,
- uint32_t doLock);
+ VkResult vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass, uint32_t doLock);
+ void vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ const VkSubpassBeginInfo* pSubpassBeginInfo, uint32_t doLock);
+ void vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfo* pSubpassBeginInfo,
+ const VkSubpassEndInfo* pSubpassEndInfo, uint32_t doLock);
+ void vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
+ const VkSubpassEndInfo* pSubpassEndInfo, uint32_t doLock);
#endif
#ifdef VK_KHR_shared_presentable_image
- VkResult vkGetSwapchainStatusKHR(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint32_t doLock);
+ VkResult vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t doLock);
#endif
#ifdef VK_KHR_external_fence_capabilities
void vkGetPhysicalDeviceExternalFencePropertiesKHR(
- VkPhysicalDevice physicalDevice,
+ VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
- VkExternalFenceProperties* pExternalFenceProperties,
- uint32_t doLock);
+ VkExternalFenceProperties* pExternalFenceProperties, uint32_t doLock);
#endif
#ifdef VK_KHR_external_fence
#endif
#ifdef VK_KHR_external_fence_win32
VkResult vkImportFenceWin32HandleKHR(
- VkDevice device,
- const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo,
+ VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo,
uint32_t doLock);
- VkResult vkGetFenceWin32HandleKHR(
- VkDevice device,
- const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
- HANDLE* pHandle,
- uint32_t doLock);
+ VkResult vkGetFenceWin32HandleKHR(VkDevice device,
+ const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+ HANDLE* pHandle, uint32_t doLock);
#endif
#ifdef VK_KHR_external_fence_fd
- VkResult vkImportFenceFdKHR(
- VkDevice device,
- const VkImportFenceFdInfoKHR* pImportFenceFdInfo,
- uint32_t doLock);
- VkResult vkGetFenceFdKHR(
- VkDevice device,
- const VkFenceGetFdInfoKHR* pGetFdInfo,
- int* pFd,
- uint32_t doLock);
+ VkResult vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo,
+ uint32_t doLock);
+ VkResult vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd,
+ uint32_t doLock);
#endif
#ifdef VK_KHR_performance_query
VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- uint32_t* pCounterCount,
+ VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount,
VkPerformanceCounterKHR* pCounters,
- VkPerformanceCounterDescriptionKHR* pCounterDescriptions,
- uint32_t doLock);
+ VkPerformanceCounterDescriptionKHR* pCounterDescriptions, uint32_t doLock);
void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
- VkPhysicalDevice physicalDevice,
+ VkPhysicalDevice physicalDevice,
const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo,
- uint32_t* pNumPasses,
- uint32_t doLock);
- VkResult vkAcquireProfilingLockKHR(
- VkDevice device,
- const VkAcquireProfilingLockInfoKHR* pInfo,
- uint32_t doLock);
- void vkReleaseProfilingLockKHR(
- VkDevice device,
- uint32_t doLock);
+ uint32_t* pNumPasses, uint32_t doLock);
+ VkResult vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo,
+ uint32_t doLock);
+ void vkReleaseProfilingLockKHR(VkDevice device, uint32_t doLock);
#endif
#ifdef VK_KHR_maintenance2
#endif
#ifdef VK_KHR_get_surface_capabilities2
VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
- VkSurfaceCapabilities2KHR* pSurfaceCapabilities,
- uint32_t doLock);
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ VkSurfaceCapabilities2KHR* pSurfaceCapabilities, uint32_t doLock);
VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
- uint32_t* pSurfaceFormatCount,
- VkSurfaceFormat2KHR* pSurfaceFormats,
- uint32_t doLock);
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats, uint32_t doLock);
#endif
#ifdef VK_KHR_variable_pointers
#endif
#ifdef VK_KHR_get_display_properties2
- VkResult vkGetPhysicalDeviceDisplayProperties2KHR(
- VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkDisplayProperties2KHR* pProperties,
- uint32_t doLock);
+ VkResult vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayProperties2KHR* pProperties,
+ uint32_t doLock);
VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
- VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkDisplayPlaneProperties2KHR* pProperties,
- uint32_t doLock);
- VkResult vkGetDisplayModeProperties2KHR(
- VkPhysicalDevice physicalDevice,
- VkDisplayKHR display,
- uint32_t* pPropertyCount,
- VkDisplayModeProperties2KHR* pProperties,
- uint32_t doLock);
- VkResult vkGetDisplayPlaneCapabilities2KHR(
- VkPhysicalDevice physicalDevice,
- const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
- VkDisplayPlaneCapabilities2KHR* pCapabilities,
- uint32_t doLock);
+ VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount,
+ VkDisplayPlaneProperties2KHR* pProperties, uint32_t doLock);
+ VkResult vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+ uint32_t* pPropertyCount,
+ VkDisplayModeProperties2KHR* pProperties,
+ uint32_t doLock);
+ VkResult vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice,
+ const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
+ VkDisplayPlaneCapabilities2KHR* pCapabilities,
+ uint32_t doLock);
#endif
#ifdef VK_KHR_dedicated_allocation
#endif
@@ -1649,78 +912,54 @@
#ifdef VK_KHR_relaxed_block_layout
#endif
#ifdef VK_KHR_get_memory_requirements2
- void vkGetImageMemoryRequirements2KHR(
- VkDevice device,
- const VkImageMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements,
- uint32_t doLock);
- void vkGetBufferMemoryRequirements2KHR(
- VkDevice device,
- const VkBufferMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements,
- uint32_t doLock);
+ void vkGetImageMemoryRequirements2KHR(VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements,
+ uint32_t doLock);
+ void vkGetBufferMemoryRequirements2KHR(VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements,
+ uint32_t doLock);
void vkGetImageSparseMemoryRequirements2KHR(
- VkDevice device,
- const VkImageSparseMemoryRequirementsInfo2* pInfo,
+ VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements,
- uint32_t doLock);
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, uint32_t doLock);
#endif
#ifdef VK_KHR_image_format_list
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
VkResult vkCreateSamplerYcbcrConversionKHR(
- VkDevice device,
- const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSamplerYcbcrConversion* pYcbcrConversion,
+ VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion,
uint32_t doLock);
- void vkDestroySamplerYcbcrConversionKHR(
- VkDevice device,
- VkSamplerYcbcrConversion ycbcrConversion,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
+ void vkDestroySamplerYcbcrConversionKHR(VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock);
#endif
#ifdef VK_KHR_bind_memory2
- VkResult vkBindBufferMemory2KHR(
- VkDevice device,
- uint32_t bindInfoCount,
- const VkBindBufferMemoryInfo* pBindInfos,
- uint32_t doLock);
- VkResult vkBindImageMemory2KHR(
- VkDevice device,
- uint32_t bindInfoCount,
- const VkBindImageMemoryInfo* pBindInfos,
- uint32_t doLock);
+ VkResult vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos, uint32_t doLock);
+ VkResult vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos, uint32_t doLock);
#endif
#ifdef VK_KHR_portability_subset
#endif
#ifdef VK_KHR_maintenance3
- void vkGetDescriptorSetLayoutSupportKHR(
- VkDevice device,
- const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- VkDescriptorSetLayoutSupport* pSupport,
- uint32_t doLock);
+ void vkGetDescriptorSetLayoutSupportKHR(VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport,
+ uint32_t doLock);
#endif
#ifdef VK_KHR_draw_indirect_count
- void vkCmdDrawIndirectCountKHR(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride,
- uint32_t doLock);
- void vkCmdDrawIndexedIndirectCountKHR(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride,
- uint32_t doLock);
+ void vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+ uint32_t stride, uint32_t doLock);
+ void vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+ uint32_t stride, uint32_t doLock);
#endif
#ifdef VK_KHR_shader_subgroup_extended_types
#endif
@@ -1739,20 +978,12 @@
#ifdef VK_KHR_swapchain_mutable_format
#endif
#ifdef VK_KHR_timeline_semaphore
- VkResult vkGetSemaphoreCounterValueKHR(
- VkDevice device,
- VkSemaphore semaphore,
- uint64_t* pValue,
- uint32_t doLock);
- VkResult vkWaitSemaphoresKHR(
- VkDevice device,
- const VkSemaphoreWaitInfo* pWaitInfo,
- uint64_t timeout,
- uint32_t doLock);
- VkResult vkSignalSemaphoreKHR(
- VkDevice device,
- const VkSemaphoreSignalInfo* pSignalInfo,
- uint32_t doLock);
+ VkResult vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t* pValue,
+ uint32_t doLock);
+ VkResult vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo,
+ uint64_t timeout, uint32_t doLock);
+ VkResult vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo,
+ uint32_t doLock);
#endif
#ifdef VK_KHR_vulkan_memory_model
#endif
@@ -1760,15 +991,12 @@
#endif
#ifdef VK_KHR_fragment_shading_rate
VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t* pFragmentShadingRateCount,
- VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates,
- uint32_t doLock);
- void vkCmdSetFragmentShadingRateKHR(
- VkCommandBuffer commandBuffer,
- const VkExtent2D* pFragmentSize,
- const VkFragmentShadingRateCombinerOpKHR combinerOps[2],
- uint32_t doLock);
+ VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount,
+ VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates, uint32_t doLock);
+ void vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer,
+ const VkExtent2D* pFragmentSize,
+ const VkFragmentShadingRateCombinerOpKHR combinerOps[2],
+ uint32_t doLock);
#endif
#ifdef VK_KHR_spirv_1_4
#endif
@@ -1777,72 +1005,48 @@
#ifdef VK_KHR_separate_depth_stencil_layouts
#endif
#ifdef VK_KHR_present_wait
- VkResult vkWaitForPresentKHR(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint64_t presentId,
- uint64_t timeout,
- uint32_t doLock);
+ VkResult vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId,
+ uint64_t timeout, uint32_t doLock);
#endif
#ifdef VK_KHR_uniform_buffer_standard_layout
#endif
#ifdef VK_KHR_buffer_device_address
- VkDeviceAddress vkGetBufferDeviceAddressKHR(
- VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo,
- uint32_t doLock);
- uint64_t vkGetBufferOpaqueCaptureAddressKHR(
- VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo,
- uint32_t doLock);
+ VkDeviceAddress vkGetBufferDeviceAddressKHR(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo,
+ uint32_t doLock);
+ uint64_t vkGetBufferOpaqueCaptureAddressKHR(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo,
+ uint32_t doLock);
uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR(
- VkDevice device,
- const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo,
- uint32_t doLock);
+ VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo, uint32_t doLock);
#endif
#ifdef VK_KHR_deferred_host_operations
- VkResult vkCreateDeferredOperationKHR(
- VkDevice device,
- const VkAllocationCallbacks* pAllocator,
- VkDeferredOperationKHR* pDeferredOperation,
- uint32_t doLock);
- void vkDestroyDeferredOperationKHR(
- VkDevice device,
- VkDeferredOperationKHR operation,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- uint32_t vkGetDeferredOperationMaxConcurrencyKHR(
- VkDevice device,
- VkDeferredOperationKHR operation,
- uint32_t doLock);
- VkResult vkGetDeferredOperationResultKHR(
- VkDevice device,
- VkDeferredOperationKHR operation,
- uint32_t doLock);
- VkResult vkDeferredOperationJoinKHR(
- VkDevice device,
- VkDeferredOperationKHR operation,
- uint32_t doLock);
+ VkResult vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks* pAllocator,
+ VkDeferredOperationKHR* pDeferredOperation,
+ uint32_t doLock);
+ void vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ uint32_t vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device,
+ VkDeferredOperationKHR operation,
+ uint32_t doLock);
+ VkResult vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation,
+ uint32_t doLock);
+ VkResult vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation,
+ uint32_t doLock);
#endif
#ifdef VK_KHR_pipeline_executable_properties
- VkResult vkGetPipelineExecutablePropertiesKHR(
- VkDevice device,
- const VkPipelineInfoKHR* pPipelineInfo,
- uint32_t* pExecutableCount,
- VkPipelineExecutablePropertiesKHR* pProperties,
- uint32_t doLock);
+ VkResult vkGetPipelineExecutablePropertiesKHR(VkDevice device,
+ const VkPipelineInfoKHR* pPipelineInfo,
+ uint32_t* pExecutableCount,
+ VkPipelineExecutablePropertiesKHR* pProperties,
+ uint32_t doLock);
VkResult vkGetPipelineExecutableStatisticsKHR(
- VkDevice device,
- const VkPipelineExecutableInfoKHR* pExecutableInfo,
- uint32_t* pStatisticCount,
- VkPipelineExecutableStatisticKHR* pStatistics,
- uint32_t doLock);
+ VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo,
+ uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics, uint32_t doLock);
VkResult vkGetPipelineExecutableInternalRepresentationsKHR(
- VkDevice device,
- const VkPipelineExecutableInfoKHR* pExecutableInfo,
+ VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo,
uint32_t* pInternalRepresentationCount,
- VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations,
- uint32_t doLock);
+ VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations, uint32_t doLock);
#endif
#ifdef VK_KHR_shader_integer_dot_product
#endif
@@ -1853,56 +1057,28 @@
#ifdef VK_KHR_present_id
#endif
#ifdef VK_KHR_video_encode_queue
- void vkCmdEncodeVideoKHR(
- VkCommandBuffer commandBuffer,
- const VkVideoEncodeInfoKHR* pEncodeInfo,
- uint32_t doLock);
+ void vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo,
+ uint32_t doLock);
#endif
#ifdef VK_KHR_synchronization2
- void vkCmdSetEvent2KHR(
- VkCommandBuffer commandBuffer,
- VkEvent event,
- const VkDependencyInfoKHR* pDependencyInfo,
- uint32_t doLock);
- void vkCmdResetEvent2KHR(
- VkCommandBuffer commandBuffer,
- VkEvent event,
- VkPipelineStageFlags2KHR stageMask,
- uint32_t doLock);
- void vkCmdWaitEvents2KHR(
- VkCommandBuffer commandBuffer,
- uint32_t eventCount,
- const VkEvent* pEvents,
- const VkDependencyInfoKHR* pDependencyInfos,
- uint32_t doLock);
- void vkCmdPipelineBarrier2KHR(
- VkCommandBuffer commandBuffer,
- const VkDependencyInfoKHR* pDependencyInfo,
- uint32_t doLock);
- void vkCmdWriteTimestamp2KHR(
- VkCommandBuffer commandBuffer,
- VkPipelineStageFlags2KHR stage,
- VkQueryPool queryPool,
- uint32_t query,
- uint32_t doLock);
- VkResult vkQueueSubmit2KHR(
- VkQueue queue,
- uint32_t submitCount,
- const VkSubmitInfo2KHR* pSubmits,
- VkFence fence,
- uint32_t doLock);
- void vkCmdWriteBufferMarker2AMD(
- VkCommandBuffer commandBuffer,
- VkPipelineStageFlags2KHR stage,
- VkBuffer dstBuffer,
- VkDeviceSize dstOffset,
- uint32_t marker,
- uint32_t doLock);
- void vkGetQueueCheckpointData2NV(
- VkQueue queue,
- uint32_t* pCheckpointDataCount,
- VkCheckpointData2NV* pCheckpointData,
- uint32_t doLock);
+ void vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
+ const VkDependencyInfoKHR* pDependencyInfo, uint32_t doLock);
+ void vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
+ VkPipelineStageFlags2KHR stageMask, uint32_t doLock);
+ void vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount,
+ const VkEvent* pEvents, const VkDependencyInfoKHR* pDependencyInfos,
+ uint32_t doLock);
+ void vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,
+ const VkDependencyInfoKHR* pDependencyInfo, uint32_t doLock);
+ void vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage,
+ VkQueryPool queryPool, uint32_t query, uint32_t doLock);
+ VkResult vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount,
+ const VkSubmitInfo2KHR* pSubmits, VkFence fence, uint32_t doLock);
+ void vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage,
+ VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker,
+ uint32_t doLock);
+ void vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount,
+ VkCheckpointData2NV* pCheckpointData, uint32_t doLock);
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
#endif
@@ -1911,95 +1087,58 @@
#ifdef VK_KHR_workgroup_memory_explicit_layout
#endif
#ifdef VK_KHR_copy_commands2
- void vkCmdCopyBuffer2KHR(
- VkCommandBuffer commandBuffer,
- const VkCopyBufferInfo2KHR* pCopyBufferInfo,
- uint32_t doLock);
- void vkCmdCopyImage2KHR(
- VkCommandBuffer commandBuffer,
- const VkCopyImageInfo2KHR* pCopyImageInfo,
- uint32_t doLock);
- void vkCmdCopyBufferToImage2KHR(
- VkCommandBuffer commandBuffer,
- const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo,
- uint32_t doLock);
- void vkCmdCopyImageToBuffer2KHR(
- VkCommandBuffer commandBuffer,
- const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo,
- uint32_t doLock);
- void vkCmdBlitImage2KHR(
- VkCommandBuffer commandBuffer,
- const VkBlitImageInfo2KHR* pBlitImageInfo,
- uint32_t doLock);
- void vkCmdResolveImage2KHR(
- VkCommandBuffer commandBuffer,
- const VkResolveImageInfo2KHR* pResolveImageInfo,
- uint32_t doLock);
+ void vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
+ const VkCopyBufferInfo2KHR* pCopyBufferInfo, uint32_t doLock);
+ void vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer,
+ const VkCopyImageInfo2KHR* pCopyImageInfo, uint32_t doLock);
+ void vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer,
+ const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo,
+ uint32_t doLock);
+ void vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer,
+ const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo,
+ uint32_t doLock);
+ void vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer,
+ const VkBlitImageInfo2KHR* pBlitImageInfo, uint32_t doLock);
+ void vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer,
+ const VkResolveImageInfo2KHR* pResolveImageInfo, uint32_t doLock);
#endif
#ifdef VK_KHR_format_feature_flags2
#endif
#ifdef VK_KHR_maintenance4
- void vkGetDeviceBufferMemoryRequirementsKHR(
- VkDevice device,
- const VkDeviceBufferMemoryRequirementsKHR* pInfo,
- VkMemoryRequirements2* pMemoryRequirements,
- uint32_t doLock);
- void vkGetDeviceImageMemoryRequirementsKHR(
- VkDevice device,
- const VkDeviceImageMemoryRequirementsKHR* pInfo,
- VkMemoryRequirements2* pMemoryRequirements,
- uint32_t doLock);
+ void vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device,
+ const VkDeviceBufferMemoryRequirementsKHR* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements,
+ uint32_t doLock);
+ void vkGetDeviceImageMemoryRequirementsKHR(VkDevice device,
+ const VkDeviceImageMemoryRequirementsKHR* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements,
+ uint32_t doLock);
void vkGetDeviceImageSparseMemoryRequirementsKHR(
- VkDevice device,
- const VkDeviceImageMemoryRequirementsKHR* pInfo,
+ VkDevice device, const VkDeviceImageMemoryRequirementsKHR* pInfo,
uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements,
- uint32_t doLock);
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, uint32_t doLock);
#endif
#ifdef VK_ANDROID_native_buffer
- VkResult vkGetSwapchainGrallocUsageANDROID(
- VkDevice device,
- VkFormat format,
- VkImageUsageFlags imageUsage,
- int* grallocUsage,
- uint32_t doLock);
- VkResult vkAcquireImageANDROID(
- VkDevice device,
- VkImage image,
- int nativeFenceFd,
- VkSemaphore semaphore,
- VkFence fence,
- uint32_t doLock);
- VkResult vkQueueSignalReleaseImageANDROID(
- VkQueue queue,
- uint32_t waitSemaphoreCount,
- const VkSemaphore* pWaitSemaphores,
- VkImage image,
- int* pNativeFenceFd,
- uint32_t doLock);
+ VkResult vkGetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format,
+ VkImageUsageFlags imageUsage, int* grallocUsage,
+ uint32_t doLock);
+ VkResult vkAcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd,
+ VkSemaphore semaphore, VkFence fence, uint32_t doLock);
+ VkResult vkQueueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount,
+ const VkSemaphore* pWaitSemaphores, VkImage image,
+ int* pNativeFenceFd, uint32_t doLock);
#endif
#ifdef VK_EXT_debug_report
- VkResult vkCreateDebugReportCallbackEXT(
- VkInstance instance,
- const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDebugReportCallbackEXT* pCallback,
- uint32_t doLock);
- void vkDestroyDebugReportCallbackEXT(
- VkInstance instance,
- VkDebugReportCallbackEXT callback,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- void vkDebugReportMessageEXT(
- VkInstance instance,
- VkDebugReportFlagsEXT flags,
- VkDebugReportObjectTypeEXT objectType,
- uint64_t object,
- size_t location,
- int32_t messageCode,
- const char* pLayerPrefix,
- const char* pMessage,
- uint32_t doLock);
+ VkResult vkCreateDebugReportCallbackEXT(VkInstance instance,
+ const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugReportCallbackEXT* pCallback, uint32_t doLock);
+ void vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ void vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
+ VkDebugReportObjectTypeEXT objectType, uint64_t object,
+ size_t location, int32_t messageCode, const char* pLayerPrefix,
+ const char* pMessage, uint32_t doLock);
#endif
#ifdef VK_NV_glsl_shader
#endif
@@ -2014,134 +1153,74 @@
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
- VkResult vkDebugMarkerSetObjectTagEXT(
- VkDevice device,
- const VkDebugMarkerObjectTagInfoEXT* pTagInfo,
- uint32_t doLock);
- VkResult vkDebugMarkerSetObjectNameEXT(
- VkDevice device,
- const VkDebugMarkerObjectNameInfoEXT* pNameInfo,
- uint32_t doLock);
- void vkCmdDebugMarkerBeginEXT(
- VkCommandBuffer commandBuffer,
- const VkDebugMarkerMarkerInfoEXT* pMarkerInfo,
- uint32_t doLock);
- void vkCmdDebugMarkerEndEXT(
- VkCommandBuffer commandBuffer,
- uint32_t doLock);
- void vkCmdDebugMarkerInsertEXT(
- VkCommandBuffer commandBuffer,
- const VkDebugMarkerMarkerInfoEXT* pMarkerInfo,
- uint32_t doLock);
+ VkResult vkDebugMarkerSetObjectTagEXT(VkDevice device,
+ const VkDebugMarkerObjectTagInfoEXT* pTagInfo,
+ uint32_t doLock);
+ VkResult vkDebugMarkerSetObjectNameEXT(VkDevice device,
+ const VkDebugMarkerObjectNameInfoEXT* pNameInfo,
+ uint32_t doLock);
+ void vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo, uint32_t doLock);
+ void vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer, uint32_t doLock);
+ void vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo, uint32_t doLock);
#endif
#ifdef VK_AMD_gcn_shader
#endif
#ifdef VK_NV_dedicated_allocation
#endif
#ifdef VK_EXT_transform_feedback
- void vkCmdBindTransformFeedbackBuffersEXT(
- VkCommandBuffer commandBuffer,
- uint32_t firstBinding,
- uint32_t bindingCount,
- const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets,
- const VkDeviceSize* pSizes,
- uint32_t doLock);
- void vkCmdBeginTransformFeedbackEXT(
- VkCommandBuffer commandBuffer,
- uint32_t firstCounterBuffer,
- uint32_t counterBufferCount,
- const VkBuffer* pCounterBuffers,
- const VkDeviceSize* pCounterBufferOffsets,
- uint32_t doLock);
- void vkCmdEndTransformFeedbackEXT(
- VkCommandBuffer commandBuffer,
- uint32_t firstCounterBuffer,
- uint32_t counterBufferCount,
- const VkBuffer* pCounterBuffers,
- const VkDeviceSize* pCounterBufferOffsets,
- uint32_t doLock);
- void vkCmdBeginQueryIndexedEXT(
- VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t query,
- VkQueryControlFlags flags,
- uint32_t index,
- uint32_t doLock);
- void vkCmdEndQueryIndexedEXT(
- VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t query,
- uint32_t index,
- uint32_t doLock);
- void vkCmdDrawIndirectByteCountEXT(
- VkCommandBuffer commandBuffer,
- uint32_t instanceCount,
- uint32_t firstInstance,
- VkBuffer counterBuffer,
- VkDeviceSize counterBufferOffset,
- uint32_t counterOffset,
- uint32_t vertexStride,
- uint32_t doLock);
+ void vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+ uint32_t bindingCount, const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets,
+ const VkDeviceSize* pSizes, uint32_t doLock);
+ void vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer,
+ uint32_t counterBufferCount,
+ const VkBuffer* pCounterBuffers,
+ const VkDeviceSize* pCounterBufferOffsets, uint32_t doLock);
+ void vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer,
+ uint32_t counterBufferCount, const VkBuffer* pCounterBuffers,
+ const VkDeviceSize* pCounterBufferOffsets, uint32_t doLock);
+ void vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t query, VkQueryControlFlags flags, uint32_t index,
+ uint32_t doLock);
+ void vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t query, uint32_t index, uint32_t doLock);
+ void vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount,
+ uint32_t firstInstance, VkBuffer counterBuffer,
+ VkDeviceSize counterBufferOffset, uint32_t counterOffset,
+ uint32_t vertexStride, uint32_t doLock);
#endif
#ifdef VK_NVX_binary_import
- VkResult vkCreateCuModuleNVX(
- VkDevice device,
- const VkCuModuleCreateInfoNVX* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkCuModuleNVX* pModule,
- uint32_t doLock);
- VkResult vkCreateCuFunctionNVX(
- VkDevice device,
- const VkCuFunctionCreateInfoNVX* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkCuFunctionNVX* pFunction,
- uint32_t doLock);
- void vkDestroyCuModuleNVX(
- VkDevice device,
- VkCuModuleNVX module,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- void vkDestroyCuFunctionNVX(
- VkDevice device,
- VkCuFunctionNVX function,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- void vkCmdCuLaunchKernelNVX(
- VkCommandBuffer commandBuffer,
- const VkCuLaunchInfoNVX* pLaunchInfo,
- uint32_t doLock);
+ VkResult vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule,
+ uint32_t doLock);
+ VkResult vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCuFunctionNVX* pFunction, uint32_t doLock);
+ void vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ void vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ void vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo,
+ uint32_t doLock);
#endif
#ifdef VK_NVX_image_view_handle
- uint32_t vkGetImageViewHandleNVX(
- VkDevice device,
- const VkImageViewHandleInfoNVX* pInfo,
- uint32_t doLock);
- VkResult vkGetImageViewAddressNVX(
- VkDevice device,
- VkImageView imageView,
- VkImageViewAddressPropertiesNVX* pProperties,
- uint32_t doLock);
+ uint32_t vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo,
+ uint32_t doLock);
+ VkResult vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView,
+ VkImageViewAddressPropertiesNVX* pProperties,
+ uint32_t doLock);
#endif
#ifdef VK_AMD_draw_indirect_count
- void vkCmdDrawIndirectCountAMD(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride,
- uint32_t doLock);
- void vkCmdDrawIndexedIndirectCountAMD(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride,
- uint32_t doLock);
+ void vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+ uint32_t stride, uint32_t doLock);
+ void vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+ uint32_t stride, uint32_t doLock);
#endif
#ifdef VK_AMD_negative_viewport_height
#endif
@@ -2158,24 +1237,16 @@
#ifdef VK_AMD_texture_gather_bias_lod
#endif
#ifdef VK_AMD_shader_info
- VkResult vkGetShaderInfoAMD(
- VkDevice device,
- VkPipeline pipeline,
- VkShaderStageFlagBits shaderStage,
- VkShaderInfoTypeAMD infoType,
- size_t* pInfoSize,
- void* pInfo,
- uint32_t doLock);
+ VkResult vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline,
+ VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType,
+ size_t* pInfoSize, void* pInfo, uint32_t doLock);
#endif
#ifdef VK_AMD_shader_image_load_store_lod
#endif
#ifdef VK_GGP_stream_descriptor_surface
VkResult vkCreateStreamDescriptorSurfaceGGP(
- VkInstance instance,
- const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock);
+ VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, uint32_t doLock);
#endif
#ifdef VK_NV_corner_sampled_image
#endif
@@ -2183,37 +1254,26 @@
#endif
#ifdef VK_NV_external_memory_capabilities
VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
- VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkImageType type,
- VkImageTiling tiling,
- VkImageUsageFlags usage,
- VkImageCreateFlags flags,
+ VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling,
+ VkImageUsageFlags usage, VkImageCreateFlags flags,
VkExternalMemoryHandleTypeFlagsNV externalHandleType,
- VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties,
- uint32_t doLock);
+ VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties, uint32_t doLock);
#endif
#ifdef VK_NV_external_memory
#endif
#ifdef VK_NV_external_memory_win32
- VkResult vkGetMemoryWin32HandleNV(
- VkDevice device,
- VkDeviceMemory memory,
- VkExternalMemoryHandleTypeFlagsNV handleType,
- HANDLE* pHandle,
- uint32_t doLock);
+ VkResult vkGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory,
+ VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle,
+ uint32_t doLock);
#endif
#ifdef VK_NV_win32_keyed_mutex
#endif
#ifdef VK_EXT_validation_flags
#endif
#ifdef VK_NN_vi_surface
- VkResult vkCreateViSurfaceNN(
- VkInstance instance,
- const VkViSurfaceCreateInfoNN* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock);
+ VkResult vkCreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface,
+ uint32_t doLock);
#endif
#ifdef VK_EXT_shader_subgroup_ballot
#endif
@@ -2225,85 +1285,54 @@
#endif
#ifdef VK_EXT_conditional_rendering
void vkCmdBeginConditionalRenderingEXT(
- VkCommandBuffer commandBuffer,
- const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin,
- uint32_t doLock);
- void vkCmdEndConditionalRenderingEXT(
- VkCommandBuffer commandBuffer,
- uint32_t doLock);
+ VkCommandBuffer commandBuffer,
+ const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin, uint32_t doLock);
+ void vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer, uint32_t doLock);
#endif
#ifdef VK_NV_clip_space_w_scaling
- void vkCmdSetViewportWScalingNV(
- VkCommandBuffer commandBuffer,
- uint32_t firstViewport,
- uint32_t viewportCount,
- const VkViewportWScalingNV* pViewportWScalings,
- uint32_t doLock);
+ void vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewportWScalingNV* pViewportWScalings,
+ uint32_t doLock);
#endif
#ifdef VK_EXT_direct_mode_display
- VkResult vkReleaseDisplayEXT(
- VkPhysicalDevice physicalDevice,
- VkDisplayKHR display,
- uint32_t doLock);
+ VkResult vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+ uint32_t doLock);
#endif
#ifdef VK_EXT_acquire_xlib_display
- VkResult vkAcquireXlibDisplayEXT(
- VkPhysicalDevice physicalDevice,
- Display* dpy,
- VkDisplayKHR display,
- uint32_t doLock);
- VkResult vkGetRandROutputDisplayEXT(
- VkPhysicalDevice physicalDevice,
- Display* dpy,
- RROutput rrOutput,
- VkDisplayKHR* pDisplay,
- uint32_t doLock);
+ VkResult vkAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy,
+ VkDisplayKHR display, uint32_t doLock);
+ VkResult vkGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy,
+ RROutput rrOutput, VkDisplayKHR* pDisplay, uint32_t doLock);
#endif
#ifdef VK_EXT_display_surface_counter
VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT(
- VkPhysicalDevice physicalDevice,
- VkSurfaceKHR surface,
- VkSurfaceCapabilities2EXT* pSurfaceCapabilities,
- uint32_t doLock);
+ VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+ VkSurfaceCapabilities2EXT* pSurfaceCapabilities, uint32_t doLock);
#endif
#ifdef VK_EXT_display_control
- VkResult vkDisplayPowerControlEXT(
- VkDevice device,
- VkDisplayKHR display,
- const VkDisplayPowerInfoEXT* pDisplayPowerInfo,
- uint32_t doLock);
- VkResult vkRegisterDeviceEventEXT(
- VkDevice device,
- const VkDeviceEventInfoEXT* pDeviceEventInfo,
- const VkAllocationCallbacks* pAllocator,
- VkFence* pFence,
- uint32_t doLock);
- VkResult vkRegisterDisplayEventEXT(
- VkDevice device,
- VkDisplayKHR display,
- const VkDisplayEventInfoEXT* pDisplayEventInfo,
- const VkAllocationCallbacks* pAllocator,
- VkFence* pFence,
- uint32_t doLock);
- VkResult vkGetSwapchainCounterEXT(
- VkDevice device,
- VkSwapchainKHR swapchain,
- VkSurfaceCounterFlagBitsEXT counter,
- uint64_t* pCounterValue,
- uint32_t doLock);
+ VkResult vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display,
+ const VkDisplayPowerInfoEXT* pDisplayPowerInfo,
+ uint32_t doLock);
+ VkResult vkRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo,
+ const VkAllocationCallbacks* pAllocator, VkFence* pFence,
+ uint32_t doLock);
+ VkResult vkRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display,
+ const VkDisplayEventInfoEXT* pDisplayEventInfo,
+ const VkAllocationCallbacks* pAllocator, VkFence* pFence,
+ uint32_t doLock);
+ VkResult vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain,
+ VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue,
+ uint32_t doLock);
#endif
#ifdef VK_GOOGLE_display_timing
- VkResult vkGetRefreshCycleDurationGOOGLE(
- VkDevice device,
- VkSwapchainKHR swapchain,
- VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties,
- uint32_t doLock);
- VkResult vkGetPastPresentationTimingGOOGLE(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint32_t* pPresentationTimingCount,
- VkPastPresentationTimingGOOGLE* pPresentationTimings,
- uint32_t doLock);
+ VkResult vkGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain,
+ VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties,
+ uint32_t doLock);
+ VkResult vkGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain,
+ uint32_t* pPresentationTimingCount,
+ VkPastPresentationTimingGOOGLE* pPresentationTimings,
+ uint32_t doLock);
#endif
#ifdef VK_NV_sample_mask_override_coverage
#endif
@@ -2316,12 +1345,9 @@
#ifdef VK_NV_viewport_swizzle
#endif
#ifdef VK_EXT_discard_rectangles
- void vkCmdSetDiscardRectangleEXT(
- VkCommandBuffer commandBuffer,
- uint32_t firstDiscardRectangle,
- uint32_t discardRectangleCount,
- const VkRect2D* pDiscardRectangles,
- uint32_t doLock);
+ void vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle,
+ uint32_t discardRectangleCount,
+ const VkRect2D* pDiscardRectangles, uint32_t doLock);
#endif
#ifdef VK_EXT_conservative_rasterization
#endif
@@ -2330,119 +1356,70 @@
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
- void vkSetHdrMetadataEXT(
- VkDevice device,
- uint32_t swapchainCount,
- const VkSwapchainKHR* pSwapchains,
- const VkHdrMetadataEXT* pMetadata,
- uint32_t doLock);
+ void vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount,
+ const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata,
+ uint32_t doLock);
#endif
#ifdef VK_MVK_ios_surface
- VkResult vkCreateIOSSurfaceMVK(
- VkInstance instance,
- const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock);
+ VkResult vkCreateIOSSurfaceMVK(VkInstance instance,
+ const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface,
+ uint32_t doLock);
#endif
#ifdef VK_MVK_macos_surface
- VkResult vkCreateMacOSSurfaceMVK(
- VkInstance instance,
- const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock);
+ VkResult vkCreateMacOSSurfaceMVK(VkInstance instance,
+ const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock);
#endif
#ifdef VK_MVK_moltenvk
- void vkGetMTLDeviceMVK(
- VkPhysicalDevice physicalDevice,
- void** pMTLDevice,
- uint32_t doLock);
- VkResult vkSetMTLTextureMVK(
- VkImage image,
- void* mtlTexture,
- uint32_t doLock);
- void vkGetMTLTextureMVK(
- VkImage image,
- void** pMTLTexture,
- uint32_t doLock);
- void vkGetMTLBufferMVK(
- VkBuffer buffer,
- void** pMTLBuffer,
- uint32_t doLock);
- VkResult vkUseIOSurfaceMVK(
- VkImage image,
- void* ioSurface,
- uint32_t doLock);
- void vkGetIOSurfaceMVK(
- VkImage image,
- void** pIOSurface,
- uint32_t doLock);
+ void vkGetMTLDeviceMVK(VkPhysicalDevice physicalDevice, void** pMTLDevice, uint32_t doLock);
+ VkResult vkSetMTLTextureMVK(VkImage image, void* mtlTexture, uint32_t doLock);
+ void vkGetMTLTextureMVK(VkImage image, void** pMTLTexture, uint32_t doLock);
+ void vkGetMTLBufferMVK(VkBuffer buffer, void** pMTLBuffer, uint32_t doLock);
+ VkResult vkUseIOSurfaceMVK(VkImage image, void* ioSurface, uint32_t doLock);
+ void vkGetIOSurfaceMVK(VkImage image, void** pIOSurface, uint32_t doLock);
#endif
#ifdef VK_EXT_external_memory_dma_buf
#endif
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
- VkResult vkSetDebugUtilsObjectNameEXT(
- VkDevice device,
- const VkDebugUtilsObjectNameInfoEXT* pNameInfo,
- uint32_t doLock);
- VkResult vkSetDebugUtilsObjectTagEXT(
- VkDevice device,
- const VkDebugUtilsObjectTagInfoEXT* pTagInfo,
- uint32_t doLock);
- void vkQueueBeginDebugUtilsLabelEXT(
- VkQueue queue,
- const VkDebugUtilsLabelEXT* pLabelInfo,
- uint32_t doLock);
- void vkQueueEndDebugUtilsLabelEXT(
- VkQueue queue,
- uint32_t doLock);
- void vkQueueInsertDebugUtilsLabelEXT(
- VkQueue queue,
- const VkDebugUtilsLabelEXT* pLabelInfo,
- uint32_t doLock);
- void vkCmdBeginDebugUtilsLabelEXT(
- VkCommandBuffer commandBuffer,
- const VkDebugUtilsLabelEXT* pLabelInfo,
- uint32_t doLock);
- void vkCmdEndDebugUtilsLabelEXT(
- VkCommandBuffer commandBuffer,
- uint32_t doLock);
- void vkCmdInsertDebugUtilsLabelEXT(
- VkCommandBuffer commandBuffer,
- const VkDebugUtilsLabelEXT* pLabelInfo,
- uint32_t doLock);
- VkResult vkCreateDebugUtilsMessengerEXT(
- VkInstance instance,
- const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDebugUtilsMessengerEXT* pMessenger,
- uint32_t doLock);
- void vkDestroyDebugUtilsMessengerEXT(
- VkInstance instance,
- VkDebugUtilsMessengerEXT messenger,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- void vkSubmitDebugUtilsMessageEXT(
- VkInstance instance,
- VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
- VkDebugUtilsMessageTypeFlagsEXT messageTypes,
- const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
- uint32_t doLock);
+ VkResult vkSetDebugUtilsObjectNameEXT(VkDevice device,
+ const VkDebugUtilsObjectNameInfoEXT* pNameInfo,
+ uint32_t doLock);
+ VkResult vkSetDebugUtilsObjectTagEXT(VkDevice device,
+ const VkDebugUtilsObjectTagInfoEXT* pTagInfo,
+ uint32_t doLock);
+ void vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo,
+ uint32_t doLock);
+ void vkQueueEndDebugUtilsLabelEXT(VkQueue queue, uint32_t doLock);
+ void vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo,
+ uint32_t doLock);
+ void vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo, uint32_t doLock);
+ void vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, uint32_t doLock);
+ void vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo, uint32_t doLock);
+ VkResult vkCreateDebugUtilsMessengerEXT(VkInstance instance,
+ const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugUtilsMessengerEXT* pMessenger, uint32_t doLock);
+ void vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ void vkSubmitDebugUtilsMessageEXT(VkInstance instance,
+ VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+ VkDebugUtilsMessageTypeFlagsEXT messageTypes,
+ const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
+ uint32_t doLock);
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
VkResult vkGetAndroidHardwareBufferPropertiesANDROID(
- VkDevice device,
- const AHardwareBuffer* buffer,
- VkAndroidHardwareBufferPropertiesANDROID* pProperties,
- uint32_t doLock);
+ VkDevice device, const AHardwareBuffer* buffer,
+ VkAndroidHardwareBufferPropertiesANDROID* pProperties, uint32_t doLock);
VkResult vkGetMemoryAndroidHardwareBufferANDROID(
- VkDevice device,
- const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
- AHardwareBuffer** pBuffer,
- uint32_t doLock);
+ VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
+ AHardwareBuffer** pBuffer, uint32_t doLock);
#endif
#ifdef VK_EXT_sampler_filter_minmax
#endif
@@ -2457,15 +1434,12 @@
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
- void vkCmdSetSampleLocationsEXT(
- VkCommandBuffer commandBuffer,
- const VkSampleLocationsInfoEXT* pSampleLocationsInfo,
- uint32_t doLock);
+ void vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer,
+ const VkSampleLocationsInfoEXT* pSampleLocationsInfo,
+ uint32_t doLock);
void vkGetPhysicalDeviceMultisamplePropertiesEXT(
- VkPhysicalDevice physicalDevice,
- VkSampleCountFlagBits samples,
- VkMultisamplePropertiesEXT* pMultisampleProperties,
- uint32_t doLock);
+ VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples,
+ VkMultisamplePropertiesEXT* pMultisampleProperties, uint32_t doLock);
#endif
#ifdef VK_EXT_blend_operation_advanced
#endif
@@ -2481,158 +1455,92 @@
#endif
#ifdef VK_EXT_image_drm_format_modifier
VkResult vkGetImageDrmFormatModifierPropertiesEXT(
- VkDevice device,
- VkImage image,
- VkImageDrmFormatModifierPropertiesEXT* pProperties,
+ VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties,
uint32_t doLock);
#endif
#ifdef VK_EXT_validation_cache
- VkResult vkCreateValidationCacheEXT(
- VkDevice device,
- const VkValidationCacheCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkValidationCacheEXT* pValidationCache,
- uint32_t doLock);
- void vkDestroyValidationCacheEXT(
- VkDevice device,
- VkValidationCacheEXT validationCache,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkMergeValidationCachesEXT(
- VkDevice device,
- VkValidationCacheEXT dstCache,
- uint32_t srcCacheCount,
- const VkValidationCacheEXT* pSrcCaches,
- uint32_t doLock);
- VkResult vkGetValidationCacheDataEXT(
- VkDevice device,
- VkValidationCacheEXT validationCache,
- size_t* pDataSize,
- void* pData,
- uint32_t doLock);
+ VkResult vkCreateValidationCacheEXT(VkDevice device,
+ const VkValidationCacheCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkValidationCacheEXT* pValidationCache, uint32_t doLock);
+ void vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ VkResult vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache,
+ uint32_t srcCacheCount,
+ const VkValidationCacheEXT* pSrcCaches, uint32_t doLock);
+ VkResult vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache,
+ size_t* pDataSize, void* pData, uint32_t doLock);
#endif
#ifdef VK_EXT_descriptor_indexing
#endif
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_NV_shading_rate_image
- void vkCmdBindShadingRateImageNV(
- VkCommandBuffer commandBuffer,
- VkImageView imageView,
- VkImageLayout imageLayout,
- uint32_t doLock);
- void vkCmdSetViewportShadingRatePaletteNV(
- VkCommandBuffer commandBuffer,
- uint32_t firstViewport,
- uint32_t viewportCount,
- const VkShadingRatePaletteNV* pShadingRatePalettes,
- uint32_t doLock);
- void vkCmdSetCoarseSampleOrderNV(
- VkCommandBuffer commandBuffer,
- VkCoarseSampleOrderTypeNV sampleOrderType,
- uint32_t customSampleOrderCount,
- const VkCoarseSampleOrderCustomNV* pCustomSampleOrders,
- uint32_t doLock);
+ void vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView,
+ VkImageLayout imageLayout, uint32_t doLock);
+ void vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkShadingRatePaletteNV* pShadingRatePalettes,
+ uint32_t doLock);
+ void vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer,
+ VkCoarseSampleOrderTypeNV sampleOrderType,
+ uint32_t customSampleOrderCount,
+ const VkCoarseSampleOrderCustomNV* pCustomSampleOrders,
+ uint32_t doLock);
#endif
#ifdef VK_NV_ray_tracing
- VkResult vkCreateAccelerationStructureNV(
- VkDevice device,
- const VkAccelerationStructureCreateInfoNV* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkAccelerationStructureNV* pAccelerationStructure,
- uint32_t doLock);
- void vkDestroyAccelerationStructureNV(
- VkDevice device,
- VkAccelerationStructureNV accelerationStructure,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
+ VkResult vkCreateAccelerationStructureNV(VkDevice device,
+ const VkAccelerationStructureCreateInfoNV* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkAccelerationStructureNV* pAccelerationStructure,
+ uint32_t doLock);
+ void vkDestroyAccelerationStructureNV(VkDevice device,
+ VkAccelerationStructureNV accelerationStructure,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
void vkGetAccelerationStructureMemoryRequirementsNV(
- VkDevice device,
- const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
- VkMemoryRequirements2KHR* pMemoryRequirements,
- uint32_t doLock);
+ VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
+ VkMemoryRequirements2KHR* pMemoryRequirements, uint32_t doLock);
VkResult vkBindAccelerationStructureMemoryNV(
- VkDevice device,
- uint32_t bindInfoCount,
- const VkBindAccelerationStructureMemoryInfoNV* pBindInfos,
- uint32_t doLock);
- void vkCmdBuildAccelerationStructureNV(
- VkCommandBuffer commandBuffer,
- const VkAccelerationStructureInfoNV* pInfo,
- VkBuffer instanceData,
- VkDeviceSize instanceOffset,
- VkBool32 update,
- VkAccelerationStructureNV dst,
- VkAccelerationStructureNV src,
- VkBuffer scratch,
- VkDeviceSize scratchOffset,
- uint32_t doLock);
- void vkCmdCopyAccelerationStructureNV(
- VkCommandBuffer commandBuffer,
- VkAccelerationStructureNV dst,
- VkAccelerationStructureNV src,
- VkCopyAccelerationStructureModeKHR mode,
- uint32_t doLock);
+ VkDevice device, uint32_t bindInfoCount,
+ const VkBindAccelerationStructureMemoryInfoNV* pBindInfos, uint32_t doLock);
+ void vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer,
+ const VkAccelerationStructureInfoNV* pInfo,
+ VkBuffer instanceData, VkDeviceSize instanceOffset,
+ VkBool32 update, VkAccelerationStructureNV dst,
+ VkAccelerationStructureNV src, VkBuffer scratch,
+ VkDeviceSize scratchOffset, uint32_t doLock);
+ void vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer,
+ VkAccelerationStructureNV dst,
+ VkAccelerationStructureNV src,
+ VkCopyAccelerationStructureModeKHR mode, uint32_t doLock);
void vkCmdTraceRaysNV(
- VkCommandBuffer commandBuffer,
- VkBuffer raygenShaderBindingTableBuffer,
- VkDeviceSize raygenShaderBindingOffset,
- VkBuffer missShaderBindingTableBuffer,
- VkDeviceSize missShaderBindingOffset,
- VkDeviceSize missShaderBindingStride,
- VkBuffer hitShaderBindingTableBuffer,
- VkDeviceSize hitShaderBindingOffset,
- VkDeviceSize hitShaderBindingStride,
- VkBuffer callableShaderBindingTableBuffer,
- VkDeviceSize callableShaderBindingOffset,
- VkDeviceSize callableShaderBindingStride,
- uint32_t width,
- uint32_t height,
- uint32_t depth,
- uint32_t doLock);
- VkResult vkCreateRayTracingPipelinesNV(
- VkDevice device,
- VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines,
- uint32_t doLock);
- VkResult vkGetRayTracingShaderGroupHandlesKHR(
- VkDevice device,
- VkPipeline pipeline,
- uint32_t firstGroup,
- uint32_t groupCount,
- size_t dataSize,
- void* pData,
- uint32_t doLock);
- VkResult vkGetRayTracingShaderGroupHandlesNV(
- VkDevice device,
- VkPipeline pipeline,
- uint32_t firstGroup,
- uint32_t groupCount,
- size_t dataSize,
- void* pData,
- uint32_t doLock);
- VkResult vkGetAccelerationStructureHandleNV(
- VkDevice device,
- VkAccelerationStructureNV accelerationStructure,
- size_t dataSize,
- void* pData,
- uint32_t doLock);
+ VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer,
+ VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer,
+ VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride,
+ VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset,
+ VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer,
+ VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride,
+ uint32_t width, uint32_t height, uint32_t depth, uint32_t doLock);
+ VkResult vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines, uint32_t doLock);
+ VkResult vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline,
+ uint32_t firstGroup, uint32_t groupCount,
+ size_t dataSize, void* pData, uint32_t doLock);
+ VkResult vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline,
+ uint32_t firstGroup, uint32_t groupCount,
+ size_t dataSize, void* pData, uint32_t doLock);
+ VkResult vkGetAccelerationStructureHandleNV(VkDevice device,
+ VkAccelerationStructureNV accelerationStructure,
+ size_t dataSize, void* pData, uint32_t doLock);
void vkCmdWriteAccelerationStructuresPropertiesNV(
- VkCommandBuffer commandBuffer,
- uint32_t accelerationStructureCount,
- const VkAccelerationStructureNV* pAccelerationStructures,
- VkQueryType queryType,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t doLock);
- VkResult vkCompileDeferredNV(
- VkDevice device,
- VkPipeline pipeline,
- uint32_t shader,
- uint32_t doLock);
+ VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount,
+ const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType,
+ VkQueryPool queryPool, uint32_t firstQuery, uint32_t doLock);
+ VkResult vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader,
+ uint32_t doLock);
#endif
#ifdef VK_NV_representative_fragment_test
#endif
@@ -2644,36 +1552,25 @@
#endif
#ifdef VK_EXT_external_memory_host
VkResult vkGetMemoryHostPointerPropertiesEXT(
- VkDevice device,
- VkExternalMemoryHandleTypeFlagBits handleType,
- const void* pHostPointer,
- VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties,
- uint32_t doLock);
+ VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer,
+ VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, uint32_t doLock);
#endif
#ifdef VK_AMD_buffer_marker
- void vkCmdWriteBufferMarkerAMD(
- VkCommandBuffer commandBuffer,
- VkPipelineStageFlagBits pipelineStage,
- VkBuffer dstBuffer,
- VkDeviceSize dstOffset,
- uint32_t marker,
- uint32_t doLock);
+ void vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer,
+ VkDeviceSize dstOffset, uint32_t marker, uint32_t doLock);
#endif
#ifdef VK_AMD_pipeline_compiler_control
#endif
#ifdef VK_EXT_calibrated_timestamps
- VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
- VkPhysicalDevice physicalDevice,
- uint32_t* pTimeDomainCount,
- VkTimeDomainEXT* pTimeDomains,
- uint32_t doLock);
- VkResult vkGetCalibratedTimestampsEXT(
- VkDevice device,
- uint32_t timestampCount,
- const VkCalibratedTimestampInfoEXT* pTimestampInfos,
- uint64_t* pTimestamps,
- uint64_t* pMaxDeviation,
- uint32_t doLock);
+ VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice,
+ uint32_t* pTimeDomainCount,
+ VkTimeDomainEXT* pTimeDomains,
+ uint32_t doLock);
+ VkResult vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount,
+ const VkCalibratedTimestampInfoEXT* pTimestampInfos,
+ uint64_t* pTimestamps, uint64_t* pMaxDeviation,
+ uint32_t doLock);
#endif
#ifdef VK_AMD_shader_core_properties
#endif
@@ -2692,116 +1589,77 @@
#ifdef VK_NV_compute_shader_derivatives
#endif
#ifdef VK_NV_mesh_shader
- void vkCmdDrawMeshTasksNV(
- VkCommandBuffer commandBuffer,
- uint32_t taskCount,
- uint32_t firstTask,
- uint32_t doLock);
- void vkCmdDrawMeshTasksIndirectNV(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- uint32_t drawCount,
- uint32_t stride,
- uint32_t doLock);
- void vkCmdDrawMeshTasksIndirectCountNV(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride,
- uint32_t doLock);
+ void vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask,
+ uint32_t doLock);
+ void vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, uint32_t drawCount, uint32_t stride,
+ uint32_t doLock);
+ void vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+ uint32_t stride, uint32_t doLock);
#endif
#ifdef VK_NV_fragment_shader_barycentric
#endif
#ifdef VK_NV_shader_image_footprint
#endif
#ifdef VK_NV_scissor_exclusive
- void vkCmdSetExclusiveScissorNV(
- VkCommandBuffer commandBuffer,
- uint32_t firstExclusiveScissor,
- uint32_t exclusiveScissorCount,
- const VkRect2D* pExclusiveScissors,
- uint32_t doLock);
+ void vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor,
+ uint32_t exclusiveScissorCount,
+ const VkRect2D* pExclusiveScissors, uint32_t doLock);
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
- void vkCmdSetCheckpointNV(
- VkCommandBuffer commandBuffer,
- const void* pCheckpointMarker,
- uint32_t doLock);
- void vkGetQueueCheckpointDataNV(
- VkQueue queue,
- uint32_t* pCheckpointDataCount,
- VkCheckpointDataNV* pCheckpointData,
- uint32_t doLock);
+ void vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker,
+ uint32_t doLock);
+ void vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount,
+ VkCheckpointDataNV* pCheckpointData, uint32_t doLock);
#endif
#ifdef VK_INTEL_shader_integer_functions2
#endif
#ifdef VK_INTEL_performance_query
VkResult vkInitializePerformanceApiINTEL(
- VkDevice device,
- const VkInitializePerformanceApiInfoINTEL* pInitializeInfo,
+ VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo,
uint32_t doLock);
- void vkUninitializePerformanceApiINTEL(
- VkDevice device,
- uint32_t doLock);
- VkResult vkCmdSetPerformanceMarkerINTEL(
- VkCommandBuffer commandBuffer,
- const VkPerformanceMarkerInfoINTEL* pMarkerInfo,
- uint32_t doLock);
+ void vkUninitializePerformanceApiINTEL(VkDevice device, uint32_t doLock);
+ VkResult vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer,
+ const VkPerformanceMarkerInfoINTEL* pMarkerInfo,
+ uint32_t doLock);
VkResult vkCmdSetPerformanceStreamMarkerINTEL(
- VkCommandBuffer commandBuffer,
- const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo,
+ VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo,
uint32_t doLock);
- VkResult vkCmdSetPerformanceOverrideINTEL(
- VkCommandBuffer commandBuffer,
- const VkPerformanceOverrideInfoINTEL* pOverrideInfo,
- uint32_t doLock);
+ VkResult vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer,
+ const VkPerformanceOverrideInfoINTEL* pOverrideInfo,
+ uint32_t doLock);
VkResult vkAcquirePerformanceConfigurationINTEL(
- VkDevice device,
- const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
- VkPerformanceConfigurationINTEL* pConfiguration,
- uint32_t doLock);
- VkResult vkReleasePerformanceConfigurationINTEL(
- VkDevice device,
- VkPerformanceConfigurationINTEL configuration,
- uint32_t doLock);
- VkResult vkQueueSetPerformanceConfigurationINTEL(
- VkQueue queue,
- VkPerformanceConfigurationINTEL configuration,
- uint32_t doLock);
- VkResult vkGetPerformanceParameterINTEL(
- VkDevice device,
- VkPerformanceParameterTypeINTEL parameter,
- VkPerformanceValueINTEL* pValue,
- uint32_t doLock);
+ VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
+ VkPerformanceConfigurationINTEL* pConfiguration, uint32_t doLock);
+ VkResult vkReleasePerformanceConfigurationINTEL(VkDevice device,
+ VkPerformanceConfigurationINTEL configuration,
+ uint32_t doLock);
+ VkResult vkQueueSetPerformanceConfigurationINTEL(VkQueue queue,
+ VkPerformanceConfigurationINTEL configuration,
+ uint32_t doLock);
+ VkResult vkGetPerformanceParameterINTEL(VkDevice device,
+ VkPerformanceParameterTypeINTEL parameter,
+ VkPerformanceValueINTEL* pValue, uint32_t doLock);
#endif
#ifdef VK_EXT_pci_bus_info
#endif
#ifdef VK_AMD_display_native_hdr
- void vkSetLocalDimmingAMD(
- VkDevice device,
- VkSwapchainKHR swapChain,
- VkBool32 localDimmingEnable,
- uint32_t doLock);
+ void vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain,
+ VkBool32 localDimmingEnable, uint32_t doLock);
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
- VkResult vkCreateImagePipeSurfaceFUCHSIA(
- VkInstance instance,
- const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock);
+ VkResult vkCreateImagePipeSurfaceFUCHSIA(VkInstance instance,
+ const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock);
#endif
#ifdef VK_EXT_metal_surface
- VkResult vkCreateMetalSurfaceEXT(
- VkInstance instance,
- const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock);
+ VkResult vkCreateMetalSurfaceEXT(VkInstance instance,
+ const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock);
#endif
#ifdef VK_EXT_fragment_density_map
#endif
@@ -2826,17 +1684,14 @@
#ifdef VK_NV_dedicated_allocation_image_aliasing
#endif
#ifdef VK_EXT_buffer_device_address
- VkDeviceAddress vkGetBufferDeviceAddressEXT(
- VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo,
- uint32_t doLock);
+ VkDeviceAddress vkGetBufferDeviceAddressEXT(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo,
+ uint32_t doLock);
#endif
#ifdef VK_EXT_tooling_info
VkResult vkGetPhysicalDeviceToolPropertiesEXT(
- VkPhysicalDevice physicalDevice,
- uint32_t* pToolCount,
- VkPhysicalDeviceToolPropertiesEXT* pToolProperties,
- uint32_t doLock);
+ VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
+ VkPhysicalDeviceToolPropertiesEXT* pToolProperties, uint32_t doLock);
#endif
#ifdef VK_EXT_separate_stencil_usage
#endif
@@ -2844,17 +1699,13 @@
#endif
#ifdef VK_NV_cooperative_matrix
VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
- VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkCooperativeMatrixPropertiesNV* pProperties,
- uint32_t doLock);
+ VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount,
+ VkCooperativeMatrixPropertiesNV* pProperties, uint32_t doLock);
#endif
#ifdef VK_NV_coverage_reduction_mode
VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
- VkPhysicalDevice physicalDevice,
- uint32_t* pCombinationCount,
- VkFramebufferMixedSamplesCombinationNV* pCombinations,
- uint32_t doLock);
+ VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount,
+ VkFramebufferMixedSamplesCombinationNV* pCombinations, uint32_t doLock);
#endif
#ifdef VK_EXT_fragment_shader_interlock
#endif
@@ -2864,112 +1715,62 @@
#endif
#ifdef VK_EXT_full_screen_exclusive
VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
- uint32_t* pPresentModeCount,
- VkPresentModeKHR* pPresentModes,
- uint32_t doLock);
- VkResult vkAcquireFullScreenExclusiveModeEXT(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint32_t doLock);
- VkResult vkReleaseFullScreenExclusiveModeEXT(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint32_t doLock);
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes, uint32_t doLock);
+ VkResult vkAcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain,
+ uint32_t doLock);
+ VkResult vkReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain,
+ uint32_t doLock);
VkResult vkGetDeviceGroupSurfacePresentModes2EXT(
- VkDevice device,
- const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
- VkDeviceGroupPresentModeFlagsKHR* pModes,
- uint32_t doLock);
+ VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ VkDeviceGroupPresentModeFlagsKHR* pModes, uint32_t doLock);
#endif
#ifdef VK_EXT_headless_surface
- VkResult vkCreateHeadlessSurfaceEXT(
- VkInstance instance,
- const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock);
+ VkResult vkCreateHeadlessSurfaceEXT(VkInstance instance,
+ const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock);
#endif
#ifdef VK_EXT_line_rasterization
- void vkCmdSetLineStippleEXT(
- VkCommandBuffer commandBuffer,
- uint32_t lineStippleFactor,
- uint16_t lineStipplePattern,
- uint32_t doLock);
+ void vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+ uint16_t lineStipplePattern, uint32_t doLock);
#endif
#ifdef VK_EXT_shader_atomic_float
#endif
#ifdef VK_EXT_host_query_reset
- void vkResetQueryPoolEXT(
- VkDevice device,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t queryCount,
- uint32_t doLock);
+ void vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
+ uint32_t queryCount, uint32_t doLock);
#endif
#ifdef VK_EXT_index_type_uint8
#endif
#ifdef VK_EXT_extended_dynamic_state
- void vkCmdSetCullModeEXT(
- VkCommandBuffer commandBuffer,
- VkCullModeFlags cullMode,
- uint32_t doLock);
- void vkCmdSetFrontFaceEXT(
- VkCommandBuffer commandBuffer,
- VkFrontFace frontFace,
- uint32_t doLock);
- void vkCmdSetPrimitiveTopologyEXT(
- VkCommandBuffer commandBuffer,
- VkPrimitiveTopology primitiveTopology,
- uint32_t doLock);
- void vkCmdSetViewportWithCountEXT(
- VkCommandBuffer commandBuffer,
- uint32_t viewportCount,
- const VkViewport* pViewports,
- uint32_t doLock);
- void vkCmdSetScissorWithCountEXT(
- VkCommandBuffer commandBuffer,
- uint32_t scissorCount,
- const VkRect2D* pScissors,
- uint32_t doLock);
- void vkCmdBindVertexBuffers2EXT(
- VkCommandBuffer commandBuffer,
- uint32_t firstBinding,
- uint32_t bindingCount,
- const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets,
- const VkDeviceSize* pSizes,
- const VkDeviceSize* pStrides,
- uint32_t doLock);
- void vkCmdSetDepthTestEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 depthTestEnable,
- uint32_t doLock);
- void vkCmdSetDepthWriteEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 depthWriteEnable,
- uint32_t doLock);
- void vkCmdSetDepthCompareOpEXT(
- VkCommandBuffer commandBuffer,
- VkCompareOp depthCompareOp,
- uint32_t doLock);
- void vkCmdSetDepthBoundsTestEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 depthBoundsTestEnable,
- uint32_t doLock);
- void vkCmdSetStencilTestEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 stencilTestEnable,
- uint32_t doLock);
- void vkCmdSetStencilOpEXT(
- VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask,
- VkStencilOp failOp,
- VkStencilOp passOp,
- VkStencilOp depthFailOp,
- VkCompareOp compareOp,
- uint32_t doLock);
+ void vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode,
+ uint32_t doLock);
+ void vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace,
+ uint32_t doLock);
+ void vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
+ VkPrimitiveTopology primitiveTopology, uint32_t doLock);
+ void vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount,
+ const VkViewport* pViewports, uint32_t doLock);
+ void vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount,
+ const VkRect2D* pScissors, uint32_t doLock);
+ void vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+ uint32_t bindingCount, const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
+ const VkDeviceSize* pStrides, uint32_t doLock);
+ void vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable,
+ uint32_t doLock);
+ void vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable,
+ uint32_t doLock);
+ void vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp,
+ uint32_t doLock);
+ void vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 depthBoundsTestEnable, uint32_t doLock);
+ void vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable,
+ uint32_t doLock);
+ void vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+ VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp,
+ VkCompareOp compareOp, uint32_t doLock);
#endif
#ifdef VK_EXT_shader_atomic_float2
#endif
@@ -2977,36 +1778,25 @@
#endif
#ifdef VK_NV_device_generated_commands
void vkGetGeneratedCommandsMemoryRequirementsNV(
- VkDevice device,
- const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,
- VkMemoryRequirements2* pMemoryRequirements,
- uint32_t doLock);
- void vkCmdPreprocessGeneratedCommandsNV(
- VkCommandBuffer commandBuffer,
- const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo,
- uint32_t doLock);
- void vkCmdExecuteGeneratedCommandsNV(
- VkCommandBuffer commandBuffer,
- VkBool32 isPreprocessed,
- const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo,
- uint32_t doLock);
- void vkCmdBindPipelineShaderGroupNV(
- VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipeline pipeline,
- uint32_t groupIndex,
- uint32_t doLock);
+ VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements, uint32_t doLock);
+ void vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer,
+ const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo,
+ uint32_t doLock);
+ void vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed,
+ const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo,
+ uint32_t doLock);
+ void vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline,
+ uint32_t groupIndex, uint32_t doLock);
VkResult vkCreateIndirectCommandsLayoutNV(
- VkDevice device,
- const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
+ VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkIndirectCommandsLayoutNV* pIndirectCommandsLayout,
- uint32_t doLock);
- void vkDestroyIndirectCommandsLayoutNV(
- VkDevice device,
- VkIndirectCommandsLayoutNV indirectCommandsLayout,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
+ VkIndirectCommandsLayoutNV* pIndirectCommandsLayout, uint32_t doLock);
+ void vkDestroyIndirectCommandsLayoutNV(VkDevice device,
+ VkIndirectCommandsLayoutNV indirectCommandsLayout,
+ const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock);
#endif
#ifdef VK_NV_inherited_viewport_scissor
#endif
@@ -3017,17 +1807,10 @@
#ifdef VK_EXT_device_memory_report
#endif
#ifdef VK_EXT_acquire_drm_display
- VkResult vkAcquireDrmDisplayEXT(
- VkPhysicalDevice physicalDevice,
- int32_t drmFd,
- VkDisplayKHR display,
- uint32_t doLock);
- VkResult vkGetDrmDisplayEXT(
- VkPhysicalDevice physicalDevice,
- int32_t drmFd,
- uint32_t connectorId,
- VkDisplayKHR* display,
- uint32_t doLock);
+ VkResult vkAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd,
+ VkDisplayKHR display, uint32_t doLock);
+ VkResult vkGetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd,
+ uint32_t connectorId, VkDisplayKHR* display, uint32_t doLock);
#endif
#ifdef VK_EXT_robustness2
#endif
@@ -3036,31 +1819,18 @@
#ifdef VK_GOOGLE_user_type
#endif
#ifdef VK_EXT_private_data
- VkResult vkCreatePrivateDataSlotEXT(
- VkDevice device,
- const VkPrivateDataSlotCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPrivateDataSlotEXT* pPrivateDataSlot,
- uint32_t doLock);
- void vkDestroyPrivateDataSlotEXT(
- VkDevice device,
- VkPrivateDataSlotEXT privateDataSlot,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- VkResult vkSetPrivateDataEXT(
- VkDevice device,
- VkObjectType objectType,
- uint64_t objectHandle,
- VkPrivateDataSlotEXT privateDataSlot,
- uint64_t data,
- uint32_t doLock);
- void vkGetPrivateDataEXT(
- VkDevice device,
- VkObjectType objectType,
- uint64_t objectHandle,
- VkPrivateDataSlotEXT privateDataSlot,
- uint64_t* pData,
- uint32_t doLock);
+ VkResult vkCreatePrivateDataSlotEXT(VkDevice device,
+ const VkPrivateDataSlotCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPrivateDataSlotEXT* pPrivateDataSlot, uint32_t doLock);
+ void vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlotEXT privateDataSlot,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ VkResult vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
+ VkPrivateDataSlotEXT privateDataSlot, uint64_t data,
+ uint32_t doLock);
+ void vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
+ VkPrivateDataSlotEXT privateDataSlot, uint64_t* pData,
+ uint32_t doLock);
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
#endif
@@ -3069,11 +1839,10 @@
#ifdef VK_QCOM_render_pass_store_ops
#endif
#ifdef VK_NV_fragment_shading_rate_enums
- void vkCmdSetFragmentShadingRateEnumNV(
- VkCommandBuffer commandBuffer,
- VkFragmentShadingRateNV shadingRate,
- const VkFragmentShadingRateCombinerOpKHR combinerOps[2],
- uint32_t doLock);
+ void vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer,
+ VkFragmentShadingRateNV shadingRate,
+ const VkFragmentShadingRateCombinerOpKHR combinerOps[2],
+ uint32_t doLock);
#endif
#ifdef VK_NV_ray_tracing_motion_blur
#endif
@@ -3090,39 +1859,28 @@
#ifdef VK_EXT_rgba10x6_formats
#endif
#ifdef VK_NV_acquire_winrt_display
- VkResult vkAcquireWinrtDisplayNV(
- VkPhysicalDevice physicalDevice,
- VkDisplayKHR display,
- uint32_t doLock);
- VkResult vkGetWinrtDisplayNV(
- VkPhysicalDevice physicalDevice,
- uint32_t deviceRelativeId,
- VkDisplayKHR* pDisplay,
- uint32_t doLock);
+ VkResult vkAcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+ uint32_t doLock);
+ VkResult vkGetWinrtDisplayNV(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId,
+ VkDisplayKHR* pDisplay, uint32_t doLock);
#endif
#ifdef VK_EXT_directfb_surface
- VkResult vkCreateDirectFBSurfaceEXT(
- VkInstance instance,
- const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock);
- VkBool32 vkGetPhysicalDeviceDirectFBPresentationSupportEXT(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- IDirectFB* dfb,
- uint32_t doLock);
+ VkResult vkCreateDirectFBSurfaceEXT(VkInstance instance,
+ const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock);
+ VkBool32 vkGetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ IDirectFB* dfb, uint32_t doLock);
#endif
#ifdef VK_VALVE_mutable_descriptor_type
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
void vkCmdSetVertexInputEXT(
- VkCommandBuffer commandBuffer,
- uint32_t vertexBindingDescriptionCount,
+ VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount,
const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions,
uint32_t vertexAttributeDescriptionCount,
- const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions,
- uint32_t doLock);
+ const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions, uint32_t doLock);
#endif
#ifdef VK_EXT_physical_device_drm
#endif
@@ -3130,437 +1888,265 @@
#endif
#ifdef VK_FUCHSIA_external_memory
VkResult vkGetMemoryZirconHandleFUCHSIA(
- VkDevice device,
- const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
- zx_handle_t* pZirconHandle,
- uint32_t doLock);
+ VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle, uint32_t doLock);
VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA(
- VkDevice device,
- VkExternalMemoryHandleTypeFlagBits handleType,
- zx_handle_t zirconHandle,
- VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties,
- uint32_t doLock);
+ VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle,
+ VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties, uint32_t doLock);
#endif
#ifdef VK_FUCHSIA_external_semaphore
VkResult vkImportSemaphoreZirconHandleFUCHSIA(
- VkDevice device,
+ VkDevice device,
const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo,
uint32_t doLock);
VkResult vkGetSemaphoreZirconHandleFUCHSIA(
- VkDevice device,
- const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
- zx_handle_t* pZirconHandle,
- uint32_t doLock);
+ VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle, uint32_t doLock);
#endif
#ifdef VK_FUCHSIA_buffer_collection
- VkResult vkCreateBufferCollectionFUCHSIA(
- VkDevice device,
- const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkBufferCollectionFUCHSIA* pCollection,
- uint32_t doLock);
+ VkResult vkCreateBufferCollectionFUCHSIA(VkDevice device,
+ const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferCollectionFUCHSIA* pCollection,
+ uint32_t doLock);
VkResult vkSetBufferCollectionImageConstraintsFUCHSIA(
- VkDevice device,
- VkBufferCollectionFUCHSIA collection,
- const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo,
- uint32_t doLock);
+ VkDevice device, VkBufferCollectionFUCHSIA collection,
+ const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo, uint32_t doLock);
VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA(
- VkDevice device,
- VkBufferCollectionFUCHSIA collection,
- const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo,
- uint32_t doLock);
- void vkDestroyBufferCollectionFUCHSIA(
- VkDevice device,
- VkBufferCollectionFUCHSIA collection,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
+ VkDevice device, VkBufferCollectionFUCHSIA collection,
+ const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo, uint32_t doLock);
+ void vkDestroyBufferCollectionFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
VkResult vkGetBufferCollectionPropertiesFUCHSIA(
- VkDevice device,
- VkBufferCollectionFUCHSIA collection,
- VkBufferCollectionPropertiesFUCHSIA* pProperties,
- uint32_t doLock);
+ VkDevice device, VkBufferCollectionFUCHSIA collection,
+ VkBufferCollectionPropertiesFUCHSIA* pProperties, uint32_t doLock);
#endif
#ifdef VK_HUAWEI_subpass_shading
- VkResult vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
- VkDevice device,
- VkRenderPass renderpass,
- VkExtent2D* pMaxWorkgroupSize,
- uint32_t doLock);
- void vkCmdSubpassShadingHUAWEI(
- VkCommandBuffer commandBuffer,
- uint32_t doLock);
+ VkResult vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device,
+ VkRenderPass renderpass,
+ VkExtent2D* pMaxWorkgroupSize,
+ uint32_t doLock);
+ void vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer, uint32_t doLock);
#endif
#ifdef VK_HUAWEI_invocation_mask
- void vkCmdBindInvocationMaskHUAWEI(
- VkCommandBuffer commandBuffer,
- VkImageView imageView,
- VkImageLayout imageLayout,
- uint32_t doLock);
+ void vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView,
+ VkImageLayout imageLayout, uint32_t doLock);
#endif
#ifdef VK_NV_external_memory_rdma
VkResult vkGetMemoryRemoteAddressNV(
- VkDevice device,
- const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo,
- VkRemoteAddressNV* pAddress,
- uint32_t doLock);
+ VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo,
+ VkRemoteAddressNV* pAddress, uint32_t doLock);
#endif
#ifdef VK_EXT_extended_dynamic_state2
- void vkCmdSetPatchControlPointsEXT(
- VkCommandBuffer commandBuffer,
- uint32_t patchControlPoints,
- uint32_t doLock);
- void vkCmdSetRasterizerDiscardEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 rasterizerDiscardEnable,
- uint32_t doLock);
- void vkCmdSetDepthBiasEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 depthBiasEnable,
- uint32_t doLock);
- void vkCmdSetLogicOpEXT(
- VkCommandBuffer commandBuffer,
- VkLogicOp logicOp,
- uint32_t doLock);
- void vkCmdSetPrimitiveRestartEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 primitiveRestartEnable,
- uint32_t doLock);
+ void vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints,
+ uint32_t doLock);
+ void vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 rasterizerDiscardEnable, uint32_t doLock);
+ void vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable,
+ uint32_t doLock);
+ void vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp, uint32_t doLock);
+ void vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 primitiveRestartEnable, uint32_t doLock);
#endif
#ifdef VK_QNX_screen_surface
- VkResult vkCreateScreenSurfaceQNX(
- VkInstance instance,
- const VkScreenSurfaceCreateInfoQNX* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface,
- uint32_t doLock);
- VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- _screen_window* window,
- uint32_t doLock);
+ VkResult vkCreateScreenSurfaceQNX(VkInstance instance,
+ const VkScreenSurfaceCreateInfoQNX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface, uint32_t doLock);
+ VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ _screen_window* window,
+ uint32_t doLock);
#endif
#ifdef VK_EXT_color_write_enable
- void vkCmdSetColorWriteEnableEXT(
- VkCommandBuffer commandBuffer,
- uint32_t attachmentCount,
- const VkBool32* pColorWriteEnables,
- uint32_t doLock);
+ void vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
+ const VkBool32* pColorWriteEnables, uint32_t doLock);
#endif
#ifdef VK_GOOGLE_gfxstream
- VkResult vkRegisterImageColorBufferGOOGLE(
- VkDevice device,
- VkImage image,
- uint32_t colorBuffer,
- uint32_t doLock);
- VkResult vkRegisterBufferColorBufferGOOGLE(
- VkDevice device,
- VkBuffer buffer,
- uint32_t colorBuffer,
- uint32_t doLock);
- VkResult vkMapMemoryIntoAddressSpaceGOOGLE(
- VkDevice device,
- VkDeviceMemory memory,
- uint64_t* pAddress,
- uint32_t doLock);
+ VkResult vkRegisterImageColorBufferGOOGLE(VkDevice device, VkImage image, uint32_t colorBuffer,
+ uint32_t doLock);
+ VkResult vkRegisterBufferColorBufferGOOGLE(VkDevice device, VkBuffer buffer,
+ uint32_t colorBuffer, uint32_t doLock);
+ VkResult vkMapMemoryIntoAddressSpaceGOOGLE(VkDevice device, VkDeviceMemory memory,
+ uint64_t* pAddress, uint32_t doLock);
void vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
- VkDevice device,
- VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- uint32_t imageInfoCount,
- uint32_t bufferInfoCount,
- uint32_t bufferViewCount,
- const uint32_t* pImageInfoEntryIndices,
- const uint32_t* pBufferInfoEntryIndices,
- const uint32_t* pBufferViewEntryIndices,
- const VkDescriptorImageInfo* pImageInfos,
- const VkDescriptorBufferInfo* pBufferInfos,
- const VkBufferView* pBufferViews,
- uint32_t doLock);
- void vkBeginCommandBufferAsyncGOOGLE(
- VkCommandBuffer commandBuffer,
- const VkCommandBufferBeginInfo* pBeginInfo,
- uint32_t doLock);
- void vkEndCommandBufferAsyncGOOGLE(
- VkCommandBuffer commandBuffer,
- uint32_t doLock);
- void vkResetCommandBufferAsyncGOOGLE(
- VkCommandBuffer commandBuffer,
- VkCommandBufferResetFlags flags,
- uint32_t doLock);
- void vkCommandBufferHostSyncGOOGLE(
- VkCommandBuffer commandBuffer,
- uint32_t needHostSync,
- uint32_t sequenceNumber,
- uint32_t doLock);
- VkResult vkCreateImageWithRequirementsGOOGLE(
- VkDevice device,
- const VkImageCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkImage* pImage,
- VkMemoryRequirements* pMemoryRequirements,
- uint32_t doLock);
- VkResult vkCreateBufferWithRequirementsGOOGLE(
- VkDevice device,
- const VkBufferCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkBuffer* pBuffer,
- VkMemoryRequirements* pMemoryRequirements,
- uint32_t doLock);
- VkResult vkGetMemoryHostAddressInfoGOOGLE(
- VkDevice device,
- VkDeviceMemory memory,
- uint64_t* pAddress,
- uint64_t* pSize,
- uint64_t* pHostmemId,
- uint32_t doLock);
- VkResult vkFreeMemorySyncGOOGLE(
- VkDevice device,
- VkDeviceMemory memory,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
- void vkQueueHostSyncGOOGLE(
- VkQueue queue,
- uint32_t needHostSync,
- uint32_t sequenceNumber,
- uint32_t doLock);
- void vkQueueSubmitAsyncGOOGLE(
- VkQueue queue,
- uint32_t submitCount,
- const VkSubmitInfo* pSubmits,
- VkFence fence,
- uint32_t doLock);
- void vkQueueWaitIdleAsyncGOOGLE(
- VkQueue queue,
- uint32_t doLock);
- void vkQueueBindSparseAsyncGOOGLE(
- VkQueue queue,
- uint32_t bindInfoCount,
- const VkBindSparseInfo* pBindInfo,
- VkFence fence,
- uint32_t doLock);
- void vkGetLinearImageLayoutGOOGLE(
- VkDevice device,
- VkFormat format,
- VkDeviceSize* pOffset,
- VkDeviceSize* pRowPitchAlignment,
- uint32_t doLock);
- void vkGetLinearImageLayout2GOOGLE(
- VkDevice device,
- const VkImageCreateInfo* pCreateInfo,
- VkDeviceSize* pOffset,
- VkDeviceSize* pRowPitchAlignment,
- uint32_t doLock);
- void vkQueueFlushCommandsGOOGLE(
- VkQueue queue,
- VkCommandBuffer commandBuffer,
- VkDeviceSize dataSize,
- const void* pData,
- uint32_t doLock);
+ VkDevice device, VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
+ uint32_t bufferInfoCount, uint32_t bufferViewCount, const uint32_t* pImageInfoEntryIndices,
+ const uint32_t* pBufferInfoEntryIndices, const uint32_t* pBufferViewEntryIndices,
+ const VkDescriptorImageInfo* pImageInfos, const VkDescriptorBufferInfo* pBufferInfos,
+ const VkBufferView* pBufferViews, uint32_t doLock);
+ void vkBeginCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo,
+ uint32_t doLock);
+ void vkEndCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer, uint32_t doLock);
+ void vkResetCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags, uint32_t doLock);
+ void vkCommandBufferHostSyncGOOGLE(VkCommandBuffer commandBuffer, uint32_t needHostSync,
+ uint32_t sequenceNumber, uint32_t doLock);
+ VkResult vkCreateImageWithRequirementsGOOGLE(VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage,
+ VkMemoryRequirements* pMemoryRequirements,
+ uint32_t doLock);
+ VkResult vkCreateBufferWithRequirementsGOOGLE(VkDevice device,
+ const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer,
+ VkMemoryRequirements* pMemoryRequirements,
+ uint32_t doLock);
+ VkResult vkGetMemoryHostAddressInfoGOOGLE(VkDevice device, VkDeviceMemory memory,
+ uint64_t* pAddress, uint64_t* pSize,
+ uint64_t* pHostmemId, uint32_t doLock);
+ VkResult vkFreeMemorySyncGOOGLE(VkDevice device, VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator, uint32_t doLock);
+ void vkQueueHostSyncGOOGLE(VkQueue queue, uint32_t needHostSync, uint32_t sequenceNumber,
+ uint32_t doLock);
+ void vkQueueSubmitAsyncGOOGLE(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits,
+ VkFence fence, uint32_t doLock);
+ void vkQueueWaitIdleAsyncGOOGLE(VkQueue queue, uint32_t doLock);
+ void vkQueueBindSparseAsyncGOOGLE(VkQueue queue, uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo, VkFence fence,
+ uint32_t doLock);
+ void vkGetLinearImageLayoutGOOGLE(VkDevice device, VkFormat format, VkDeviceSize* pOffset,
+ VkDeviceSize* pRowPitchAlignment, uint32_t doLock);
+ void vkGetLinearImageLayout2GOOGLE(VkDevice device, const VkImageCreateInfo* pCreateInfo,
+ VkDeviceSize* pOffset, VkDeviceSize* pRowPitchAlignment,
+ uint32_t doLock);
+ void vkQueueFlushCommandsGOOGLE(VkQueue queue, VkCommandBuffer commandBuffer,
+ VkDeviceSize dataSize, const void* pData, uint32_t doLock);
void vkQueueCommitDescriptorSetUpdatesGOOGLE(
- VkQueue queue,
- uint32_t descriptorPoolCount,
- const VkDescriptorPool* pDescriptorPools,
- uint32_t descriptorSetCount,
- const VkDescriptorSetLayout* pSetLayouts,
- const uint64_t* pDescriptorSetPoolIds,
- const uint32_t* pDescriptorSetWhichPool,
+ VkQueue queue, uint32_t descriptorPoolCount, const VkDescriptorPool* pDescriptorPools,
+ uint32_t descriptorSetCount, const VkDescriptorSetLayout* pSetLayouts,
+ const uint64_t* pDescriptorSetPoolIds, const uint32_t* pDescriptorSetWhichPool,
const uint32_t* pDescriptorSetPendingAllocation,
- const uint32_t* pDescriptorWriteStartingIndices,
- uint32_t pendingDescriptorWriteCount,
- const VkWriteDescriptorSet* pPendingDescriptorWrites,
- uint32_t doLock);
- void vkCollectDescriptorPoolIdsGOOGLE(
- VkDevice device,
- VkDescriptorPool descriptorPool,
- uint32_t* pPoolIdCount,
- uint64_t* pPoolIds,
- uint32_t doLock);
- void vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(
- VkQueue queue,
- uint32_t waitSemaphoreCount,
- const VkSemaphore* pWaitSemaphores,
- VkImage image,
- uint32_t doLock);
+ const uint32_t* pDescriptorWriteStartingIndices, uint32_t pendingDescriptorWriteCount,
+ const VkWriteDescriptorSet* pPendingDescriptorWrites, uint32_t doLock);
+ void vkCollectDescriptorPoolIdsGOOGLE(VkDevice device, VkDescriptorPool descriptorPool,
+ uint32_t* pPoolIdCount, uint64_t* pPoolIds,
+ uint32_t doLock);
+ void vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(VkQueue queue, uint32_t waitSemaphoreCount,
+ const VkSemaphore* pWaitSemaphores,
+ VkImage image, uint32_t doLock);
#endif
#ifdef VK_EXT_global_priority_query
#endif
#ifdef VK_EXT_multi_draw
- void vkCmdDrawMultiEXT(
- VkCommandBuffer commandBuffer,
- uint32_t drawCount,
- const VkMultiDrawInfoEXT* pVertexInfo,
- uint32_t instanceCount,
- uint32_t firstInstance,
- uint32_t stride,
- uint32_t doLock);
- void vkCmdDrawMultiIndexedEXT(
- VkCommandBuffer commandBuffer,
- uint32_t drawCount,
- const VkMultiDrawIndexedInfoEXT* pIndexInfo,
- uint32_t instanceCount,
- uint32_t firstInstance,
- uint32_t stride,
- const int32_t* pVertexOffset,
- uint32_t doLock);
+ void vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount,
+ const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount,
+ uint32_t firstInstance, uint32_t stride, uint32_t doLock);
+ void vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount,
+ const VkMultiDrawIndexedInfoEXT* pIndexInfo,
+ uint32_t instanceCount, uint32_t firstInstance, uint32_t stride,
+ const int32_t* pVertexOffset, uint32_t doLock);
#endif
#ifdef VK_EXT_load_store_op_none
#endif
#ifdef VK_EXT_border_color_swizzle
#endif
#ifdef VK_EXT_pageable_device_local_memory
- void vkSetDeviceMemoryPriorityEXT(
- VkDevice device,
- VkDeviceMemory memory,
- float priority,
- uint32_t doLock);
+ void vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority,
+ uint32_t doLock);
#endif
#ifdef VK_KHR_acceleration_structure
VkResult vkCreateAccelerationStructureKHR(
- VkDevice device,
- const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkAccelerationStructureKHR* pAccelerationStructure,
+ VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure,
uint32_t doLock);
- void vkDestroyAccelerationStructureKHR(
- VkDevice device,
- VkAccelerationStructureKHR accelerationStructure,
- const VkAllocationCallbacks* pAllocator,
- uint32_t doLock);
+ void vkDestroyAccelerationStructureKHR(VkDevice device,
+ VkAccelerationStructureKHR accelerationStructure,
+ const VkAllocationCallbacks* pAllocator,
+ uint32_t doLock);
void vkCmdBuildAccelerationStructuresKHR(
- VkCommandBuffer commandBuffer,
- uint32_t infoCount,
+ VkCommandBuffer commandBuffer, uint32_t infoCount,
const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
- const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos,
- uint32_t doLock);
+ const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos, uint32_t doLock);
void vkCmdBuildAccelerationStructuresIndirectKHR(
- VkCommandBuffer commandBuffer,
- uint32_t infoCount,
+ VkCommandBuffer commandBuffer, uint32_t infoCount,
const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
- const VkDeviceAddress* pIndirectDeviceAddresses,
- const uint32_t* pIndirectStrides,
- const uint32_t* const* ppMaxPrimitiveCounts,
- uint32_t doLock);
+ const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides,
+ const uint32_t* const* ppMaxPrimitiveCounts, uint32_t doLock);
VkResult vkBuildAccelerationStructuresKHR(
- VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- uint32_t infoCount,
+ VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount,
const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
- const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos,
- uint32_t doLock);
- VkResult vkCopyAccelerationStructureKHR(
- VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- const VkCopyAccelerationStructureInfoKHR* pInfo,
- uint32_t doLock);
+ const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos, uint32_t doLock);
+ VkResult vkCopyAccelerationStructureKHR(VkDevice device,
+ VkDeferredOperationKHR deferredOperation,
+ const VkCopyAccelerationStructureInfoKHR* pInfo,
+ uint32_t doLock);
VkResult vkCopyAccelerationStructureToMemoryKHR(
- VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo,
- uint32_t doLock);
+ VkDevice device, VkDeferredOperationKHR deferredOperation,
+ const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo, uint32_t doLock);
VkResult vkCopyMemoryToAccelerationStructureKHR(
- VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo,
- uint32_t doLock);
+ VkDevice device, VkDeferredOperationKHR deferredOperation,
+ const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo, uint32_t doLock);
VkResult vkWriteAccelerationStructuresPropertiesKHR(
- VkDevice device,
- uint32_t accelerationStructureCount,
- const VkAccelerationStructureKHR* pAccelerationStructures,
- VkQueryType queryType,
- size_t dataSize,
- void* pData,
- size_t stride,
- uint32_t doLock);
- void vkCmdCopyAccelerationStructureKHR(
- VkCommandBuffer commandBuffer,
- const VkCopyAccelerationStructureInfoKHR* pInfo,
- uint32_t doLock);
+ VkDevice device, uint32_t accelerationStructureCount,
+ const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType,
+ size_t dataSize, void* pData, size_t stride, uint32_t doLock);
+ void vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer,
+ const VkCopyAccelerationStructureInfoKHR* pInfo,
+ uint32_t doLock);
void vkCmdCopyAccelerationStructureToMemoryKHR(
- VkCommandBuffer commandBuffer,
- const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo,
+ VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo,
uint32_t doLock);
void vkCmdCopyMemoryToAccelerationStructureKHR(
- VkCommandBuffer commandBuffer,
- const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo,
+ VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo,
uint32_t doLock);
VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR(
- VkDevice device,
- const VkAccelerationStructureDeviceAddressInfoKHR* pInfo,
- uint32_t doLock);
+ VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo, uint32_t doLock);
void vkCmdWriteAccelerationStructuresPropertiesKHR(
- VkCommandBuffer commandBuffer,
- uint32_t accelerationStructureCount,
- const VkAccelerationStructureKHR* pAccelerationStructures,
- VkQueryType queryType,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t doLock);
+ VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount,
+ const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType,
+ VkQueryPool queryPool, uint32_t firstQuery, uint32_t doLock);
void vkGetDeviceAccelerationStructureCompatibilityKHR(
- VkDevice device,
- const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
- VkAccelerationStructureCompatibilityKHR* pCompatibility,
- uint32_t doLock);
+ VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
+ VkAccelerationStructureCompatibilityKHR* pCompatibility, uint32_t doLock);
void vkGetAccelerationStructureBuildSizesKHR(
- VkDevice device,
- VkAccelerationStructureBuildTypeKHR buildType,
+ VkDevice device, VkAccelerationStructureBuildTypeKHR buildType,
const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo,
- const uint32_t* pMaxPrimitiveCounts,
- VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo,
+ const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo,
uint32_t doLock);
#endif
#ifdef VK_KHR_ray_tracing_pipeline
- void vkCmdTraceRaysKHR(
- VkCommandBuffer commandBuffer,
- const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
- const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
- const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
- const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
- uint32_t width,
- uint32_t height,
- uint32_t depth,
- uint32_t doLock);
- VkResult vkCreateRayTracingPipelinesKHR(
- VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines,
- uint32_t doLock);
- VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
- VkDevice device,
- VkPipeline pipeline,
- uint32_t firstGroup,
- uint32_t groupCount,
- size_t dataSize,
- void* pData,
- uint32_t doLock);
+ void vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer,
+ const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
+ uint32_t width, uint32_t height, uint32_t depth, uint32_t doLock);
+ VkResult vkCreateRayTracingPipelinesKHR(VkDevice device,
+ VkDeferredOperationKHR deferredOperation,
+ VkPipelineCache pipelineCache, uint32_t createInfoCount,
+ const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines, uint32_t doLock);
+ VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline,
+ uint32_t firstGroup,
+ uint32_t groupCount, size_t dataSize,
+ void* pData, uint32_t doLock);
void vkCmdTraceRaysIndirectKHR(
- VkCommandBuffer commandBuffer,
+ VkCommandBuffer commandBuffer,
const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
- VkDeviceAddress indirectDeviceAddress,
- uint32_t doLock);
- VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR(
- VkDevice device,
- VkPipeline pipeline,
- uint32_t group,
- VkShaderGroupShaderKHR groupShader,
- uint32_t doLock);
- void vkCmdSetRayTracingPipelineStackSizeKHR(
- VkCommandBuffer commandBuffer,
- uint32_t pipelineStackSize,
- uint32_t doLock);
+ VkDeviceAddress indirectDeviceAddress, uint32_t doLock);
+ VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline,
+ uint32_t group,
+ VkShaderGroupShaderKHR groupShader,
+ uint32_t doLock);
+ void vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer,
+ uint32_t pipelineStackSize, uint32_t doLock);
#endif
#ifdef VK_KHR_ray_query
#endif
-private:
+ private:
class Impl;
std::unique_ptr<Impl> mImpl;
+ HealthMonitor<>* mHealthMonitor;
};
-} // namespace goldfish_vk
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/VulkanHandles.h b/system/vulkan_enc/VulkanHandles.h
index 6c541f4..205e7e5 100644
--- a/system/vulkan_enc/VulkanHandles.h
+++ b/system/vulkan_enc/VulkanHandles.h
@@ -86,7 +86,7 @@
#ifdef VK_USE_PLATFORM_FUCHSIA
#define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_FUCHSIA(f) \
- f(VkBufferCollectionFUCHSIA) f(VkBufferCollectionFUCHSIAX)
+ f(VkBufferCollectionFUCHSIA)
#else
diff --git a/system/vulkan_enc/func_table.cpp b/system/vulkan_enc/func_table.cpp
index 54b232e..98f4b0e 100644
--- a/system/vulkan_enc/func_table.cpp
+++ b/system/vulkan_enc/func_table.cpp
@@ -14,242 +14,211 @@
// limitations under the License.
// Autogenerated module func_table
-// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal -o ../qemu/android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+//
+// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
+// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
-// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+//
+// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
+// $CEREAL_OUTPUT_DIR
+//
#include "func_table.h"
+#include <log/log.h>
-#include "VkEncoder.h"
+#include <cstring>
+
#include "../OpenglSystemCommon/HostConnection.h"
#include "ResourceTracker.h"
-
+#include "VkEncoder.h"
#include "goldfish_vk_private_defs.h"
-#include <log/log.h>
-#include <cstring>
-
// Stuff we are not going to use but if included,
// will cause compile errors. These are Android Vulkan
// required extensions, but the approach will be to
// implement them completely on the guest side.
#undef VK_KHR_android_surface
-
namespace goldfish_vk {
-static void sOnInvalidDynamicallyCheckedCall(const char* apiname, const char* neededFeature)
-{
+static void sOnInvalidDynamicallyCheckedCall(const char* apiname, const char* neededFeature) {
ALOGE("invalid call to %s: %s not supported", apiname, neededFeature);
abort();
}
#ifdef VK_VERSION_1_0
-static VkResult entry_vkCreateInstance(
- const VkInstanceCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkInstance* pInstance)
-{
+static VkResult entry_vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkInstance* pInstance) {
AEMU_SCOPED_TRACE("vkCreateInstance");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateInstance_VkResult_return = (VkResult)0;
- vkCreateInstance_VkResult_return = vkEnc->vkCreateInstance(pCreateInfo, pAllocator, pInstance, true /* do lock */);
+ vkCreateInstance_VkResult_return =
+ vkEnc->vkCreateInstance(pCreateInfo, pAllocator, pInstance, true /* do lock */);
return vkCreateInstance_VkResult_return;
}
-static void entry_vkDestroyInstance(
- VkInstance instance,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyInstance");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyInstance(instance, pAllocator, true /* do lock */);
}
-static VkResult entry_vkEnumeratePhysicalDevices(
- VkInstance instance,
- uint32_t* pPhysicalDeviceCount,
- VkPhysicalDevice* pPhysicalDevices)
-{
+static VkResult entry_vkEnumeratePhysicalDevices(VkInstance instance,
+ uint32_t* pPhysicalDeviceCount,
+ VkPhysicalDevice* pPhysicalDevices) {
AEMU_SCOPED_TRACE("vkEnumeratePhysicalDevices");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkEnumeratePhysicalDevices_VkResult_return = resources->on_vkEnumeratePhysicalDevices(vkEnc, VK_SUCCESS, instance, pPhysicalDeviceCount, pPhysicalDevices);
+ vkEnumeratePhysicalDevices_VkResult_return = resources->on_vkEnumeratePhysicalDevices(
+ vkEnc, VK_SUCCESS, instance, pPhysicalDeviceCount, pPhysicalDevices);
return vkEnumeratePhysicalDevices_VkResult_return;
}
-static void entry_vkGetPhysicalDeviceFeatures(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures* pFeatures)
-{
+static void entry_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures* pFeatures) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures, true /* do lock */);
}
-static void entry_vkGetPhysicalDeviceFormatProperties(
- VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties* pFormatProperties)
-{
+static void entry_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties* pFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties, true /* do lock */);
+ vkEnc->vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties,
+ true /* do lock */);
}
static VkResult entry_vkGetPhysicalDeviceImageFormatProperties(
- VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkImageType type,
- VkImageTiling tiling,
- VkImageUsageFlags usage,
- VkImageCreateFlags flags,
- VkImageFormatProperties* pImageFormatProperties)
-{
+ VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling,
+ VkImageUsageFlags usage, VkImageCreateFlags flags,
+ VkImageFormatProperties* pImageFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceImageFormatProperties_VkResult_return = vkEnc->vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, true /* do lock */);
+ vkGetPhysicalDeviceImageFormatProperties_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage,
+ flags, pImageFormatProperties,
+ true /* do lock */);
return vkGetPhysicalDeviceImageFormatProperties_VkResult_return;
}
-static void entry_vkGetPhysicalDeviceProperties(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties* pProperties)
-{
+static void entry_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetPhysicalDeviceProperties(physicalDevice, pProperties, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceQueueFamilyProperties(
- VkPhysicalDevice physicalDevice,
- uint32_t* pQueueFamilyPropertyCount,
- VkQueueFamilyProperties* pQueueFamilyProperties)
-{
+ VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties* pQueueFamilyProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, true /* do lock */);
+ vkEnc->vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount,
+ pQueueFamilyProperties, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceMemoryProperties(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceMemoryProperties* pMemoryProperties)
-{
+ VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties, true /* do lock */);
+ vkEnc->vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties,
+ true /* do lock */);
}
-static PFN_vkVoidFunction entry_vkGetInstanceProcAddr(
- VkInstance instance,
- const char* pName)
-{
+static PFN_vkVoidFunction entry_vkGetInstanceProcAddr(VkInstance instance, const char* pName) {
AEMU_SCOPED_TRACE("vkGetInstanceProcAddr");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
PFN_vkVoidFunction vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
- vkGetInstanceProcAddr_PFN_vkVoidFunction_return = vkEnc->vkGetInstanceProcAddr(instance, pName, true /* do lock */);
+ vkGetInstanceProcAddr_PFN_vkVoidFunction_return =
+ vkEnc->vkGetInstanceProcAddr(instance, pName, true /* do lock */);
return vkGetInstanceProcAddr_PFN_vkVoidFunction_return;
}
-static PFN_vkVoidFunction entry_vkGetDeviceProcAddr(
- VkDevice device,
- const char* pName)
-{
+static PFN_vkVoidFunction entry_vkGetDeviceProcAddr(VkDevice device, const char* pName) {
AEMU_SCOPED_TRACE("vkGetDeviceProcAddr");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
PFN_vkVoidFunction vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
- vkGetDeviceProcAddr_PFN_vkVoidFunction_return = vkEnc->vkGetDeviceProcAddr(device, pName, true /* do lock */);
+ vkGetDeviceProcAddr_PFN_vkVoidFunction_return =
+ vkEnc->vkGetDeviceProcAddr(device, pName, true /* do lock */);
return vkGetDeviceProcAddr_PFN_vkVoidFunction_return;
}
-static VkResult entry_vkCreateDevice(
- VkPhysicalDevice physicalDevice,
- const VkDeviceCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDevice* pDevice)
-{
+static VkResult entry_vkCreateDevice(VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
AEMU_SCOPED_TRACE("vkCreateDevice");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDevice_VkResult_return = (VkResult)0;
- vkCreateDevice_VkResult_return = vkEnc->vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice, true /* do lock */);
+ vkCreateDevice_VkResult_return =
+ vkEnc->vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice, true /* do lock */);
return vkCreateDevice_VkResult_return;
}
-static void entry_vkDestroyDevice(
- VkDevice device,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyDevice");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyDevice(device, pAllocator, true /* do lock */);
}
-static VkResult entry_vkEnumerateInstanceExtensionProperties(
- const char* pLayerName,
- uint32_t* pPropertyCount,
- VkExtensionProperties* pProperties)
-{
+static VkResult entry_vkEnumerateInstanceExtensionProperties(const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties) {
AEMU_SCOPED_TRACE("vkEnumerateInstanceExtensionProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkEnumerateInstanceExtensionProperties_VkResult_return = resources->on_vkEnumerateInstanceExtensionProperties(vkEnc, VK_SUCCESS, pLayerName, pPropertyCount, pProperties);
+ vkEnumerateInstanceExtensionProperties_VkResult_return =
+ resources->on_vkEnumerateInstanceExtensionProperties(vkEnc, VK_SUCCESS, pLayerName,
+ pPropertyCount, pProperties);
return vkEnumerateInstanceExtensionProperties_VkResult_return;
}
-static VkResult entry_vkEnumerateDeviceExtensionProperties(
- VkPhysicalDevice physicalDevice,
- const char* pLayerName,
- uint32_t* pPropertyCount,
- VkExtensionProperties* pProperties)
-{
+static VkResult entry_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
+ const char* pLayerName,
+ uint32_t* pPropertyCount,
+ VkExtensionProperties* pProperties) {
AEMU_SCOPED_TRACE("vkEnumerateDeviceExtensionProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkEnumerateDeviceExtensionProperties_VkResult_return = resources->on_vkEnumerateDeviceExtensionProperties(vkEnc, VK_SUCCESS, physicalDevice, pLayerName, pPropertyCount, pProperties);
+ vkEnumerateDeviceExtensionProperties_VkResult_return =
+ resources->on_vkEnumerateDeviceExtensionProperties(vkEnc, VK_SUCCESS, physicalDevice,
+ pLayerName, pPropertyCount, pProperties);
return vkEnumerateDeviceExtensionProperties_VkResult_return;
}
-static VkResult entry_vkEnumerateInstanceLayerProperties(
- uint32_t* pPropertyCount,
- VkLayerProperties* pProperties)
-{
+static VkResult entry_vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties) {
AEMU_SCOPED_TRACE("vkEnumerateInstanceLayerProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
- vkEnumerateInstanceLayerProperties_VkResult_return = vkEnc->vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties, true /* do lock */);
+ vkEnumerateInstanceLayerProperties_VkResult_return =
+ vkEnc->vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties, true /* do lock */);
return vkEnumerateInstanceLayerProperties_VkResult_return;
}
-static VkResult entry_vkEnumerateDeviceLayerProperties(
- VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkLayerProperties* pProperties)
-{
+static VkResult entry_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkLayerProperties* pProperties) {
AEMU_SCOPED_TRACE("vkEnumerateDeviceLayerProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
- vkEnumerateDeviceLayerProperties_VkResult_return = vkEnc->vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties, true /* do lock */);
+ vkEnumerateDeviceLayerProperties_VkResult_return = vkEnc->vkEnumerateDeviceLayerProperties(
+ physicalDevice, pPropertyCount, pProperties, true /* do lock */);
return vkEnumerateDeviceLayerProperties_VkResult_return;
}
-static void entry_vkGetDeviceQueue(
- VkDevice device,
- uint32_t queueFamilyIndex,
- uint32_t queueIndex,
- VkQueue* pQueue)
-{
+static void entry_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex,
+ VkQueue* pQueue) {
AEMU_SCOPED_TRACE("vkGetDeviceQueue");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue, true /* do lock */);
}
-static VkResult entry_vkQueueSubmit(
- VkQueue queue,
- uint32_t submitCount,
- const VkSubmitInfo* pSubmits,
- VkFence fence)
-{
+static VkResult entry_vkQueueSubmit(VkQueue queue, uint32_t submitCount,
+ const VkSubmitInfo* pSubmits, VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueSubmit");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkQueueSubmit_VkResult_return = resources->on_vkQueueSubmit(vkEnc, VK_SUCCESS, queue, submitCount, pSubmits, fence);
+ vkQueueSubmit_VkResult_return =
+ resources->on_vkQueueSubmit(vkEnc, VK_SUCCESS, queue, submitCount, pSubmits, fence);
return vkQueueSubmit_VkResult_return;
}
-static VkResult entry_vkQueueWaitIdle(
- VkQueue queue)
-{
+static VkResult entry_vkQueueWaitIdle(VkQueue queue) {
AEMU_SCOPED_TRACE("vkQueueWaitIdle");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
@@ -257,1294 +226,971 @@
vkQueueWaitIdle_VkResult_return = resources->on_vkQueueWaitIdle(vkEnc, VK_SUCCESS, queue);
return vkQueueWaitIdle_VkResult_return;
}
-static VkResult entry_vkDeviceWaitIdle(
- VkDevice device)
-{
+static VkResult entry_vkDeviceWaitIdle(VkDevice device) {
AEMU_SCOPED_TRACE("vkDeviceWaitIdle");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
vkDeviceWaitIdle_VkResult_return = vkEnc->vkDeviceWaitIdle(device, true /* do lock */);
return vkDeviceWaitIdle_VkResult_return;
}
-static VkResult entry_vkAllocateMemory(
- VkDevice device,
- const VkMemoryAllocateInfo* pAllocateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDeviceMemory* pMemory)
-{
+static VkResult entry_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory) {
AEMU_SCOPED_TRACE("vkAllocateMemory");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAllocateMemory_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkAllocateMemory_VkResult_return = resources->on_vkAllocateMemory(vkEnc, VK_SUCCESS, device, pAllocateInfo, pAllocator, pMemory);
+ vkAllocateMemory_VkResult_return = resources->on_vkAllocateMemory(
+ vkEnc, VK_SUCCESS, device, pAllocateInfo, pAllocator, pMemory);
return vkAllocateMemory_VkResult_return;
}
-static void entry_vkFreeMemory(
- VkDevice device,
- VkDeviceMemory memory,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkFreeMemory(VkDevice device, VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkFreeMemory");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkFreeMemory(vkEnc, device, memory, pAllocator);
}
-static VkResult entry_vkMapMemory(
- VkDevice device,
- VkDeviceMemory memory,
- VkDeviceSize offset,
- VkDeviceSize size,
- VkMemoryMapFlags flags,
- void** ppData)
-{
+static VkResult entry_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset,
+ VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
AEMU_SCOPED_TRACE("vkMapMemory");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkMapMemory_VkResult_return = (VkResult)0;
- vkMapMemory_VkResult_return = vkEnc->vkMapMemory(device, memory, offset, size, flags, ppData, true /* do lock */);
+ vkMapMemory_VkResult_return =
+ vkEnc->vkMapMemory(device, memory, offset, size, flags, ppData, true /* do lock */);
return vkMapMemory_VkResult_return;
}
-static void entry_vkUnmapMemory(
- VkDevice device,
- VkDeviceMemory memory)
-{
+static void entry_vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
AEMU_SCOPED_TRACE("vkUnmapMemory");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkUnmapMemory(device, memory, true /* do lock */);
}
-static VkResult entry_vkFlushMappedMemoryRanges(
- VkDevice device,
- uint32_t memoryRangeCount,
- const VkMappedMemoryRange* pMemoryRanges)
-{
+static VkResult entry_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges) {
AEMU_SCOPED_TRACE("vkFlushMappedMemoryRanges");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
- vkFlushMappedMemoryRanges_VkResult_return = vkEnc->vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges, true /* do lock */);
+ vkFlushMappedMemoryRanges_VkResult_return = vkEnc->vkFlushMappedMemoryRanges(
+ device, memoryRangeCount, pMemoryRanges, true /* do lock */);
return vkFlushMappedMemoryRanges_VkResult_return;
}
-static VkResult entry_vkInvalidateMappedMemoryRanges(
- VkDevice device,
- uint32_t memoryRangeCount,
- const VkMappedMemoryRange* pMemoryRanges)
-{
+static VkResult entry_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges) {
AEMU_SCOPED_TRACE("vkInvalidateMappedMemoryRanges");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
- vkInvalidateMappedMemoryRanges_VkResult_return = vkEnc->vkInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges, true /* do lock */);
+ vkInvalidateMappedMemoryRanges_VkResult_return = vkEnc->vkInvalidateMappedMemoryRanges(
+ device, memoryRangeCount, pMemoryRanges, true /* do lock */);
return vkInvalidateMappedMemoryRanges_VkResult_return;
}
-static void entry_vkGetDeviceMemoryCommitment(
- VkDevice device,
- VkDeviceMemory memory,
- VkDeviceSize* pCommittedMemoryInBytes)
-{
+static void entry_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
+ VkDeviceSize* pCommittedMemoryInBytes) {
AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes, true /* do lock */);
}
-static VkResult entry_vkBindBufferMemory(
- VkDevice device,
- VkBuffer buffer,
- VkDeviceMemory memory,
- VkDeviceSize memoryOffset)
-{
+static VkResult entry_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
+ VkDeviceSize memoryOffset) {
AEMU_SCOPED_TRACE("vkBindBufferMemory");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindBufferMemory_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkBindBufferMemory_VkResult_return = resources->on_vkBindBufferMemory(vkEnc, VK_SUCCESS, device, buffer, memory, memoryOffset);
+ vkBindBufferMemory_VkResult_return =
+ resources->on_vkBindBufferMemory(vkEnc, VK_SUCCESS, device, buffer, memory, memoryOffset);
return vkBindBufferMemory_VkResult_return;
}
-static VkResult entry_vkBindImageMemory(
- VkDevice device,
- VkImage image,
- VkDeviceMemory memory,
- VkDeviceSize memoryOffset)
-{
+static VkResult entry_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory,
+ VkDeviceSize memoryOffset) {
AEMU_SCOPED_TRACE("vkBindImageMemory");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindImageMemory_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkBindImageMemory_VkResult_return = resources->on_vkBindImageMemory(vkEnc, VK_SUCCESS, device, image, memory, memoryOffset);
+ vkBindImageMemory_VkResult_return =
+ resources->on_vkBindImageMemory(vkEnc, VK_SUCCESS, device, image, memory, memoryOffset);
return vkBindImageMemory_VkResult_return;
}
-static void entry_vkGetBufferMemoryRequirements(
- VkDevice device,
- VkBuffer buffer,
- VkMemoryRequirements* pMemoryRequirements)
-{
+static void entry_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
+ VkMemoryRequirements* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkGetBufferMemoryRequirements(vkEnc, device, buffer, pMemoryRequirements);
}
-static void entry_vkGetImageMemoryRequirements(
- VkDevice device,
- VkImage image,
- VkMemoryRequirements* pMemoryRequirements)
-{
+static void entry_vkGetImageMemoryRequirements(VkDevice device, VkImage image,
+ VkMemoryRequirements* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkGetImageMemoryRequirements(vkEnc, device, image, pMemoryRequirements);
}
static void entry_vkGetImageSparseMemoryRequirements(
- VkDevice device,
- VkImage image,
- uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
-{
+ VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements, true /* do lock */);
+ vkEnc->vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount,
+ pSparseMemoryRequirements, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceSparseImageFormatProperties(
- VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkImageType type,
- VkSampleCountFlagBits samples,
- VkImageUsageFlags usage,
- VkImageTiling tiling,
- uint32_t* pPropertyCount,
- VkSparseImageFormatProperties* pProperties)
-{
+ VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
+ VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling,
+ uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties, true /* do lock */);
+ vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples,
+ usage, tiling, pPropertyCount,
+ pProperties, true /* do lock */);
}
-static VkResult entry_vkQueueBindSparse(
- VkQueue queue,
- uint32_t bindInfoCount,
- const VkBindSparseInfo* pBindInfo,
- VkFence fence)
-{
+static VkResult entry_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo, VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueBindSparse");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
- vkQueueBindSparse_VkResult_return = vkEnc->vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence, true /* do lock */);
+ vkQueueBindSparse_VkResult_return =
+ vkEnc->vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence, true /* do lock */);
return vkQueueBindSparse_VkResult_return;
}
-static VkResult entry_vkCreateFence(
- VkDevice device,
- const VkFenceCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkFence* pFence)
-{
+static VkResult entry_vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
AEMU_SCOPED_TRACE("vkCreateFence");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateFence_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkCreateFence_VkResult_return = resources->on_vkCreateFence(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pFence);
+ vkCreateFence_VkResult_return =
+ resources->on_vkCreateFence(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pFence);
return vkCreateFence_VkResult_return;
}
-static void entry_vkDestroyFence(
- VkDevice device,
- VkFence fence,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyFence(VkDevice device, VkFence fence,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyFence");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyFence(device, fence, pAllocator, true /* do lock */);
}
-static VkResult entry_vkResetFences(
- VkDevice device,
- uint32_t fenceCount,
- const VkFence* pFences)
-{
+static VkResult entry_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
AEMU_SCOPED_TRACE("vkResetFences");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkResetFences_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkResetFences_VkResult_return = resources->on_vkResetFences(vkEnc, VK_SUCCESS, device, fenceCount, pFences);
+ vkResetFences_VkResult_return =
+ resources->on_vkResetFences(vkEnc, VK_SUCCESS, device, fenceCount, pFences);
return vkResetFences_VkResult_return;
}
-static VkResult entry_vkGetFenceStatus(
- VkDevice device,
- VkFence fence)
-{
+static VkResult entry_vkGetFenceStatus(VkDevice device, VkFence fence) {
AEMU_SCOPED_TRACE("vkGetFenceStatus");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
vkGetFenceStatus_VkResult_return = vkEnc->vkGetFenceStatus(device, fence, true /* do lock */);
return vkGetFenceStatus_VkResult_return;
}
-static VkResult entry_vkWaitForFences(
- VkDevice device,
- uint32_t fenceCount,
- const VkFence* pFences,
- VkBool32 waitAll,
- uint64_t timeout)
-{
+static VkResult entry_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences,
+ VkBool32 waitAll, uint64_t timeout) {
AEMU_SCOPED_TRACE("vkWaitForFences");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkWaitForFences_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkWaitForFences_VkResult_return = resources->on_vkWaitForFences(vkEnc, VK_SUCCESS, device, fenceCount, pFences, waitAll, timeout);
+ vkWaitForFences_VkResult_return = resources->on_vkWaitForFences(
+ vkEnc, VK_SUCCESS, device, fenceCount, pFences, waitAll, timeout);
return vkWaitForFences_VkResult_return;
}
-static VkResult entry_vkCreateSemaphore(
- VkDevice device,
- const VkSemaphoreCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSemaphore* pSemaphore)
-{
+static VkResult entry_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSemaphore* pSemaphore) {
AEMU_SCOPED_TRACE("vkCreateSemaphore");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSemaphore_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkCreateSemaphore_VkResult_return = resources->on_vkCreateSemaphore(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSemaphore);
+ vkCreateSemaphore_VkResult_return = resources->on_vkCreateSemaphore(
+ vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSemaphore);
return vkCreateSemaphore_VkResult_return;
}
-static void entry_vkDestroySemaphore(
- VkDevice device,
- VkSemaphore semaphore,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroySemaphore");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkDestroySemaphore(vkEnc, device, semaphore, pAllocator);
}
-static VkResult entry_vkCreateEvent(
- VkDevice device,
- const VkEventCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkEvent* pEvent)
-{
+static VkResult entry_vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
AEMU_SCOPED_TRACE("vkCreateEvent");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateEvent_VkResult_return = (VkResult)0;
- vkCreateEvent_VkResult_return = vkEnc->vkCreateEvent(device, pCreateInfo, pAllocator, pEvent, true /* do lock */);
+ vkCreateEvent_VkResult_return =
+ vkEnc->vkCreateEvent(device, pCreateInfo, pAllocator, pEvent, true /* do lock */);
return vkCreateEvent_VkResult_return;
}
-static void entry_vkDestroyEvent(
- VkDevice device,
- VkEvent event,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyEvent(VkDevice device, VkEvent event,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyEvent");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyEvent(device, event, pAllocator, true /* do lock */);
}
-static VkResult entry_vkGetEventStatus(
- VkDevice device,
- VkEvent event)
-{
+static VkResult entry_vkGetEventStatus(VkDevice device, VkEvent event) {
AEMU_SCOPED_TRACE("vkGetEventStatus");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
vkGetEventStatus_VkResult_return = vkEnc->vkGetEventStatus(device, event, true /* do lock */);
return vkGetEventStatus_VkResult_return;
}
-static VkResult entry_vkSetEvent(
- VkDevice device,
- VkEvent event)
-{
+static VkResult entry_vkSetEvent(VkDevice device, VkEvent event) {
AEMU_SCOPED_TRACE("vkSetEvent");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSetEvent_VkResult_return = (VkResult)0;
vkSetEvent_VkResult_return = vkEnc->vkSetEvent(device, event, true /* do lock */);
return vkSetEvent_VkResult_return;
}
-static VkResult entry_vkResetEvent(
- VkDevice device,
- VkEvent event)
-{
+static VkResult entry_vkResetEvent(VkDevice device, VkEvent event) {
AEMU_SCOPED_TRACE("vkResetEvent");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkResetEvent_VkResult_return = (VkResult)0;
vkResetEvent_VkResult_return = vkEnc->vkResetEvent(device, event, true /* do lock */);
return vkResetEvent_VkResult_return;
}
-static VkResult entry_vkCreateQueryPool(
- VkDevice device,
- const VkQueryPoolCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkQueryPool* pQueryPool)
-{
+static VkResult entry_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkQueryPool* pQueryPool) {
AEMU_SCOPED_TRACE("vkCreateQueryPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateQueryPool_VkResult_return = (VkResult)0;
- vkCreateQueryPool_VkResult_return = vkEnc->vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool, true /* do lock */);
+ vkCreateQueryPool_VkResult_return =
+ vkEnc->vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool, true /* do lock */);
return vkCreateQueryPool_VkResult_return;
}
-static void entry_vkDestroyQueryPool(
- VkDevice device,
- VkQueryPool queryPool,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyQueryPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyQueryPool(device, queryPool, pAllocator, true /* do lock */);
}
-static VkResult entry_vkGetQueryPoolResults(
- VkDevice device,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t queryCount,
- size_t dataSize,
- void* pData,
- VkDeviceSize stride,
- VkQueryResultFlags flags)
-{
+static VkResult entry_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool,
+ uint32_t firstQuery, uint32_t queryCount,
+ size_t dataSize, void* pData, VkDeviceSize stride,
+ VkQueryResultFlags flags) {
AEMU_SCOPED_TRACE("vkGetQueryPoolResults");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0;
- vkGetQueryPoolResults_VkResult_return = vkEnc->vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags, true /* do lock */);
+ vkGetQueryPoolResults_VkResult_return =
+ vkEnc->vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData,
+ stride, flags, true /* do lock */);
return vkGetQueryPoolResults_VkResult_return;
}
-static VkResult entry_vkCreateBuffer(
- VkDevice device,
- const VkBufferCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkBuffer* pBuffer)
-{
+static VkResult entry_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
AEMU_SCOPED_TRACE("vkCreateBuffer");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateBuffer_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkCreateBuffer_VkResult_return = resources->on_vkCreateBuffer(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pBuffer);
+ vkCreateBuffer_VkResult_return =
+ resources->on_vkCreateBuffer(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pBuffer);
return vkCreateBuffer_VkResult_return;
}
-static void entry_vkDestroyBuffer(
- VkDevice device,
- VkBuffer buffer,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyBuffer(VkDevice device, VkBuffer buffer,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyBuffer");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkDestroyBuffer(vkEnc, device, buffer, pAllocator);
}
-static VkResult entry_vkCreateBufferView(
- VkDevice device,
- const VkBufferViewCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkBufferView* pView)
-{
+static VkResult entry_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferView* pView) {
AEMU_SCOPED_TRACE("vkCreateBufferView");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateBufferView_VkResult_return = (VkResult)0;
- vkCreateBufferView_VkResult_return = vkEnc->vkCreateBufferView(device, pCreateInfo, pAllocator, pView, true /* do lock */);
+ vkCreateBufferView_VkResult_return =
+ vkEnc->vkCreateBufferView(device, pCreateInfo, pAllocator, pView, true /* do lock */);
return vkCreateBufferView_VkResult_return;
}
-static void entry_vkDestroyBufferView(
- VkDevice device,
- VkBufferView bufferView,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyBufferView(VkDevice device, VkBufferView bufferView,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyBufferView");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyBufferView(device, bufferView, pAllocator, true /* do lock */);
}
-static VkResult entry_vkCreateImage(
- VkDevice device,
- const VkImageCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkImage* pImage)
-{
+static VkResult entry_vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
AEMU_SCOPED_TRACE("vkCreateImage");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateImage_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkCreateImage_VkResult_return = resources->on_vkCreateImage(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pImage);
+ vkCreateImage_VkResult_return =
+ resources->on_vkCreateImage(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pImage);
return vkCreateImage_VkResult_return;
}
-static void entry_vkDestroyImage(
- VkDevice device,
- VkImage image,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyImage(VkDevice device, VkImage image,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyImage");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkDestroyImage(vkEnc, device, image, pAllocator);
}
-static void entry_vkGetImageSubresourceLayout(
- VkDevice device,
- VkImage image,
- const VkImageSubresource* pSubresource,
- VkSubresourceLayout* pLayout)
-{
+static void entry_vkGetImageSubresourceLayout(VkDevice device, VkImage image,
+ const VkImageSubresource* pSubresource,
+ VkSubresourceLayout* pLayout) {
AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetImageSubresourceLayout(device, image, pSubresource, pLayout, true /* do lock */);
}
-static VkResult entry_vkCreateImageView(
- VkDevice device,
- const VkImageViewCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkImageView* pView)
-{
+static VkResult entry_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkImageView* pView) {
AEMU_SCOPED_TRACE("vkCreateImageView");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateImageView_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkCreateImageView_VkResult_return = resources->on_vkCreateImageView(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pView);
+ vkCreateImageView_VkResult_return =
+ resources->on_vkCreateImageView(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pView);
return vkCreateImageView_VkResult_return;
}
-static void entry_vkDestroyImageView(
- VkDevice device,
- VkImageView imageView,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyImageView(VkDevice device, VkImageView imageView,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyImageView");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyImageView(device, imageView, pAllocator, true /* do lock */);
}
-static VkResult entry_vkCreateShaderModule(
- VkDevice device,
- const VkShaderModuleCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkShaderModule* pShaderModule)
-{
+static VkResult entry_vkCreateShaderModule(VkDevice device,
+ const VkShaderModuleCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkShaderModule* pShaderModule) {
AEMU_SCOPED_TRACE("vkCreateShaderModule");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateShaderModule_VkResult_return = (VkResult)0;
- vkCreateShaderModule_VkResult_return = vkEnc->vkCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule, true /* do lock */);
+ vkCreateShaderModule_VkResult_return = vkEnc->vkCreateShaderModule(
+ device, pCreateInfo, pAllocator, pShaderModule, true /* do lock */);
return vkCreateShaderModule_VkResult_return;
}
-static void entry_vkDestroyShaderModule(
- VkDevice device,
- VkShaderModule shaderModule,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyShaderModule");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyShaderModule(device, shaderModule, pAllocator, true /* do lock */);
}
-static VkResult entry_vkCreatePipelineCache(
- VkDevice device,
- const VkPipelineCacheCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPipelineCache* pPipelineCache)
-{
+static VkResult entry_vkCreatePipelineCache(VkDevice device,
+ const VkPipelineCacheCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineCache* pPipelineCache) {
AEMU_SCOPED_TRACE("vkCreatePipelineCache");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0;
- vkCreatePipelineCache_VkResult_return = vkEnc->vkCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache, true /* do lock */);
+ vkCreatePipelineCache_VkResult_return = vkEnc->vkCreatePipelineCache(
+ device, pCreateInfo, pAllocator, pPipelineCache, true /* do lock */);
return vkCreatePipelineCache_VkResult_return;
}
-static void entry_vkDestroyPipelineCache(
- VkDevice device,
- VkPipelineCache pipelineCache,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyPipelineCache");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyPipelineCache(device, pipelineCache, pAllocator, true /* do lock */);
}
-static VkResult entry_vkGetPipelineCacheData(
- VkDevice device,
- VkPipelineCache pipelineCache,
- size_t* pDataSize,
- void* pData)
-{
+static VkResult entry_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
+ size_t* pDataSize, void* pData) {
AEMU_SCOPED_TRACE("vkGetPipelineCacheData");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPipelineCacheData_VkResult_return = (VkResult)0;
- vkGetPipelineCacheData_VkResult_return = vkEnc->vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData, true /* do lock */);
+ vkGetPipelineCacheData_VkResult_return =
+ vkEnc->vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData, true /* do lock */);
return vkGetPipelineCacheData_VkResult_return;
}
-static VkResult entry_vkMergePipelineCaches(
- VkDevice device,
- VkPipelineCache dstCache,
- uint32_t srcCacheCount,
- const VkPipelineCache* pSrcCaches)
-{
+static VkResult entry_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
+ uint32_t srcCacheCount,
+ const VkPipelineCache* pSrcCaches) {
AEMU_SCOPED_TRACE("vkMergePipelineCaches");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0;
- vkMergePipelineCaches_VkResult_return = vkEnc->vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches, true /* do lock */);
+ vkMergePipelineCaches_VkResult_return = vkEnc->vkMergePipelineCaches(
+ device, dstCache, srcCacheCount, pSrcCaches, true /* do lock */);
return vkMergePipelineCaches_VkResult_return;
}
-static VkResult entry_vkCreateGraphicsPipelines(
- VkDevice device,
- VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkGraphicsPipelineCreateInfo* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines)
-{
+static VkResult entry_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkGraphicsPipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines) {
AEMU_SCOPED_TRACE("vkCreateGraphicsPipelines");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkCreateGraphicsPipelines_VkResult_return = resources->on_vkCreateGraphicsPipelines(vkEnc, VK_SUCCESS, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+ vkCreateGraphicsPipelines_VkResult_return = resources->on_vkCreateGraphicsPipelines(
+ vkEnc, VK_SUCCESS, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator,
+ pPipelines);
return vkCreateGraphicsPipelines_VkResult_return;
}
-static VkResult entry_vkCreateComputePipelines(
- VkDevice device,
- VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkComputePipelineCreateInfo* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines)
-{
+static VkResult entry_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkComputePipelineCreateInfo* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines) {
AEMU_SCOPED_TRACE("vkCreateComputePipelines");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0;
- vkCreateComputePipelines_VkResult_return = vkEnc->vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, true /* do lock */);
+ vkCreateComputePipelines_VkResult_return =
+ vkEnc->vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos,
+ pAllocator, pPipelines, true /* do lock */);
return vkCreateComputePipelines_VkResult_return;
}
-static void entry_vkDestroyPipeline(
- VkDevice device,
- VkPipeline pipeline,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyPipeline(VkDevice device, VkPipeline pipeline,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyPipeline");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyPipeline(device, pipeline, pAllocator, true /* do lock */);
}
-static VkResult entry_vkCreatePipelineLayout(
- VkDevice device,
- const VkPipelineLayoutCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPipelineLayout* pPipelineLayout)
-{
+static VkResult entry_vkCreatePipelineLayout(VkDevice device,
+ const VkPipelineLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPipelineLayout* pPipelineLayout) {
AEMU_SCOPED_TRACE("vkCreatePipelineLayout");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0;
- vkCreatePipelineLayout_VkResult_return = vkEnc->vkCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout, true /* do lock */);
+ vkCreatePipelineLayout_VkResult_return = vkEnc->vkCreatePipelineLayout(
+ device, pCreateInfo, pAllocator, pPipelineLayout, true /* do lock */);
return vkCreatePipelineLayout_VkResult_return;
}
-static void entry_vkDestroyPipelineLayout(
- VkDevice device,
- VkPipelineLayout pipelineLayout,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyPipelineLayout");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyPipelineLayout(device, pipelineLayout, pAllocator, true /* do lock */);
}
-static VkResult entry_vkCreateSampler(
- VkDevice device,
- const VkSamplerCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSampler* pSampler)
-{
+static VkResult entry_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSampler* pSampler) {
AEMU_SCOPED_TRACE("vkCreateSampler");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSampler_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkCreateSampler_VkResult_return = resources->on_vkCreateSampler(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSampler);
+ vkCreateSampler_VkResult_return =
+ resources->on_vkCreateSampler(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSampler);
return vkCreateSampler_VkResult_return;
}
-static void entry_vkDestroySampler(
- VkDevice device,
- VkSampler sampler,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroySampler(VkDevice device, VkSampler sampler,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroySampler");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroySampler(device, sampler, pAllocator, true /* do lock */);
}
static VkResult entry_vkCreateDescriptorSetLayout(
- VkDevice device,
- const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDescriptorSetLayout* pSetLayout)
-{
+ VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkCreateDescriptorSetLayout_VkResult_return = resources->on_vkCreateDescriptorSetLayout(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSetLayout);
+ vkCreateDescriptorSetLayout_VkResult_return = resources->on_vkCreateDescriptorSetLayout(
+ vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSetLayout);
return vkCreateDescriptorSetLayout_VkResult_return;
}
-static void entry_vkDestroyDescriptorSetLayout(
- VkDevice device,
- VkDescriptorSetLayout descriptorSetLayout,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyDescriptorSetLayout(VkDevice device,
+ VkDescriptorSetLayout descriptorSetLayout,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyDescriptorSetLayout");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkDestroyDescriptorSetLayout(vkEnc, device, descriptorSetLayout, pAllocator);
}
-static VkResult entry_vkCreateDescriptorPool(
- VkDevice device,
- const VkDescriptorPoolCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDescriptorPool* pDescriptorPool)
-{
+static VkResult entry_vkCreateDescriptorPool(VkDevice device,
+ const VkDescriptorPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDescriptorPool* pDescriptorPool) {
AEMU_SCOPED_TRACE("vkCreateDescriptorPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkCreateDescriptorPool_VkResult_return = resources->on_vkCreateDescriptorPool(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pDescriptorPool);
+ vkCreateDescriptorPool_VkResult_return = resources->on_vkCreateDescriptorPool(
+ vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pDescriptorPool);
return vkCreateDescriptorPool_VkResult_return;
}
-static void entry_vkDestroyDescriptorPool(
- VkDevice device,
- VkDescriptorPool descriptorPool,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyDescriptorPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkDestroyDescriptorPool(vkEnc, device, descriptorPool, pAllocator);
}
-static VkResult entry_vkResetDescriptorPool(
- VkDevice device,
- VkDescriptorPool descriptorPool,
- VkDescriptorPoolResetFlags flags)
-{
+static VkResult entry_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+ VkDescriptorPoolResetFlags flags) {
AEMU_SCOPED_TRACE("vkResetDescriptorPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkResetDescriptorPool_VkResult_return = resources->on_vkResetDescriptorPool(vkEnc, VK_SUCCESS, device, descriptorPool, flags);
+ vkResetDescriptorPool_VkResult_return =
+ resources->on_vkResetDescriptorPool(vkEnc, VK_SUCCESS, device, descriptorPool, flags);
return vkResetDescriptorPool_VkResult_return;
}
-static VkResult entry_vkAllocateDescriptorSets(
- VkDevice device,
- const VkDescriptorSetAllocateInfo* pAllocateInfo,
- VkDescriptorSet* pDescriptorSets)
-{
+static VkResult entry_vkAllocateDescriptorSets(VkDevice device,
+ const VkDescriptorSetAllocateInfo* pAllocateInfo,
+ VkDescriptorSet* pDescriptorSets) {
AEMU_SCOPED_TRACE("vkAllocateDescriptorSets");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkAllocateDescriptorSets_VkResult_return = resources->on_vkAllocateDescriptorSets(vkEnc, VK_SUCCESS, device, pAllocateInfo, pDescriptorSets);
+ vkAllocateDescriptorSets_VkResult_return = resources->on_vkAllocateDescriptorSets(
+ vkEnc, VK_SUCCESS, device, pAllocateInfo, pDescriptorSets);
return vkAllocateDescriptorSets_VkResult_return;
}
-static VkResult entry_vkFreeDescriptorSets(
- VkDevice device,
- VkDescriptorPool descriptorPool,
- uint32_t descriptorSetCount,
- const VkDescriptorSet* pDescriptorSets)
-{
+static VkResult entry_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet* pDescriptorSets) {
AEMU_SCOPED_TRACE("vkFreeDescriptorSets");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkFreeDescriptorSets_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkFreeDescriptorSets_VkResult_return = resources->on_vkFreeDescriptorSets(vkEnc, VK_SUCCESS, device, descriptorPool, descriptorSetCount, pDescriptorSets);
+ vkFreeDescriptorSets_VkResult_return = resources->on_vkFreeDescriptorSets(
+ vkEnc, VK_SUCCESS, device, descriptorPool, descriptorSetCount, pDescriptorSets);
return vkFreeDescriptorSets_VkResult_return;
}
-static void entry_vkUpdateDescriptorSets(
- VkDevice device,
- uint32_t descriptorWriteCount,
- const VkWriteDescriptorSet* pDescriptorWrites,
- uint32_t descriptorCopyCount,
- const VkCopyDescriptorSet* pDescriptorCopies)
-{
+static void entry_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites,
+ uint32_t descriptorCopyCount,
+ const VkCopyDescriptorSet* pDescriptorCopies) {
AEMU_SCOPED_TRACE("vkUpdateDescriptorSets");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
- resources->on_vkUpdateDescriptorSets(vkEnc, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+ resources->on_vkUpdateDescriptorSets(vkEnc, device, descriptorWriteCount, pDescriptorWrites,
+ descriptorCopyCount, pDescriptorCopies);
}
-static VkResult entry_vkCreateFramebuffer(
- VkDevice device,
- const VkFramebufferCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkFramebuffer* pFramebuffer)
-{
+static VkResult entry_vkCreateFramebuffer(VkDevice device,
+ const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFramebuffer* pFramebuffer) {
AEMU_SCOPED_TRACE("vkCreateFramebuffer");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0;
- vkCreateFramebuffer_VkResult_return = vkEnc->vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer, true /* do lock */);
+ vkCreateFramebuffer_VkResult_return = vkEnc->vkCreateFramebuffer(
+ device, pCreateInfo, pAllocator, pFramebuffer, true /* do lock */);
return vkCreateFramebuffer_VkResult_return;
}
-static void entry_vkDestroyFramebuffer(
- VkDevice device,
- VkFramebuffer framebuffer,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyFramebuffer");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyFramebuffer(device, framebuffer, pAllocator, true /* do lock */);
}
-static VkResult entry_vkCreateRenderPass(
- VkDevice device,
- const VkRenderPassCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass)
-{
+static VkResult entry_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass) {
AEMU_SCOPED_TRACE("vkCreateRenderPass");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateRenderPass_VkResult_return = (VkResult)0;
- vkCreateRenderPass_VkResult_return = vkEnc->vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
+ vkCreateRenderPass_VkResult_return =
+ vkEnc->vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
return vkCreateRenderPass_VkResult_return;
}
-static void entry_vkDestroyRenderPass(
- VkDevice device,
- VkRenderPass renderPass,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyRenderPass");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyRenderPass(device, renderPass, pAllocator, true /* do lock */);
}
-static void entry_vkGetRenderAreaGranularity(
- VkDevice device,
- VkRenderPass renderPass,
- VkExtent2D* pGranularity)
-{
+static void entry_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
+ VkExtent2D* pGranularity) {
AEMU_SCOPED_TRACE("vkGetRenderAreaGranularity");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetRenderAreaGranularity(device, renderPass, pGranularity, true /* do lock */);
}
-static VkResult entry_vkCreateCommandPool(
- VkDevice device,
- const VkCommandPoolCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkCommandPool* pCommandPool)
-{
+static VkResult entry_vkCreateCommandPool(VkDevice device,
+ const VkCommandPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCommandPool* pCommandPool) {
AEMU_SCOPED_TRACE("vkCreateCommandPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateCommandPool_VkResult_return = (VkResult)0;
- vkCreateCommandPool_VkResult_return = vkEnc->vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool, true /* do lock */);
+ vkCreateCommandPool_VkResult_return = vkEnc->vkCreateCommandPool(
+ device, pCreateInfo, pAllocator, pCommandPool, true /* do lock */);
return vkCreateCommandPool_VkResult_return;
}
-static void entry_vkDestroyCommandPool(
- VkDevice device,
- VkCommandPool commandPool,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyCommandPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyCommandPool(device, commandPool, pAllocator, true /* do lock */);
}
-static VkResult entry_vkResetCommandPool(
- VkDevice device,
- VkCommandPool commandPool,
- VkCommandPoolResetFlags flags)
-{
+static VkResult entry_vkResetCommandPool(VkDevice device, VkCommandPool commandPool,
+ VkCommandPoolResetFlags flags) {
AEMU_SCOPED_TRACE("vkResetCommandPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkResetCommandPool_VkResult_return = (VkResult)0;
- vkResetCommandPool_VkResult_return = vkEnc->vkResetCommandPool(device, commandPool, flags, true /* do lock */);
+ vkResetCommandPool_VkResult_return =
+ vkEnc->vkResetCommandPool(device, commandPool, flags, true /* do lock */);
if (vkResetCommandPool_VkResult_return == VK_SUCCESS) {
ResourceTracker::get()->resetCommandPoolStagingInfo(commandPool);
}
return vkResetCommandPool_VkResult_return;
}
-static VkResult entry_vkAllocateCommandBuffers(
- VkDevice device,
- const VkCommandBufferAllocateInfo* pAllocateInfo,
- VkCommandBuffer* pCommandBuffers)
-{
+static VkResult entry_vkAllocateCommandBuffers(VkDevice device,
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers) {
AEMU_SCOPED_TRACE("vkAllocateCommandBuffers");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkAllocateCommandBuffers_VkResult_return = resources->on_vkAllocateCommandBuffers(vkEnc, VK_SUCCESS, device, pAllocateInfo, pCommandBuffers);
+ vkAllocateCommandBuffers_VkResult_return = resources->on_vkAllocateCommandBuffers(
+ vkEnc, VK_SUCCESS, device, pAllocateInfo, pCommandBuffers);
if (vkAllocateCommandBuffers_VkResult_return == VK_SUCCESS) {
- ResourceTracker::get()->addToCommandPool(pAllocateInfo->commandPool, pAllocateInfo->commandBufferCount, pCommandBuffers);
+ ResourceTracker::get()->addToCommandPool(
+ pAllocateInfo->commandPool, pAllocateInfo->commandBufferCount, pCommandBuffers);
}
return vkAllocateCommandBuffers_VkResult_return;
}
-static void entry_vkFreeCommandBuffers(
- VkDevice device,
- VkCommandPool commandPool,
- uint32_t commandBufferCount,
- const VkCommandBuffer* pCommandBuffers)
-{
+static void entry_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers) {
AEMU_SCOPED_TRACE("vkFreeCommandBuffers");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers, true /* do lock */);
+ vkEnc->vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers,
+ true /* do lock */);
}
-static VkResult entry_vkBeginCommandBuffer(
- VkCommandBuffer commandBuffer,
- const VkCommandBufferBeginInfo* pBeginInfo)
-{
+static VkResult entry_vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo) {
AEMU_SCOPED_TRACE("vkBeginCommandBuffer");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkBeginCommandBuffer_VkResult_return = resources->on_vkBeginCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer, pBeginInfo);
+ vkBeginCommandBuffer_VkResult_return =
+ resources->on_vkBeginCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer, pBeginInfo);
return vkBeginCommandBuffer_VkResult_return;
}
-static VkResult entry_vkEndCommandBuffer(
- VkCommandBuffer commandBuffer)
-{
+static VkResult entry_vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
AEMU_SCOPED_TRACE("vkEndCommandBuffer");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkEndCommandBuffer_VkResult_return = resources->on_vkEndCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer);
+ vkEndCommandBuffer_VkResult_return =
+ resources->on_vkEndCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer);
return vkEndCommandBuffer_VkResult_return;
}
-static VkResult entry_vkResetCommandBuffer(
- VkCommandBuffer commandBuffer,
- VkCommandBufferResetFlags flags)
-{
+static VkResult entry_vkResetCommandBuffer(VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags) {
AEMU_SCOPED_TRACE("vkResetCommandBuffer");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkResetCommandBuffer_VkResult_return = resources->on_vkResetCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer, flags);
+ vkResetCommandBuffer_VkResult_return =
+ resources->on_vkResetCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer, flags);
return vkResetCommandBuffer_VkResult_return;
}
-static void entry_vkCmdBindPipeline(
- VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipeline pipeline)
-{
+static void entry_vkCmdBindPipeline(VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
AEMU_SCOPED_TRACE("vkCmdBindPipeline");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline, true /* do lock */);
}
-static void entry_vkCmdSetViewport(
- VkCommandBuffer commandBuffer,
- uint32_t firstViewport,
- uint32_t viewportCount,
- const VkViewport* pViewports)
-{
+static void entry_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
+ uint32_t viewportCount, const VkViewport* pViewports) {
AEMU_SCOPED_TRACE("vkCmdSetViewport");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports, true /* do lock */);
+ vkEnc->vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports,
+ true /* do lock */);
}
-static void entry_vkCmdSetScissor(
- VkCommandBuffer commandBuffer,
- uint32_t firstScissor,
- uint32_t scissorCount,
- const VkRect2D* pScissors)
-{
+static void entry_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
+ uint32_t scissorCount, const VkRect2D* pScissors) {
AEMU_SCOPED_TRACE("vkCmdSetScissor");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors, true /* do lock */);
+ vkEnc->vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors,
+ true /* do lock */);
}
-static void entry_vkCmdSetLineWidth(
- VkCommandBuffer commandBuffer,
- float lineWidth)
-{
+static void entry_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
AEMU_SCOPED_TRACE("vkCmdSetLineWidth");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetLineWidth(commandBuffer, lineWidth, true /* do lock */);
}
-static void entry_vkCmdSetDepthBias(
- VkCommandBuffer commandBuffer,
- float depthBiasConstantFactor,
- float depthBiasClamp,
- float depthBiasSlopeFactor)
-{
+static void entry_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
+ float depthBiasClamp, float depthBiasSlopeFactor) {
AEMU_SCOPED_TRACE("vkCmdSetDepthBias");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor, true /* do lock */);
+ vkEnc->vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp,
+ depthBiasSlopeFactor, true /* do lock */);
}
-static void entry_vkCmdSetBlendConstants(
- VkCommandBuffer commandBuffer,
- const float blendConstants[4])
-{
+static void entry_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer,
+ const float blendConstants[4]) {
AEMU_SCOPED_TRACE("vkCmdSetBlendConstants");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetBlendConstants(commandBuffer, blendConstants, true /* do lock */);
}
-static void entry_vkCmdSetDepthBounds(
- VkCommandBuffer commandBuffer,
- float minDepthBounds,
- float maxDepthBounds)
-{
+static void entry_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
+ float maxDepthBounds) {
AEMU_SCOPED_TRACE("vkCmdSetDepthBounds");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds, true /* do lock */);
}
-static void entry_vkCmdSetStencilCompareMask(
- VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask,
- uint32_t compareMask)
-{
+static void entry_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask, uint32_t compareMask) {
AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask, true /* do lock */);
}
-static void entry_vkCmdSetStencilWriteMask(
- VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask,
- uint32_t writeMask)
-{
+static void entry_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask, uint32_t writeMask) {
AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask, true /* do lock */);
}
-static void entry_vkCmdSetStencilReference(
- VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask,
- uint32_t reference)
-{
+static void entry_vkCmdSetStencilReference(VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask, uint32_t reference) {
AEMU_SCOPED_TRACE("vkCmdSetStencilReference");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetStencilReference(commandBuffer, faceMask, reference, true /* do lock */);
}
static void entry_vkCmdBindDescriptorSets(
- VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipelineLayout layout,
- uint32_t firstSet,
- uint32_t descriptorSetCount,
- const VkDescriptorSet* pDescriptorSets,
- uint32_t dynamicOffsetCount,
- const uint32_t* pDynamicOffsets)
-{
+ VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
+ uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets,
+ uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
AEMU_SCOPED_TRACE("vkCmdBindDescriptorSets");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
auto resources = ResourceTracker::get();
- resources->on_vkCmdBindDescriptorSets(vkEnc, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+ resources->on_vkCmdBindDescriptorSets(vkEnc, commandBuffer, pipelineBindPoint, layout, firstSet,
+ descriptorSetCount, pDescriptorSets, dynamicOffsetCount,
+ pDynamicOffsets);
}
-static void entry_vkCmdBindIndexBuffer(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkIndexType indexType)
-{
+static void entry_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkIndexType indexType) {
AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType, true /* do lock */);
}
-static void entry_vkCmdBindVertexBuffers(
- VkCommandBuffer commandBuffer,
- uint32_t firstBinding,
- uint32_t bindingCount,
- const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets)
-{
+static void entry_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+ uint32_t bindingCount, const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets) {
AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, true /* do lock */);
+ vkEnc->vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets,
+ true /* do lock */);
}
-static void entry_vkCmdDraw(
- VkCommandBuffer commandBuffer,
- uint32_t vertexCount,
- uint32_t instanceCount,
- uint32_t firstVertex,
- uint32_t firstInstance)
-{
+static void entry_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount,
+ uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
AEMU_SCOPED_TRACE("vkCmdDraw");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance, true /* do lock */);
+ vkEnc->vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance,
+ true /* do lock */);
}
-static void entry_vkCmdDrawIndexed(
- VkCommandBuffer commandBuffer,
- uint32_t indexCount,
- uint32_t instanceCount,
- uint32_t firstIndex,
- int32_t vertexOffset,
- uint32_t firstInstance)
-{
+static void entry_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
+ uint32_t instanceCount, uint32_t firstIndex,
+ int32_t vertexOffset, uint32_t firstInstance) {
AEMU_SCOPED_TRACE("vkCmdDrawIndexed");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance, true /* do lock */);
+ vkEnc->vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset,
+ firstInstance, true /* do lock */);
}
-static void entry_vkCmdDrawIndirect(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- uint32_t drawCount,
- uint32_t stride)
-{
+static void entry_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
AEMU_SCOPED_TRACE("vkCmdDrawIndirect");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride, true /* do lock */);
}
-static void entry_vkCmdDrawIndexedIndirect(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- uint32_t drawCount,
- uint32_t stride)
-{
+static void entry_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, uint32_t drawCount,
+ uint32_t stride) {
AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride, true /* do lock */);
+ vkEnc->vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride,
+ true /* do lock */);
}
-static void entry_vkCmdDispatch(
- VkCommandBuffer commandBuffer,
- uint32_t groupCountX,
- uint32_t groupCountY,
- uint32_t groupCountZ)
-{
+static void entry_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX,
+ uint32_t groupCountY, uint32_t groupCountZ) {
AEMU_SCOPED_TRACE("vkCmdDispatch");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ, true /* do lock */);
}
-static void entry_vkCmdDispatchIndirect(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset)
-{
+static void entry_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset) {
AEMU_SCOPED_TRACE("vkCmdDispatchIndirect");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdDispatchIndirect(commandBuffer, buffer, offset, true /* do lock */);
}
-static void entry_vkCmdCopyBuffer(
- VkCommandBuffer commandBuffer,
- VkBuffer srcBuffer,
- VkBuffer dstBuffer,
- uint32_t regionCount,
- const VkBufferCopy* pRegions)
-{
+static void entry_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
+ VkBuffer dstBuffer, uint32_t regionCount,
+ const VkBufferCopy* pRegions) {
AEMU_SCOPED_TRACE("vkCmdCopyBuffer");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions, true /* do lock */);
+ vkEnc->vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions,
+ true /* do lock */);
}
-static void entry_vkCmdCopyImage(
- VkCommandBuffer commandBuffer,
- VkImage srcImage,
- VkImageLayout srcImageLayout,
- VkImage dstImage,
- VkImageLayout dstImageLayout,
- uint32_t regionCount,
- const VkImageCopy* pRegions)
-{
+static void entry_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+ VkImageLayout srcImageLayout, VkImage dstImage,
+ VkImageLayout dstImageLayout, uint32_t regionCount,
+ const VkImageCopy* pRegions) {
AEMU_SCOPED_TRACE("vkCmdCopyImage");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, true /* do lock */);
+ vkEnc->vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
+ regionCount, pRegions, true /* do lock */);
}
-static void entry_vkCmdBlitImage(
- VkCommandBuffer commandBuffer,
- VkImage srcImage,
- VkImageLayout srcImageLayout,
- VkImage dstImage,
- VkImageLayout dstImageLayout,
- uint32_t regionCount,
- const VkImageBlit* pRegions,
- VkFilter filter)
-{
+static void entry_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+ VkImageLayout srcImageLayout, VkImage dstImage,
+ VkImageLayout dstImageLayout, uint32_t regionCount,
+ const VkImageBlit* pRegions, VkFilter filter) {
AEMU_SCOPED_TRACE("vkCmdBlitImage");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter, true /* do lock */);
+ vkEnc->vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
+ regionCount, pRegions, filter, true /* do lock */);
}
-static void entry_vkCmdCopyBufferToImage(
- VkCommandBuffer commandBuffer,
- VkBuffer srcBuffer,
- VkImage dstImage,
- VkImageLayout dstImageLayout,
- uint32_t regionCount,
- const VkBufferImageCopy* pRegions)
-{
+static void entry_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
+ VkImage dstImage, VkImageLayout dstImageLayout,
+ uint32_t regionCount, const VkBufferImageCopy* pRegions) {
AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions, true /* do lock */);
+ vkEnc->vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount,
+ pRegions, true /* do lock */);
}
-static void entry_vkCmdCopyImageToBuffer(
- VkCommandBuffer commandBuffer,
- VkImage srcImage,
- VkImageLayout srcImageLayout,
- VkBuffer dstBuffer,
- uint32_t regionCount,
- const VkBufferImageCopy* pRegions)
-{
+static void entry_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
+ VkImageLayout srcImageLayout, VkBuffer dstBuffer,
+ uint32_t regionCount, const VkBufferImageCopy* pRegions) {
AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions, true /* do lock */);
+ vkEnc->vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount,
+ pRegions, true /* do lock */);
}
-static void entry_vkCmdUpdateBuffer(
- VkCommandBuffer commandBuffer,
- VkBuffer dstBuffer,
- VkDeviceSize dstOffset,
- VkDeviceSize dataSize,
- const void* pData)
-{
+static void entry_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
+ VkDeviceSize dstOffset, VkDeviceSize dataSize,
+ const void* pData) {
AEMU_SCOPED_TRACE("vkCmdUpdateBuffer");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData, true /* do lock */);
+ vkEnc->vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData,
+ true /* do lock */);
}
-static void entry_vkCmdFillBuffer(
- VkCommandBuffer commandBuffer,
- VkBuffer dstBuffer,
- VkDeviceSize dstOffset,
- VkDeviceSize size,
- uint32_t data)
-{
+static void entry_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
+ VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
AEMU_SCOPED_TRACE("vkCmdFillBuffer");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data, true /* do lock */);
}
-static void entry_vkCmdClearColorImage(
- VkCommandBuffer commandBuffer,
- VkImage image,
- VkImageLayout imageLayout,
- const VkClearColorValue* pColor,
- uint32_t rangeCount,
- const VkImageSubresourceRange* pRanges)
-{
+static void entry_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
+ VkImageLayout imageLayout, const VkClearColorValue* pColor,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges) {
AEMU_SCOPED_TRACE("vkCmdClearColorImage");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges, true /* do lock */);
+ vkEnc->vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges,
+ true /* do lock */);
}
-static void entry_vkCmdClearDepthStencilImage(
- VkCommandBuffer commandBuffer,
- VkImage image,
- VkImageLayout imageLayout,
- const VkClearDepthStencilValue* pDepthStencil,
- uint32_t rangeCount,
- const VkImageSubresourceRange* pRanges)
-{
+static void entry_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearDepthStencilValue* pDepthStencil,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange* pRanges) {
AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges, true /* do lock */);
+ vkEnc->vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount,
+ pRanges, true /* do lock */);
}
-static void entry_vkCmdClearAttachments(
- VkCommandBuffer commandBuffer,
- uint32_t attachmentCount,
- const VkClearAttachment* pAttachments,
- uint32_t rectCount,
- const VkClearRect* pRects)
-{
+static void entry_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
+ const VkClearAttachment* pAttachments, uint32_t rectCount,
+ const VkClearRect* pRects) {
AEMU_SCOPED_TRACE("vkCmdClearAttachments");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects, true /* do lock */);
+ vkEnc->vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects,
+ true /* do lock */);
}
-static void entry_vkCmdResolveImage(
- VkCommandBuffer commandBuffer,
- VkImage srcImage,
- VkImageLayout srcImageLayout,
- VkImage dstImage,
- VkImageLayout dstImageLayout,
- uint32_t regionCount,
- const VkImageResolve* pRegions)
-{
+static void entry_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+ VkImageLayout srcImageLayout, VkImage dstImage,
+ VkImageLayout dstImageLayout, uint32_t regionCount,
+ const VkImageResolve* pRegions) {
AEMU_SCOPED_TRACE("vkCmdResolveImage");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, true /* do lock */);
+ vkEnc->vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
+ regionCount, pRegions, true /* do lock */);
}
-static void entry_vkCmdSetEvent(
- VkCommandBuffer commandBuffer,
- VkEvent event,
- VkPipelineStageFlags stageMask)
-{
+static void entry_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
+ VkPipelineStageFlags stageMask) {
AEMU_SCOPED_TRACE("vkCmdSetEvent");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetEvent(commandBuffer, event, stageMask, true /* do lock */);
}
-static void entry_vkCmdResetEvent(
- VkCommandBuffer commandBuffer,
- VkEvent event,
- VkPipelineStageFlags stageMask)
-{
+static void entry_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
+ VkPipelineStageFlags stageMask) {
AEMU_SCOPED_TRACE("vkCmdResetEvent");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdResetEvent(commandBuffer, event, stageMask, true /* do lock */);
}
-static void entry_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)
-{
+static void entry_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) {
AEMU_SCOPED_TRACE("vkCmdWaitEvents");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers, true /* do lock */);
+ vkEnc->vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask,
+ memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
+ pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers,
+ true /* do lock */);
}
static void entry_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)
-{
+ 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) {
AEMU_SCOPED_TRACE("vkCmdPipelineBarrier");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers, true /* do lock */);
+ auto resources = ResourceTracker::get();
+ resources->on_vkCmdPipelineBarrier(vkEnc, commandBuffer, srcStageMask, dstStageMask,
+ dependencyFlags, memoryBarrierCount, pMemoryBarriers,
+ bufferMemoryBarrierCount, pBufferMemoryBarriers,
+ imageMemoryBarrierCount, pImageMemoryBarriers);
}
-static void entry_vkCmdBeginQuery(
- VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t query,
- VkQueryControlFlags flags)
-{
+static void entry_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t query, VkQueryControlFlags flags) {
AEMU_SCOPED_TRACE("vkCmdBeginQuery");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdBeginQuery(commandBuffer, queryPool, query, flags, true /* do lock */);
}
-static void entry_vkCmdEndQuery(
- VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t query)
-{
+static void entry_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t query) {
AEMU_SCOPED_TRACE("vkCmdEndQuery");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdEndQuery(commandBuffer, queryPool, query, true /* do lock */);
}
-static void entry_vkCmdResetQueryPool(
- VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t queryCount)
-{
+static void entry_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t firstQuery, uint32_t queryCount) {
AEMU_SCOPED_TRACE("vkCmdResetQueryPool");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount, true /* do lock */);
+ vkEnc->vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount,
+ true /* do lock */);
}
-static void entry_vkCmdWriteTimestamp(
- VkCommandBuffer commandBuffer,
- VkPipelineStageFlagBits pipelineStage,
- VkQueryPool queryPool,
- uint32_t query)
-{
+static void entry_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool,
+ uint32_t query) {
AEMU_SCOPED_TRACE("vkCmdWriteTimestamp");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query, true /* do lock */);
}
-static void entry_vkCmdCopyQueryPoolResults(
- VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t queryCount,
- VkBuffer dstBuffer,
- VkDeviceSize dstOffset,
- VkDeviceSize stride,
- VkQueryResultFlags flags)
-{
+static void entry_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t firstQuery, uint32_t queryCount,
+ VkBuffer dstBuffer, VkDeviceSize dstOffset,
+ VkDeviceSize stride, VkQueryResultFlags flags) {
AEMU_SCOPED_TRACE("vkCmdCopyQueryPoolResults");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags, true /* do lock */);
+ vkEnc->vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer,
+ dstOffset, stride, flags, true /* do lock */);
}
-static void entry_vkCmdPushConstants(
- VkCommandBuffer commandBuffer,
- VkPipelineLayout layout,
- VkShaderStageFlags stageFlags,
- uint32_t offset,
- uint32_t size,
- const void* pValues)
-{
+static void entry_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
+ const void* pValues) {
AEMU_SCOPED_TRACE("vkCmdPushConstants");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues, true /* do lock */);
+ vkEnc->vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues,
+ true /* do lock */);
}
-static void entry_vkCmdBeginRenderPass(
- VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo* pRenderPassBegin,
- VkSubpassContents contents)
-{
+static void entry_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ VkSubpassContents contents) {
AEMU_SCOPED_TRACE("vkCmdBeginRenderPass");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents, true /* do lock */);
}
-static void entry_vkCmdNextSubpass(
- VkCommandBuffer commandBuffer,
- VkSubpassContents contents)
-{
+static void entry_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
AEMU_SCOPED_TRACE("vkCmdNextSubpass");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdNextSubpass(commandBuffer, contents, true /* do lock */);
}
-static void entry_vkCmdEndRenderPass(
- VkCommandBuffer commandBuffer)
-{
+static void entry_vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
AEMU_SCOPED_TRACE("vkCmdEndRenderPass");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdEndRenderPass(commandBuffer, true /* do lock */);
}
-static void entry_vkCmdExecuteCommands(
- VkCommandBuffer commandBuffer,
- uint32_t commandBufferCount,
- const VkCommandBuffer* pCommandBuffers)
-{
+static void entry_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
+ const VkCommandBuffer* pCommandBuffers) {
AEMU_SCOPED_TRACE("vkCmdExecuteCommands");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
auto resources = ResourceTracker::get();
@@ -1552,205 +1198,137 @@
}
#endif
#ifdef VK_VERSION_1_1
-static VkResult entry_vkEnumerateInstanceVersion(
- uint32_t* pApiVersion)
-{
+static VkResult entry_vkEnumerateInstanceVersion(uint32_t* pApiVersion) {
AEMU_SCOPED_TRACE("vkEnumerateInstanceVersion");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
- vkEnumerateInstanceVersion_VkResult_return = vkEnc->vkEnumerateInstanceVersion(pApiVersion, true /* do lock */);
+ vkEnumerateInstanceVersion_VkResult_return =
+ vkEnc->vkEnumerateInstanceVersion(pApiVersion, true /* do lock */);
return vkEnumerateInstanceVersion_VkResult_return;
}
-static VkResult entry_vkBindBufferMemory2(
- VkDevice device,
- uint32_t bindInfoCount,
- const VkBindBufferMemoryInfo* pBindInfos)
-{
+static VkResult entry_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos) {
AEMU_SCOPED_TRACE("vkBindBufferMemory2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkBindBufferMemory2_VkResult_return = resources->on_vkBindBufferMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
+ vkBindBufferMemory2_VkResult_return =
+ resources->on_vkBindBufferMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
return vkBindBufferMemory2_VkResult_return;
}
-static VkResult dynCheck_entry_vkBindBufferMemory2(
- VkDevice device,
- uint32_t bindInfoCount,
- const VkBindBufferMemoryInfo* pBindInfos)
-{
+static VkResult dynCheck_entry_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos) {
auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1)
- {
+ if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkBindBufferMemory2", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkBindBufferMemory2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
- vkBindBufferMemory2_VkResult_return = resources->on_vkBindBufferMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
+ vkBindBufferMemory2_VkResult_return =
+ resources->on_vkBindBufferMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
return vkBindBufferMemory2_VkResult_return;
}
-static VkResult entry_vkBindImageMemory2(
- VkDevice device,
- uint32_t bindInfoCount,
- const VkBindImageMemoryInfo* pBindInfos)
-{
+static VkResult entry_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos) {
AEMU_SCOPED_TRACE("vkBindImageMemory2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkBindImageMemory2_VkResult_return = resources->on_vkBindImageMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
+ vkBindImageMemory2_VkResult_return =
+ resources->on_vkBindImageMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
return vkBindImageMemory2_VkResult_return;
}
-static VkResult dynCheck_entry_vkBindImageMemory2(
- VkDevice device,
- uint32_t bindInfoCount,
- const VkBindImageMemoryInfo* pBindInfos)
-{
+static VkResult dynCheck_entry_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos) {
auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1)
- {
+ if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkBindImageMemory2", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkBindImageMemory2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
- vkBindImageMemory2_VkResult_return = resources->on_vkBindImageMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
+ vkBindImageMemory2_VkResult_return =
+ resources->on_vkBindImageMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
return vkBindImageMemory2_VkResult_return;
}
static void entry_vkGetDeviceGroupPeerMemoryFeatures(
- VkDevice device,
- uint32_t heapIndex,
- uint32_t localDeviceIndex,
- uint32_t remoteDeviceIndex,
- VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
-{
+ VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, true /* do lock */);
+ vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex,
+ remoteDeviceIndex, pPeerMemoryFeatures,
+ true /* do lock */);
}
static void dynCheck_entry_vkGetDeviceGroupPeerMemoryFeatures(
- VkDevice device,
- uint32_t heapIndex,
- uint32_t localDeviceIndex,
- uint32_t remoteDeviceIndex,
- VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
-{
+ VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1)
- {
+ if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkGetDeviceGroupPeerMemoryFeatures", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, true /* do lock */);
+ vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex,
+ remoteDeviceIndex, pPeerMemoryFeatures,
+ true /* do lock */);
}
-static void entry_vkCmdSetDeviceMask(
- VkCommandBuffer commandBuffer,
- uint32_t deviceMask)
-{
+static void entry_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) {
AEMU_SCOPED_TRACE("vkCmdSetDeviceMask");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetDeviceMask(commandBuffer, deviceMask, true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetDeviceMask(
- VkCommandBuffer commandBuffer,
- uint32_t deviceMask)
-{
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1)
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetDeviceMask", "VK_VERSION_1_1");
- }
- AEMU_SCOPED_TRACE("vkCmdSetDeviceMask");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDeviceMask(commandBuffer, deviceMask, true /* do lock */);
-}
-static void entry_vkCmdDispatchBase(
- VkCommandBuffer commandBuffer,
- uint32_t baseGroupX,
- uint32_t baseGroupY,
- uint32_t baseGroupZ,
- uint32_t groupCountX,
- uint32_t groupCountY,
- uint32_t groupCountZ)
-{
+static void entry_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX,
+ uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX,
+ uint32_t groupCountY, uint32_t groupCountZ) {
AEMU_SCOPED_TRACE("vkCmdDispatchBase");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdDispatchBase(
- VkCommandBuffer commandBuffer,
- uint32_t baseGroupX,
- uint32_t baseGroupY,
- uint32_t baseGroupZ,
- uint32_t groupCountX,
- uint32_t groupCountY,
- uint32_t groupCountZ)
-{
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1)
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdDispatchBase", "VK_VERSION_1_1");
- }
- AEMU_SCOPED_TRACE("vkCmdDispatchBase");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ, true /* do lock */);
+ vkEnc->vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX,
+ groupCountY, groupCountZ, true /* do lock */);
}
static VkResult entry_vkEnumeratePhysicalDeviceGroups(
- VkInstance instance,
- uint32_t* pPhysicalDeviceGroupCount,
- VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
-{
+ VkInstance instance, uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroups");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
- vkEnumeratePhysicalDeviceGroups_VkResult_return = vkEnc->vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, true /* do lock */);
+ vkEnumeratePhysicalDeviceGroups_VkResult_return = vkEnc->vkEnumeratePhysicalDeviceGroups(
+ instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, true /* do lock */);
return vkEnumeratePhysicalDeviceGroups_VkResult_return;
}
-static void entry_vkGetImageMemoryRequirements2(
- VkDevice device,
- const VkImageMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements)
-{
+static void entry_vkGetImageMemoryRequirements2(VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkGetImageMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
}
static void dynCheck_entry_vkGetImageMemoryRequirements2(
- VkDevice device,
- const VkImageMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements)
-{
+ VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1)
- {
+ if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkGetImageMemoryRequirements2", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
resources->on_vkGetImageMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
}
-static void entry_vkGetBufferMemoryRequirements2(
- VkDevice device,
- const VkBufferMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements)
-{
+static void entry_vkGetBufferMemoryRequirements2(VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkGetBufferMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
}
static void dynCheck_entry_vkGetBufferMemoryRequirements2(
- VkDevice device,
- const VkBufferMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements)
-{
+ VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1)
- {
+ if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkGetBufferMemoryRequirements2", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2");
@@ -1758,134 +1336,108 @@
resources->on_vkGetBufferMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
}
static void entry_vkGetImageSparseMemoryRequirements2(
- VkDevice device,
- const VkImageSparseMemoryRequirementsInfo2* pInfo,
+ VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
-{
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, true /* do lock */);
+ vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount,
+ pSparseMemoryRequirements, true /* do lock */);
}
static void dynCheck_entry_vkGetImageSparseMemoryRequirements2(
- VkDevice device,
- const VkImageSparseMemoryRequirementsInfo2* pInfo,
+ VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
-{
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1)
- {
+ if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkGetImageSparseMemoryRequirements2", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, true /* do lock */);
+ vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount,
+ pSparseMemoryRequirements, true /* do lock */);
}
-static void entry_vkGetPhysicalDeviceFeatures2(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures2* pFeatures)
-{
+static void entry_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures, true /* do lock */);
}
-static void entry_vkGetPhysicalDeviceProperties2(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties2* pProperties)
-{
+static void entry_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetPhysicalDeviceProperties2(physicalDevice, pProperties, true /* do lock */);
}
-static void entry_vkGetPhysicalDeviceFormatProperties2(
- VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties2* pFormatProperties)
-{
+static void entry_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2* pFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties, true /* do lock */);
+ vkEnc->vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties,
+ true /* do lock */);
}
static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
- VkImageFormatProperties2* pImageFormatProperties)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+ VkImageFormatProperties2* pImageFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = resources->on_vkGetPhysicalDeviceImageFormatProperties2(vkEnc, VK_SUCCESS, physicalDevice, pImageFormatInfo, pImageFormatProperties);
+ vkGetPhysicalDeviceImageFormatProperties2_VkResult_return =
+ resources->on_vkGetPhysicalDeviceImageFormatProperties2(
+ vkEnc, VK_SUCCESS, physicalDevice, pImageFormatInfo, pImageFormatProperties);
return vkGetPhysicalDeviceImageFormatProperties2_VkResult_return;
}
static void entry_vkGetPhysicalDeviceQueueFamilyProperties2(
- VkPhysicalDevice physicalDevice,
- uint32_t* pQueueFamilyPropertyCount,
- VkQueueFamilyProperties2* pQueueFamilyProperties)
-{
+ VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2* pQueueFamilyProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, true /* do lock */);
+ vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount,
+ pQueueFamilyProperties, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceMemoryProperties2(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
-{
+ VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties, true /* do lock */);
+ vkEnc->vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties,
+ true /* do lock */);
}
static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
- uint32_t* pPropertyCount,
- VkSparseImageFormatProperties2* pProperties)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+ uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties, true /* do lock */);
+ vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2(
+ physicalDevice, pFormatInfo, pPropertyCount, pProperties, true /* do lock */);
}
-static void entry_vkTrimCommandPool(
- VkDevice device,
- VkCommandPool commandPool,
- VkCommandPoolTrimFlags flags)
-{
+static void entry_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags) {
AEMU_SCOPED_TRACE("vkTrimCommandPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkTrimCommandPool(device, commandPool, flags, true /* do lock */);
}
-static void dynCheck_entry_vkTrimCommandPool(
- VkDevice device,
- VkCommandPool commandPool,
- VkCommandPoolTrimFlags flags)
-{
+static void dynCheck_entry_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags) {
auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1)
- {
+ if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkTrimCommandPool", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkTrimCommandPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkTrimCommandPool(device, commandPool, flags, true /* do lock */);
}
-static void entry_vkGetDeviceQueue2(
- VkDevice device,
- const VkDeviceQueueInfo2* pQueueInfo,
- VkQueue* pQueue)
-{
+static void entry_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo,
+ VkQueue* pQueue) {
AEMU_SCOPED_TRACE("vkGetDeviceQueue2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetDeviceQueue2(device, pQueueInfo, pQueue, true /* do lock */);
}
-static void dynCheck_entry_vkGetDeviceQueue2(
- VkDevice device,
- const VkDeviceQueueInfo2* pQueueInfo,
- VkQueue* pQueue)
-{
+static void dynCheck_entry_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo,
+ VkQueue* pQueue) {
auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1)
- {
+ if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkGetDeviceQueue2", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkGetDeviceQueue2");
@@ -1893,53 +1445,43 @@
vkEnc->vkGetDeviceQueue2(device, pQueueInfo, pQueue, true /* do lock */);
}
static VkResult entry_vkCreateSamplerYcbcrConversion(
- VkDevice device,
- const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSamplerYcbcrConversion* pYcbcrConversion)
-{
+ VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkCreateSamplerYcbcrConversion_VkResult_return = resources->on_vkCreateSamplerYcbcrConversion(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pYcbcrConversion);
+ vkCreateSamplerYcbcrConversion_VkResult_return = resources->on_vkCreateSamplerYcbcrConversion(
+ vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pYcbcrConversion);
return vkCreateSamplerYcbcrConversion_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateSamplerYcbcrConversion(
- VkDevice device,
- const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSamplerYcbcrConversion* pYcbcrConversion)
-{
+ VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1)
- {
+ if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkCreateSamplerYcbcrConversion", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
- vkCreateSamplerYcbcrConversion_VkResult_return = resources->on_vkCreateSamplerYcbcrConversion(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pYcbcrConversion);
+ vkCreateSamplerYcbcrConversion_VkResult_return = resources->on_vkCreateSamplerYcbcrConversion(
+ vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pYcbcrConversion);
return vkCreateSamplerYcbcrConversion_VkResult_return;
}
-static void entry_vkDestroySamplerYcbcrConversion(
- VkDevice device,
- VkSamplerYcbcrConversion ycbcrConversion,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroySamplerYcbcrConversion(VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkDestroySamplerYcbcrConversion(vkEnc, device, ycbcrConversion, pAllocator);
}
static void dynCheck_entry_vkDestroySamplerYcbcrConversion(
- VkDevice device,
- VkSamplerYcbcrConversion ycbcrConversion,
- const VkAllocationCallbacks* pAllocator)
-{
+ VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1)
- {
+ if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkDestroySamplerYcbcrConversion", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion");
@@ -1947,128 +1489,110 @@
resources->on_vkDestroySamplerYcbcrConversion(vkEnc, device, ycbcrConversion, pAllocator);
}
static VkResult entry_vkCreateDescriptorUpdateTemplate(
- VkDevice device,
- const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+ VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
-{
+ VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
- vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, true /* do lock */);
+ vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(
+ device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, true /* do lock */);
return vkCreateDescriptorUpdateTemplate_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateDescriptorUpdateTemplate(
- VkDevice device,
- const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+ VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
-{
+ VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1)
- {
+ if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkCreateDescriptorUpdateTemplate", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
- vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, true /* do lock */);
+ vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(
+ device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, true /* do lock */);
return vkCreateDescriptorUpdateTemplate_VkResult_return;
}
static void entry_vkDestroyDescriptorUpdateTemplate(
- VkDevice device,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const VkAllocationCallbacks* pAllocator)
-{
+ VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator, true /* do lock */);
+ vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator,
+ true /* do lock */);
}
static void dynCheck_entry_vkDestroyDescriptorUpdateTemplate(
- VkDevice device,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const VkAllocationCallbacks* pAllocator)
-{
+ VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1)
- {
+ if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkDestroyDescriptorUpdateTemplate", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator, true /* do lock */);
+ vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator,
+ true /* do lock */);
}
static void entry_vkUpdateDescriptorSetWithTemplate(
- VkDevice device,
- VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const void* pData)
-{
+ VkDevice device, VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
- resources->on_vkUpdateDescriptorSetWithTemplate(vkEnc, device, descriptorSet, descriptorUpdateTemplate, pData);
+ resources->on_vkUpdateDescriptorSetWithTemplate(vkEnc, device, descriptorSet,
+ descriptorUpdateTemplate, pData);
}
static void dynCheck_entry_vkUpdateDescriptorSetWithTemplate(
- VkDevice device,
- VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const void* pData)
-{
+ VkDevice device, VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1)
- {
+ if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplate", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- resources->on_vkUpdateDescriptorSetWithTemplate(vkEnc, device, descriptorSet, descriptorUpdateTemplate, pData);
+ resources->on_vkUpdateDescriptorSetWithTemplate(vkEnc, device, descriptorSet,
+ descriptorUpdateTemplate, pData);
}
static void entry_vkGetPhysicalDeviceExternalBufferProperties(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
- VkExternalBufferProperties* pExternalBufferProperties)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+ VkExternalBufferProperties* pExternalBufferProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties, true /* do lock */);
+ vkEnc->vkGetPhysicalDeviceExternalBufferProperties(
+ physicalDevice, pExternalBufferInfo, pExternalBufferProperties, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceExternalFenceProperties(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
- VkExternalFenceProperties* pExternalFenceProperties)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+ VkExternalFenceProperties* pExternalFenceProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFenceProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
- resources->on_vkGetPhysicalDeviceExternalFenceProperties(vkEnc, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+ resources->on_vkGetPhysicalDeviceExternalFenceProperties(
+ vkEnc, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
}
static void entry_vkGetPhysicalDeviceExternalSemaphoreProperties(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
- VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
-{
+ VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphoreProperties");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, true /* do lock */);
+ vkEnc->vkGetPhysicalDeviceExternalSemaphoreProperties(
+ physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, true /* do lock */);
}
static void entry_vkGetDescriptorSetLayoutSupport(
- VkDevice device,
- const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- VkDescriptorSetLayoutSupport* pSupport)
-{
+ VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport) {
AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport, true /* do lock */);
}
static void dynCheck_entry_vkGetDescriptorSetLayoutSupport(
- VkDevice device,
- const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- VkDescriptorSetLayoutSupport* pSupport)
-{
+ VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport) {
auto resources = ResourceTracker::get();
- if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1)
- {
+ if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
sOnInvalidDynamicallyCheckedCall("vkGetDescriptorSetLayoutSupport", "VK_VERSION_1_1");
}
AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport");
@@ -2077,854 +1601,670 @@
}
#endif
#ifdef VK_VERSION_1_2
-static void entry_vkCmdDrawIndirectCount(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride)
-{
+static void entry_vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+ uint32_t stride) {
AEMU_SCOPED_TRACE("vkCmdDrawIndirectCount");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, true /* do lock */);
+ vkEnc->vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset,
+ maxDrawCount, stride, true /* do lock */);
}
-static void dynCheck_entry_vkCmdDrawIndirectCount(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride)
-{
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdDrawIndirectCount", "VK_VERSION_1_2");
- }
- AEMU_SCOPED_TRACE("vkCmdDrawIndirectCount");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, true /* do lock */);
-}
-static void entry_vkCmdDrawIndexedIndirectCount(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride)
-{
+static void entry_vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount, uint32_t stride) {
AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCount");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, true /* do lock */);
+ vkEnc->vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer,
+ countBufferOffset, maxDrawCount, stride,
+ true /* do lock */);
}
-static void dynCheck_entry_vkCmdDrawIndexedIndirectCount(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride)
-{
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdDrawIndexedIndirectCount", "VK_VERSION_1_2");
- }
- AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCount");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, true /* do lock */);
-}
-static VkResult entry_vkCreateRenderPass2(
- VkDevice device,
- const VkRenderPassCreateInfo2* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass)
-{
+static VkResult entry_vkCreateRenderPass2(VkDevice device,
+ const VkRenderPassCreateInfo2* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass) {
AEMU_SCOPED_TRACE("vkCreateRenderPass2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateRenderPass2_VkResult_return = (VkResult)0;
- vkCreateRenderPass2_VkResult_return = vkEnc->vkCreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
+ vkCreateRenderPass2_VkResult_return = vkEnc->vkCreateRenderPass2(
+ device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
return vkCreateRenderPass2_VkResult_return;
}
-static VkResult dynCheck_entry_vkCreateRenderPass2(
- VkDevice device,
- const VkRenderPassCreateInfo2* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass)
-{
+static VkResult dynCheck_entry_vkCreateRenderPass2(VkDevice device,
+ const VkRenderPassCreateInfo2* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2")) {
sOnInvalidDynamicallyCheckedCall("vkCreateRenderPass2", "VK_VERSION_1_2");
}
AEMU_SCOPED_TRACE("vkCreateRenderPass2");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateRenderPass2_VkResult_return = (VkResult)0;
- vkCreateRenderPass2_VkResult_return = vkEnc->vkCreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
+ vkCreateRenderPass2_VkResult_return = vkEnc->vkCreateRenderPass2(
+ device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
return vkCreateRenderPass2_VkResult_return;
}
-static void entry_vkCmdBeginRenderPass2(
- VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo* pRenderPassBegin,
- const VkSubpassBeginInfo* pSubpassBeginInfo)
-{
+static void entry_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ const VkSubpassBeginInfo* pSubpassBeginInfo) {
AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo, true /* do lock */);
+ vkEnc->vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo,
+ true /* do lock */);
}
-static void dynCheck_entry_vkCmdBeginRenderPass2(
- VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo* pRenderPassBegin,
- const VkSubpassBeginInfo* pSubpassBeginInfo)
-{
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdBeginRenderPass2", "VK_VERSION_1_2");
- }
- AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo, true /* do lock */);
-}
-static void entry_vkCmdNextSubpass2(
- VkCommandBuffer commandBuffer,
- const VkSubpassBeginInfo* pSubpassBeginInfo,
- const VkSubpassEndInfo* pSubpassEndInfo)
-{
+static void entry_vkCmdNextSubpass2(VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfo* pSubpassBeginInfo,
+ const VkSubpassEndInfo* pSubpassEndInfo) {
AEMU_SCOPED_TRACE("vkCmdNextSubpass2");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo, true /* do lock */);
}
-static void dynCheck_entry_vkCmdNextSubpass2(
- VkCommandBuffer commandBuffer,
- const VkSubpassBeginInfo* pSubpassBeginInfo,
- const VkSubpassEndInfo* pSubpassEndInfo)
-{
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdNextSubpass2", "VK_VERSION_1_2");
- }
- AEMU_SCOPED_TRACE("vkCmdNextSubpass2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo, true /* do lock */);
-}
-static void entry_vkCmdEndRenderPass2(
- VkCommandBuffer commandBuffer,
- const VkSubpassEndInfo* pSubpassEndInfo)
-{
+static void entry_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer,
+ const VkSubpassEndInfo* pSubpassEndInfo) {
AEMU_SCOPED_TRACE("vkCmdEndRenderPass2");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo, true /* do lock */);
}
-static void dynCheck_entry_vkCmdEndRenderPass2(
- VkCommandBuffer commandBuffer,
- const VkSubpassEndInfo* pSubpassEndInfo)
-{
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdEndRenderPass2", "VK_VERSION_1_2");
- }
- AEMU_SCOPED_TRACE("vkCmdEndRenderPass2");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo, true /* do lock */);
-}
-static void entry_vkResetQueryPool(
- VkDevice device,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t queryCount)
-{
+static void entry_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
+ uint32_t queryCount) {
AEMU_SCOPED_TRACE("vkResetQueryPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkResetQueryPool(device, queryPool, firstQuery, queryCount, true /* do lock */);
}
-static void dynCheck_entry_vkResetQueryPool(
- VkDevice device,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t queryCount)
-{
+static void dynCheck_entry_vkResetQueryPool(VkDevice device, VkQueryPool queryPool,
+ uint32_t firstQuery, uint32_t queryCount) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2")) {
sOnInvalidDynamicallyCheckedCall("vkResetQueryPool", "VK_VERSION_1_2");
}
AEMU_SCOPED_TRACE("vkResetQueryPool");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkResetQueryPool(device, queryPool, firstQuery, queryCount, true /* do lock */);
}
-static VkResult entry_vkGetSemaphoreCounterValue(
- VkDevice device,
- VkSemaphore semaphore,
- uint64_t* pValue)
-{
+static VkResult entry_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore,
+ uint64_t* pValue) {
AEMU_SCOPED_TRACE("vkGetSemaphoreCounterValue");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSemaphoreCounterValue_VkResult_return = (VkResult)0;
- vkGetSemaphoreCounterValue_VkResult_return = vkEnc->vkGetSemaphoreCounterValue(device, semaphore, pValue, true /* do lock */);
+ vkGetSemaphoreCounterValue_VkResult_return =
+ vkEnc->vkGetSemaphoreCounterValue(device, semaphore, pValue, true /* do lock */);
return vkGetSemaphoreCounterValue_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetSemaphoreCounterValue(
- VkDevice device,
- VkSemaphore semaphore,
- uint64_t* pValue)
-{
+static VkResult dynCheck_entry_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore,
+ uint64_t* pValue) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2")) {
sOnInvalidDynamicallyCheckedCall("vkGetSemaphoreCounterValue", "VK_VERSION_1_2");
}
AEMU_SCOPED_TRACE("vkGetSemaphoreCounterValue");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSemaphoreCounterValue_VkResult_return = (VkResult)0;
- vkGetSemaphoreCounterValue_VkResult_return = vkEnc->vkGetSemaphoreCounterValue(device, semaphore, pValue, true /* do lock */);
+ vkGetSemaphoreCounterValue_VkResult_return =
+ vkEnc->vkGetSemaphoreCounterValue(device, semaphore, pValue, true /* do lock */);
return vkGetSemaphoreCounterValue_VkResult_return;
}
-static VkResult entry_vkWaitSemaphores(
- VkDevice device,
- const VkSemaphoreWaitInfo* pWaitInfo,
- uint64_t timeout)
-{
+static VkResult entry_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo,
+ uint64_t timeout) {
AEMU_SCOPED_TRACE("vkWaitSemaphores");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkWaitSemaphores_VkResult_return = (VkResult)0;
- vkWaitSemaphores_VkResult_return = vkEnc->vkWaitSemaphores(device, pWaitInfo, timeout, true /* do lock */);
+ vkWaitSemaphores_VkResult_return =
+ vkEnc->vkWaitSemaphores(device, pWaitInfo, timeout, true /* do lock */);
return vkWaitSemaphores_VkResult_return;
}
-static VkResult dynCheck_entry_vkWaitSemaphores(
- VkDevice device,
- const VkSemaphoreWaitInfo* pWaitInfo,
- uint64_t timeout)
-{
+static VkResult dynCheck_entry_vkWaitSemaphores(VkDevice device,
+ const VkSemaphoreWaitInfo* pWaitInfo,
+ uint64_t timeout) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2")) {
sOnInvalidDynamicallyCheckedCall("vkWaitSemaphores", "VK_VERSION_1_2");
}
AEMU_SCOPED_TRACE("vkWaitSemaphores");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkWaitSemaphores_VkResult_return = (VkResult)0;
- vkWaitSemaphores_VkResult_return = vkEnc->vkWaitSemaphores(device, pWaitInfo, timeout, true /* do lock */);
+ vkWaitSemaphores_VkResult_return =
+ vkEnc->vkWaitSemaphores(device, pWaitInfo, timeout, true /* do lock */);
return vkWaitSemaphores_VkResult_return;
}
-static VkResult entry_vkSignalSemaphore(
- VkDevice device,
- const VkSemaphoreSignalInfo* pSignalInfo)
-{
+static VkResult entry_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) {
AEMU_SCOPED_TRACE("vkSignalSemaphore");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSignalSemaphore_VkResult_return = (VkResult)0;
- vkSignalSemaphore_VkResult_return = vkEnc->vkSignalSemaphore(device, pSignalInfo, true /* do lock */);
+ vkSignalSemaphore_VkResult_return =
+ vkEnc->vkSignalSemaphore(device, pSignalInfo, true /* do lock */);
return vkSignalSemaphore_VkResult_return;
}
-static VkResult dynCheck_entry_vkSignalSemaphore(
- VkDevice device,
- const VkSemaphoreSignalInfo* pSignalInfo)
-{
+static VkResult dynCheck_entry_vkSignalSemaphore(VkDevice device,
+ const VkSemaphoreSignalInfo* pSignalInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2")) {
sOnInvalidDynamicallyCheckedCall("vkSignalSemaphore", "VK_VERSION_1_2");
}
AEMU_SCOPED_TRACE("vkSignalSemaphore");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSignalSemaphore_VkResult_return = (VkResult)0;
- vkSignalSemaphore_VkResult_return = vkEnc->vkSignalSemaphore(device, pSignalInfo, true /* do lock */);
+ vkSignalSemaphore_VkResult_return =
+ vkEnc->vkSignalSemaphore(device, pSignalInfo, true /* do lock */);
return vkSignalSemaphore_VkResult_return;
}
-static VkDeviceAddress entry_vkGetBufferDeviceAddress(
- VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo)
-{
+static VkDeviceAddress entry_vkGetBufferDeviceAddress(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetBufferDeviceAddress");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkDeviceAddress vkGetBufferDeviceAddress_VkDeviceAddress_return = (VkDeviceAddress)0;
- vkGetBufferDeviceAddress_VkDeviceAddress_return = vkEnc->vkGetBufferDeviceAddress(device, pInfo, true /* do lock */);
+ vkGetBufferDeviceAddress_VkDeviceAddress_return =
+ vkEnc->vkGetBufferDeviceAddress(device, pInfo, true /* do lock */);
return vkGetBufferDeviceAddress_VkDeviceAddress_return;
}
static VkDeviceAddress dynCheck_entry_vkGetBufferDeviceAddress(
- VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo)
-{
+ VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2")) {
sOnInvalidDynamicallyCheckedCall("vkGetBufferDeviceAddress", "VK_VERSION_1_2");
}
AEMU_SCOPED_TRACE("vkGetBufferDeviceAddress");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkDeviceAddress vkGetBufferDeviceAddress_VkDeviceAddress_return = (VkDeviceAddress)0;
- vkGetBufferDeviceAddress_VkDeviceAddress_return = vkEnc->vkGetBufferDeviceAddress(device, pInfo, true /* do lock */);
+ vkGetBufferDeviceAddress_VkDeviceAddress_return =
+ vkEnc->vkGetBufferDeviceAddress(device, pInfo, true /* do lock */);
return vkGetBufferDeviceAddress_VkDeviceAddress_return;
}
-static uint64_t entry_vkGetBufferOpaqueCaptureAddress(
- VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo)
-{
+static uint64_t entry_vkGetBufferOpaqueCaptureAddress(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddress");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint64_t vkGetBufferOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
- vkGetBufferOpaqueCaptureAddress_uint64_t_return = vkEnc->vkGetBufferOpaqueCaptureAddress(device, pInfo, true /* do lock */);
+ vkGetBufferOpaqueCaptureAddress_uint64_t_return =
+ vkEnc->vkGetBufferOpaqueCaptureAddress(device, pInfo, true /* do lock */);
return vkGetBufferOpaqueCaptureAddress_uint64_t_return;
}
static uint64_t dynCheck_entry_vkGetBufferOpaqueCaptureAddress(
- VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo)
-{
+ VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2")) {
sOnInvalidDynamicallyCheckedCall("vkGetBufferOpaqueCaptureAddress", "VK_VERSION_1_2");
}
AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddress");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint64_t vkGetBufferOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
- vkGetBufferOpaqueCaptureAddress_uint64_t_return = vkEnc->vkGetBufferOpaqueCaptureAddress(device, pInfo, true /* do lock */);
+ vkGetBufferOpaqueCaptureAddress_uint64_t_return =
+ vkEnc->vkGetBufferOpaqueCaptureAddress(device, pInfo, true /* do lock */);
return vkGetBufferOpaqueCaptureAddress_uint64_t_return;
}
static uint64_t entry_vkGetDeviceMemoryOpaqueCaptureAddress(
- VkDevice device,
- const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
-{
+ VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddress");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint64_t vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
- vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return = vkEnc->vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo, true /* do lock */);
+ vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return =
+ vkEnc->vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo, true /* do lock */);
return vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return;
}
static uint64_t dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddress(
- VkDevice device,
- const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
-{
+ VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_VERSION_1_2")) {
sOnInvalidDynamicallyCheckedCall("vkGetDeviceMemoryOpaqueCaptureAddress", "VK_VERSION_1_2");
}
AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddress");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint64_t vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
- vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return = vkEnc->vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo, true /* do lock */);
+ vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return =
+ vkEnc->vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo, true /* do lock */);
return vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return;
}
#endif
#ifdef VK_KHR_surface
-static void entry_vkDestroySurfaceKHR(
- VkInstance instance,
- VkSurfaceKHR surface,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroySurfaceKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroySurfaceKHR(instance, surface, pAllocator, true /* do lock */);
}
-static VkResult entry_vkGetPhysicalDeviceSurfaceSupportKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- VkSurfaceKHR surface,
- VkBool32* pSupported)
-{
+static VkResult entry_vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ VkSurfaceKHR surface,
+ VkBool32* pSupported) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceSupportKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported, true /* do lock */);
+ vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface,
+ pSupported, true /* do lock */);
return vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
- VkPhysicalDevice physicalDevice,
- VkSurfaceKHR surface,
- VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
-{
+ VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+ VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities, true /* do lock */);
+ vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface,
+ pSurfaceCapabilities, true /* do lock */);
return vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return;
}
-static VkResult entry_vkGetPhysicalDeviceSurfaceFormatsKHR(
- VkPhysicalDevice physicalDevice,
- VkSurfaceKHR surface,
- uint32_t* pSurfaceFormatCount,
- VkSurfaceFormatKHR* pSurfaceFormats)
-{
+static VkResult entry_vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pSurfaceFormatCount,
+ VkSurfaceFormatKHR* pSurfaceFormats) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormatsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats, true /* do lock */);
+ vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount,
+ pSurfaceFormats, true /* do lock */);
return vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return;
}
-static VkResult entry_vkGetPhysicalDeviceSurfacePresentModesKHR(
- VkPhysicalDevice physicalDevice,
- VkSurfaceKHR surface,
- uint32_t* pPresentModeCount,
- VkPresentModeKHR* pPresentModes)
-{
+static VkResult entry_vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pPresentModeCount,
+ VkPresentModeKHR* pPresentModes) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfacePresentModesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes, true /* do lock */);
+ vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount,
+ pPresentModes, true /* do lock */);
return vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_swapchain
-static VkResult entry_vkCreateSwapchainKHR(
- VkDevice device,
- const VkSwapchainCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSwapchainKHR* pSwapchain)
-{
+static VkResult entry_vkCreateSwapchainKHR(VkDevice device,
+ const VkSwapchainCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchain) {
AEMU_SCOPED_TRACE("vkCreateSwapchainKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
- vkCreateSwapchainKHR_VkResult_return = vkEnc->vkCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain, true /* do lock */);
+ vkCreateSwapchainKHR_VkResult_return = vkEnc->vkCreateSwapchainKHR(
+ device, pCreateInfo, pAllocator, pSwapchain, true /* do lock */);
return vkCreateSwapchainKHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkCreateSwapchainKHR(
- VkDevice device,
- const VkSwapchainCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSwapchainKHR* pSwapchain)
-{
+static VkResult dynCheck_entry_vkCreateSwapchainKHR(VkDevice device,
+ const VkSwapchainCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchain) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
sOnInvalidDynamicallyCheckedCall("vkCreateSwapchainKHR", "VK_KHR_swapchain");
}
AEMU_SCOPED_TRACE("vkCreateSwapchainKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
- vkCreateSwapchainKHR_VkResult_return = vkEnc->vkCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain, true /* do lock */);
+ vkCreateSwapchainKHR_VkResult_return = vkEnc->vkCreateSwapchainKHR(
+ device, pCreateInfo, pAllocator, pSwapchain, true /* do lock */);
return vkCreateSwapchainKHR_VkResult_return;
}
-static void entry_vkDestroySwapchainKHR(
- VkDevice device,
- VkSwapchainKHR swapchain,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroySwapchainKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroySwapchainKHR(device, swapchain, pAllocator, true /* do lock */);
}
-static void dynCheck_entry_vkDestroySwapchainKHR(
- VkDevice device,
- VkSwapchainKHR swapchain,
- const VkAllocationCallbacks* pAllocator)
-{
+static void dynCheck_entry_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
+ const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
sOnInvalidDynamicallyCheckedCall("vkDestroySwapchainKHR", "VK_KHR_swapchain");
}
AEMU_SCOPED_TRACE("vkDestroySwapchainKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroySwapchainKHR(device, swapchain, pAllocator, true /* do lock */);
}
-static VkResult entry_vkGetSwapchainImagesKHR(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint32_t* pSwapchainImageCount,
- VkImage* pSwapchainImages)
-{
+static VkResult entry_vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain,
+ uint32_t* pSwapchainImageCount,
+ VkImage* pSwapchainImages) {
AEMU_SCOPED_TRACE("vkGetSwapchainImagesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
- vkGetSwapchainImagesKHR_VkResult_return = vkEnc->vkGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages, true /* do lock */);
+ vkGetSwapchainImagesKHR_VkResult_return = vkEnc->vkGetSwapchainImagesKHR(
+ device, swapchain, pSwapchainImageCount, pSwapchainImages, true /* do lock */);
return vkGetSwapchainImagesKHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetSwapchainImagesKHR(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint32_t* pSwapchainImageCount,
- VkImage* pSwapchainImages)
-{
+static VkResult dynCheck_entry_vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain,
+ uint32_t* pSwapchainImageCount,
+ VkImage* pSwapchainImages) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
sOnInvalidDynamicallyCheckedCall("vkGetSwapchainImagesKHR", "VK_KHR_swapchain");
}
AEMU_SCOPED_TRACE("vkGetSwapchainImagesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
- vkGetSwapchainImagesKHR_VkResult_return = vkEnc->vkGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages, true /* do lock */);
+ vkGetSwapchainImagesKHR_VkResult_return = vkEnc->vkGetSwapchainImagesKHR(
+ device, swapchain, pSwapchainImageCount, pSwapchainImages, true /* do lock */);
return vkGetSwapchainImagesKHR_VkResult_return;
}
-static VkResult entry_vkAcquireNextImageKHR(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint64_t timeout,
- VkSemaphore semaphore,
- VkFence fence,
- uint32_t* pImageIndex)
-{
+static VkResult entry_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain,
+ uint64_t timeout, VkSemaphore semaphore, VkFence fence,
+ uint32_t* pImageIndex) {
AEMU_SCOPED_TRACE("vkAcquireNextImageKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
- vkAcquireNextImageKHR_VkResult_return = vkEnc->vkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex, true /* do lock */);
+ vkAcquireNextImageKHR_VkResult_return = vkEnc->vkAcquireNextImageKHR(
+ device, swapchain, timeout, semaphore, fence, pImageIndex, true /* do lock */);
return vkAcquireNextImageKHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkAcquireNextImageKHR(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint64_t timeout,
- VkSemaphore semaphore,
- VkFence fence,
- uint32_t* pImageIndex)
-{
+static VkResult dynCheck_entry_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain,
+ uint64_t timeout, VkSemaphore semaphore,
+ VkFence fence, uint32_t* pImageIndex) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
sOnInvalidDynamicallyCheckedCall("vkAcquireNextImageKHR", "VK_KHR_swapchain");
}
AEMU_SCOPED_TRACE("vkAcquireNextImageKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
- vkAcquireNextImageKHR_VkResult_return = vkEnc->vkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex, true /* do lock */);
+ vkAcquireNextImageKHR_VkResult_return = vkEnc->vkAcquireNextImageKHR(
+ device, swapchain, timeout, semaphore, fence, pImageIndex, true /* do lock */);
return vkAcquireNextImageKHR_VkResult_return;
}
-static VkResult entry_vkQueuePresentKHR(
- VkQueue queue,
- const VkPresentInfoKHR* pPresentInfo)
-{
+static VkResult entry_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) {
AEMU_SCOPED_TRACE("vkQueuePresentKHR");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueuePresentKHR_VkResult_return = (VkResult)0;
- vkQueuePresentKHR_VkResult_return = vkEnc->vkQueuePresentKHR(queue, pPresentInfo, true /* do lock */);
+ vkQueuePresentKHR_VkResult_return =
+ vkEnc->vkQueuePresentKHR(queue, pPresentInfo, true /* do lock */);
return vkQueuePresentKHR_VkResult_return;
}
static VkResult entry_vkGetDeviceGroupPresentCapabilitiesKHR(
- VkDevice device,
- VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
-{
+ VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
AEMU_SCOPED_TRACE("vkGetDeviceGroupPresentCapabilitiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
- vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = vkEnc->vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities, true /* do lock */);
+ vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return =
+ vkEnc->vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities,
+ true /* do lock */);
return vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetDeviceGroupPresentCapabilitiesKHR(
- VkDevice device,
- VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
-{
+ VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceGroupPresentCapabilitiesKHR", "VK_KHR_swapchain");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetDeviceGroupPresentCapabilitiesKHR",
+ "VK_KHR_swapchain");
}
AEMU_SCOPED_TRACE("vkGetDeviceGroupPresentCapabilitiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
- vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = vkEnc->vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities, true /* do lock */);
+ vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return =
+ vkEnc->vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities,
+ true /* do lock */);
return vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return;
}
static VkResult entry_vkGetDeviceGroupSurfacePresentModesKHR(
- VkDevice device,
- VkSurfaceKHR surface,
- VkDeviceGroupPresentModeFlagsKHR* pModes)
-{
+ VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) {
AEMU_SCOPED_TRACE("vkGetDeviceGroupSurfacePresentModesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
- vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = vkEnc->vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes, true /* do lock */);
+ vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return =
+ vkEnc->vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes, true /* do lock */);
return vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetDeviceGroupSurfacePresentModesKHR(
- VkDevice device,
- VkSurfaceKHR surface,
- VkDeviceGroupPresentModeFlagsKHR* pModes)
-{
+ VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceGroupSurfacePresentModesKHR", "VK_KHR_swapchain");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetDeviceGroupSurfacePresentModesKHR",
+ "VK_KHR_swapchain");
}
AEMU_SCOPED_TRACE("vkGetDeviceGroupSurfacePresentModesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
- vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = vkEnc->vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes, true /* do lock */);
+ vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return =
+ vkEnc->vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes, true /* do lock */);
return vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return;
}
-static VkResult entry_vkGetPhysicalDevicePresentRectanglesKHR(
- VkPhysicalDevice physicalDevice,
- VkSurfaceKHR surface,
- uint32_t* pRectCount,
- VkRect2D* pRects)
-{
+static VkResult entry_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t* pRectCount,
+ VkRect2D* pRects) {
AEMU_SCOPED_TRACE("vkGetPhysicalDevicePresentRectanglesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = (VkResult)0;
- vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = vkEnc->vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects, true /* do lock */);
+ vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return =
+ vkEnc->vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects,
+ true /* do lock */);
return vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return;
}
-static VkResult entry_vkAcquireNextImage2KHR(
- VkDevice device,
- const VkAcquireNextImageInfoKHR* pAcquireInfo,
- uint32_t* pImageIndex)
-{
+static VkResult entry_vkAcquireNextImage2KHR(VkDevice device,
+ const VkAcquireNextImageInfoKHR* pAcquireInfo,
+ uint32_t* pImageIndex) {
AEMU_SCOPED_TRACE("vkAcquireNextImage2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
- vkAcquireNextImage2KHR_VkResult_return = vkEnc->vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex, true /* do lock */);
+ vkAcquireNextImage2KHR_VkResult_return =
+ vkEnc->vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex, true /* do lock */);
return vkAcquireNextImage2KHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkAcquireNextImage2KHR(
- VkDevice device,
- const VkAcquireNextImageInfoKHR* pAcquireInfo,
- uint32_t* pImageIndex)
-{
+static VkResult dynCheck_entry_vkAcquireNextImage2KHR(VkDevice device,
+ const VkAcquireNextImageInfoKHR* pAcquireInfo,
+ uint32_t* pImageIndex) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
sOnInvalidDynamicallyCheckedCall("vkAcquireNextImage2KHR", "VK_KHR_swapchain");
}
AEMU_SCOPED_TRACE("vkAcquireNextImage2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
- vkAcquireNextImage2KHR_VkResult_return = vkEnc->vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex, true /* do lock */);
+ vkAcquireNextImage2KHR_VkResult_return =
+ vkEnc->vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex, true /* do lock */);
return vkAcquireNextImage2KHR_VkResult_return;
}
#endif
#ifdef VK_KHR_display
-static VkResult entry_vkGetPhysicalDeviceDisplayPropertiesKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkDisplayPropertiesKHR* pProperties)
-{
+static VkResult entry_vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
+ uint32_t* pPropertyCount,
+ VkDisplayPropertiesKHR* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPropertiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties, true /* do lock */);
+ vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties,
+ true /* do lock */);
return vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkDisplayPlanePropertiesKHR* pProperties)
-{
+ VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount,
+ VkDisplayPlanePropertiesKHR* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlanePropertiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties, true /* do lock */);
+ vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount,
+ pProperties, true /* do lock */);
return vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return;
}
-static VkResult entry_vkGetDisplayPlaneSupportedDisplaysKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t planeIndex,
- uint32_t* pDisplayCount,
- VkDisplayKHR* pDisplays)
-{
+static VkResult entry_vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice,
+ uint32_t planeIndex,
+ uint32_t* pDisplayCount,
+ VkDisplayKHR* pDisplays) {
AEMU_SCOPED_TRACE("vkGetDisplayPlaneSupportedDisplaysKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = (VkResult)0;
- vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = vkEnc->vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays, true /* do lock */);
+ vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return =
+ vkEnc->vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount,
+ pDisplays, true /* do lock */);
return vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return;
}
-static VkResult entry_vkGetDisplayModePropertiesKHR(
- VkPhysicalDevice physicalDevice,
- VkDisplayKHR display,
- uint32_t* pPropertyCount,
- VkDisplayModePropertiesKHR* pProperties)
-{
+static VkResult entry_vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display, uint32_t* pPropertyCount,
+ VkDisplayModePropertiesKHR* pProperties) {
AEMU_SCOPED_TRACE("vkGetDisplayModePropertiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDisplayModePropertiesKHR_VkResult_return = (VkResult)0;
- vkGetDisplayModePropertiesKHR_VkResult_return = vkEnc->vkGetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties, true /* do lock */);
+ vkGetDisplayModePropertiesKHR_VkResult_return = vkEnc->vkGetDisplayModePropertiesKHR(
+ physicalDevice, display, pPropertyCount, pProperties, true /* do lock */);
return vkGetDisplayModePropertiesKHR_VkResult_return;
}
-static VkResult entry_vkCreateDisplayModeKHR(
- VkPhysicalDevice physicalDevice,
- VkDisplayKHR display,
- const VkDisplayModeCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDisplayModeKHR* pMode)
-{
+static VkResult entry_vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
+ const VkDisplayModeCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDisplayModeKHR* pMode) {
AEMU_SCOPED_TRACE("vkCreateDisplayModeKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDisplayModeKHR_VkResult_return = (VkResult)0;
- vkCreateDisplayModeKHR_VkResult_return = vkEnc->vkCreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode, true /* do lock */);
+ vkCreateDisplayModeKHR_VkResult_return = vkEnc->vkCreateDisplayModeKHR(
+ physicalDevice, display, pCreateInfo, pAllocator, pMode, true /* do lock */);
return vkCreateDisplayModeKHR_VkResult_return;
}
static VkResult entry_vkGetDisplayPlaneCapabilitiesKHR(
- VkPhysicalDevice physicalDevice,
- VkDisplayModeKHR mode,
- uint32_t planeIndex,
- VkDisplayPlaneCapabilitiesKHR* pCapabilities)
-{
+ VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex,
+ VkDisplayPlaneCapabilitiesKHR* pCapabilities) {
AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilitiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = (VkResult)0;
- vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = vkEnc->vkGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities, true /* do lock */);
+ vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = vkEnc->vkGetDisplayPlaneCapabilitiesKHR(
+ physicalDevice, mode, planeIndex, pCapabilities, true /* do lock */);
return vkGetDisplayPlaneCapabilitiesKHR_VkResult_return;
}
static VkResult entry_vkCreateDisplayPlaneSurfaceKHR(
- VkInstance instance,
- const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface)
-{
+ VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateDisplayPlaneSurfaceKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDisplayPlaneSurfaceKHR_VkResult_return = (VkResult)0;
- vkCreateDisplayPlaneSurfaceKHR_VkResult_return = vkEnc->vkCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
+ vkCreateDisplayPlaneSurfaceKHR_VkResult_return = vkEnc->vkCreateDisplayPlaneSurfaceKHR(
+ instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateDisplayPlaneSurfaceKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_display_swapchain
-static VkResult entry_vkCreateSharedSwapchainsKHR(
- VkDevice device,
- uint32_t swapchainCount,
- const VkSwapchainCreateInfoKHR* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkSwapchainKHR* pSwapchains)
-{
+static VkResult entry_vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
+ const VkSwapchainCreateInfoKHR* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator,
+ VkSwapchainKHR* pSwapchains) {
AEMU_SCOPED_TRACE("vkCreateSharedSwapchainsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0;
- vkCreateSharedSwapchainsKHR_VkResult_return = vkEnc->vkCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains, true /* do lock */);
+ vkCreateSharedSwapchainsKHR_VkResult_return = vkEnc->vkCreateSharedSwapchainsKHR(
+ device, swapchainCount, pCreateInfos, pAllocator, pSwapchains, true /* do lock */);
return vkCreateSharedSwapchainsKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateSharedSwapchainsKHR(
- VkDevice device,
- uint32_t swapchainCount,
- const VkSwapchainCreateInfoKHR* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkSwapchainKHR* pSwapchains)
-{
+ VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_display_swapchain"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_display_swapchain")) {
sOnInvalidDynamicallyCheckedCall("vkCreateSharedSwapchainsKHR", "VK_KHR_display_swapchain");
}
AEMU_SCOPED_TRACE("vkCreateSharedSwapchainsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0;
- vkCreateSharedSwapchainsKHR_VkResult_return = vkEnc->vkCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains, true /* do lock */);
+ vkCreateSharedSwapchainsKHR_VkResult_return = vkEnc->vkCreateSharedSwapchainsKHR(
+ device, swapchainCount, pCreateInfos, pAllocator, pSwapchains, true /* do lock */);
return vkCreateSharedSwapchainsKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_xlib_surface
-static VkResult entry_vkCreateXlibSurfaceKHR(
- VkInstance instance,
- const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface)
-{
+static VkResult entry_vkCreateXlibSurfaceKHR(VkInstance instance,
+ const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateXlibSurfaceKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateXlibSurfaceKHR_VkResult_return = (VkResult)0;
- vkCreateXlibSurfaceKHR_VkResult_return = vkEnc->vkCreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
+ vkCreateXlibSurfaceKHR_VkResult_return = vkEnc->vkCreateXlibSurfaceKHR(
+ instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateXlibSurfaceKHR_VkResult_return;
}
-static VkBool32 entry_vkGetPhysicalDeviceXlibPresentationSupportKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- Display* dpy,
- VisualID visualID)
-{
+static VkBool32 entry_vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ Display* dpy,
+ VisualID visualID) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXlibPresentationSupportKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = (VkBool32)0;
- vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID, true /* do lock */);
+ vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return =
+ vkEnc->vkGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy,
+ visualID, true /* do lock */);
return vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return;
}
#endif
#ifdef VK_KHR_xcb_surface
-static VkResult entry_vkCreateXcbSurfaceKHR(
- VkInstance instance,
- const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface)
-{
+static VkResult entry_vkCreateXcbSurfaceKHR(VkInstance instance,
+ const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateXcbSurfaceKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateXcbSurfaceKHR_VkResult_return = (VkResult)0;
- vkCreateXcbSurfaceKHR_VkResult_return = vkEnc->vkCreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
+ vkCreateXcbSurfaceKHR_VkResult_return = vkEnc->vkCreateXcbSurfaceKHR(
+ instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateXcbSurfaceKHR_VkResult_return;
}
-static VkBool32 entry_vkGetPhysicalDeviceXcbPresentationSupportKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- xcb_connection_t* connection,
- xcb_visualid_t visual_id)
-{
+static VkBool32 entry_vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ xcb_connection_t* connection,
+ xcb_visualid_t visual_id) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXcbPresentationSupportKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = (VkBool32)0;
- vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id, true /* do lock */);
+ vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return =
+ vkEnc->vkGetPhysicalDeviceXcbPresentationSupportKHR(
+ physicalDevice, queueFamilyIndex, connection, visual_id, true /* do lock */);
return vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return;
}
#endif
#ifdef VK_KHR_wayland_surface
-static VkResult entry_vkCreateWaylandSurfaceKHR(
- VkInstance instance,
- const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface)
-{
+static VkResult entry_vkCreateWaylandSurfaceKHR(VkInstance instance,
+ const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateWaylandSurfaceKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateWaylandSurfaceKHR_VkResult_return = (VkResult)0;
- vkCreateWaylandSurfaceKHR_VkResult_return = vkEnc->vkCreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
+ vkCreateWaylandSurfaceKHR_VkResult_return = vkEnc->vkCreateWaylandSurfaceKHR(
+ instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateWaylandSurfaceKHR_VkResult_return;
}
static VkBool32 entry_vkGetPhysicalDeviceWaylandPresentationSupportKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- wl_display* display)
-{
+ VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, wl_display* display) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWaylandPresentationSupportKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return = (VkBool32)0;
- vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display, true /* do lock */);
+ vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return =
+ vkEnc->vkGetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex,
+ display, true /* do lock */);
return vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return;
}
#endif
#ifdef VK_KHR_android_surface
-static VkResult entry_vkCreateAndroidSurfaceKHR(
- VkInstance instance,
- const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface)
-{
+static VkResult entry_vkCreateAndroidSurfaceKHR(VkInstance instance,
+ const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateAndroidSurfaceKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0;
- vkCreateAndroidSurfaceKHR_VkResult_return = vkEnc->vkCreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
+ vkCreateAndroidSurfaceKHR_VkResult_return = vkEnc->vkCreateAndroidSurfaceKHR(
+ instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateAndroidSurfaceKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_win32_surface
-static VkResult entry_vkCreateWin32SurfaceKHR(
- VkInstance instance,
- const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface)
-{
+static VkResult entry_vkCreateWin32SurfaceKHR(VkInstance instance,
+ const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateWin32SurfaceKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateWin32SurfaceKHR_VkResult_return = (VkResult)0;
- vkCreateWin32SurfaceKHR_VkResult_return = vkEnc->vkCreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
+ vkCreateWin32SurfaceKHR_VkResult_return = vkEnc->vkCreateWin32SurfaceKHR(
+ instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateWin32SurfaceKHR_VkResult_return;
}
static VkBool32 entry_vkGetPhysicalDeviceWin32PresentationSupportKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex)
-{
+ VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWin32PresentationSupportKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = (VkBool32)0;
- vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex, true /* do lock */);
+ vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return =
+ vkEnc->vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex,
+ true /* do lock */);
return vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return;
}
#endif
@@ -2932,74 +2272,63 @@
#endif
#ifdef VK_KHR_video_queue
static VkResult entry_vkGetPhysicalDeviceVideoCapabilitiesKHR(
- VkPhysicalDevice physicalDevice,
- const VkVideoProfileKHR* pVideoProfile,
- VkVideoCapabilitiesKHR* pCapabilities)
-{
+ VkPhysicalDevice physicalDevice, const VkVideoProfileKHR* pVideoProfile,
+ VkVideoCapabilitiesKHR* pCapabilities) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceVideoCapabilitiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceVideoCapabilitiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, pVideoProfile, pCapabilities, true /* do lock */);
+ vkGetPhysicalDeviceVideoCapabilitiesKHR_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, pVideoProfile, pCapabilities,
+ true /* do lock */);
return vkGetPhysicalDeviceVideoCapabilitiesKHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDeviceVideoFormatPropertiesKHR(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo,
- uint32_t* pVideoFormatPropertyCount,
- VkVideoFormatPropertiesKHR* pVideoFormatProperties)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo,
+ uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceVideoFormatPropertiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceVideoFormatPropertiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties, true /* do lock */);
+ vkGetPhysicalDeviceVideoFormatPropertiesKHR_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceVideoFormatPropertiesKHR(
+ physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties,
+ true /* do lock */);
return vkGetPhysicalDeviceVideoFormatPropertiesKHR_VkResult_return;
}
-static VkResult entry_vkCreateVideoSessionKHR(
- VkDevice device,
- const VkVideoSessionCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkVideoSessionKHR* pVideoSession)
-{
+static VkResult entry_vkCreateVideoSessionKHR(VkDevice device,
+ const VkVideoSessionCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkVideoSessionKHR* pVideoSession) {
AEMU_SCOPED_TRACE("vkCreateVideoSessionKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateVideoSessionKHR_VkResult_return = (VkResult)0;
- vkCreateVideoSessionKHR_VkResult_return = vkEnc->vkCreateVideoSessionKHR(device, pCreateInfo, pAllocator, pVideoSession, true /* do lock */);
+ vkCreateVideoSessionKHR_VkResult_return = vkEnc->vkCreateVideoSessionKHR(
+ device, pCreateInfo, pAllocator, pVideoSession, true /* do lock */);
return vkCreateVideoSessionKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateVideoSessionKHR(
- VkDevice device,
- const VkVideoSessionCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkVideoSessionKHR* pVideoSession)
-{
+ VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue")) {
sOnInvalidDynamicallyCheckedCall("vkCreateVideoSessionKHR", "VK_KHR_video_queue");
}
AEMU_SCOPED_TRACE("vkCreateVideoSessionKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateVideoSessionKHR_VkResult_return = (VkResult)0;
- vkCreateVideoSessionKHR_VkResult_return = vkEnc->vkCreateVideoSessionKHR(device, pCreateInfo, pAllocator, pVideoSession, true /* do lock */);
+ vkCreateVideoSessionKHR_VkResult_return = vkEnc->vkCreateVideoSessionKHR(
+ device, pCreateInfo, pAllocator, pVideoSession, true /* do lock */);
return vkCreateVideoSessionKHR_VkResult_return;
}
-static void entry_vkDestroyVideoSessionKHR(
- VkDevice device,
- VkVideoSessionKHR videoSession,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyVideoSessionKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyVideoSessionKHR(device, videoSession, pAllocator, true /* do lock */);
}
-static void dynCheck_entry_vkDestroyVideoSessionKHR(
- VkDevice device,
- VkVideoSessionKHR videoSession,
- const VkAllocationCallbacks* pAllocator)
-{
+static void dynCheck_entry_vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession,
+ const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue")) {
sOnInvalidDynamicallyCheckedCall("vkDestroyVideoSessionKHR", "VK_KHR_video_queue");
}
AEMU_SCOPED_TRACE("vkDestroyVideoSessionKHR");
@@ -3007,180 +2336,159 @@
vkEnc->vkDestroyVideoSessionKHR(device, videoSession, pAllocator, true /* do lock */);
}
static VkResult entry_vkGetVideoSessionMemoryRequirementsKHR(
- VkDevice device,
- VkVideoSessionKHR videoSession,
- uint32_t* pVideoSessionMemoryRequirementsCount,
- VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements)
-{
+ VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pVideoSessionMemoryRequirementsCount,
+ VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetVideoSessionMemoryRequirementsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetVideoSessionMemoryRequirementsKHR_VkResult_return = (VkResult)0;
- vkGetVideoSessionMemoryRequirementsKHR_VkResult_return = vkEnc->vkGetVideoSessionMemoryRequirementsKHR(device, videoSession, pVideoSessionMemoryRequirementsCount, pVideoSessionMemoryRequirements, true /* do lock */);
+ vkGetVideoSessionMemoryRequirementsKHR_VkResult_return =
+ vkEnc->vkGetVideoSessionMemoryRequirementsKHR(
+ device, videoSession, pVideoSessionMemoryRequirementsCount,
+ pVideoSessionMemoryRequirements, true /* do lock */);
return vkGetVideoSessionMemoryRequirementsKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetVideoSessionMemoryRequirementsKHR(
- VkDevice device,
- VkVideoSessionKHR videoSession,
- uint32_t* pVideoSessionMemoryRequirementsCount,
- VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements)
-{
+ VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pVideoSessionMemoryRequirementsCount,
+ VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetVideoSessionMemoryRequirementsKHR", "VK_KHR_video_queue");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetVideoSessionMemoryRequirementsKHR",
+ "VK_KHR_video_queue");
}
AEMU_SCOPED_TRACE("vkGetVideoSessionMemoryRequirementsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetVideoSessionMemoryRequirementsKHR_VkResult_return = (VkResult)0;
- vkGetVideoSessionMemoryRequirementsKHR_VkResult_return = vkEnc->vkGetVideoSessionMemoryRequirementsKHR(device, videoSession, pVideoSessionMemoryRequirementsCount, pVideoSessionMemoryRequirements, true /* do lock */);
+ vkGetVideoSessionMemoryRequirementsKHR_VkResult_return =
+ vkEnc->vkGetVideoSessionMemoryRequirementsKHR(
+ device, videoSession, pVideoSessionMemoryRequirementsCount,
+ pVideoSessionMemoryRequirements, true /* do lock */);
return vkGetVideoSessionMemoryRequirementsKHR_VkResult_return;
}
static VkResult entry_vkBindVideoSessionMemoryKHR(
- VkDevice device,
- VkVideoSessionKHR videoSession,
- uint32_t videoSessionBindMemoryCount,
- const VkVideoBindMemoryKHR* pVideoSessionBindMemories)
-{
+ VkDevice device, VkVideoSessionKHR videoSession, uint32_t videoSessionBindMemoryCount,
+ const VkVideoBindMemoryKHR* pVideoSessionBindMemories) {
AEMU_SCOPED_TRACE("vkBindVideoSessionMemoryKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindVideoSessionMemoryKHR_VkResult_return = (VkResult)0;
- vkBindVideoSessionMemoryKHR_VkResult_return = vkEnc->vkBindVideoSessionMemoryKHR(device, videoSession, videoSessionBindMemoryCount, pVideoSessionBindMemories, true /* do lock */);
+ vkBindVideoSessionMemoryKHR_VkResult_return =
+ vkEnc->vkBindVideoSessionMemoryKHR(device, videoSession, videoSessionBindMemoryCount,
+ pVideoSessionBindMemories, true /* do lock */);
return vkBindVideoSessionMemoryKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkBindVideoSessionMemoryKHR(
- VkDevice device,
- VkVideoSessionKHR videoSession,
- uint32_t videoSessionBindMemoryCount,
- const VkVideoBindMemoryKHR* pVideoSessionBindMemories)
-{
+ VkDevice device, VkVideoSessionKHR videoSession, uint32_t videoSessionBindMemoryCount,
+ const VkVideoBindMemoryKHR* pVideoSessionBindMemories) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue")) {
sOnInvalidDynamicallyCheckedCall("vkBindVideoSessionMemoryKHR", "VK_KHR_video_queue");
}
AEMU_SCOPED_TRACE("vkBindVideoSessionMemoryKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindVideoSessionMemoryKHR_VkResult_return = (VkResult)0;
- vkBindVideoSessionMemoryKHR_VkResult_return = vkEnc->vkBindVideoSessionMemoryKHR(device, videoSession, videoSessionBindMemoryCount, pVideoSessionBindMemories, true /* do lock */);
+ vkBindVideoSessionMemoryKHR_VkResult_return =
+ vkEnc->vkBindVideoSessionMemoryKHR(device, videoSession, videoSessionBindMemoryCount,
+ pVideoSessionBindMemories, true /* do lock */);
return vkBindVideoSessionMemoryKHR_VkResult_return;
}
static VkResult entry_vkCreateVideoSessionParametersKHR(
- VkDevice device,
- const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkVideoSessionParametersKHR* pVideoSessionParameters)
-{
+ VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) {
AEMU_SCOPED_TRACE("vkCreateVideoSessionParametersKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateVideoSessionParametersKHR_VkResult_return = (VkResult)0;
- vkCreateVideoSessionParametersKHR_VkResult_return = vkEnc->vkCreateVideoSessionParametersKHR(device, pCreateInfo, pAllocator, pVideoSessionParameters, true /* do lock */);
+ vkCreateVideoSessionParametersKHR_VkResult_return = vkEnc->vkCreateVideoSessionParametersKHR(
+ device, pCreateInfo, pAllocator, pVideoSessionParameters, true /* do lock */);
return vkCreateVideoSessionParametersKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateVideoSessionParametersKHR(
- VkDevice device,
- const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkVideoSessionParametersKHR* pVideoSessionParameters)
-{
+ VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue")) {
sOnInvalidDynamicallyCheckedCall("vkCreateVideoSessionParametersKHR", "VK_KHR_video_queue");
}
AEMU_SCOPED_TRACE("vkCreateVideoSessionParametersKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateVideoSessionParametersKHR_VkResult_return = (VkResult)0;
- vkCreateVideoSessionParametersKHR_VkResult_return = vkEnc->vkCreateVideoSessionParametersKHR(device, pCreateInfo, pAllocator, pVideoSessionParameters, true /* do lock */);
+ vkCreateVideoSessionParametersKHR_VkResult_return = vkEnc->vkCreateVideoSessionParametersKHR(
+ device, pCreateInfo, pAllocator, pVideoSessionParameters, true /* do lock */);
return vkCreateVideoSessionParametersKHR_VkResult_return;
}
static VkResult entry_vkUpdateVideoSessionParametersKHR(
- VkDevice device,
- VkVideoSessionParametersKHR videoSessionParameters,
- const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo)
-{
+ VkDevice device, VkVideoSessionParametersKHR videoSessionParameters,
+ const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) {
AEMU_SCOPED_TRACE("vkUpdateVideoSessionParametersKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkUpdateVideoSessionParametersKHR_VkResult_return = (VkResult)0;
- vkUpdateVideoSessionParametersKHR_VkResult_return = vkEnc->vkUpdateVideoSessionParametersKHR(device, videoSessionParameters, pUpdateInfo, true /* do lock */);
+ vkUpdateVideoSessionParametersKHR_VkResult_return = vkEnc->vkUpdateVideoSessionParametersKHR(
+ device, videoSessionParameters, pUpdateInfo, true /* do lock */);
return vkUpdateVideoSessionParametersKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkUpdateVideoSessionParametersKHR(
- VkDevice device,
- VkVideoSessionParametersKHR videoSessionParameters,
- const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo)
-{
+ VkDevice device, VkVideoSessionParametersKHR videoSessionParameters,
+ const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue")) {
sOnInvalidDynamicallyCheckedCall("vkUpdateVideoSessionParametersKHR", "VK_KHR_video_queue");
}
AEMU_SCOPED_TRACE("vkUpdateVideoSessionParametersKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkUpdateVideoSessionParametersKHR_VkResult_return = (VkResult)0;
- vkUpdateVideoSessionParametersKHR_VkResult_return = vkEnc->vkUpdateVideoSessionParametersKHR(device, videoSessionParameters, pUpdateInfo, true /* do lock */);
+ vkUpdateVideoSessionParametersKHR_VkResult_return = vkEnc->vkUpdateVideoSessionParametersKHR(
+ device, videoSessionParameters, pUpdateInfo, true /* do lock */);
return vkUpdateVideoSessionParametersKHR_VkResult_return;
}
static void entry_vkDestroyVideoSessionParametersKHR(
- VkDevice device,
- VkVideoSessionParametersKHR videoSessionParameters,
- const VkAllocationCallbacks* pAllocator)
-{
+ VkDevice device, VkVideoSessionParametersKHR videoSessionParameters,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyVideoSessionParametersKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyVideoSessionParametersKHR(device, videoSessionParameters, pAllocator, true /* do lock */);
+ vkEnc->vkDestroyVideoSessionParametersKHR(device, videoSessionParameters, pAllocator,
+ true /* do lock */);
}
static void dynCheck_entry_vkDestroyVideoSessionParametersKHR(
- VkDevice device,
- VkVideoSessionParametersKHR videoSessionParameters,
- const VkAllocationCallbacks* pAllocator)
-{
+ VkDevice device, VkVideoSessionParametersKHR videoSessionParameters,
+ const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue"))
- {
- sOnInvalidDynamicallyCheckedCall("vkDestroyVideoSessionParametersKHR", "VK_KHR_video_queue");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue")) {
+ sOnInvalidDynamicallyCheckedCall("vkDestroyVideoSessionParametersKHR",
+ "VK_KHR_video_queue");
}
AEMU_SCOPED_TRACE("vkDestroyVideoSessionParametersKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyVideoSessionParametersKHR(device, videoSessionParameters, pAllocator, true /* do lock */);
+ vkEnc->vkDestroyVideoSessionParametersKHR(device, videoSessionParameters, pAllocator,
+ true /* do lock */);
}
-static void entry_vkCmdBeginVideoCodingKHR(
- VkCommandBuffer commandBuffer,
- const VkVideoBeginCodingInfoKHR* pBeginInfo)
-{
+static void entry_vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer,
+ const VkVideoBeginCodingInfoKHR* pBeginInfo) {
AEMU_SCOPED_TRACE("vkCmdBeginVideoCodingKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdBeginVideoCodingKHR(commandBuffer, pBeginInfo, true /* do lock */);
}
-static void dynCheck_entry_vkCmdBeginVideoCodingKHR(
- VkCommandBuffer commandBuffer,
- const VkVideoBeginCodingInfoKHR* pBeginInfo)
-{
+static void dynCheck_entry_vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer,
+ const VkVideoBeginCodingInfoKHR* pBeginInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue")) {
sOnInvalidDynamicallyCheckedCall("vkCmdBeginVideoCodingKHR", "VK_KHR_video_queue");
}
AEMU_SCOPED_TRACE("vkCmdBeginVideoCodingKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdBeginVideoCodingKHR(commandBuffer, pBeginInfo, true /* do lock */);
}
-static void entry_vkCmdEndVideoCodingKHR(
- VkCommandBuffer commandBuffer,
- const VkVideoEndCodingInfoKHR* pEndCodingInfo)
-{
+static void entry_vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer,
+ const VkVideoEndCodingInfoKHR* pEndCodingInfo) {
AEMU_SCOPED_TRACE("vkCmdEndVideoCodingKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdEndVideoCodingKHR(commandBuffer, pEndCodingInfo, true /* do lock */);
}
-static void dynCheck_entry_vkCmdEndVideoCodingKHR(
- VkCommandBuffer commandBuffer,
- const VkVideoEndCodingInfoKHR* pEndCodingInfo)
-{
+static void dynCheck_entry_vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer,
+ const VkVideoEndCodingInfoKHR* pEndCodingInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue")) {
sOnInvalidDynamicallyCheckedCall("vkCmdEndVideoCodingKHR", "VK_KHR_video_queue");
}
AEMU_SCOPED_TRACE("vkCmdEndVideoCodingKHR");
@@ -3188,21 +2496,17 @@
vkEnc->vkCmdEndVideoCodingKHR(commandBuffer, pEndCodingInfo, true /* do lock */);
}
static void entry_vkCmdControlVideoCodingKHR(
- VkCommandBuffer commandBuffer,
- const VkVideoCodingControlInfoKHR* pCodingControlInfo)
-{
+ VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) {
AEMU_SCOPED_TRACE("vkCmdControlVideoCodingKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdControlVideoCodingKHR(commandBuffer, pCodingControlInfo, true /* do lock */);
}
static void dynCheck_entry_vkCmdControlVideoCodingKHR(
- VkCommandBuffer commandBuffer,
- const VkVideoCodingControlInfoKHR* pCodingControlInfo)
-{
+ VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_video_queue")) {
sOnInvalidDynamicallyCheckedCall("vkCmdControlVideoCodingKHR", "VK_KHR_video_queue");
}
AEMU_SCOPED_TRACE("vkCmdControlVideoCodingKHR");
@@ -3211,22 +2515,18 @@
}
#endif
#ifdef VK_KHR_video_decode_queue
-static void entry_vkCmdDecodeVideoKHR(
- VkCommandBuffer commandBuffer,
- const VkVideoDecodeInfoKHR* pFrameInfo)
-{
+static void entry_vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer,
+ const VkVideoDecodeInfoKHR* pFrameInfo) {
AEMU_SCOPED_TRACE("vkCmdDecodeVideoKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdDecodeVideoKHR(commandBuffer, pFrameInfo, true /* do lock */);
}
-static void dynCheck_entry_vkCmdDecodeVideoKHR(
- VkCommandBuffer commandBuffer,
- const VkVideoDecodeInfoKHR* pFrameInfo)
-{
+static void dynCheck_entry_vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer,
+ const VkVideoDecodeInfoKHR* pFrameInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_video_decode_queue"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_video_decode_queue")) {
sOnInvalidDynamicallyCheckedCall("vkCmdDecodeVideoKHR", "VK_KHR_video_decode_queue");
}
AEMU_SCOPED_TRACE("vkCmdDecodeVideoKHR");
@@ -3235,42 +2535,34 @@
}
#endif
#ifdef VK_KHR_dynamic_rendering
-static void entry_vkCmdBeginRenderingKHR(
- VkCommandBuffer commandBuffer,
- const VkRenderingInfoKHR* pRenderingInfo)
-{
+static void entry_vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer,
+ const VkRenderingInfoKHR* pRenderingInfo) {
AEMU_SCOPED_TRACE("vkCmdBeginRenderingKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdBeginRenderingKHR(commandBuffer, pRenderingInfo, true /* do lock */);
}
-static void dynCheck_entry_vkCmdBeginRenderingKHR(
- VkCommandBuffer commandBuffer,
- const VkRenderingInfoKHR* pRenderingInfo)
-{
+static void dynCheck_entry_vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer,
+ const VkRenderingInfoKHR* pRenderingInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering")) {
sOnInvalidDynamicallyCheckedCall("vkCmdBeginRenderingKHR", "VK_KHR_dynamic_rendering");
}
AEMU_SCOPED_TRACE("vkCmdBeginRenderingKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdBeginRenderingKHR(commandBuffer, pRenderingInfo, true /* do lock */);
}
-static void entry_vkCmdEndRenderingKHR(
- VkCommandBuffer commandBuffer)
-{
+static void entry_vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) {
AEMU_SCOPED_TRACE("vkCmdEndRenderingKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdEndRenderingKHR(commandBuffer, true /* do lock */);
}
-static void dynCheck_entry_vkCmdEndRenderingKHR(
- VkCommandBuffer commandBuffer)
-{
+static void dynCheck_entry_vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering")) {
sOnInvalidDynamicallyCheckedCall("vkCmdEndRenderingKHR", "VK_KHR_dynamic_rendering");
}
AEMU_SCOPED_TRACE("vkCmdEndRenderingKHR");
@@ -3281,174 +2573,141 @@
#ifdef VK_KHR_multiview
#endif
#ifdef VK_KHR_get_physical_device_properties2
-static void entry_vkGetPhysicalDeviceFeatures2KHR(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceFeatures2* pFeatures)
-{
+static void entry_vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceFeatures2* pFeatures) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures, true /* do lock */);
}
-static void entry_vkGetPhysicalDeviceProperties2KHR(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceProperties2* pProperties)
-{
+static void entry_vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceProperties2* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties, true /* do lock */);
}
-static void entry_vkGetPhysicalDeviceFormatProperties2KHR(
- VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties2* pFormatProperties)
-{
+static void entry_vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2* pFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties, true /* do lock */);
+ vkEnc->vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties,
+ true /* do lock */);
}
static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2KHR(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
- VkImageFormatProperties2* pImageFormatProperties)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+ VkImageFormatProperties2* pImageFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = resources->on_vkGetPhysicalDeviceImageFormatProperties2KHR(vkEnc, VK_SUCCESS, physicalDevice, pImageFormatInfo, pImageFormatProperties);
+ vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return =
+ resources->on_vkGetPhysicalDeviceImageFormatProperties2KHR(
+ vkEnc, VK_SUCCESS, physicalDevice, pImageFormatInfo, pImageFormatProperties);
return vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return;
}
static void entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR(
- VkPhysicalDevice physicalDevice,
- uint32_t* pQueueFamilyPropertyCount,
- VkQueueFamilyProperties2* pQueueFamilyProperties)
-{
+ VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2* pQueueFamilyProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, true /* do lock */);
+ vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount,
+ pQueueFamilyProperties, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceMemoryProperties2KHR(
- VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
-{
+ VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties, true /* do lock */);
+ vkEnc->vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties,
+ true /* do lock */);
}
static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
- uint32_t* pPropertyCount,
- VkSparseImageFormatProperties2* pProperties)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+ uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties, true /* do lock */);
+ vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+ physicalDevice, pFormatInfo, pPropertyCount, pProperties, true /* do lock */);
}
#endif
#ifdef VK_KHR_device_group
static void entry_vkGetDeviceGroupPeerMemoryFeaturesKHR(
- VkDevice device,
- uint32_t heapIndex,
- uint32_t localDeviceIndex,
- uint32_t remoteDeviceIndex,
- VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
-{
+ VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeaturesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, true /* do lock */);
+ vkEnc->vkGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex,
+ remoteDeviceIndex, pPeerMemoryFeatures,
+ true /* do lock */);
}
static void dynCheck_entry_vkGetDeviceGroupPeerMemoryFeaturesKHR(
- VkDevice device,
- uint32_t heapIndex,
- uint32_t localDeviceIndex,
- uint32_t remoteDeviceIndex,
- VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
-{
+ VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_device_group"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceGroupPeerMemoryFeaturesKHR", "VK_KHR_device_group");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_device_group")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetDeviceGroupPeerMemoryFeaturesKHR",
+ "VK_KHR_device_group");
}
AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeaturesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, true /* do lock */);
+ vkEnc->vkGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex,
+ remoteDeviceIndex, pPeerMemoryFeatures,
+ true /* do lock */);
}
-static void entry_vkCmdSetDeviceMaskKHR(
- VkCommandBuffer commandBuffer,
- uint32_t deviceMask)
-{
+static void entry_vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) {
AEMU_SCOPED_TRACE("vkCmdSetDeviceMaskKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetDeviceMaskKHR(commandBuffer, deviceMask, true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetDeviceMaskKHR(
- VkCommandBuffer commandBuffer,
- uint32_t deviceMask)
-{
+static void dynCheck_entry_vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer,
+ uint32_t deviceMask) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_device_group"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_device_group")) {
sOnInvalidDynamicallyCheckedCall("vkCmdSetDeviceMaskKHR", "VK_KHR_device_group");
}
AEMU_SCOPED_TRACE("vkCmdSetDeviceMaskKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetDeviceMaskKHR(commandBuffer, deviceMask, true /* do lock */);
}
-static void entry_vkCmdDispatchBaseKHR(
- VkCommandBuffer commandBuffer,
- uint32_t baseGroupX,
- uint32_t baseGroupY,
- uint32_t baseGroupZ,
- uint32_t groupCountX,
- uint32_t groupCountY,
- uint32_t groupCountZ)
-{
+static void entry_vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX,
+ uint32_t baseGroupY, uint32_t baseGroupZ,
+ uint32_t groupCountX, uint32_t groupCountY,
+ uint32_t groupCountZ) {
AEMU_SCOPED_TRACE("vkCmdDispatchBaseKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ, true /* do lock */);
+ vkEnc->vkCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX,
+ groupCountY, groupCountZ, true /* do lock */);
}
-static void dynCheck_entry_vkCmdDispatchBaseKHR(
- VkCommandBuffer commandBuffer,
- uint32_t baseGroupX,
- uint32_t baseGroupY,
- uint32_t baseGroupZ,
- uint32_t groupCountX,
- uint32_t groupCountY,
- uint32_t groupCountZ)
-{
+static void dynCheck_entry_vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX,
+ uint32_t baseGroupY, uint32_t baseGroupZ,
+ uint32_t groupCountX, uint32_t groupCountY,
+ uint32_t groupCountZ) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_device_group"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_device_group")) {
sOnInvalidDynamicallyCheckedCall("vkCmdDispatchBaseKHR", "VK_KHR_device_group");
}
AEMU_SCOPED_TRACE("vkCmdDispatchBaseKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ, true /* do lock */);
+ vkEnc->vkCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX,
+ groupCountY, groupCountZ, true /* do lock */);
}
#endif
#ifdef VK_KHR_shader_draw_parameters
#endif
#ifdef VK_KHR_maintenance1
-static void entry_vkTrimCommandPoolKHR(
- VkDevice device,
- VkCommandPool commandPool,
- VkCommandPoolTrimFlags flags)
-{
+static void entry_vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags) {
AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkTrimCommandPoolKHR(device, commandPool, flags, true /* do lock */);
}
-static void dynCheck_entry_vkTrimCommandPoolKHR(
- VkDevice device,
- VkCommandPool commandPool,
- VkCommandPoolTrimFlags flags)
-{
+static void dynCheck_entry_vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool,
+ VkCommandPoolTrimFlags flags) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance1"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance1")) {
sOnInvalidDynamicallyCheckedCall("vkTrimCommandPoolKHR", "VK_KHR_maintenance1");
}
AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR");
@@ -3458,143 +2717,126 @@
#endif
#ifdef VK_KHR_device_group_creation
static VkResult entry_vkEnumeratePhysicalDeviceGroupsKHR(
- VkInstance instance,
- uint32_t* pPhysicalDeviceGroupCount,
- VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
-{
+ VkInstance instance, uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroupsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return = (VkResult)0;
- vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return = vkEnc->vkEnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, true /* do lock */);
+ vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return = vkEnc->vkEnumeratePhysicalDeviceGroupsKHR(
+ instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, true /* do lock */);
return vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_external_memory_capabilities
static void entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
- VkExternalBufferProperties* pExternalBufferProperties)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
+ VkExternalBufferProperties* pExternalBufferProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferPropertiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties, true /* do lock */);
+ vkEnc->vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+ physicalDevice, pExternalBufferInfo, pExternalBufferProperties, true /* do lock */);
}
#endif
#ifdef VK_KHR_external_memory
#endif
#ifdef VK_KHR_external_memory_win32
static VkResult entry_vkGetMemoryWin32HandleKHR(
- VkDevice device,
- const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
- HANDLE* pHandle)
-{
+ VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {
AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryWin32HandleKHR_VkResult_return = (VkResult)0;
- vkGetMemoryWin32HandleKHR_VkResult_return = vkEnc->vkGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle, true /* do lock */);
+ vkGetMemoryWin32HandleKHR_VkResult_return =
+ vkEnc->vkGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle, true /* do lock */);
return vkGetMemoryWin32HandleKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetMemoryWin32HandleKHR(
- VkDevice device,
- const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
- HANDLE* pHandle)
-{
+ VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_external_memory_win32"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetMemoryWin32HandleKHR", "VK_KHR_external_memory_win32");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_external_memory_win32")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetMemoryWin32HandleKHR",
+ "VK_KHR_external_memory_win32");
}
AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryWin32HandleKHR_VkResult_return = (VkResult)0;
- vkGetMemoryWin32HandleKHR_VkResult_return = vkEnc->vkGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle, true /* do lock */);
+ vkGetMemoryWin32HandleKHR_VkResult_return =
+ vkEnc->vkGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle, true /* do lock */);
return vkGetMemoryWin32HandleKHR_VkResult_return;
}
static VkResult entry_vkGetMemoryWin32HandlePropertiesKHR(
- VkDevice device,
- VkExternalMemoryHandleTypeFlagBits handleType,
- HANDLE handle,
- VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
-{
+ VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle,
+ VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) {
AEMU_SCOPED_TRACE("vkGetMemoryWin32HandlePropertiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = (VkResult)0;
- vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = vkEnc->vkGetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties, true /* do lock */);
+ vkGetMemoryWin32HandlePropertiesKHR_VkResult_return =
+ vkEnc->vkGetMemoryWin32HandlePropertiesKHR(
+ device, handleType, handle, pMemoryWin32HandleProperties, true /* do lock */);
return vkGetMemoryWin32HandlePropertiesKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetMemoryWin32HandlePropertiesKHR(
- VkDevice device,
- VkExternalMemoryHandleTypeFlagBits handleType,
- HANDLE handle,
- VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
-{
+ VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle,
+ VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_external_memory_win32"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetMemoryWin32HandlePropertiesKHR", "VK_KHR_external_memory_win32");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_external_memory_win32")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetMemoryWin32HandlePropertiesKHR",
+ "VK_KHR_external_memory_win32");
}
AEMU_SCOPED_TRACE("vkGetMemoryWin32HandlePropertiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = (VkResult)0;
- vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = vkEnc->vkGetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties, true /* do lock */);
+ vkGetMemoryWin32HandlePropertiesKHR_VkResult_return =
+ vkEnc->vkGetMemoryWin32HandlePropertiesKHR(
+ device, handleType, handle, pMemoryWin32HandleProperties, true /* do lock */);
return vkGetMemoryWin32HandlePropertiesKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_external_memory_fd
-static VkResult entry_vkGetMemoryFdKHR(
- VkDevice device,
- const VkMemoryGetFdInfoKHR* pGetFdInfo,
- int* pFd)
-{
+static VkResult entry_vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo,
+ int* pFd) {
AEMU_SCOPED_TRACE("vkGetMemoryFdKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryFdKHR_VkResult_return = (VkResult)0;
- vkGetMemoryFdKHR_VkResult_return = vkEnc->vkGetMemoryFdKHR(device, pGetFdInfo, pFd, true /* do lock */);
+ vkGetMemoryFdKHR_VkResult_return =
+ vkEnc->vkGetMemoryFdKHR(device, pGetFdInfo, pFd, true /* do lock */);
return vkGetMemoryFdKHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetMemoryFdKHR(
- VkDevice device,
- const VkMemoryGetFdInfoKHR* pGetFdInfo,
- int* pFd)
-{
+static VkResult dynCheck_entry_vkGetMemoryFdKHR(VkDevice device,
+ const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_external_memory_fd"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_external_memory_fd")) {
sOnInvalidDynamicallyCheckedCall("vkGetMemoryFdKHR", "VK_KHR_external_memory_fd");
}
AEMU_SCOPED_TRACE("vkGetMemoryFdKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryFdKHR_VkResult_return = (VkResult)0;
- vkGetMemoryFdKHR_VkResult_return = vkEnc->vkGetMemoryFdKHR(device, pGetFdInfo, pFd, true /* do lock */);
+ vkGetMemoryFdKHR_VkResult_return =
+ vkEnc->vkGetMemoryFdKHR(device, pGetFdInfo, pFd, true /* do lock */);
return vkGetMemoryFdKHR_VkResult_return;
}
-static VkResult entry_vkGetMemoryFdPropertiesKHR(
- VkDevice device,
- VkExternalMemoryHandleTypeFlagBits handleType,
- int fd,
- VkMemoryFdPropertiesKHR* pMemoryFdProperties)
-{
+static VkResult entry_vkGetMemoryFdPropertiesKHR(VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ int fd,
+ VkMemoryFdPropertiesKHR* pMemoryFdProperties) {
AEMU_SCOPED_TRACE("vkGetMemoryFdPropertiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryFdPropertiesKHR_VkResult_return = (VkResult)0;
- vkGetMemoryFdPropertiesKHR_VkResult_return = vkEnc->vkGetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties, true /* do lock */);
+ vkGetMemoryFdPropertiesKHR_VkResult_return = vkEnc->vkGetMemoryFdPropertiesKHR(
+ device, handleType, fd, pMemoryFdProperties, true /* do lock */);
return vkGetMemoryFdPropertiesKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetMemoryFdPropertiesKHR(
- VkDevice device,
- VkExternalMemoryHandleTypeFlagBits handleType,
- int fd,
- VkMemoryFdPropertiesKHR* pMemoryFdProperties)
-{
+ VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd,
+ VkMemoryFdPropertiesKHR* pMemoryFdProperties) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_external_memory_fd"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_external_memory_fd")) {
sOnInvalidDynamicallyCheckedCall("vkGetMemoryFdPropertiesKHR", "VK_KHR_external_memory_fd");
}
AEMU_SCOPED_TRACE("vkGetMemoryFdPropertiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryFdPropertiesKHR_VkResult_return = (VkResult)0;
- vkGetMemoryFdPropertiesKHR_VkResult_return = vkEnc->vkGetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties, true /* do lock */);
+ vkGetMemoryFdPropertiesKHR_VkResult_return = vkEnc->vkGetMemoryFdPropertiesKHR(
+ device, handleType, fd, pMemoryFdProperties, true /* do lock */);
return vkGetMemoryFdPropertiesKHR_VkResult_return;
}
#endif
@@ -3604,183 +2846,159 @@
static void entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
- VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
-{
+ VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, true /* do lock */);
+ vkEnc->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+ physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, true /* do lock */);
}
#endif
#ifdef VK_KHR_external_semaphore
#endif
#ifdef VK_KHR_external_semaphore_win32
static VkResult entry_vkImportSemaphoreWin32HandleKHR(
- VkDevice device,
- const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
-{
+ VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) {
AEMU_SCOPED_TRACE("vkImportSemaphoreWin32HandleKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkImportSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
- vkImportSemaphoreWin32HandleKHR_VkResult_return = vkEnc->vkImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo, true /* do lock */);
+ vkImportSemaphoreWin32HandleKHR_VkResult_return = vkEnc->vkImportSemaphoreWin32HandleKHR(
+ device, pImportSemaphoreWin32HandleInfo, true /* do lock */);
return vkImportSemaphoreWin32HandleKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkImportSemaphoreWin32HandleKHR(
- VkDevice device,
- const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
-{
+ VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_win32"))
- {
- sOnInvalidDynamicallyCheckedCall("vkImportSemaphoreWin32HandleKHR", "VK_KHR_external_semaphore_win32");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_win32")) {
+ sOnInvalidDynamicallyCheckedCall("vkImportSemaphoreWin32HandleKHR",
+ "VK_KHR_external_semaphore_win32");
}
AEMU_SCOPED_TRACE("vkImportSemaphoreWin32HandleKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkImportSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
- vkImportSemaphoreWin32HandleKHR_VkResult_return = vkEnc->vkImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo, true /* do lock */);
+ vkImportSemaphoreWin32HandleKHR_VkResult_return = vkEnc->vkImportSemaphoreWin32HandleKHR(
+ device, pImportSemaphoreWin32HandleInfo, true /* do lock */);
return vkImportSemaphoreWin32HandleKHR_VkResult_return;
}
static VkResult entry_vkGetSemaphoreWin32HandleKHR(
- VkDevice device,
- const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
- HANDLE* pHandle)
-{
+ VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {
AEMU_SCOPED_TRACE("vkGetSemaphoreWin32HandleKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
- vkGetSemaphoreWin32HandleKHR_VkResult_return = vkEnc->vkGetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle, true /* do lock */);
+ vkGetSemaphoreWin32HandleKHR_VkResult_return = vkEnc->vkGetSemaphoreWin32HandleKHR(
+ device, pGetWin32HandleInfo, pHandle, true /* do lock */);
return vkGetSemaphoreWin32HandleKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetSemaphoreWin32HandleKHR(
- VkDevice device,
- const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
- HANDLE* pHandle)
-{
+ VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_win32"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetSemaphoreWin32HandleKHR", "VK_KHR_external_semaphore_win32");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_win32")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetSemaphoreWin32HandleKHR",
+ "VK_KHR_external_semaphore_win32");
}
AEMU_SCOPED_TRACE("vkGetSemaphoreWin32HandleKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
- vkGetSemaphoreWin32HandleKHR_VkResult_return = vkEnc->vkGetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle, true /* do lock */);
+ vkGetSemaphoreWin32HandleKHR_VkResult_return = vkEnc->vkGetSemaphoreWin32HandleKHR(
+ device, pGetWin32HandleInfo, pHandle, true /* do lock */);
return vkGetSemaphoreWin32HandleKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_external_semaphore_fd
static VkResult entry_vkImportSemaphoreFdKHR(
- VkDevice device,
- const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
-{
+ VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkImportSemaphoreFdKHR_VkResult_return = resources->on_vkImportSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pImportSemaphoreFdInfo);
+ vkImportSemaphoreFdKHR_VkResult_return =
+ resources->on_vkImportSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pImportSemaphoreFdInfo);
return vkImportSemaphoreFdKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkImportSemaphoreFdKHR(
- VkDevice device,
- const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
-{
+ VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd")) {
sOnInvalidDynamicallyCheckedCall("vkImportSemaphoreFdKHR", "VK_KHR_external_semaphore_fd");
}
AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
- vkImportSemaphoreFdKHR_VkResult_return = resources->on_vkImportSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pImportSemaphoreFdInfo);
+ vkImportSemaphoreFdKHR_VkResult_return =
+ resources->on_vkImportSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pImportSemaphoreFdInfo);
return vkImportSemaphoreFdKHR_VkResult_return;
}
-static VkResult entry_vkGetSemaphoreFdKHR(
- VkDevice device,
- const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
- int* pFd)
-{
+static VkResult entry_vkGetSemaphoreFdKHR(VkDevice device,
+ const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) {
AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkGetSemaphoreFdKHR_VkResult_return = resources->on_vkGetSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
+ vkGetSemaphoreFdKHR_VkResult_return =
+ resources->on_vkGetSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
return vkGetSemaphoreFdKHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetSemaphoreFdKHR(
- VkDevice device,
- const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
- int* pFd)
-{
+static VkResult dynCheck_entry_vkGetSemaphoreFdKHR(VkDevice device,
+ const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+ int* pFd) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd")) {
sOnInvalidDynamicallyCheckedCall("vkGetSemaphoreFdKHR", "VK_KHR_external_semaphore_fd");
}
AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
- vkGetSemaphoreFdKHR_VkResult_return = resources->on_vkGetSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
+ vkGetSemaphoreFdKHR_VkResult_return =
+ resources->on_vkGetSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
return vkGetSemaphoreFdKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_push_descriptor
-static void entry_vkCmdPushDescriptorSetKHR(
- VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipelineLayout layout,
- uint32_t set,
- uint32_t descriptorWriteCount,
- const VkWriteDescriptorSet* pDescriptorWrites)
-{
+static void entry_vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout, uint32_t set,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet* pDescriptorWrites) {
AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites, true /* do lock */);
+ vkEnc->vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set,
+ descriptorWriteCount, pDescriptorWrites, true /* do lock */);
}
static void dynCheck_entry_vkCmdPushDescriptorSetKHR(
- VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipelineLayout layout,
- uint32_t set,
- uint32_t descriptorWriteCount,
- const VkWriteDescriptorSet* pDescriptorWrites)
-{
+ VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
+ uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_push_descriptor"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_push_descriptor")) {
sOnInvalidDynamicallyCheckedCall("vkCmdPushDescriptorSetKHR", "VK_KHR_push_descriptor");
}
AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites, true /* do lock */);
+ vkEnc->vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set,
+ descriptorWriteCount, pDescriptorWrites, true /* do lock */);
}
static void entry_vkCmdPushDescriptorSetWithTemplateKHR(
- VkCommandBuffer commandBuffer,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- VkPipelineLayout layout,
- uint32_t set,
- const void* pData)
-{
+ VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ VkPipelineLayout layout, uint32_t set, const void* pData) {
AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetWithTemplateKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData, true /* do lock */);
+ vkEnc->vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout,
+ set, pData, true /* do lock */);
}
static void dynCheck_entry_vkCmdPushDescriptorSetWithTemplateKHR(
- VkCommandBuffer commandBuffer,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- VkPipelineLayout layout,
- uint32_t set,
- const void* pData)
-{
+ VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ VkPipelineLayout layout, uint32_t set, const void* pData) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_push_descriptor"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdPushDescriptorSetWithTemplateKHR", "VK_KHR_push_descriptor");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_push_descriptor")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdPushDescriptorSetWithTemplateKHR",
+ "VK_KHR_push_descriptor");
}
AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetWithTemplateKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData, true /* do lock */);
+ vkEnc->vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout,
+ set, pData, true /* do lock */);
}
#endif
#ifdef VK_KHR_shader_float16_int8
@@ -3791,179 +3009,162 @@
#endif
#ifdef VK_KHR_descriptor_update_template
static VkResult entry_vkCreateDescriptorUpdateTemplateKHR(
- VkDevice device,
- const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+ VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
-{
+ VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
- vkCreateDescriptorUpdateTemplateKHR_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, true /* do lock */);
+ vkCreateDescriptorUpdateTemplateKHR_VkResult_return =
+ vkEnc->vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator,
+ pDescriptorUpdateTemplate, true /* do lock */);
return vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateDescriptorUpdateTemplateKHR(
- VkDevice device,
- const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+ VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
- VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
-{
+ VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCreateDescriptorUpdateTemplateKHR", "VK_KHR_descriptor_update_template");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template")) {
+ sOnInvalidDynamicallyCheckedCall("vkCreateDescriptorUpdateTemplateKHR",
+ "VK_KHR_descriptor_update_template");
}
AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
- vkCreateDescriptorUpdateTemplateKHR_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, true /* do lock */);
+ vkCreateDescriptorUpdateTemplateKHR_VkResult_return =
+ vkEnc->vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator,
+ pDescriptorUpdateTemplate, true /* do lock */);
return vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
}
static void entry_vkDestroyDescriptorUpdateTemplateKHR(
- VkDevice device,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const VkAllocationCallbacks* pAllocator)
-{
+ VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator, true /* do lock */);
+ vkEnc->vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator,
+ true /* do lock */);
}
static void dynCheck_entry_vkDestroyDescriptorUpdateTemplateKHR(
- VkDevice device,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const VkAllocationCallbacks* pAllocator)
-{
+ VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template"))
- {
- sOnInvalidDynamicallyCheckedCall("vkDestroyDescriptorUpdateTemplateKHR", "VK_KHR_descriptor_update_template");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template")) {
+ sOnInvalidDynamicallyCheckedCall("vkDestroyDescriptorUpdateTemplateKHR",
+ "VK_KHR_descriptor_update_template");
}
AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator, true /* do lock */);
+ vkEnc->vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator,
+ true /* do lock */);
}
static void entry_vkUpdateDescriptorSetWithTemplateKHR(
- VkDevice device,
- VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const void* pData)
-{
+ VkDevice device, VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData, true /* do lock */);
+ vkEnc->vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate,
+ pData, true /* do lock */);
}
static void dynCheck_entry_vkUpdateDescriptorSetWithTemplateKHR(
- VkDevice device,
- VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const void* pData)
-{
+ VkDevice device, VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template"))
- {
- sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplateKHR", "VK_KHR_descriptor_update_template");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template")) {
+ sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplateKHR",
+ "VK_KHR_descriptor_update_template");
}
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData, true /* do lock */);
+ vkEnc->vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate,
+ pData, true /* do lock */);
}
#endif
#ifdef VK_KHR_imageless_framebuffer
#endif
#ifdef VK_KHR_create_renderpass2
-static VkResult entry_vkCreateRenderPass2KHR(
- VkDevice device,
- const VkRenderPassCreateInfo2* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass)
-{
+static VkResult entry_vkCreateRenderPass2KHR(VkDevice device,
+ const VkRenderPassCreateInfo2* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass) {
AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
- vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
+ vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(
+ device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
return vkCreateRenderPass2KHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkCreateRenderPass2KHR(
- VkDevice device,
- const VkRenderPassCreateInfo2* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkRenderPass* pRenderPass)
-{
+static VkResult dynCheck_entry_vkCreateRenderPass2KHR(VkDevice device,
+ const VkRenderPassCreateInfo2* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkRenderPass* pRenderPass) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2")) {
sOnInvalidDynamicallyCheckedCall("vkCreateRenderPass2KHR", "VK_KHR_create_renderpass2");
}
AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
- vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
+ vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(
+ device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
return vkCreateRenderPass2KHR_VkResult_return;
}
-static void entry_vkCmdBeginRenderPass2KHR(
- VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo* pRenderPassBegin,
- const VkSubpassBeginInfo* pSubpassBeginInfo)
-{
+static void entry_vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ const VkSubpassBeginInfo* pSubpassBeginInfo) {
AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo, true /* do lock */);
+ vkEnc->vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo,
+ true /* do lock */);
}
-static void dynCheck_entry_vkCmdBeginRenderPass2KHR(
- VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo* pRenderPassBegin,
- const VkSubpassBeginInfo* pSubpassBeginInfo)
-{
+static void dynCheck_entry_vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo* pRenderPassBegin,
+ const VkSubpassBeginInfo* pSubpassBeginInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2")) {
sOnInvalidDynamicallyCheckedCall("vkCmdBeginRenderPass2KHR", "VK_KHR_create_renderpass2");
}
AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo, true /* do lock */);
+ vkEnc->vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo,
+ true /* do lock */);
}
-static void entry_vkCmdNextSubpass2KHR(
- VkCommandBuffer commandBuffer,
- const VkSubpassBeginInfo* pSubpassBeginInfo,
- const VkSubpassEndInfo* pSubpassEndInfo)
-{
+static void entry_vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfo* pSubpassBeginInfo,
+ const VkSubpassEndInfo* pSubpassEndInfo) {
AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo, true /* do lock */);
+ vkEnc->vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo,
+ true /* do lock */);
}
-static void dynCheck_entry_vkCmdNextSubpass2KHR(
- VkCommandBuffer commandBuffer,
- const VkSubpassBeginInfo* pSubpassBeginInfo,
- const VkSubpassEndInfo* pSubpassEndInfo)
-{
+static void dynCheck_entry_vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfo* pSubpassBeginInfo,
+ const VkSubpassEndInfo* pSubpassEndInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2")) {
sOnInvalidDynamicallyCheckedCall("vkCmdNextSubpass2KHR", "VK_KHR_create_renderpass2");
}
AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo, true /* do lock */);
+ vkEnc->vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo,
+ true /* do lock */);
}
-static void entry_vkCmdEndRenderPass2KHR(
- VkCommandBuffer commandBuffer,
- const VkSubpassEndInfo* pSubpassEndInfo)
-{
+static void entry_vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
+ const VkSubpassEndInfo* pSubpassEndInfo) {
AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo, true /* do lock */);
}
-static void dynCheck_entry_vkCmdEndRenderPass2KHR(
- VkCommandBuffer commandBuffer,
- const VkSubpassEndInfo* pSubpassEndInfo)
-{
+static void dynCheck_entry_vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
+ const VkSubpassEndInfo* pSubpassEndInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2")) {
sOnInvalidDynamicallyCheckedCall("vkCmdEndRenderPass2KHR", "VK_KHR_create_renderpass2");
}
AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR");
@@ -3972,217 +3173,188 @@
}
#endif
#ifdef VK_KHR_shared_presentable_image
-static VkResult entry_vkGetSwapchainStatusKHR(
- VkDevice device,
- VkSwapchainKHR swapchain)
-{
+static VkResult entry_vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) {
AEMU_SCOPED_TRACE("vkGetSwapchainStatusKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSwapchainStatusKHR_VkResult_return = (VkResult)0;
- vkGetSwapchainStatusKHR_VkResult_return = vkEnc->vkGetSwapchainStatusKHR(device, swapchain, true /* do lock */);
+ vkGetSwapchainStatusKHR_VkResult_return =
+ vkEnc->vkGetSwapchainStatusKHR(device, swapchain, true /* do lock */);
return vkGetSwapchainStatusKHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetSwapchainStatusKHR(
- VkDevice device,
- VkSwapchainKHR swapchain)
-{
+static VkResult dynCheck_entry_vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_shared_presentable_image"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetSwapchainStatusKHR", "VK_KHR_shared_presentable_image");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_shared_presentable_image")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetSwapchainStatusKHR",
+ "VK_KHR_shared_presentable_image");
}
AEMU_SCOPED_TRACE("vkGetSwapchainStatusKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSwapchainStatusKHR_VkResult_return = (VkResult)0;
- vkGetSwapchainStatusKHR_VkResult_return = vkEnc->vkGetSwapchainStatusKHR(device, swapchain, true /* do lock */);
+ vkGetSwapchainStatusKHR_VkResult_return =
+ vkEnc->vkGetSwapchainStatusKHR(device, swapchain, true /* do lock */);
return vkGetSwapchainStatusKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_external_fence_capabilities
static void entry_vkGetPhysicalDeviceExternalFencePropertiesKHR(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
- VkExternalFenceProperties* pExternalFenceProperties)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
+ VkExternalFenceProperties* pExternalFenceProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFencePropertiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
- resources->on_vkGetPhysicalDeviceExternalFencePropertiesKHR(vkEnc, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+ resources->on_vkGetPhysicalDeviceExternalFencePropertiesKHR(
+ vkEnc, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
}
#endif
#ifdef VK_KHR_external_fence
#endif
#ifdef VK_KHR_external_fence_win32
static VkResult entry_vkImportFenceWin32HandleKHR(
- VkDevice device,
- const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
-{
+ VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) {
AEMU_SCOPED_TRACE("vkImportFenceWin32HandleKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkImportFenceWin32HandleKHR_VkResult_return = (VkResult)0;
- vkImportFenceWin32HandleKHR_VkResult_return = vkEnc->vkImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo, true /* do lock */);
+ vkImportFenceWin32HandleKHR_VkResult_return =
+ vkEnc->vkImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo, true /* do lock */);
return vkImportFenceWin32HandleKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkImportFenceWin32HandleKHR(
- VkDevice device,
- const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
-{
+ VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_external_fence_win32"))
- {
- sOnInvalidDynamicallyCheckedCall("vkImportFenceWin32HandleKHR", "VK_KHR_external_fence_win32");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_external_fence_win32")) {
+ sOnInvalidDynamicallyCheckedCall("vkImportFenceWin32HandleKHR",
+ "VK_KHR_external_fence_win32");
}
AEMU_SCOPED_TRACE("vkImportFenceWin32HandleKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkImportFenceWin32HandleKHR_VkResult_return = (VkResult)0;
- vkImportFenceWin32HandleKHR_VkResult_return = vkEnc->vkImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo, true /* do lock */);
+ vkImportFenceWin32HandleKHR_VkResult_return =
+ vkEnc->vkImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo, true /* do lock */);
return vkImportFenceWin32HandleKHR_VkResult_return;
}
static VkResult entry_vkGetFenceWin32HandleKHR(
- VkDevice device,
- const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
- HANDLE* pHandle)
-{
+ VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {
AEMU_SCOPED_TRACE("vkGetFenceWin32HandleKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetFenceWin32HandleKHR_VkResult_return = (VkResult)0;
- vkGetFenceWin32HandleKHR_VkResult_return = vkEnc->vkGetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle, true /* do lock */);
+ vkGetFenceWin32HandleKHR_VkResult_return =
+ vkEnc->vkGetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle, true /* do lock */);
return vkGetFenceWin32HandleKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetFenceWin32HandleKHR(
- VkDevice device,
- const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
- HANDLE* pHandle)
-{
+ VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_external_fence_win32"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_external_fence_win32")) {
sOnInvalidDynamicallyCheckedCall("vkGetFenceWin32HandleKHR", "VK_KHR_external_fence_win32");
}
AEMU_SCOPED_TRACE("vkGetFenceWin32HandleKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetFenceWin32HandleKHR_VkResult_return = (VkResult)0;
- vkGetFenceWin32HandleKHR_VkResult_return = vkEnc->vkGetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle, true /* do lock */);
+ vkGetFenceWin32HandleKHR_VkResult_return =
+ vkEnc->vkGetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle, true /* do lock */);
return vkGetFenceWin32HandleKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_external_fence_fd
-static VkResult entry_vkImportFenceFdKHR(
- VkDevice device,
- const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
-{
+static VkResult entry_vkImportFenceFdKHR(VkDevice device,
+ const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
AEMU_SCOPED_TRACE("vkImportFenceFdKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkImportFenceFdKHR_VkResult_return = resources->on_vkImportFenceFdKHR(vkEnc, VK_SUCCESS, device, pImportFenceFdInfo);
+ vkImportFenceFdKHR_VkResult_return =
+ resources->on_vkImportFenceFdKHR(vkEnc, VK_SUCCESS, device, pImportFenceFdInfo);
return vkImportFenceFdKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkImportFenceFdKHR(
- VkDevice device,
- const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
-{
+ VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd")) {
sOnInvalidDynamicallyCheckedCall("vkImportFenceFdKHR", "VK_KHR_external_fence_fd");
}
AEMU_SCOPED_TRACE("vkImportFenceFdKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
- vkImportFenceFdKHR_VkResult_return = resources->on_vkImportFenceFdKHR(vkEnc, VK_SUCCESS, device, pImportFenceFdInfo);
+ vkImportFenceFdKHR_VkResult_return =
+ resources->on_vkImportFenceFdKHR(vkEnc, VK_SUCCESS, device, pImportFenceFdInfo);
return vkImportFenceFdKHR_VkResult_return;
}
-static VkResult entry_vkGetFenceFdKHR(
- VkDevice device,
- const VkFenceGetFdInfoKHR* pGetFdInfo,
- int* pFd)
-{
+static VkResult entry_vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo,
+ int* pFd) {
AEMU_SCOPED_TRACE("vkGetFenceFdKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkGetFenceFdKHR_VkResult_return = resources->on_vkGetFenceFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
+ vkGetFenceFdKHR_VkResult_return =
+ resources->on_vkGetFenceFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
return vkGetFenceFdKHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetFenceFdKHR(
- VkDevice device,
- const VkFenceGetFdInfoKHR* pGetFdInfo,
- int* pFd)
-{
+static VkResult dynCheck_entry_vkGetFenceFdKHR(VkDevice device,
+ const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd")) {
sOnInvalidDynamicallyCheckedCall("vkGetFenceFdKHR", "VK_KHR_external_fence_fd");
}
AEMU_SCOPED_TRACE("vkGetFenceFdKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
- vkGetFenceFdKHR_VkResult_return = resources->on_vkGetFenceFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
+ vkGetFenceFdKHR_VkResult_return =
+ resources->on_vkGetFenceFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
return vkGetFenceFdKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_performance_query
static VkResult entry_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- uint32_t* pCounterCount,
- VkPerformanceCounterKHR* pCounters,
- VkPerformanceCounterDescriptionKHR* pCounterDescriptions)
-{
+ VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount,
+ VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions) {
AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_VkResult_return = (VkResult)0;
- vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_VkResult_return = vkEnc->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions, true /* do lock */);
+ VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_VkResult_return =
+ (VkResult)0;
+ vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_VkResult_return =
+ vkEnc->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+ physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions,
+ true /* do lock */);
return vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_VkResult_return;
}
static void entry_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
VkPhysicalDevice physicalDevice,
- const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo,
- uint32_t* pNumPasses)
-{
+ const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice, pPerformanceQueryCreateInfo, pNumPasses, true /* do lock */);
+ vkEnc->vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
+ physicalDevice, pPerformanceQueryCreateInfo, pNumPasses, true /* do lock */);
}
-static VkResult entry_vkAcquireProfilingLockKHR(
- VkDevice device,
- const VkAcquireProfilingLockInfoKHR* pInfo)
-{
+static VkResult entry_vkAcquireProfilingLockKHR(VkDevice device,
+ const VkAcquireProfilingLockInfoKHR* pInfo) {
AEMU_SCOPED_TRACE("vkAcquireProfilingLockKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquireProfilingLockKHR_VkResult_return = (VkResult)0;
- vkAcquireProfilingLockKHR_VkResult_return = vkEnc->vkAcquireProfilingLockKHR(device, pInfo, true /* do lock */);
+ vkAcquireProfilingLockKHR_VkResult_return =
+ vkEnc->vkAcquireProfilingLockKHR(device, pInfo, true /* do lock */);
return vkAcquireProfilingLockKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkAcquireProfilingLockKHR(
- VkDevice device,
- const VkAcquireProfilingLockInfoKHR* pInfo)
-{
+ VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_performance_query"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_performance_query")) {
sOnInvalidDynamicallyCheckedCall("vkAcquireProfilingLockKHR", "VK_KHR_performance_query");
}
AEMU_SCOPED_TRACE("vkAcquireProfilingLockKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquireProfilingLockKHR_VkResult_return = (VkResult)0;
- vkAcquireProfilingLockKHR_VkResult_return = vkEnc->vkAcquireProfilingLockKHR(device, pInfo, true /* do lock */);
+ vkAcquireProfilingLockKHR_VkResult_return =
+ vkEnc->vkAcquireProfilingLockKHR(device, pInfo, true /* do lock */);
return vkAcquireProfilingLockKHR_VkResult_return;
}
-static void entry_vkReleaseProfilingLockKHR(
- VkDevice device)
-{
+static void entry_vkReleaseProfilingLockKHR(VkDevice device) {
AEMU_SCOPED_TRACE("vkReleaseProfilingLockKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkReleaseProfilingLockKHR(device, true /* do lock */);
}
-static void dynCheck_entry_vkReleaseProfilingLockKHR(
- VkDevice device)
-{
+static void dynCheck_entry_vkReleaseProfilingLockKHR(VkDevice device) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_performance_query"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_performance_query")) {
sOnInvalidDynamicallyCheckedCall("vkReleaseProfilingLockKHR", "VK_KHR_performance_query");
}
AEMU_SCOPED_TRACE("vkReleaseProfilingLockKHR");
@@ -4194,26 +3366,25 @@
#endif
#ifdef VK_KHR_get_surface_capabilities2
static VkResult entry_vkGetPhysicalDeviceSurfaceCapabilities2KHR(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
- VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities, true /* do lock */);
+ vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo,
+ pSurfaceCapabilities, true /* do lock */);
return vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDeviceSurfaceFormats2KHR(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
- uint32_t* pSurfaceFormatCount,
- VkSurfaceFormat2KHR* pSurfaceFormats)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormats2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats, true /* do lock */);
+ vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceSurfaceFormats2KHR(
+ physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats, true /* do lock */);
return vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return;
}
#endif
@@ -4221,48 +3392,45 @@
#endif
#ifdef VK_KHR_get_display_properties2
static VkResult entry_vkGetPhysicalDeviceDisplayProperties2KHR(
- VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkDisplayProperties2KHR* pProperties)
-{
+ VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount,
+ VkDisplayProperties2KHR* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayProperties2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties, true /* do lock */);
+ vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties,
+ true /* do lock */);
return vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
- VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkDisplayPlaneProperties2KHR* pProperties)
-{
+ VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount,
+ VkDisplayPlaneProperties2KHR* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlaneProperties2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties, true /* do lock */);
+ vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount,
+ pProperties, true /* do lock */);
return vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return;
}
-static VkResult entry_vkGetDisplayModeProperties2KHR(
- VkPhysicalDevice physicalDevice,
- VkDisplayKHR display,
- uint32_t* pPropertyCount,
- VkDisplayModeProperties2KHR* pProperties)
-{
+static VkResult entry_vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display, uint32_t* pPropertyCount,
+ VkDisplayModeProperties2KHR* pProperties) {
AEMU_SCOPED_TRACE("vkGetDisplayModeProperties2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDisplayModeProperties2KHR_VkResult_return = (VkResult)0;
- vkGetDisplayModeProperties2KHR_VkResult_return = vkEnc->vkGetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties, true /* do lock */);
+ vkGetDisplayModeProperties2KHR_VkResult_return = vkEnc->vkGetDisplayModeProperties2KHR(
+ physicalDevice, display, pPropertyCount, pProperties, true /* do lock */);
return vkGetDisplayModeProperties2KHR_VkResult_return;
}
static VkResult entry_vkGetDisplayPlaneCapabilities2KHR(
- VkPhysicalDevice physicalDevice,
- const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
- VkDisplayPlaneCapabilities2KHR* pCapabilities)
-{
+ VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
+ VkDisplayPlaneCapabilities2KHR* pCapabilities) {
AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilities2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDisplayPlaneCapabilities2KHR_VkResult_return = (VkResult)0;
- vkGetDisplayPlaneCapabilities2KHR_VkResult_return = vkEnc->vkGetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities, true /* do lock */);
+ vkGetDisplayPlaneCapabilities2KHR_VkResult_return = vkEnc->vkGetDisplayPlaneCapabilities2KHR(
+ physicalDevice, pDisplayPlaneInfo, pCapabilities, true /* do lock */);
return vkGetDisplayPlaneCapabilities2KHR_VkResult_return;
}
#endif
@@ -4273,132 +3441,116 @@
#ifdef VK_KHR_relaxed_block_layout
#endif
#ifdef VK_KHR_get_memory_requirements2
-static void entry_vkGetImageMemoryRequirements2KHR(
- VkDevice device,
- const VkImageMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements)
-{
+static void entry_vkGetImageMemoryRequirements2KHR(VkDevice device,
+ const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkGetImageMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
}
static void dynCheck_entry_vkGetImageMemoryRequirements2KHR(
- VkDevice device,
- const VkImageMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements)
-{
+ VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetImageMemoryRequirements2KHR", "VK_KHR_get_memory_requirements2");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetImageMemoryRequirements2KHR",
+ "VK_KHR_get_memory_requirements2");
}
AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
resources->on_vkGetImageMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
}
-static void entry_vkGetBufferMemoryRequirements2KHR(
- VkDevice device,
- const VkBufferMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements)
-{
+static void entry_vkGetBufferMemoryRequirements2KHR(VkDevice device,
+ const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkGetBufferMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
}
static void dynCheck_entry_vkGetBufferMemoryRequirements2KHR(
- VkDevice device,
- const VkBufferMemoryRequirementsInfo2* pInfo,
- VkMemoryRequirements2* pMemoryRequirements)
-{
+ VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetBufferMemoryRequirements2KHR", "VK_KHR_get_memory_requirements2");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetBufferMemoryRequirements2KHR",
+ "VK_KHR_get_memory_requirements2");
}
AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
resources->on_vkGetBufferMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
}
static void entry_vkGetImageSparseMemoryRequirements2KHR(
- VkDevice device,
- const VkImageSparseMemoryRequirementsInfo2* pInfo,
+ VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
-{
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, true /* do lock */);
+ vkEnc->vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount,
+ pSparseMemoryRequirements, true /* do lock */);
}
static void dynCheck_entry_vkGetImageSparseMemoryRequirements2KHR(
- VkDevice device,
- const VkImageSparseMemoryRequirementsInfo2* pInfo,
+ VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
-{
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetImageSparseMemoryRequirements2KHR", "VK_KHR_get_memory_requirements2");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetImageSparseMemoryRequirements2KHR",
+ "VK_KHR_get_memory_requirements2");
}
AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, true /* do lock */);
+ vkEnc->vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount,
+ pSparseMemoryRequirements, true /* do lock */);
}
#endif
#ifdef VK_KHR_image_format_list
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
static VkResult entry_vkCreateSamplerYcbcrConversionKHR(
- VkDevice device,
- const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSamplerYcbcrConversion* pYcbcrConversion)
-{
+ VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkCreateSamplerYcbcrConversionKHR_VkResult_return = resources->on_vkCreateSamplerYcbcrConversionKHR(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pYcbcrConversion);
+ vkCreateSamplerYcbcrConversionKHR_VkResult_return =
+ resources->on_vkCreateSamplerYcbcrConversionKHR(vkEnc, VK_SUCCESS, device, pCreateInfo,
+ pAllocator, pYcbcrConversion);
return vkCreateSamplerYcbcrConversionKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateSamplerYcbcrConversionKHR(
- VkDevice device,
- const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSamplerYcbcrConversion* pYcbcrConversion)
-{
+ VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCreateSamplerYcbcrConversionKHR", "VK_KHR_sampler_ycbcr_conversion");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion")) {
+ sOnInvalidDynamicallyCheckedCall("vkCreateSamplerYcbcrConversionKHR",
+ "VK_KHR_sampler_ycbcr_conversion");
}
AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
- vkCreateSamplerYcbcrConversionKHR_VkResult_return = resources->on_vkCreateSamplerYcbcrConversionKHR(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pYcbcrConversion);
+ vkCreateSamplerYcbcrConversionKHR_VkResult_return =
+ resources->on_vkCreateSamplerYcbcrConversionKHR(vkEnc, VK_SUCCESS, device, pCreateInfo,
+ pAllocator, pYcbcrConversion);
return vkCreateSamplerYcbcrConversionKHR_VkResult_return;
}
-static void entry_vkDestroySamplerYcbcrConversionKHR(
- VkDevice device,
- VkSamplerYcbcrConversion ycbcrConversion,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroySamplerYcbcrConversionKHR(VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
auto resources = ResourceTracker::get();
resources->on_vkDestroySamplerYcbcrConversionKHR(vkEnc, device, ycbcrConversion, pAllocator);
}
static void dynCheck_entry_vkDestroySamplerYcbcrConversionKHR(
- VkDevice device,
- VkSamplerYcbcrConversion ycbcrConversion,
- const VkAllocationCallbacks* pAllocator)
-{
+ VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion"))
- {
- sOnInvalidDynamicallyCheckedCall("vkDestroySamplerYcbcrConversionKHR", "VK_KHR_sampler_ycbcr_conversion");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion")) {
+ sOnInvalidDynamicallyCheckedCall("vkDestroySamplerYcbcrConversionKHR",
+ "VK_KHR_sampler_ycbcr_conversion");
}
AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
@@ -4406,60 +3558,50 @@
}
#endif
#ifdef VK_KHR_bind_memory2
-static VkResult entry_vkBindBufferMemory2KHR(
- VkDevice device,
- uint32_t bindInfoCount,
- const VkBindBufferMemoryInfo* pBindInfos)
-{
+static VkResult entry_vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos) {
AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkBindBufferMemory2KHR_VkResult_return = resources->on_vkBindBufferMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
+ vkBindBufferMemory2KHR_VkResult_return =
+ resources->on_vkBindBufferMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
return vkBindBufferMemory2KHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkBindBufferMemory2KHR(
- VkDevice device,
- uint32_t bindInfoCount,
- const VkBindBufferMemoryInfo* pBindInfos)
-{
+static VkResult dynCheck_entry_vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
+ const VkBindBufferMemoryInfo* pBindInfos) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_bind_memory2"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_bind_memory2")) {
sOnInvalidDynamicallyCheckedCall("vkBindBufferMemory2KHR", "VK_KHR_bind_memory2");
}
AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
- vkBindBufferMemory2KHR_VkResult_return = resources->on_vkBindBufferMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
+ vkBindBufferMemory2KHR_VkResult_return =
+ resources->on_vkBindBufferMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
return vkBindBufferMemory2KHR_VkResult_return;
}
-static VkResult entry_vkBindImageMemory2KHR(
- VkDevice device,
- uint32_t bindInfoCount,
- const VkBindImageMemoryInfo* pBindInfos)
-{
+static VkResult entry_vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos) {
AEMU_SCOPED_TRACE("vkBindImageMemory2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkBindImageMemory2KHR_VkResult_return = resources->on_vkBindImageMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
+ vkBindImageMemory2KHR_VkResult_return =
+ resources->on_vkBindImageMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
return vkBindImageMemory2KHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkBindImageMemory2KHR(
- VkDevice device,
- uint32_t bindInfoCount,
- const VkBindImageMemoryInfo* pBindInfos)
-{
+static VkResult dynCheck_entry_vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
+ const VkBindImageMemoryInfo* pBindInfos) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_bind_memory2"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_bind_memory2")) {
sOnInvalidDynamicallyCheckedCall("vkBindImageMemory2KHR", "VK_KHR_bind_memory2");
}
AEMU_SCOPED_TRACE("vkBindImageMemory2KHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
- vkBindImageMemory2KHR_VkResult_return = resources->on_vkBindImageMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
+ vkBindImageMemory2KHR_VkResult_return =
+ resources->on_vkBindImageMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
return vkBindImageMemory2KHR_VkResult_return;
}
#endif
@@ -4467,23 +3609,19 @@
#endif
#ifdef VK_KHR_maintenance3
static void entry_vkGetDescriptorSetLayoutSupportKHR(
- VkDevice device,
- const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- VkDescriptorSetLayoutSupport* pSupport)
-{
+ VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport) {
AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport, true /* do lock */);
}
static void dynCheck_entry_vkGetDescriptorSetLayoutSupportKHR(
- VkDevice device,
- const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- VkDescriptorSetLayoutSupport* pSupport)
-{
+ VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+ VkDescriptorSetLayoutSupport* pSupport) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance3"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetDescriptorSetLayoutSupportKHR", "VK_KHR_maintenance3");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance3")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetDescriptorSetLayoutSupportKHR",
+ "VK_KHR_maintenance3");
}
AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
@@ -4491,69 +3629,55 @@
}
#endif
#ifdef VK_KHR_draw_indirect_count
-static void entry_vkCmdDrawIndirectCountKHR(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride)
-{
+static void entry_vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+ uint32_t stride) {
AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, true /* do lock */);
+ vkEnc->vkCmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset,
+ maxDrawCount, stride, true /* do lock */);
}
-static void dynCheck_entry_vkCmdDrawIndirectCountKHR(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride)
-{
+static void dynCheck_entry_vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount, uint32_t stride) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_draw_indirect_count"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_draw_indirect_count")) {
sOnInvalidDynamicallyCheckedCall("vkCmdDrawIndirectCountKHR", "VK_KHR_draw_indirect_count");
}
AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, true /* do lock */);
+ vkEnc->vkCmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset,
+ maxDrawCount, stride, true /* do lock */);
}
-static void entry_vkCmdDrawIndexedIndirectCountKHR(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride)
-{
+static void entry_vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount, uint32_t stride) {
AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, true /* do lock */);
+ vkEnc->vkCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer,
+ countBufferOffset, maxDrawCount, stride,
+ true /* do lock */);
}
static void dynCheck_entry_vkCmdDrawIndexedIndirectCountKHR(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride)
-{
+ VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_draw_indirect_count"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdDrawIndexedIndirectCountKHR", "VK_KHR_draw_indirect_count");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_draw_indirect_count")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdDrawIndexedIndirectCountKHR",
+ "VK_KHR_draw_indirect_count");
}
AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, true /* do lock */);
+ vkEnc->vkCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer,
+ countBufferOffset, maxDrawCount, stride,
+ true /* do lock */);
}
#endif
#ifdef VK_KHR_shader_subgroup_extended_types
@@ -4573,83 +3697,72 @@
#ifdef VK_KHR_swapchain_mutable_format
#endif
#ifdef VK_KHR_timeline_semaphore
-static VkResult entry_vkGetSemaphoreCounterValueKHR(
- VkDevice device,
- VkSemaphore semaphore,
- uint64_t* pValue)
-{
+static VkResult entry_vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore,
+ uint64_t* pValue) {
AEMU_SCOPED_TRACE("vkGetSemaphoreCounterValueKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSemaphoreCounterValueKHR_VkResult_return = (VkResult)0;
- vkGetSemaphoreCounterValueKHR_VkResult_return = vkEnc->vkGetSemaphoreCounterValueKHR(device, semaphore, pValue, true /* do lock */);
+ vkGetSemaphoreCounterValueKHR_VkResult_return =
+ vkEnc->vkGetSemaphoreCounterValueKHR(device, semaphore, pValue, true /* do lock */);
return vkGetSemaphoreCounterValueKHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetSemaphoreCounterValueKHR(
- VkDevice device,
- VkSemaphore semaphore,
- uint64_t* pValue)
-{
+static VkResult dynCheck_entry_vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore,
+ uint64_t* pValue) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_timeline_semaphore"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetSemaphoreCounterValueKHR", "VK_KHR_timeline_semaphore");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_timeline_semaphore")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetSemaphoreCounterValueKHR",
+ "VK_KHR_timeline_semaphore");
}
AEMU_SCOPED_TRACE("vkGetSemaphoreCounterValueKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSemaphoreCounterValueKHR_VkResult_return = (VkResult)0;
- vkGetSemaphoreCounterValueKHR_VkResult_return = vkEnc->vkGetSemaphoreCounterValueKHR(device, semaphore, pValue, true /* do lock */);
+ vkGetSemaphoreCounterValueKHR_VkResult_return =
+ vkEnc->vkGetSemaphoreCounterValueKHR(device, semaphore, pValue, true /* do lock */);
return vkGetSemaphoreCounterValueKHR_VkResult_return;
}
-static VkResult entry_vkWaitSemaphoresKHR(
- VkDevice device,
- const VkSemaphoreWaitInfo* pWaitInfo,
- uint64_t timeout)
-{
+static VkResult entry_vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo,
+ uint64_t timeout) {
AEMU_SCOPED_TRACE("vkWaitSemaphoresKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkWaitSemaphoresKHR_VkResult_return = (VkResult)0;
- vkWaitSemaphoresKHR_VkResult_return = vkEnc->vkWaitSemaphoresKHR(device, pWaitInfo, timeout, true /* do lock */);
+ vkWaitSemaphoresKHR_VkResult_return =
+ vkEnc->vkWaitSemaphoresKHR(device, pWaitInfo, timeout, true /* do lock */);
return vkWaitSemaphoresKHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkWaitSemaphoresKHR(
- VkDevice device,
- const VkSemaphoreWaitInfo* pWaitInfo,
- uint64_t timeout)
-{
+static VkResult dynCheck_entry_vkWaitSemaphoresKHR(VkDevice device,
+ const VkSemaphoreWaitInfo* pWaitInfo,
+ uint64_t timeout) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_timeline_semaphore"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_timeline_semaphore")) {
sOnInvalidDynamicallyCheckedCall("vkWaitSemaphoresKHR", "VK_KHR_timeline_semaphore");
}
AEMU_SCOPED_TRACE("vkWaitSemaphoresKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkWaitSemaphoresKHR_VkResult_return = (VkResult)0;
- vkWaitSemaphoresKHR_VkResult_return = vkEnc->vkWaitSemaphoresKHR(device, pWaitInfo, timeout, true /* do lock */);
+ vkWaitSemaphoresKHR_VkResult_return =
+ vkEnc->vkWaitSemaphoresKHR(device, pWaitInfo, timeout, true /* do lock */);
return vkWaitSemaphoresKHR_VkResult_return;
}
-static VkResult entry_vkSignalSemaphoreKHR(
- VkDevice device,
- const VkSemaphoreSignalInfo* pSignalInfo)
-{
+static VkResult entry_vkSignalSemaphoreKHR(VkDevice device,
+ const VkSemaphoreSignalInfo* pSignalInfo) {
AEMU_SCOPED_TRACE("vkSignalSemaphoreKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSignalSemaphoreKHR_VkResult_return = (VkResult)0;
- vkSignalSemaphoreKHR_VkResult_return = vkEnc->vkSignalSemaphoreKHR(device, pSignalInfo, true /* do lock */);
+ vkSignalSemaphoreKHR_VkResult_return =
+ vkEnc->vkSignalSemaphoreKHR(device, pSignalInfo, true /* do lock */);
return vkSignalSemaphoreKHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkSignalSemaphoreKHR(
- VkDevice device,
- const VkSemaphoreSignalInfo* pSignalInfo)
-{
+static VkResult dynCheck_entry_vkSignalSemaphoreKHR(VkDevice device,
+ const VkSemaphoreSignalInfo* pSignalInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_timeline_semaphore"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_timeline_semaphore")) {
sOnInvalidDynamicallyCheckedCall("vkSignalSemaphoreKHR", "VK_KHR_timeline_semaphore");
}
AEMU_SCOPED_TRACE("vkSignalSemaphoreKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSignalSemaphoreKHR_VkResult_return = (VkResult)0;
- vkSignalSemaphoreKHR_VkResult_return = vkEnc->vkSignalSemaphoreKHR(device, pSignalInfo, true /* do lock */);
+ vkSignalSemaphoreKHR_VkResult_return =
+ vkEnc->vkSignalSemaphoreKHR(device, pSignalInfo, true /* do lock */);
return vkSignalSemaphoreKHR_VkResult_return;
}
#endif
@@ -4659,39 +3772,38 @@
#endif
#ifdef VK_KHR_fragment_shading_rate
static VkResult entry_vkGetPhysicalDeviceFragmentShadingRatesKHR(
- VkPhysicalDevice physicalDevice,
- uint32_t* pFragmentShadingRateCount,
- VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates)
-{
+ VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount,
+ VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFragmentShadingRatesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceFragmentShadingRatesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates, true /* do lock */);
+ vkGetPhysicalDeviceFragmentShadingRatesKHR_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceFragmentShadingRatesKHR(
+ physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates, true /* do lock */);
return vkGetPhysicalDeviceFragmentShadingRatesKHR_VkResult_return;
}
static void entry_vkCmdSetFragmentShadingRateKHR(
- VkCommandBuffer commandBuffer,
- const VkExtent2D* pFragmentSize,
- const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
-{
+ VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize,
+ const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) {
AEMU_SCOPED_TRACE("vkCmdSetFragmentShadingRateKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps, true /* do lock */);
+ vkEnc->vkCmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps,
+ true /* do lock */);
}
static void dynCheck_entry_vkCmdSetFragmentShadingRateKHR(
- VkCommandBuffer commandBuffer,
- const VkExtent2D* pFragmentSize,
- const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
-{
+ VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize,
+ const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_fragment_shading_rate"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetFragmentShadingRateKHR", "VK_KHR_fragment_shading_rate");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_fragment_shading_rate")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetFragmentShadingRateKHR",
+ "VK_KHR_fragment_shading_rate");
}
AEMU_SCOPED_TRACE("vkCmdSetFragmentShadingRateKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps, true /* do lock */);
+ vkEnc->vkCmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps,
+ true /* do lock */);
}
#endif
#ifdef VK_KHR_spirv_1_4
@@ -4701,328 +3813,300 @@
#ifdef VK_KHR_separate_depth_stencil_layouts
#endif
#ifdef VK_KHR_present_wait
-static VkResult entry_vkWaitForPresentKHR(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint64_t presentId,
- uint64_t timeout)
-{
+static VkResult entry_vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain,
+ uint64_t presentId, uint64_t timeout) {
AEMU_SCOPED_TRACE("vkWaitForPresentKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkWaitForPresentKHR_VkResult_return = (VkResult)0;
- vkWaitForPresentKHR_VkResult_return = vkEnc->vkWaitForPresentKHR(device, swapchain, presentId, timeout, true /* do lock */);
+ vkWaitForPresentKHR_VkResult_return =
+ vkEnc->vkWaitForPresentKHR(device, swapchain, presentId, timeout, true /* do lock */);
return vkWaitForPresentKHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkWaitForPresentKHR(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint64_t presentId,
- uint64_t timeout)
-{
+static VkResult dynCheck_entry_vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain,
+ uint64_t presentId, uint64_t timeout) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_present_wait"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_KHR_present_wait")) {
sOnInvalidDynamicallyCheckedCall("vkWaitForPresentKHR", "VK_KHR_present_wait");
}
AEMU_SCOPED_TRACE("vkWaitForPresentKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkWaitForPresentKHR_VkResult_return = (VkResult)0;
- vkWaitForPresentKHR_VkResult_return = vkEnc->vkWaitForPresentKHR(device, swapchain, presentId, timeout, true /* do lock */);
+ vkWaitForPresentKHR_VkResult_return =
+ vkEnc->vkWaitForPresentKHR(device, swapchain, presentId, timeout, true /* do lock */);
return vkWaitForPresentKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_uniform_buffer_standard_layout
#endif
#ifdef VK_KHR_buffer_device_address
-static VkDeviceAddress entry_vkGetBufferDeviceAddressKHR(
- VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo)
-{
+static VkDeviceAddress entry_vkGetBufferDeviceAddressKHR(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetBufferDeviceAddressKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkDeviceAddress vkGetBufferDeviceAddressKHR_VkDeviceAddress_return = (VkDeviceAddress)0;
- vkGetBufferDeviceAddressKHR_VkDeviceAddress_return = vkEnc->vkGetBufferDeviceAddressKHR(device, pInfo, true /* do lock */);
+ vkGetBufferDeviceAddressKHR_VkDeviceAddress_return =
+ vkEnc->vkGetBufferDeviceAddressKHR(device, pInfo, true /* do lock */);
return vkGetBufferDeviceAddressKHR_VkDeviceAddress_return;
}
static VkDeviceAddress dynCheck_entry_vkGetBufferDeviceAddressKHR(
- VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo)
-{
+ VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetBufferDeviceAddressKHR", "VK_KHR_buffer_device_address");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetBufferDeviceAddressKHR",
+ "VK_KHR_buffer_device_address");
}
AEMU_SCOPED_TRACE("vkGetBufferDeviceAddressKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkDeviceAddress vkGetBufferDeviceAddressKHR_VkDeviceAddress_return = (VkDeviceAddress)0;
- vkGetBufferDeviceAddressKHR_VkDeviceAddress_return = vkEnc->vkGetBufferDeviceAddressKHR(device, pInfo, true /* do lock */);
+ vkGetBufferDeviceAddressKHR_VkDeviceAddress_return =
+ vkEnc->vkGetBufferDeviceAddressKHR(device, pInfo, true /* do lock */);
return vkGetBufferDeviceAddressKHR_VkDeviceAddress_return;
}
-static uint64_t entry_vkGetBufferOpaqueCaptureAddressKHR(
- VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo)
-{
+static uint64_t entry_vkGetBufferOpaqueCaptureAddressKHR(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddressKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint64_t vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
- vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return = vkEnc->vkGetBufferOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
+ vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return =
+ vkEnc->vkGetBufferOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
return vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return;
}
static uint64_t dynCheck_entry_vkGetBufferOpaqueCaptureAddressKHR(
- VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo)
-{
+ VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetBufferOpaqueCaptureAddressKHR", "VK_KHR_buffer_device_address");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetBufferOpaqueCaptureAddressKHR",
+ "VK_KHR_buffer_device_address");
}
AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddressKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint64_t vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
- vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return = vkEnc->vkGetBufferOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
+ vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return =
+ vkEnc->vkGetBufferOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
return vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return;
}
static uint64_t entry_vkGetDeviceMemoryOpaqueCaptureAddressKHR(
- VkDevice device,
- const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
-{
+ VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddressKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
- vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return = vkEnc->vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
+ vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return =
+ vkEnc->vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
return vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return;
}
static uint64_t dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddressKHR(
- VkDevice device,
- const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
-{
+ VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceMemoryOpaqueCaptureAddressKHR", "VK_KHR_buffer_device_address");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetDeviceMemoryOpaqueCaptureAddressKHR",
+ "VK_KHR_buffer_device_address");
}
AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddressKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
- vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return = vkEnc->vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
+ vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return =
+ vkEnc->vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
return vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return;
}
#endif
#ifdef VK_KHR_deferred_host_operations
-static VkResult entry_vkCreateDeferredOperationKHR(
- VkDevice device,
- const VkAllocationCallbacks* pAllocator,
- VkDeferredOperationKHR* pDeferredOperation)
-{
+static VkResult entry_vkCreateDeferredOperationKHR(VkDevice device,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeferredOperationKHR* pDeferredOperation) {
AEMU_SCOPED_TRACE("vkCreateDeferredOperationKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDeferredOperationKHR_VkResult_return = (VkResult)0;
- vkCreateDeferredOperationKHR_VkResult_return = vkEnc->vkCreateDeferredOperationKHR(device, pAllocator, pDeferredOperation, true /* do lock */);
+ vkCreateDeferredOperationKHR_VkResult_return = vkEnc->vkCreateDeferredOperationKHR(
+ device, pAllocator, pDeferredOperation, true /* do lock */);
return vkCreateDeferredOperationKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateDeferredOperationKHR(
- VkDevice device,
- const VkAllocationCallbacks* pAllocator,
- VkDeferredOperationKHR* pDeferredOperation)
-{
+ VkDevice device, const VkAllocationCallbacks* pAllocator,
+ VkDeferredOperationKHR* pDeferredOperation) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_deferred_host_operations"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCreateDeferredOperationKHR", "VK_KHR_deferred_host_operations");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_deferred_host_operations")) {
+ sOnInvalidDynamicallyCheckedCall("vkCreateDeferredOperationKHR",
+ "VK_KHR_deferred_host_operations");
}
AEMU_SCOPED_TRACE("vkCreateDeferredOperationKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDeferredOperationKHR_VkResult_return = (VkResult)0;
- vkCreateDeferredOperationKHR_VkResult_return = vkEnc->vkCreateDeferredOperationKHR(device, pAllocator, pDeferredOperation, true /* do lock */);
+ vkCreateDeferredOperationKHR_VkResult_return = vkEnc->vkCreateDeferredOperationKHR(
+ device, pAllocator, pDeferredOperation, true /* do lock */);
return vkCreateDeferredOperationKHR_VkResult_return;
}
-static void entry_vkDestroyDeferredOperationKHR(
- VkDevice device,
- VkDeferredOperationKHR operation,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyDeferredOperationKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyDeferredOperationKHR(device, operation, pAllocator, true /* do lock */);
}
-static void dynCheck_entry_vkDestroyDeferredOperationKHR(
- VkDevice device,
- VkDeferredOperationKHR operation,
- const VkAllocationCallbacks* pAllocator)
-{
+static void dynCheck_entry_vkDestroyDeferredOperationKHR(VkDevice device,
+ VkDeferredOperationKHR operation,
+ const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_deferred_host_operations"))
- {
- sOnInvalidDynamicallyCheckedCall("vkDestroyDeferredOperationKHR", "VK_KHR_deferred_host_operations");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_deferred_host_operations")) {
+ sOnInvalidDynamicallyCheckedCall("vkDestroyDeferredOperationKHR",
+ "VK_KHR_deferred_host_operations");
}
AEMU_SCOPED_TRACE("vkDestroyDeferredOperationKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyDeferredOperationKHR(device, operation, pAllocator, true /* do lock */);
}
-static uint32_t entry_vkGetDeferredOperationMaxConcurrencyKHR(
- VkDevice device,
- VkDeferredOperationKHR operation)
-{
+static uint32_t entry_vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device,
+ VkDeferredOperationKHR operation) {
AEMU_SCOPED_TRACE("vkGetDeferredOperationMaxConcurrencyKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint32_t vkGetDeferredOperationMaxConcurrencyKHR_uint32_t_return = (uint32_t)0;
- vkGetDeferredOperationMaxConcurrencyKHR_uint32_t_return = vkEnc->vkGetDeferredOperationMaxConcurrencyKHR(device, operation, true /* do lock */);
+ vkGetDeferredOperationMaxConcurrencyKHR_uint32_t_return =
+ vkEnc->vkGetDeferredOperationMaxConcurrencyKHR(device, operation, true /* do lock */);
return vkGetDeferredOperationMaxConcurrencyKHR_uint32_t_return;
}
static uint32_t dynCheck_entry_vkGetDeferredOperationMaxConcurrencyKHR(
- VkDevice device,
- VkDeferredOperationKHR operation)
-{
+ VkDevice device, VkDeferredOperationKHR operation) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_deferred_host_operations"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetDeferredOperationMaxConcurrencyKHR", "VK_KHR_deferred_host_operations");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_deferred_host_operations")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetDeferredOperationMaxConcurrencyKHR",
+ "VK_KHR_deferred_host_operations");
}
AEMU_SCOPED_TRACE("vkGetDeferredOperationMaxConcurrencyKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint32_t vkGetDeferredOperationMaxConcurrencyKHR_uint32_t_return = (uint32_t)0;
- vkGetDeferredOperationMaxConcurrencyKHR_uint32_t_return = vkEnc->vkGetDeferredOperationMaxConcurrencyKHR(device, operation, true /* do lock */);
+ vkGetDeferredOperationMaxConcurrencyKHR_uint32_t_return =
+ vkEnc->vkGetDeferredOperationMaxConcurrencyKHR(device, operation, true /* do lock */);
return vkGetDeferredOperationMaxConcurrencyKHR_uint32_t_return;
}
-static VkResult entry_vkGetDeferredOperationResultKHR(
- VkDevice device,
- VkDeferredOperationKHR operation)
-{
+static VkResult entry_vkGetDeferredOperationResultKHR(VkDevice device,
+ VkDeferredOperationKHR operation) {
AEMU_SCOPED_TRACE("vkGetDeferredOperationResultKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDeferredOperationResultKHR_VkResult_return = (VkResult)0;
- vkGetDeferredOperationResultKHR_VkResult_return = vkEnc->vkGetDeferredOperationResultKHR(device, operation, true /* do lock */);
+ vkGetDeferredOperationResultKHR_VkResult_return =
+ vkEnc->vkGetDeferredOperationResultKHR(device, operation, true /* do lock */);
return vkGetDeferredOperationResultKHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetDeferredOperationResultKHR(
- VkDevice device,
- VkDeferredOperationKHR operation)
-{
+static VkResult dynCheck_entry_vkGetDeferredOperationResultKHR(VkDevice device,
+ VkDeferredOperationKHR operation) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_deferred_host_operations"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetDeferredOperationResultKHR", "VK_KHR_deferred_host_operations");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_deferred_host_operations")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetDeferredOperationResultKHR",
+ "VK_KHR_deferred_host_operations");
}
AEMU_SCOPED_TRACE("vkGetDeferredOperationResultKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDeferredOperationResultKHR_VkResult_return = (VkResult)0;
- vkGetDeferredOperationResultKHR_VkResult_return = vkEnc->vkGetDeferredOperationResultKHR(device, operation, true /* do lock */);
+ vkGetDeferredOperationResultKHR_VkResult_return =
+ vkEnc->vkGetDeferredOperationResultKHR(device, operation, true /* do lock */);
return vkGetDeferredOperationResultKHR_VkResult_return;
}
-static VkResult entry_vkDeferredOperationJoinKHR(
- VkDevice device,
- VkDeferredOperationKHR operation)
-{
+static VkResult entry_vkDeferredOperationJoinKHR(VkDevice device,
+ VkDeferredOperationKHR operation) {
AEMU_SCOPED_TRACE("vkDeferredOperationJoinKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkDeferredOperationJoinKHR_VkResult_return = (VkResult)0;
- vkDeferredOperationJoinKHR_VkResult_return = vkEnc->vkDeferredOperationJoinKHR(device, operation, true /* do lock */);
+ vkDeferredOperationJoinKHR_VkResult_return =
+ vkEnc->vkDeferredOperationJoinKHR(device, operation, true /* do lock */);
return vkDeferredOperationJoinKHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkDeferredOperationJoinKHR(
- VkDevice device,
- VkDeferredOperationKHR operation)
-{
+static VkResult dynCheck_entry_vkDeferredOperationJoinKHR(VkDevice device,
+ VkDeferredOperationKHR operation) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_deferred_host_operations"))
- {
- sOnInvalidDynamicallyCheckedCall("vkDeferredOperationJoinKHR", "VK_KHR_deferred_host_operations");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_deferred_host_operations")) {
+ sOnInvalidDynamicallyCheckedCall("vkDeferredOperationJoinKHR",
+ "VK_KHR_deferred_host_operations");
}
AEMU_SCOPED_TRACE("vkDeferredOperationJoinKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkDeferredOperationJoinKHR_VkResult_return = (VkResult)0;
- vkDeferredOperationJoinKHR_VkResult_return = vkEnc->vkDeferredOperationJoinKHR(device, operation, true /* do lock */);
+ vkDeferredOperationJoinKHR_VkResult_return =
+ vkEnc->vkDeferredOperationJoinKHR(device, operation, true /* do lock */);
return vkDeferredOperationJoinKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
static VkResult entry_vkGetPipelineExecutablePropertiesKHR(
- VkDevice device,
- const VkPipelineInfoKHR* pPipelineInfo,
- uint32_t* pExecutableCount,
- VkPipelineExecutablePropertiesKHR* pProperties)
-{
+ VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount,
+ VkPipelineExecutablePropertiesKHR* pProperties) {
AEMU_SCOPED_TRACE("vkGetPipelineExecutablePropertiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPipelineExecutablePropertiesKHR_VkResult_return = (VkResult)0;
- vkGetPipelineExecutablePropertiesKHR_VkResult_return = vkEnc->vkGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties, true /* do lock */);
+ vkGetPipelineExecutablePropertiesKHR_VkResult_return =
+ vkEnc->vkGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount,
+ pProperties, true /* do lock */);
return vkGetPipelineExecutablePropertiesKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetPipelineExecutablePropertiesKHR(
- VkDevice device,
- const VkPipelineInfoKHR* pPipelineInfo,
- uint32_t* pExecutableCount,
- VkPipelineExecutablePropertiesKHR* pProperties)
-{
+ VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount,
+ VkPipelineExecutablePropertiesKHR* pProperties) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetPipelineExecutablePropertiesKHR", "VK_KHR_pipeline_executable_properties");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetPipelineExecutablePropertiesKHR",
+ "VK_KHR_pipeline_executable_properties");
}
AEMU_SCOPED_TRACE("vkGetPipelineExecutablePropertiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPipelineExecutablePropertiesKHR_VkResult_return = (VkResult)0;
- vkGetPipelineExecutablePropertiesKHR_VkResult_return = vkEnc->vkGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties, true /* do lock */);
+ vkGetPipelineExecutablePropertiesKHR_VkResult_return =
+ vkEnc->vkGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount,
+ pProperties, true /* do lock */);
return vkGetPipelineExecutablePropertiesKHR_VkResult_return;
}
static VkResult entry_vkGetPipelineExecutableStatisticsKHR(
- VkDevice device,
- const VkPipelineExecutableInfoKHR* pExecutableInfo,
- uint32_t* pStatisticCount,
- VkPipelineExecutableStatisticKHR* pStatistics)
-{
+ VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount,
+ VkPipelineExecutableStatisticKHR* pStatistics) {
AEMU_SCOPED_TRACE("vkGetPipelineExecutableStatisticsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPipelineExecutableStatisticsKHR_VkResult_return = (VkResult)0;
- vkGetPipelineExecutableStatisticsKHR_VkResult_return = vkEnc->vkGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics, true /* do lock */);
+ vkGetPipelineExecutableStatisticsKHR_VkResult_return =
+ vkEnc->vkGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount,
+ pStatistics, true /* do lock */);
return vkGetPipelineExecutableStatisticsKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetPipelineExecutableStatisticsKHR(
- VkDevice device,
- const VkPipelineExecutableInfoKHR* pExecutableInfo,
- uint32_t* pStatisticCount,
- VkPipelineExecutableStatisticKHR* pStatistics)
-{
+ VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount,
+ VkPipelineExecutableStatisticKHR* pStatistics) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetPipelineExecutableStatisticsKHR", "VK_KHR_pipeline_executable_properties");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetPipelineExecutableStatisticsKHR",
+ "VK_KHR_pipeline_executable_properties");
}
AEMU_SCOPED_TRACE("vkGetPipelineExecutableStatisticsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPipelineExecutableStatisticsKHR_VkResult_return = (VkResult)0;
- vkGetPipelineExecutableStatisticsKHR_VkResult_return = vkEnc->vkGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics, true /* do lock */);
+ vkGetPipelineExecutableStatisticsKHR_VkResult_return =
+ vkEnc->vkGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount,
+ pStatistics, true /* do lock */);
return vkGetPipelineExecutableStatisticsKHR_VkResult_return;
}
static VkResult entry_vkGetPipelineExecutableInternalRepresentationsKHR(
- VkDevice device,
- const VkPipelineExecutableInfoKHR* pExecutableInfo,
+ VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo,
uint32_t* pInternalRepresentationCount,
- VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations)
-{
+ VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
AEMU_SCOPED_TRACE("vkGetPipelineExecutableInternalRepresentationsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return = (VkResult)0;
- vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return = vkEnc->vkGetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations, true /* do lock */);
+ vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return =
+ vkEnc->vkGetPipelineExecutableInternalRepresentationsKHR(
+ device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations,
+ true /* do lock */);
return vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetPipelineExecutableInternalRepresentationsKHR(
- VkDevice device,
- const VkPipelineExecutableInfoKHR* pExecutableInfo,
+ VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo,
uint32_t* pInternalRepresentationCount,
- VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations)
-{
+ VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetPipelineExecutableInternalRepresentationsKHR", "VK_KHR_pipeline_executable_properties");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetPipelineExecutableInternalRepresentationsKHR",
+ "VK_KHR_pipeline_executable_properties");
}
AEMU_SCOPED_TRACE("vkGetPipelineExecutableInternalRepresentationsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return = (VkResult)0;
- vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return = vkEnc->vkGetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations, true /* do lock */);
+ vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return =
+ vkEnc->vkGetPipelineExecutableInternalRepresentationsKHR(
+ device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations,
+ true /* do lock */);
return vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return;
}
#endif
@@ -5035,22 +4119,18 @@
#ifdef VK_KHR_present_id
#endif
#ifdef VK_KHR_video_encode_queue
-static void entry_vkCmdEncodeVideoKHR(
- VkCommandBuffer commandBuffer,
- const VkVideoEncodeInfoKHR* pEncodeInfo)
-{
+static void entry_vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer,
+ const VkVideoEncodeInfoKHR* pEncodeInfo) {
AEMU_SCOPED_TRACE("vkCmdEncodeVideoKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdEncodeVideoKHR(commandBuffer, pEncodeInfo, true /* do lock */);
}
-static void dynCheck_entry_vkCmdEncodeVideoKHR(
- VkCommandBuffer commandBuffer,
- const VkVideoEncodeInfoKHR* pEncodeInfo)
-{
+static void dynCheck_entry_vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer,
+ const VkVideoEncodeInfoKHR* pEncodeInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_video_encode_queue"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_video_encode_queue")) {
sOnInvalidDynamicallyCheckedCall("vkCmdEncodeVideoKHR", "VK_KHR_video_encode_queue");
}
AEMU_SCOPED_TRACE("vkCmdEncodeVideoKHR");
@@ -5059,176 +4139,140 @@
}
#endif
#ifdef VK_KHR_synchronization2
-static void entry_vkCmdSetEvent2KHR(
- VkCommandBuffer commandBuffer,
- VkEvent event,
- const VkDependencyInfoKHR* pDependencyInfo)
-{
+static void entry_vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
+ const VkDependencyInfoKHR* pDependencyInfo) {
AEMU_SCOPED_TRACE("vkCmdSetEvent2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo, true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetEvent2KHR(
- VkCommandBuffer commandBuffer,
- VkEvent event,
- const VkDependencyInfoKHR* pDependencyInfo)
-{
+static void dynCheck_entry_vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
+ const VkDependencyInfoKHR* pDependencyInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
sOnInvalidDynamicallyCheckedCall("vkCmdSetEvent2KHR", "VK_KHR_synchronization2");
}
AEMU_SCOPED_TRACE("vkCmdSetEvent2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo, true /* do lock */);
}
-static void entry_vkCmdResetEvent2KHR(
- VkCommandBuffer commandBuffer,
- VkEvent event,
- VkPipelineStageFlags2KHR stageMask)
-{
+static void entry_vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
+ VkPipelineStageFlags2KHR stageMask) {
AEMU_SCOPED_TRACE("vkCmdResetEvent2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdResetEvent2KHR(commandBuffer, event, stageMask, true /* do lock */);
}
-static void dynCheck_entry_vkCmdResetEvent2KHR(
- VkCommandBuffer commandBuffer,
- VkEvent event,
- VkPipelineStageFlags2KHR stageMask)
-{
+static void dynCheck_entry_vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
+ VkPipelineStageFlags2KHR stageMask) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
sOnInvalidDynamicallyCheckedCall("vkCmdResetEvent2KHR", "VK_KHR_synchronization2");
}
AEMU_SCOPED_TRACE("vkCmdResetEvent2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdResetEvent2KHR(commandBuffer, event, stageMask, true /* do lock */);
}
-static void entry_vkCmdWaitEvents2KHR(
- VkCommandBuffer commandBuffer,
- uint32_t eventCount,
- const VkEvent* pEvents,
- const VkDependencyInfoKHR* pDependencyInfos)
-{
+static void entry_vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount,
+ const VkEvent* pEvents,
+ const VkDependencyInfoKHR* pDependencyInfos) {
AEMU_SCOPED_TRACE("vkCmdWaitEvents2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos, true /* do lock */);
+ vkEnc->vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos,
+ true /* do lock */);
}
-static void dynCheck_entry_vkCmdWaitEvents2KHR(
- VkCommandBuffer commandBuffer,
- uint32_t eventCount,
- const VkEvent* pEvents,
- const VkDependencyInfoKHR* pDependencyInfos)
-{
+static void dynCheck_entry_vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount,
+ const VkEvent* pEvents,
+ const VkDependencyInfoKHR* pDependencyInfos) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
sOnInvalidDynamicallyCheckedCall("vkCmdWaitEvents2KHR", "VK_KHR_synchronization2");
}
AEMU_SCOPED_TRACE("vkCmdWaitEvents2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos, true /* do lock */);
+ vkEnc->vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos,
+ true /* do lock */);
}
-static void entry_vkCmdPipelineBarrier2KHR(
- VkCommandBuffer commandBuffer,
- const VkDependencyInfoKHR* pDependencyInfo)
-{
+static void entry_vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,
+ const VkDependencyInfoKHR* pDependencyInfo) {
AEMU_SCOPED_TRACE("vkCmdPipelineBarrier2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo, true /* do lock */);
}
-static void dynCheck_entry_vkCmdPipelineBarrier2KHR(
- VkCommandBuffer commandBuffer,
- const VkDependencyInfoKHR* pDependencyInfo)
-{
+static void dynCheck_entry_vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,
+ const VkDependencyInfoKHR* pDependencyInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
sOnInvalidDynamicallyCheckedCall("vkCmdPipelineBarrier2KHR", "VK_KHR_synchronization2");
}
AEMU_SCOPED_TRACE("vkCmdPipelineBarrier2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo, true /* do lock */);
}
-static void entry_vkCmdWriteTimestamp2KHR(
- VkCommandBuffer commandBuffer,
- VkPipelineStageFlags2KHR stage,
- VkQueryPool queryPool,
- uint32_t query)
-{
+static void entry_vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer,
+ VkPipelineStageFlags2KHR stage, VkQueryPool queryPool,
+ uint32_t query) {
AEMU_SCOPED_TRACE("vkCmdWriteTimestamp2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query, true /* do lock */);
}
-static void dynCheck_entry_vkCmdWriteTimestamp2KHR(
- VkCommandBuffer commandBuffer,
- VkPipelineStageFlags2KHR stage,
- VkQueryPool queryPool,
- uint32_t query)
-{
+static void dynCheck_entry_vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer,
+ VkPipelineStageFlags2KHR stage,
+ VkQueryPool queryPool, uint32_t query) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
sOnInvalidDynamicallyCheckedCall("vkCmdWriteTimestamp2KHR", "VK_KHR_synchronization2");
}
AEMU_SCOPED_TRACE("vkCmdWriteTimestamp2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query, true /* do lock */);
}
-static VkResult entry_vkQueueSubmit2KHR(
- VkQueue queue,
- uint32_t submitCount,
- const VkSubmitInfo2KHR* pSubmits,
- VkFence fence)
-{
+static VkResult entry_vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount,
+ const VkSubmitInfo2KHR* pSubmits, VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueSubmit2KHR");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueSubmit2KHR_VkResult_return = (VkResult)0;
- vkQueueSubmit2KHR_VkResult_return = vkEnc->vkQueueSubmit2KHR(queue, submitCount, pSubmits, fence, true /* do lock */);
+ vkQueueSubmit2KHR_VkResult_return =
+ vkEnc->vkQueueSubmit2KHR(queue, submitCount, pSubmits, fence, true /* do lock */);
return vkQueueSubmit2KHR_VkResult_return;
}
-static void entry_vkCmdWriteBufferMarker2AMD(
- VkCommandBuffer commandBuffer,
- VkPipelineStageFlags2KHR stage,
- VkBuffer dstBuffer,
- VkDeviceSize dstOffset,
- uint32_t marker)
-{
+static void entry_vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,
+ VkPipelineStageFlags2KHR stage, VkBuffer dstBuffer,
+ VkDeviceSize dstOffset, uint32_t marker) {
AEMU_SCOPED_TRACE("vkCmdWriteBufferMarker2AMD");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker, true /* do lock */);
+ vkEnc->vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker,
+ true /* do lock */);
}
-static void dynCheck_entry_vkCmdWriteBufferMarker2AMD(
- VkCommandBuffer commandBuffer,
- VkPipelineStageFlags2KHR stage,
- VkBuffer dstBuffer,
- VkDeviceSize dstOffset,
- uint32_t marker)
-{
+static void dynCheck_entry_vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,
+ VkPipelineStageFlags2KHR stage,
+ VkBuffer dstBuffer, VkDeviceSize dstOffset,
+ uint32_t marker) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
sOnInvalidDynamicallyCheckedCall("vkCmdWriteBufferMarker2AMD", "VK_KHR_synchronization2");
}
AEMU_SCOPED_TRACE("vkCmdWriteBufferMarker2AMD");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker, true /* do lock */);
+ vkEnc->vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker,
+ true /* do lock */);
}
-static void entry_vkGetQueueCheckpointData2NV(
- VkQueue queue,
- uint32_t* pCheckpointDataCount,
- VkCheckpointData2NV* pCheckpointData)
-{
+static void entry_vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount,
+ VkCheckpointData2NV* pCheckpointData) {
AEMU_SCOPED_TRACE("vkGetQueueCheckpointData2NV");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkGetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData, true /* do lock */);
+ vkEnc->vkGetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData,
+ true /* do lock */);
}
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
@@ -5238,44 +4282,36 @@
#ifdef VK_KHR_workgroup_memory_explicit_layout
#endif
#ifdef VK_KHR_copy_commands2
-static void entry_vkCmdCopyBuffer2KHR(
- VkCommandBuffer commandBuffer,
- const VkCopyBufferInfo2KHR* pCopyBufferInfo)
-{
+static void entry_vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
+ const VkCopyBufferInfo2KHR* pCopyBufferInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyBuffer2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo, true /* do lock */);
}
-static void dynCheck_entry_vkCmdCopyBuffer2KHR(
- VkCommandBuffer commandBuffer,
- const VkCopyBufferInfo2KHR* pCopyBufferInfo)
-{
+static void dynCheck_entry_vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
+ const VkCopyBufferInfo2KHR* pCopyBufferInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
sOnInvalidDynamicallyCheckedCall("vkCmdCopyBuffer2KHR", "VK_KHR_copy_commands2");
}
AEMU_SCOPED_TRACE("vkCmdCopyBuffer2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo, true /* do lock */);
}
-static void entry_vkCmdCopyImage2KHR(
- VkCommandBuffer commandBuffer,
- const VkCopyImageInfo2KHR* pCopyImageInfo)
-{
+static void entry_vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer,
+ const VkCopyImageInfo2KHR* pCopyImageInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyImage2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo, true /* do lock */);
}
-static void dynCheck_entry_vkCmdCopyImage2KHR(
- VkCommandBuffer commandBuffer,
- const VkCopyImageInfo2KHR* pCopyImageInfo)
-{
+static void dynCheck_entry_vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer,
+ const VkCopyImageInfo2KHR* pCopyImageInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
sOnInvalidDynamicallyCheckedCall("vkCmdCopyImage2KHR", "VK_KHR_copy_commands2");
}
AEMU_SCOPED_TRACE("vkCmdCopyImage2KHR");
@@ -5283,21 +4319,17 @@
vkEnc->vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo, true /* do lock */);
}
static void entry_vkCmdCopyBufferToImage2KHR(
- VkCommandBuffer commandBuffer,
- const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo)
-{
+ VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo, true /* do lock */);
}
static void dynCheck_entry_vkCmdCopyBufferToImage2KHR(
- VkCommandBuffer commandBuffer,
- const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo)
-{
+ VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
sOnInvalidDynamicallyCheckedCall("vkCmdCopyBufferToImage2KHR", "VK_KHR_copy_commands2");
}
AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage2KHR");
@@ -5305,65 +4337,53 @@
vkEnc->vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo, true /* do lock */);
}
static void entry_vkCmdCopyImageToBuffer2KHR(
- VkCommandBuffer commandBuffer,
- const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo)
-{
+ VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo, true /* do lock */);
}
static void dynCheck_entry_vkCmdCopyImageToBuffer2KHR(
- VkCommandBuffer commandBuffer,
- const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo)
-{
+ VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
sOnInvalidDynamicallyCheckedCall("vkCmdCopyImageToBuffer2KHR", "VK_KHR_copy_commands2");
}
AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo, true /* do lock */);
}
-static void entry_vkCmdBlitImage2KHR(
- VkCommandBuffer commandBuffer,
- const VkBlitImageInfo2KHR* pBlitImageInfo)
-{
+static void entry_vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer,
+ const VkBlitImageInfo2KHR* pBlitImageInfo) {
AEMU_SCOPED_TRACE("vkCmdBlitImage2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo, true /* do lock */);
}
-static void dynCheck_entry_vkCmdBlitImage2KHR(
- VkCommandBuffer commandBuffer,
- const VkBlitImageInfo2KHR* pBlitImageInfo)
-{
+static void dynCheck_entry_vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer,
+ const VkBlitImageInfo2KHR* pBlitImageInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
sOnInvalidDynamicallyCheckedCall("vkCmdBlitImage2KHR", "VK_KHR_copy_commands2");
}
AEMU_SCOPED_TRACE("vkCmdBlitImage2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo, true /* do lock */);
}
-static void entry_vkCmdResolveImage2KHR(
- VkCommandBuffer commandBuffer,
- const VkResolveImageInfo2KHR* pResolveImageInfo)
-{
+static void entry_vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer,
+ const VkResolveImageInfo2KHR* pResolveImageInfo) {
AEMU_SCOPED_TRACE("vkCmdResolveImage2KHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo, true /* do lock */);
}
-static void dynCheck_entry_vkCmdResolveImage2KHR(
- VkCommandBuffer commandBuffer,
- const VkResolveImageInfo2KHR* pResolveImageInfo)
-{
+static void dynCheck_entry_vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer,
+ const VkResolveImageInfo2KHR* pResolveImageInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
sOnInvalidDynamicallyCheckedCall("vkCmdResolveImage2KHR", "VK_KHR_copy_commands2");
}
AEMU_SCOPED_TRACE("vkCmdResolveImage2KHR");
@@ -5375,188 +4395,161 @@
#endif
#ifdef VK_KHR_maintenance4
static void entry_vkGetDeviceBufferMemoryRequirementsKHR(
- VkDevice device,
- const VkDeviceBufferMemoryRequirementsKHR* pInfo,
- VkMemoryRequirements2* pMemoryRequirements)
-{
+ VkDevice device, const VkDeviceBufferMemoryRequirementsKHR* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetDeviceBufferMemoryRequirementsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements, true /* do lock */);
+ vkEnc->vkGetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements,
+ true /* do lock */);
}
static void dynCheck_entry_vkGetDeviceBufferMemoryRequirementsKHR(
- VkDevice device,
- const VkDeviceBufferMemoryRequirementsKHR* pInfo,
- VkMemoryRequirements2* pMemoryRequirements)
-{
+ VkDevice device, const VkDeviceBufferMemoryRequirementsKHR* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance4"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceBufferMemoryRequirementsKHR", "VK_KHR_maintenance4");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance4")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetDeviceBufferMemoryRequirementsKHR",
+ "VK_KHR_maintenance4");
}
AEMU_SCOPED_TRACE("vkGetDeviceBufferMemoryRequirementsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements, true /* do lock */);
+ vkEnc->vkGetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements,
+ true /* do lock */);
}
static void entry_vkGetDeviceImageMemoryRequirementsKHR(
- VkDevice device,
- const VkDeviceImageMemoryRequirementsKHR* pInfo,
- VkMemoryRequirements2* pMemoryRequirements)
-{
+ VkDevice device, const VkDeviceImageMemoryRequirementsKHR* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirementsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements, true /* do lock */);
+ vkEnc->vkGetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements,
+ true /* do lock */);
}
static void dynCheck_entry_vkGetDeviceImageMemoryRequirementsKHR(
- VkDevice device,
- const VkDeviceImageMemoryRequirementsKHR* pInfo,
- VkMemoryRequirements2* pMemoryRequirements)
-{
+ VkDevice device, const VkDeviceImageMemoryRequirementsKHR* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance4"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageMemoryRequirementsKHR", "VK_KHR_maintenance4");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance4")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageMemoryRequirementsKHR",
+ "VK_KHR_maintenance4");
}
AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirementsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements, true /* do lock */);
+ vkEnc->vkGetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements,
+ true /* do lock */);
}
static void entry_vkGetDeviceImageSparseMemoryRequirementsKHR(
- VkDevice device,
- const VkDeviceImageMemoryRequirementsKHR* pInfo,
+ VkDevice device, const VkDeviceImageMemoryRequirementsKHR* pInfo,
uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
-{
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetDeviceImageSparseMemoryRequirementsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, true /* do lock */);
+ vkEnc->vkGetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount,
+ pSparseMemoryRequirements,
+ true /* do lock */);
}
static void dynCheck_entry_vkGetDeviceImageSparseMemoryRequirementsKHR(
- VkDevice device,
- const VkDeviceImageMemoryRequirementsKHR* pInfo,
+ VkDevice device, const VkDeviceImageMemoryRequirementsKHR* pInfo,
uint32_t* pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
-{
+ VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance4"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageSparseMemoryRequirementsKHR", "VK_KHR_maintenance4");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance4")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageSparseMemoryRequirementsKHR",
+ "VK_KHR_maintenance4");
}
AEMU_SCOPED_TRACE("vkGetDeviceImageSparseMemoryRequirementsKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, true /* do lock */);
+ vkEnc->vkGetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount,
+ pSparseMemoryRequirements,
+ true /* do lock */);
}
#endif
#ifdef VK_ANDROID_native_buffer
-static VkResult entry_vkGetSwapchainGrallocUsageANDROID(
- VkDevice device,
- VkFormat format,
- VkImageUsageFlags imageUsage,
- int* grallocUsage)
-{
+static VkResult entry_vkGetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format,
+ VkImageUsageFlags imageUsage,
+ int* grallocUsage) {
AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
- vkGetSwapchainGrallocUsageANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsageANDROID(device, format, imageUsage, grallocUsage, true /* do lock */);
+ vkGetSwapchainGrallocUsageANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsageANDROID(
+ device, format, imageUsage, grallocUsage, true /* do lock */);
return vkGetSwapchainGrallocUsageANDROID_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetSwapchainGrallocUsageANDROID(
- VkDevice device,
- VkFormat format,
- VkImageUsageFlags imageUsage,
- int* grallocUsage)
-{
+static VkResult dynCheck_entry_vkGetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format,
+ VkImageUsageFlags imageUsage,
+ int* grallocUsage) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetSwapchainGrallocUsageANDROID", "VK_ANDROID_native_buffer");
+ if (!resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetSwapchainGrallocUsageANDROID",
+ "VK_ANDROID_native_buffer");
}
AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
- vkGetSwapchainGrallocUsageANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsageANDROID(device, format, imageUsage, grallocUsage, true /* do lock */);
+ vkGetSwapchainGrallocUsageANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsageANDROID(
+ device, format, imageUsage, grallocUsage, true /* do lock */);
return vkGetSwapchainGrallocUsageANDROID_VkResult_return;
}
-static VkResult entry_vkAcquireImageANDROID(
- VkDevice device,
- VkImage image,
- int nativeFenceFd,
- VkSemaphore semaphore,
- VkFence fence)
-{
+static VkResult entry_vkAcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd,
+ VkSemaphore semaphore, VkFence fence) {
AEMU_SCOPED_TRACE("vkAcquireImageANDROID");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
- vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(device, image, nativeFenceFd, semaphore, fence, true /* do lock */);
+ vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(
+ device, image, nativeFenceFd, semaphore, fence, true /* do lock */);
return vkAcquireImageANDROID_VkResult_return;
}
-static VkResult dynCheck_entry_vkAcquireImageANDROID(
- VkDevice device,
- VkImage image,
- int nativeFenceFd,
- VkSemaphore semaphore,
- VkFence fence)
-{
+static VkResult dynCheck_entry_vkAcquireImageANDROID(VkDevice device, VkImage image,
+ int nativeFenceFd, VkSemaphore semaphore,
+ VkFence fence) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer")) {
sOnInvalidDynamicallyCheckedCall("vkAcquireImageANDROID", "VK_ANDROID_native_buffer");
}
AEMU_SCOPED_TRACE("vkAcquireImageANDROID");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
- vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(device, image, nativeFenceFd, semaphore, fence, true /* do lock */);
+ vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(
+ device, image, nativeFenceFd, semaphore, fence, true /* do lock */);
return vkAcquireImageANDROID_VkResult_return;
}
-static VkResult entry_vkQueueSignalReleaseImageANDROID(
- VkQueue queue,
- uint32_t waitSemaphoreCount,
- const VkSemaphore* pWaitSemaphores,
- VkImage image,
- int* pNativeFenceFd)
-{
+static VkResult entry_vkQueueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount,
+ const VkSemaphore* pWaitSemaphores,
+ VkImage image, int* pNativeFenceFd) {
AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROID");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkQueueSignalReleaseImageANDROID_VkResult_return = resources->on_vkQueueSignalReleaseImageANDROID(vkEnc, VK_SUCCESS, queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd);
+ vkQueueSignalReleaseImageANDROID_VkResult_return =
+ resources->on_vkQueueSignalReleaseImageANDROID(vkEnc, VK_SUCCESS, queue, waitSemaphoreCount,
+ pWaitSemaphores, image, pNativeFenceFd);
return vkQueueSignalReleaseImageANDROID_VkResult_return;
}
#endif
#ifdef VK_EXT_debug_report
static VkResult entry_vkCreateDebugReportCallbackEXT(
- VkInstance instance,
- const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDebugReportCallbackEXT* pCallback)
-{
+ VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) {
AEMU_SCOPED_TRACE("vkCreateDebugReportCallbackEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDebugReportCallbackEXT_VkResult_return = (VkResult)0;
- vkCreateDebugReportCallbackEXT_VkResult_return = vkEnc->vkCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback, true /* do lock */);
+ vkCreateDebugReportCallbackEXT_VkResult_return = vkEnc->vkCreateDebugReportCallbackEXT(
+ instance, pCreateInfo, pAllocator, pCallback, true /* do lock */);
return vkCreateDebugReportCallbackEXT_VkResult_return;
}
-static void entry_vkDestroyDebugReportCallbackEXT(
- VkInstance instance,
- VkDebugReportCallbackEXT callback,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyDebugReportCallbackEXT(VkInstance instance,
+ VkDebugReportCallbackEXT callback,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyDebugReportCallbackEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyDebugReportCallbackEXT(instance, callback, pAllocator, true /* do lock */);
}
-static void entry_vkDebugReportMessageEXT(
- VkInstance instance,
- VkDebugReportFlagsEXT flags,
- VkDebugReportObjectTypeEXT objectType,
- uint64_t object,
- size_t location,
- int32_t messageCode,
- const char* pLayerPrefix,
- const char* pMessage)
-{
+static void entry_vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
+ VkDebugReportObjectTypeEXT objectType, uint64_t object,
+ size_t location, int32_t messageCode,
+ const char* pLayerPrefix, const char* pMessage) {
AEMU_SCOPED_TRACE("vkDebugReportMessageEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage, true /* do lock */);
+ vkEnc->vkDebugReportMessageEXT(instance, flags, objectType, object, location, messageCode,
+ pLayerPrefix, pMessage, true /* do lock */);
}
#endif
#ifdef VK_NV_glsl_shader
@@ -5572,114 +4565,96 @@
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
-static VkResult entry_vkDebugMarkerSetObjectTagEXT(
- VkDevice device,
- const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
-{
+static VkResult entry_vkDebugMarkerSetObjectTagEXT(VkDevice device,
+ const VkDebugMarkerObjectTagInfoEXT* pTagInfo) {
AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectTagEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkDebugMarkerSetObjectTagEXT_VkResult_return = (VkResult)0;
- vkDebugMarkerSetObjectTagEXT_VkResult_return = vkEnc->vkDebugMarkerSetObjectTagEXT(device, pTagInfo, true /* do lock */);
+ vkDebugMarkerSetObjectTagEXT_VkResult_return =
+ vkEnc->vkDebugMarkerSetObjectTagEXT(device, pTagInfo, true /* do lock */);
return vkDebugMarkerSetObjectTagEXT_VkResult_return;
}
static VkResult dynCheck_entry_vkDebugMarkerSetObjectTagEXT(
- VkDevice device,
- const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
-{
+ VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_debug_marker"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_EXT_debug_marker")) {
sOnInvalidDynamicallyCheckedCall("vkDebugMarkerSetObjectTagEXT", "VK_EXT_debug_marker");
}
AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectTagEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkDebugMarkerSetObjectTagEXT_VkResult_return = (VkResult)0;
- vkDebugMarkerSetObjectTagEXT_VkResult_return = vkEnc->vkDebugMarkerSetObjectTagEXT(device, pTagInfo, true /* do lock */);
+ vkDebugMarkerSetObjectTagEXT_VkResult_return =
+ vkEnc->vkDebugMarkerSetObjectTagEXT(device, pTagInfo, true /* do lock */);
return vkDebugMarkerSetObjectTagEXT_VkResult_return;
}
static VkResult entry_vkDebugMarkerSetObjectNameEXT(
- VkDevice device,
- const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
-{
+ VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) {
AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectNameEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkDebugMarkerSetObjectNameEXT_VkResult_return = (VkResult)0;
- vkDebugMarkerSetObjectNameEXT_VkResult_return = vkEnc->vkDebugMarkerSetObjectNameEXT(device, pNameInfo, true /* do lock */);
+ vkDebugMarkerSetObjectNameEXT_VkResult_return =
+ vkEnc->vkDebugMarkerSetObjectNameEXT(device, pNameInfo, true /* do lock */);
return vkDebugMarkerSetObjectNameEXT_VkResult_return;
}
static VkResult dynCheck_entry_vkDebugMarkerSetObjectNameEXT(
- VkDevice device,
- const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
-{
+ VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_debug_marker"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_EXT_debug_marker")) {
sOnInvalidDynamicallyCheckedCall("vkDebugMarkerSetObjectNameEXT", "VK_EXT_debug_marker");
}
AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectNameEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkDebugMarkerSetObjectNameEXT_VkResult_return = (VkResult)0;
- vkDebugMarkerSetObjectNameEXT_VkResult_return = vkEnc->vkDebugMarkerSetObjectNameEXT(device, pNameInfo, true /* do lock */);
+ vkDebugMarkerSetObjectNameEXT_VkResult_return =
+ vkEnc->vkDebugMarkerSetObjectNameEXT(device, pNameInfo, true /* do lock */);
return vkDebugMarkerSetObjectNameEXT_VkResult_return;
}
-static void entry_vkCmdDebugMarkerBeginEXT(
- VkCommandBuffer commandBuffer,
- const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
-{
+static void entry_vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {
AEMU_SCOPED_TRACE("vkCmdDebugMarkerBeginEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo, true /* do lock */);
}
-static void dynCheck_entry_vkCmdDebugMarkerBeginEXT(
- VkCommandBuffer commandBuffer,
- const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
-{
+static void dynCheck_entry_vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_debug_marker"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_debug_marker")) {
sOnInvalidDynamicallyCheckedCall("vkCmdDebugMarkerBeginEXT", "VK_EXT_debug_marker");
}
AEMU_SCOPED_TRACE("vkCmdDebugMarkerBeginEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo, true /* do lock */);
}
-static void entry_vkCmdDebugMarkerEndEXT(
- VkCommandBuffer commandBuffer)
-{
+static void entry_vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) {
AEMU_SCOPED_TRACE("vkCmdDebugMarkerEndEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdDebugMarkerEndEXT(commandBuffer, true /* do lock */);
}
-static void dynCheck_entry_vkCmdDebugMarkerEndEXT(
- VkCommandBuffer commandBuffer)
-{
+static void dynCheck_entry_vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_debug_marker"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_debug_marker")) {
sOnInvalidDynamicallyCheckedCall("vkCmdDebugMarkerEndEXT", "VK_EXT_debug_marker");
}
AEMU_SCOPED_TRACE("vkCmdDebugMarkerEndEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdDebugMarkerEndEXT(commandBuffer, true /* do lock */);
}
-static void entry_vkCmdDebugMarkerInsertEXT(
- VkCommandBuffer commandBuffer,
- const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
-{
+static void entry_vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer,
+ const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {
AEMU_SCOPED_TRACE("vkCmdDebugMarkerInsertEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo, true /* do lock */);
}
static void dynCheck_entry_vkCmdDebugMarkerInsertEXT(
- VkCommandBuffer commandBuffer,
- const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
-{
+ VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_debug_marker"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_debug_marker")) {
sOnInvalidDynamicallyCheckedCall("vkCmdDebugMarkerInsertEXT", "VK_EXT_debug_marker");
}
AEMU_SCOPED_TRACE("vkCmdDebugMarkerInsertEXT");
@@ -5692,300 +4667,252 @@
#ifdef VK_NV_dedicated_allocation
#endif
#ifdef VK_EXT_transform_feedback
-static void entry_vkCmdBindTransformFeedbackBuffersEXT(
- VkCommandBuffer commandBuffer,
- uint32_t firstBinding,
- uint32_t bindingCount,
- const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets,
- const VkDeviceSize* pSizes)
-{
+static void entry_vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer,
+ uint32_t firstBinding, uint32_t bindingCount,
+ const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets,
+ const VkDeviceSize* pSizes) {
AEMU_SCOPED_TRACE("vkCmdBindTransformFeedbackBuffersEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, true /* do lock */);
+ vkEnc->vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers,
+ pOffsets, pSizes, true /* do lock */);
}
static void dynCheck_entry_vkCmdBindTransformFeedbackBuffersEXT(
- VkCommandBuffer commandBuffer,
- uint32_t firstBinding,
- uint32_t bindingCount,
- const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets,
- const VkDeviceSize* pSizes)
-{
+ VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount,
+ const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdBindTransformFeedbackBuffersEXT", "VK_EXT_transform_feedback");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdBindTransformFeedbackBuffersEXT",
+ "VK_EXT_transform_feedback");
}
AEMU_SCOPED_TRACE("vkCmdBindTransformFeedbackBuffersEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, true /* do lock */);
+ vkEnc->vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers,
+ pOffsets, pSizes, true /* do lock */);
}
-static void entry_vkCmdBeginTransformFeedbackEXT(
- VkCommandBuffer commandBuffer,
- uint32_t firstCounterBuffer,
- uint32_t counterBufferCount,
- const VkBuffer* pCounterBuffers,
- const VkDeviceSize* pCounterBufferOffsets)
-{
+static void entry_vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer,
+ uint32_t firstCounterBuffer,
+ uint32_t counterBufferCount,
+ const VkBuffer* pCounterBuffers,
+ const VkDeviceSize* pCounterBufferOffsets) {
AEMU_SCOPED_TRACE("vkCmdBeginTransformFeedbackEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets, true /* do lock */);
+ vkEnc->vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount,
+ pCounterBuffers, pCounterBufferOffsets,
+ true /* do lock */);
}
static void dynCheck_entry_vkCmdBeginTransformFeedbackEXT(
- VkCommandBuffer commandBuffer,
- uint32_t firstCounterBuffer,
- uint32_t counterBufferCount,
- const VkBuffer* pCounterBuffers,
- const VkDeviceSize* pCounterBufferOffsets)
-{
+ VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount,
+ const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdBeginTransformFeedbackEXT", "VK_EXT_transform_feedback");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdBeginTransformFeedbackEXT",
+ "VK_EXT_transform_feedback");
}
AEMU_SCOPED_TRACE("vkCmdBeginTransformFeedbackEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets, true /* do lock */);
+ vkEnc->vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount,
+ pCounterBuffers, pCounterBufferOffsets,
+ true /* do lock */);
}
-static void entry_vkCmdEndTransformFeedbackEXT(
- VkCommandBuffer commandBuffer,
- uint32_t firstCounterBuffer,
- uint32_t counterBufferCount,
- const VkBuffer* pCounterBuffers,
- const VkDeviceSize* pCounterBufferOffsets)
-{
+static void entry_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,
+ uint32_t firstCounterBuffer,
+ uint32_t counterBufferCount,
+ const VkBuffer* pCounterBuffers,
+ const VkDeviceSize* pCounterBufferOffsets) {
AEMU_SCOPED_TRACE("vkCmdEndTransformFeedbackEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets, true /* do lock */);
+ vkEnc->vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount,
+ pCounterBuffers, pCounterBufferOffsets, true /* do lock */);
}
-static void dynCheck_entry_vkCmdEndTransformFeedbackEXT(
- VkCommandBuffer commandBuffer,
- uint32_t firstCounterBuffer,
- uint32_t counterBufferCount,
- const VkBuffer* pCounterBuffers,
- const VkDeviceSize* pCounterBufferOffsets)
-{
+static void dynCheck_entry_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,
+ uint32_t firstCounterBuffer,
+ uint32_t counterBufferCount,
+ const VkBuffer* pCounterBuffers,
+ const VkDeviceSize* pCounterBufferOffsets) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdEndTransformFeedbackEXT", "VK_EXT_transform_feedback");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdEndTransformFeedbackEXT",
+ "VK_EXT_transform_feedback");
}
AEMU_SCOPED_TRACE("vkCmdEndTransformFeedbackEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets, true /* do lock */);
+ vkEnc->vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount,
+ pCounterBuffers, pCounterBufferOffsets, true /* do lock */);
}
-static void entry_vkCmdBeginQueryIndexedEXT(
- VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t query,
- VkQueryControlFlags flags,
- uint32_t index)
-{
+static void entry_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t query, VkQueryControlFlags flags,
+ uint32_t index) {
AEMU_SCOPED_TRACE("vkCmdBeginQueryIndexedEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index, true /* do lock */);
+ vkEnc->vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index,
+ true /* do lock */);
}
-static void dynCheck_entry_vkCmdBeginQueryIndexedEXT(
- VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t query,
- VkQueryControlFlags flags,
- uint32_t index)
-{
+static void dynCheck_entry_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool, uint32_t query,
+ VkQueryControlFlags flags, uint32_t index) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
sOnInvalidDynamicallyCheckedCall("vkCmdBeginQueryIndexedEXT", "VK_EXT_transform_feedback");
}
AEMU_SCOPED_TRACE("vkCmdBeginQueryIndexedEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index, true /* do lock */);
+ vkEnc->vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index,
+ true /* do lock */);
}
-static void entry_vkCmdEndQueryIndexedEXT(
- VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t query,
- uint32_t index)
-{
+static void entry_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+ uint32_t query, uint32_t index) {
AEMU_SCOPED_TRACE("vkCmdEndQueryIndexedEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index, true /* do lock */);
}
-static void dynCheck_entry_vkCmdEndQueryIndexedEXT(
- VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t query,
- uint32_t index)
-{
+static void dynCheck_entry_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool, uint32_t query,
+ uint32_t index) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
sOnInvalidDynamicallyCheckedCall("vkCmdEndQueryIndexedEXT", "VK_EXT_transform_feedback");
}
AEMU_SCOPED_TRACE("vkCmdEndQueryIndexedEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index, true /* do lock */);
}
-static void entry_vkCmdDrawIndirectByteCountEXT(
- VkCommandBuffer commandBuffer,
- uint32_t instanceCount,
- uint32_t firstInstance,
- VkBuffer counterBuffer,
- VkDeviceSize counterBufferOffset,
- uint32_t counterOffset,
- uint32_t vertexStride)
-{
+static void entry_vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer,
+ uint32_t instanceCount, uint32_t firstInstance,
+ VkBuffer counterBuffer,
+ VkDeviceSize counterBufferOffset,
+ uint32_t counterOffset, uint32_t vertexStride) {
AEMU_SCOPED_TRACE("vkCmdDrawIndirectByteCountEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride, true /* do lock */);
+ vkEnc->vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer,
+ counterBufferOffset, counterOffset, vertexStride,
+ true /* do lock */);
}
static void dynCheck_entry_vkCmdDrawIndirectByteCountEXT(
- VkCommandBuffer commandBuffer,
- uint32_t instanceCount,
- uint32_t firstInstance,
- VkBuffer counterBuffer,
- VkDeviceSize counterBufferOffset,
- uint32_t counterOffset,
- uint32_t vertexStride)
-{
+ VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance,
+ VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset,
+ uint32_t vertexStride) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdDrawIndirectByteCountEXT", "VK_EXT_transform_feedback");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdDrawIndirectByteCountEXT",
+ "VK_EXT_transform_feedback");
}
AEMU_SCOPED_TRACE("vkCmdDrawIndirectByteCountEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride, true /* do lock */);
+ vkEnc->vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer,
+ counterBufferOffset, counterOffset, vertexStride,
+ true /* do lock */);
}
#endif
#ifdef VK_NVX_binary_import
-static VkResult entry_vkCreateCuModuleNVX(
- VkDevice device,
- const VkCuModuleCreateInfoNVX* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkCuModuleNVX* pModule)
-{
+static VkResult entry_vkCreateCuModuleNVX(VkDevice device,
+ const VkCuModuleCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCuModuleNVX* pModule) {
AEMU_SCOPED_TRACE("vkCreateCuModuleNVX");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateCuModuleNVX_VkResult_return = (VkResult)0;
- vkCreateCuModuleNVX_VkResult_return = vkEnc->vkCreateCuModuleNVX(device, pCreateInfo, pAllocator, pModule, true /* do lock */);
+ vkCreateCuModuleNVX_VkResult_return =
+ vkEnc->vkCreateCuModuleNVX(device, pCreateInfo, pAllocator, pModule, true /* do lock */);
return vkCreateCuModuleNVX_VkResult_return;
}
-static VkResult dynCheck_entry_vkCreateCuModuleNVX(
- VkDevice device,
- const VkCuModuleCreateInfoNVX* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkCuModuleNVX* pModule)
-{
+static VkResult dynCheck_entry_vkCreateCuModuleNVX(VkDevice device,
+ const VkCuModuleCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCuModuleNVX* pModule) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_NVX_binary_import"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_NVX_binary_import")) {
sOnInvalidDynamicallyCheckedCall("vkCreateCuModuleNVX", "VK_NVX_binary_import");
}
AEMU_SCOPED_TRACE("vkCreateCuModuleNVX");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateCuModuleNVX_VkResult_return = (VkResult)0;
- vkCreateCuModuleNVX_VkResult_return = vkEnc->vkCreateCuModuleNVX(device, pCreateInfo, pAllocator, pModule, true /* do lock */);
+ vkCreateCuModuleNVX_VkResult_return =
+ vkEnc->vkCreateCuModuleNVX(device, pCreateInfo, pAllocator, pModule, true /* do lock */);
return vkCreateCuModuleNVX_VkResult_return;
}
-static VkResult entry_vkCreateCuFunctionNVX(
- VkDevice device,
- const VkCuFunctionCreateInfoNVX* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkCuFunctionNVX* pFunction)
-{
+static VkResult entry_vkCreateCuFunctionNVX(VkDevice device,
+ const VkCuFunctionCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCuFunctionNVX* pFunction) {
AEMU_SCOPED_TRACE("vkCreateCuFunctionNVX");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateCuFunctionNVX_VkResult_return = (VkResult)0;
- vkCreateCuFunctionNVX_VkResult_return = vkEnc->vkCreateCuFunctionNVX(device, pCreateInfo, pAllocator, pFunction, true /* do lock */);
+ vkCreateCuFunctionNVX_VkResult_return = vkEnc->vkCreateCuFunctionNVX(
+ device, pCreateInfo, pAllocator, pFunction, true /* do lock */);
return vkCreateCuFunctionNVX_VkResult_return;
}
-static VkResult dynCheck_entry_vkCreateCuFunctionNVX(
- VkDevice device,
- const VkCuFunctionCreateInfoNVX* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkCuFunctionNVX* pFunction)
-{
+static VkResult dynCheck_entry_vkCreateCuFunctionNVX(VkDevice device,
+ const VkCuFunctionCreateInfoNVX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCuFunctionNVX* pFunction) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_NVX_binary_import"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_NVX_binary_import")) {
sOnInvalidDynamicallyCheckedCall("vkCreateCuFunctionNVX", "VK_NVX_binary_import");
}
AEMU_SCOPED_TRACE("vkCreateCuFunctionNVX");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateCuFunctionNVX_VkResult_return = (VkResult)0;
- vkCreateCuFunctionNVX_VkResult_return = vkEnc->vkCreateCuFunctionNVX(device, pCreateInfo, pAllocator, pFunction, true /* do lock */);
+ vkCreateCuFunctionNVX_VkResult_return = vkEnc->vkCreateCuFunctionNVX(
+ device, pCreateInfo, pAllocator, pFunction, true /* do lock */);
return vkCreateCuFunctionNVX_VkResult_return;
}
-static void entry_vkDestroyCuModuleNVX(
- VkDevice device,
- VkCuModuleNVX module,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyCuModuleNVX");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyCuModuleNVX(device, module, pAllocator, true /* do lock */);
}
-static void dynCheck_entry_vkDestroyCuModuleNVX(
- VkDevice device,
- VkCuModuleNVX module,
- const VkAllocationCallbacks* pAllocator)
-{
+static void dynCheck_entry_vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module,
+ const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_NVX_binary_import"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_NVX_binary_import")) {
sOnInvalidDynamicallyCheckedCall("vkDestroyCuModuleNVX", "VK_NVX_binary_import");
}
AEMU_SCOPED_TRACE("vkDestroyCuModuleNVX");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyCuModuleNVX(device, module, pAllocator, true /* do lock */);
}
-static void entry_vkDestroyCuFunctionNVX(
- VkDevice device,
- VkCuFunctionNVX function,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyCuFunctionNVX");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyCuFunctionNVX(device, function, pAllocator, true /* do lock */);
}
-static void dynCheck_entry_vkDestroyCuFunctionNVX(
- VkDevice device,
- VkCuFunctionNVX function,
- const VkAllocationCallbacks* pAllocator)
-{
+static void dynCheck_entry_vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function,
+ const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_NVX_binary_import"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_NVX_binary_import")) {
sOnInvalidDynamicallyCheckedCall("vkDestroyCuFunctionNVX", "VK_NVX_binary_import");
}
AEMU_SCOPED_TRACE("vkDestroyCuFunctionNVX");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyCuFunctionNVX(device, function, pAllocator, true /* do lock */);
}
-static void entry_vkCmdCuLaunchKernelNVX(
- VkCommandBuffer commandBuffer,
- const VkCuLaunchInfoNVX* pLaunchInfo)
-{
+static void entry_vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer,
+ const VkCuLaunchInfoNVX* pLaunchInfo) {
AEMU_SCOPED_TRACE("vkCmdCuLaunchKernelNVX");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdCuLaunchKernelNVX(commandBuffer, pLaunchInfo, true /* do lock */);
}
-static void dynCheck_entry_vkCmdCuLaunchKernelNVX(
- VkCommandBuffer commandBuffer,
- const VkCuLaunchInfoNVX* pLaunchInfo)
-{
+static void dynCheck_entry_vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer,
+ const VkCuLaunchInfoNVX* pLaunchInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_NVX_binary_import"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_NVX_binary_import")) {
sOnInvalidDynamicallyCheckedCall("vkCmdCuLaunchKernelNVX", "VK_NVX_binary_import");
}
AEMU_SCOPED_TRACE("vkCmdCuLaunchKernelNVX");
@@ -5994,123 +4921,101 @@
}
#endif
#ifdef VK_NVX_image_view_handle
-static uint32_t entry_vkGetImageViewHandleNVX(
- VkDevice device,
- const VkImageViewHandleInfoNVX* pInfo)
-{
+static uint32_t entry_vkGetImageViewHandleNVX(VkDevice device,
+ const VkImageViewHandleInfoNVX* pInfo) {
AEMU_SCOPED_TRACE("vkGetImageViewHandleNVX");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint32_t vkGetImageViewHandleNVX_uint32_t_return = (uint32_t)0;
- vkGetImageViewHandleNVX_uint32_t_return = vkEnc->vkGetImageViewHandleNVX(device, pInfo, true /* do lock */);
+ vkGetImageViewHandleNVX_uint32_t_return =
+ vkEnc->vkGetImageViewHandleNVX(device, pInfo, true /* do lock */);
return vkGetImageViewHandleNVX_uint32_t_return;
}
-static uint32_t dynCheck_entry_vkGetImageViewHandleNVX(
- VkDevice device,
- const VkImageViewHandleInfoNVX* pInfo)
-{
+static uint32_t dynCheck_entry_vkGetImageViewHandleNVX(VkDevice device,
+ const VkImageViewHandleInfoNVX* pInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_NVX_image_view_handle"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_NVX_image_view_handle")) {
sOnInvalidDynamicallyCheckedCall("vkGetImageViewHandleNVX", "VK_NVX_image_view_handle");
}
AEMU_SCOPED_TRACE("vkGetImageViewHandleNVX");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
uint32_t vkGetImageViewHandleNVX_uint32_t_return = (uint32_t)0;
- vkGetImageViewHandleNVX_uint32_t_return = vkEnc->vkGetImageViewHandleNVX(device, pInfo, true /* do lock */);
+ vkGetImageViewHandleNVX_uint32_t_return =
+ vkEnc->vkGetImageViewHandleNVX(device, pInfo, true /* do lock */);
return vkGetImageViewHandleNVX_uint32_t_return;
}
-static VkResult entry_vkGetImageViewAddressNVX(
- VkDevice device,
- VkImageView imageView,
- VkImageViewAddressPropertiesNVX* pProperties)
-{
+static VkResult entry_vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView,
+ VkImageViewAddressPropertiesNVX* pProperties) {
AEMU_SCOPED_TRACE("vkGetImageViewAddressNVX");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetImageViewAddressNVX_VkResult_return = (VkResult)0;
- vkGetImageViewAddressNVX_VkResult_return = vkEnc->vkGetImageViewAddressNVX(device, imageView, pProperties, true /* do lock */);
+ vkGetImageViewAddressNVX_VkResult_return =
+ vkEnc->vkGetImageViewAddressNVX(device, imageView, pProperties, true /* do lock */);
return vkGetImageViewAddressNVX_VkResult_return;
}
static VkResult dynCheck_entry_vkGetImageViewAddressNVX(
- VkDevice device,
- VkImageView imageView,
- VkImageViewAddressPropertiesNVX* pProperties)
-{
+ VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_NVX_image_view_handle"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_NVX_image_view_handle")) {
sOnInvalidDynamicallyCheckedCall("vkGetImageViewAddressNVX", "VK_NVX_image_view_handle");
}
AEMU_SCOPED_TRACE("vkGetImageViewAddressNVX");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetImageViewAddressNVX_VkResult_return = (VkResult)0;
- vkGetImageViewAddressNVX_VkResult_return = vkEnc->vkGetImageViewAddressNVX(device, imageView, pProperties, true /* do lock */);
+ vkGetImageViewAddressNVX_VkResult_return =
+ vkEnc->vkGetImageViewAddressNVX(device, imageView, pProperties, true /* do lock */);
return vkGetImageViewAddressNVX_VkResult_return;
}
#endif
#ifdef VK_AMD_draw_indirect_count
-static void entry_vkCmdDrawIndirectCountAMD(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride)
-{
+static void entry_vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+ uint32_t stride) {
AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountAMD");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, true /* do lock */);
+ vkEnc->vkCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset,
+ maxDrawCount, stride, true /* do lock */);
}
-static void dynCheck_entry_vkCmdDrawIndirectCountAMD(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride)
-{
+static void dynCheck_entry_vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount, uint32_t stride) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_AMD_draw_indirect_count"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_AMD_draw_indirect_count")) {
sOnInvalidDynamicallyCheckedCall("vkCmdDrawIndirectCountAMD", "VK_AMD_draw_indirect_count");
}
AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountAMD");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, true /* do lock */);
+ vkEnc->vkCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset,
+ maxDrawCount, stride, true /* do lock */);
}
-static void entry_vkCmdDrawIndexedIndirectCountAMD(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride)
-{
+static void entry_vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount, uint32_t stride) {
AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountAMD");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, true /* do lock */);
+ vkEnc->vkCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer,
+ countBufferOffset, maxDrawCount, stride,
+ true /* do lock */);
}
static void dynCheck_entry_vkCmdDrawIndexedIndirectCountAMD(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride)
-{
+ VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_AMD_draw_indirect_count"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdDrawIndexedIndirectCountAMD", "VK_AMD_draw_indirect_count");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_AMD_draw_indirect_count")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdDrawIndexedIndirectCountAMD",
+ "VK_AMD_draw_indirect_count");
}
AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountAMD");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, true /* do lock */);
+ vkEnc->vkCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer,
+ countBufferOffset, maxDrawCount, stride,
+ true /* do lock */);
}
#endif
#ifdef VK_AMD_negative_viewport_height
@@ -6128,37 +5033,30 @@
#ifdef VK_AMD_texture_gather_bias_lod
#endif
#ifdef VK_AMD_shader_info
-static VkResult entry_vkGetShaderInfoAMD(
- VkDevice device,
- VkPipeline pipeline,
- VkShaderStageFlagBits shaderStage,
- VkShaderInfoTypeAMD infoType,
- size_t* pInfoSize,
- void* pInfo)
-{
+static VkResult entry_vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline,
+ VkShaderStageFlagBits shaderStage,
+ VkShaderInfoTypeAMD infoType, size_t* pInfoSize,
+ void* pInfo) {
AEMU_SCOPED_TRACE("vkGetShaderInfoAMD");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetShaderInfoAMD_VkResult_return = (VkResult)0;
- vkGetShaderInfoAMD_VkResult_return = vkEnc->vkGetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo, true /* do lock */);
+ vkGetShaderInfoAMD_VkResult_return = vkEnc->vkGetShaderInfoAMD(
+ device, pipeline, shaderStage, infoType, pInfoSize, pInfo, true /* do lock */);
return vkGetShaderInfoAMD_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetShaderInfoAMD(
- VkDevice device,
- VkPipeline pipeline,
- VkShaderStageFlagBits shaderStage,
- VkShaderInfoTypeAMD infoType,
- size_t* pInfoSize,
- void* pInfo)
-{
+static VkResult dynCheck_entry_vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline,
+ VkShaderStageFlagBits shaderStage,
+ VkShaderInfoTypeAMD infoType, size_t* pInfoSize,
+ void* pInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_AMD_shader_info"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_AMD_shader_info")) {
sOnInvalidDynamicallyCheckedCall("vkGetShaderInfoAMD", "VK_AMD_shader_info");
}
AEMU_SCOPED_TRACE("vkGetShaderInfoAMD");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetShaderInfoAMD_VkResult_return = (VkResult)0;
- vkGetShaderInfoAMD_VkResult_return = vkEnc->vkGetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo, true /* do lock */);
+ vkGetShaderInfoAMD_VkResult_return = vkEnc->vkGetShaderInfoAMD(
+ device, pipeline, shaderStage, infoType, pInfoSize, pInfo, true /* do lock */);
return vkGetShaderInfoAMD_VkResult_return;
}
#endif
@@ -6166,15 +5064,13 @@
#endif
#ifdef VK_GGP_stream_descriptor_surface
static VkResult entry_vkCreateStreamDescriptorSurfaceGGP(
- VkInstance instance,
- const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface)
-{
+ VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateStreamDescriptorSurfaceGGP");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateStreamDescriptorSurfaceGGP_VkResult_return = (VkResult)0;
- vkCreateStreamDescriptorSurfaceGGP_VkResult_return = vkEnc->vkCreateStreamDescriptorSurfaceGGP(instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
+ vkCreateStreamDescriptorSurfaceGGP_VkResult_return = vkEnc->vkCreateStreamDescriptorSurfaceGGP(
+ instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateStreamDescriptorSurfaceGGP_VkResult_return;
}
#endif
@@ -6184,52 +5080,45 @@
#endif
#ifdef VK_NV_external_memory_capabilities
static VkResult entry_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
- VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkImageType type,
- VkImageTiling tiling,
- VkImageUsageFlags usage,
- VkImageCreateFlags flags,
+ VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling,
+ VkImageUsageFlags usage, VkImageCreateFlags flags,
VkExternalMemoryHandleTypeFlagsNV externalHandleType,
- VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
-{
+ VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalImageFormatPropertiesNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return = vkEnc->vkGetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties, true /* do lock */);
+ vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+ physicalDevice, format, type, tiling, usage, flags, externalHandleType,
+ pExternalImageFormatProperties, true /* do lock */);
return vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return;
}
#endif
#ifdef VK_NV_external_memory
#endif
#ifdef VK_NV_external_memory_win32
-static VkResult entry_vkGetMemoryWin32HandleNV(
- VkDevice device,
- VkDeviceMemory memory,
- VkExternalMemoryHandleTypeFlagsNV handleType,
- HANDLE* pHandle)
-{
+static VkResult entry_vkGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory,
+ VkExternalMemoryHandleTypeFlagsNV handleType,
+ HANDLE* pHandle) {
AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryWin32HandleNV_VkResult_return = (VkResult)0;
- vkGetMemoryWin32HandleNV_VkResult_return = vkEnc->vkGetMemoryWin32HandleNV(device, memory, handleType, pHandle, true /* do lock */);
+ vkGetMemoryWin32HandleNV_VkResult_return =
+ vkEnc->vkGetMemoryWin32HandleNV(device, memory, handleType, pHandle, true /* do lock */);
return vkGetMemoryWin32HandleNV_VkResult_return;
}
static VkResult dynCheck_entry_vkGetMemoryWin32HandleNV(
- VkDevice device,
- VkDeviceMemory memory,
- VkExternalMemoryHandleTypeFlagsNV handleType,
- HANDLE* pHandle)
-{
+ VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType,
+ HANDLE* pHandle) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_NV_external_memory_win32"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_NV_external_memory_win32")) {
sOnInvalidDynamicallyCheckedCall("vkGetMemoryWin32HandleNV", "VK_NV_external_memory_win32");
}
AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryWin32HandleNV_VkResult_return = (VkResult)0;
- vkGetMemoryWin32HandleNV_VkResult_return = vkEnc->vkGetMemoryWin32HandleNV(device, memory, handleType, pHandle, true /* do lock */);
+ vkGetMemoryWin32HandleNV_VkResult_return =
+ vkEnc->vkGetMemoryWin32HandleNV(device, memory, handleType, pHandle, true /* do lock */);
return vkGetMemoryWin32HandleNV_VkResult_return;
}
#endif
@@ -6238,16 +5127,15 @@
#ifdef VK_EXT_validation_flags
#endif
#ifdef VK_NN_vi_surface
-static VkResult entry_vkCreateViSurfaceNN(
- VkInstance instance,
- const VkViSurfaceCreateInfoNN* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface)
-{
+static VkResult entry_vkCreateViSurfaceNN(VkInstance instance,
+ const VkViSurfaceCreateInfoNN* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateViSurfaceNN");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateViSurfaceNN_VkResult_return = (VkResult)0;
- vkCreateViSurfaceNN_VkResult_return = vkEnc->vkCreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
+ vkCreateViSurfaceNN_VkResult_return =
+ vkEnc->vkCreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateViSurfaceNN_VkResult_return;
}
#endif
@@ -6262,41 +5150,39 @@
#ifdef VK_EXT_conditional_rendering
static void entry_vkCmdBeginConditionalRenderingEXT(
VkCommandBuffer commandBuffer,
- const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
-{
+ const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) {
AEMU_SCOPED_TRACE("vkCmdBeginConditionalRenderingEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin, true /* do lock */);
+ vkEnc->vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin,
+ true /* do lock */);
}
static void dynCheck_entry_vkCmdBeginConditionalRenderingEXT(
VkCommandBuffer commandBuffer,
- const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
-{
+ const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_conditional_rendering"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdBeginConditionalRenderingEXT", "VK_EXT_conditional_rendering");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_conditional_rendering")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdBeginConditionalRenderingEXT",
+ "VK_EXT_conditional_rendering");
}
AEMU_SCOPED_TRACE("vkCmdBeginConditionalRenderingEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin, true /* do lock */);
+ vkEnc->vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin,
+ true /* do lock */);
}
-static void entry_vkCmdEndConditionalRenderingEXT(
- VkCommandBuffer commandBuffer)
-{
+static void entry_vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) {
AEMU_SCOPED_TRACE("vkCmdEndConditionalRenderingEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdEndConditionalRenderingEXT(commandBuffer, true /* do lock */);
}
-static void dynCheck_entry_vkCmdEndConditionalRenderingEXT(
- VkCommandBuffer commandBuffer)
-{
+static void dynCheck_entry_vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_conditional_rendering"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdEndConditionalRenderingEXT", "VK_EXT_conditional_rendering");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_conditional_rendering")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdEndConditionalRenderingEXT",
+ "VK_EXT_conditional_rendering");
}
AEMU_SCOPED_TRACE("vkCmdEndConditionalRenderingEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
@@ -6304,256 +5190,220 @@
}
#endif
#ifdef VK_NV_clip_space_w_scaling
-static void entry_vkCmdSetViewportWScalingNV(
- VkCommandBuffer commandBuffer,
- uint32_t firstViewport,
- uint32_t viewportCount,
- const VkViewportWScalingNV* pViewportWScalings)
-{
+static void entry_vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewportWScalingNV* pViewportWScalings) {
AEMU_SCOPED_TRACE("vkCmdSetViewportWScalingNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings, true /* do lock */);
+ vkEnc->vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount,
+ pViewportWScalings, true /* do lock */);
}
static void dynCheck_entry_vkCmdSetViewportWScalingNV(
- VkCommandBuffer commandBuffer,
- uint32_t firstViewport,
- uint32_t viewportCount,
- const VkViewportWScalingNV* pViewportWScalings)
-{
+ VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount,
+ const VkViewportWScalingNV* pViewportWScalings) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_NV_clip_space_w_scaling"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetViewportWScalingNV", "VK_NV_clip_space_w_scaling");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_NV_clip_space_w_scaling")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetViewportWScalingNV",
+ "VK_NV_clip_space_w_scaling");
}
AEMU_SCOPED_TRACE("vkCmdSetViewportWScalingNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings, true /* do lock */);
+ vkEnc->vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount,
+ pViewportWScalings, true /* do lock */);
}
#endif
#ifdef VK_EXT_direct_mode_display
-static VkResult entry_vkReleaseDisplayEXT(
- VkPhysicalDevice physicalDevice,
- VkDisplayKHR display)
-{
+static VkResult entry_vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) {
AEMU_SCOPED_TRACE("vkReleaseDisplayEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkReleaseDisplayEXT_VkResult_return = (VkResult)0;
- vkReleaseDisplayEXT_VkResult_return = vkEnc->vkReleaseDisplayEXT(physicalDevice, display, true /* do lock */);
+ vkReleaseDisplayEXT_VkResult_return =
+ vkEnc->vkReleaseDisplayEXT(physicalDevice, display, true /* do lock */);
return vkReleaseDisplayEXT_VkResult_return;
}
#endif
#ifdef VK_EXT_acquire_xlib_display
-static VkResult entry_vkAcquireXlibDisplayEXT(
- VkPhysicalDevice physicalDevice,
- Display* dpy,
- VkDisplayKHR display)
-{
+static VkResult entry_vkAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy,
+ VkDisplayKHR display) {
AEMU_SCOPED_TRACE("vkAcquireXlibDisplayEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquireXlibDisplayEXT_VkResult_return = (VkResult)0;
- vkAcquireXlibDisplayEXT_VkResult_return = vkEnc->vkAcquireXlibDisplayEXT(physicalDevice, dpy, display, true /* do lock */);
+ vkAcquireXlibDisplayEXT_VkResult_return =
+ vkEnc->vkAcquireXlibDisplayEXT(physicalDevice, dpy, display, true /* do lock */);
return vkAcquireXlibDisplayEXT_VkResult_return;
}
-static VkResult entry_vkGetRandROutputDisplayEXT(
- VkPhysicalDevice physicalDevice,
- Display* dpy,
- RROutput rrOutput,
- VkDisplayKHR* pDisplay)
-{
+static VkResult entry_vkGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy,
+ RROutput rrOutput, VkDisplayKHR* pDisplay) {
AEMU_SCOPED_TRACE("vkGetRandROutputDisplayEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetRandROutputDisplayEXT_VkResult_return = (VkResult)0;
- vkGetRandROutputDisplayEXT_VkResult_return = vkEnc->vkGetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay, true /* do lock */);
+ vkGetRandROutputDisplayEXT_VkResult_return = vkEnc->vkGetRandROutputDisplayEXT(
+ physicalDevice, dpy, rrOutput, pDisplay, true /* do lock */);
return vkGetRandROutputDisplayEXT_VkResult_return;
}
#endif
#ifdef VK_EXT_display_surface_counter
static VkResult entry_vkGetPhysicalDeviceSurfaceCapabilities2EXT(
- VkPhysicalDevice physicalDevice,
- VkSurfaceKHR surface,
- VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
-{
+ VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+ VkSurfaceCapabilities2EXT* pSurfaceCapabilities) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2EXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities, true /* do lock */);
+ vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface,
+ pSurfaceCapabilities, true /* do lock */);
return vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return;
}
#endif
#ifdef VK_EXT_display_control
-static VkResult entry_vkDisplayPowerControlEXT(
- VkDevice device,
- VkDisplayKHR display,
- const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
-{
+static VkResult entry_vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display,
+ const VkDisplayPowerInfoEXT* pDisplayPowerInfo) {
AEMU_SCOPED_TRACE("vkDisplayPowerControlEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkDisplayPowerControlEXT_VkResult_return = (VkResult)0;
- vkDisplayPowerControlEXT_VkResult_return = vkEnc->vkDisplayPowerControlEXT(device, display, pDisplayPowerInfo, true /* do lock */);
+ vkDisplayPowerControlEXT_VkResult_return =
+ vkEnc->vkDisplayPowerControlEXT(device, display, pDisplayPowerInfo, true /* do lock */);
return vkDisplayPowerControlEXT_VkResult_return;
}
static VkResult dynCheck_entry_vkDisplayPowerControlEXT(
- VkDevice device,
- VkDisplayKHR display,
- const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
-{
+ VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_display_control"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_EXT_display_control")) {
sOnInvalidDynamicallyCheckedCall("vkDisplayPowerControlEXT", "VK_EXT_display_control");
}
AEMU_SCOPED_TRACE("vkDisplayPowerControlEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkDisplayPowerControlEXT_VkResult_return = (VkResult)0;
- vkDisplayPowerControlEXT_VkResult_return = vkEnc->vkDisplayPowerControlEXT(device, display, pDisplayPowerInfo, true /* do lock */);
+ vkDisplayPowerControlEXT_VkResult_return =
+ vkEnc->vkDisplayPowerControlEXT(device, display, pDisplayPowerInfo, true /* do lock */);
return vkDisplayPowerControlEXT_VkResult_return;
}
-static VkResult entry_vkRegisterDeviceEventEXT(
- VkDevice device,
- const VkDeviceEventInfoEXT* pDeviceEventInfo,
- const VkAllocationCallbacks* pAllocator,
- VkFence* pFence)
-{
+static VkResult entry_vkRegisterDeviceEventEXT(VkDevice device,
+ const VkDeviceEventInfoEXT* pDeviceEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence) {
AEMU_SCOPED_TRACE("vkRegisterDeviceEventEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkRegisterDeviceEventEXT_VkResult_return = (VkResult)0;
- vkRegisterDeviceEventEXT_VkResult_return = vkEnc->vkRegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence, true /* do lock */);
+ vkRegisterDeviceEventEXT_VkResult_return = vkEnc->vkRegisterDeviceEventEXT(
+ device, pDeviceEventInfo, pAllocator, pFence, true /* do lock */);
return vkRegisterDeviceEventEXT_VkResult_return;
}
static VkResult dynCheck_entry_vkRegisterDeviceEventEXT(
- VkDevice device,
- const VkDeviceEventInfoEXT* pDeviceEventInfo,
- const VkAllocationCallbacks* pAllocator,
- VkFence* pFence)
-{
+ VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo,
+ const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_display_control"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_EXT_display_control")) {
sOnInvalidDynamicallyCheckedCall("vkRegisterDeviceEventEXT", "VK_EXT_display_control");
}
AEMU_SCOPED_TRACE("vkRegisterDeviceEventEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkRegisterDeviceEventEXT_VkResult_return = (VkResult)0;
- vkRegisterDeviceEventEXT_VkResult_return = vkEnc->vkRegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence, true /* do lock */);
+ vkRegisterDeviceEventEXT_VkResult_return = vkEnc->vkRegisterDeviceEventEXT(
+ device, pDeviceEventInfo, pAllocator, pFence, true /* do lock */);
return vkRegisterDeviceEventEXT_VkResult_return;
}
-static VkResult entry_vkRegisterDisplayEventEXT(
- VkDevice device,
- VkDisplayKHR display,
- const VkDisplayEventInfoEXT* pDisplayEventInfo,
- const VkAllocationCallbacks* pAllocator,
- VkFence* pFence)
-{
+static VkResult entry_vkRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display,
+ const VkDisplayEventInfoEXT* pDisplayEventInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkFence* pFence) {
AEMU_SCOPED_TRACE("vkRegisterDisplayEventEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkRegisterDisplayEventEXT_VkResult_return = (VkResult)0;
- vkRegisterDisplayEventEXT_VkResult_return = vkEnc->vkRegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence, true /* do lock */);
+ vkRegisterDisplayEventEXT_VkResult_return = vkEnc->vkRegisterDisplayEventEXT(
+ device, display, pDisplayEventInfo, pAllocator, pFence, true /* do lock */);
return vkRegisterDisplayEventEXT_VkResult_return;
}
static VkResult dynCheck_entry_vkRegisterDisplayEventEXT(
- VkDevice device,
- VkDisplayKHR display,
- const VkDisplayEventInfoEXT* pDisplayEventInfo,
- const VkAllocationCallbacks* pAllocator,
- VkFence* pFence)
-{
+ VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo,
+ const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_display_control"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_EXT_display_control")) {
sOnInvalidDynamicallyCheckedCall("vkRegisterDisplayEventEXT", "VK_EXT_display_control");
}
AEMU_SCOPED_TRACE("vkRegisterDisplayEventEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkRegisterDisplayEventEXT_VkResult_return = (VkResult)0;
- vkRegisterDisplayEventEXT_VkResult_return = vkEnc->vkRegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence, true /* do lock */);
+ vkRegisterDisplayEventEXT_VkResult_return = vkEnc->vkRegisterDisplayEventEXT(
+ device, display, pDisplayEventInfo, pAllocator, pFence, true /* do lock */);
return vkRegisterDisplayEventEXT_VkResult_return;
}
-static VkResult entry_vkGetSwapchainCounterEXT(
- VkDevice device,
- VkSwapchainKHR swapchain,
- VkSurfaceCounterFlagBitsEXT counter,
- uint64_t* pCounterValue)
-{
+static VkResult entry_vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain,
+ VkSurfaceCounterFlagBitsEXT counter,
+ uint64_t* pCounterValue) {
AEMU_SCOPED_TRACE("vkGetSwapchainCounterEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSwapchainCounterEXT_VkResult_return = (VkResult)0;
- vkGetSwapchainCounterEXT_VkResult_return = vkEnc->vkGetSwapchainCounterEXT(device, swapchain, counter, pCounterValue, true /* do lock */);
+ vkGetSwapchainCounterEXT_VkResult_return = vkEnc->vkGetSwapchainCounterEXT(
+ device, swapchain, counter, pCounterValue, true /* do lock */);
return vkGetSwapchainCounterEXT_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetSwapchainCounterEXT(
- VkDevice device,
- VkSwapchainKHR swapchain,
- VkSurfaceCounterFlagBitsEXT counter,
- uint64_t* pCounterValue)
-{
+static VkResult dynCheck_entry_vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain,
+ VkSurfaceCounterFlagBitsEXT counter,
+ uint64_t* pCounterValue) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_display_control"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_EXT_display_control")) {
sOnInvalidDynamicallyCheckedCall("vkGetSwapchainCounterEXT", "VK_EXT_display_control");
}
AEMU_SCOPED_TRACE("vkGetSwapchainCounterEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSwapchainCounterEXT_VkResult_return = (VkResult)0;
- vkGetSwapchainCounterEXT_VkResult_return = vkEnc->vkGetSwapchainCounterEXT(device, swapchain, counter, pCounterValue, true /* do lock */);
+ vkGetSwapchainCounterEXT_VkResult_return = vkEnc->vkGetSwapchainCounterEXT(
+ device, swapchain, counter, pCounterValue, true /* do lock */);
return vkGetSwapchainCounterEXT_VkResult_return;
}
#endif
#ifdef VK_GOOGLE_display_timing
static VkResult entry_vkGetRefreshCycleDurationGOOGLE(
- VkDevice device,
- VkSwapchainKHR swapchain,
- VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
-{
+ VkDevice device, VkSwapchainKHR swapchain,
+ VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
AEMU_SCOPED_TRACE("vkGetRefreshCycleDurationGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetRefreshCycleDurationGOOGLE_VkResult_return = (VkResult)0;
- vkGetRefreshCycleDurationGOOGLE_VkResult_return = vkEnc->vkGetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties, true /* do lock */);
+ vkGetRefreshCycleDurationGOOGLE_VkResult_return = vkEnc->vkGetRefreshCycleDurationGOOGLE(
+ device, swapchain, pDisplayTimingProperties, true /* do lock */);
return vkGetRefreshCycleDurationGOOGLE_VkResult_return;
}
static VkResult dynCheck_entry_vkGetRefreshCycleDurationGOOGLE(
- VkDevice device,
- VkSwapchainKHR swapchain,
- VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
-{
+ VkDevice device, VkSwapchainKHR swapchain,
+ VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_display_timing"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetRefreshCycleDurationGOOGLE", "VK_GOOGLE_display_timing");
+ if (!resources->hasDeviceExtension(device, "VK_GOOGLE_display_timing")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetRefreshCycleDurationGOOGLE",
+ "VK_GOOGLE_display_timing");
}
AEMU_SCOPED_TRACE("vkGetRefreshCycleDurationGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetRefreshCycleDurationGOOGLE_VkResult_return = (VkResult)0;
- vkGetRefreshCycleDurationGOOGLE_VkResult_return = vkEnc->vkGetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties, true /* do lock */);
+ vkGetRefreshCycleDurationGOOGLE_VkResult_return = vkEnc->vkGetRefreshCycleDurationGOOGLE(
+ device, swapchain, pDisplayTimingProperties, true /* do lock */);
return vkGetRefreshCycleDurationGOOGLE_VkResult_return;
}
static VkResult entry_vkGetPastPresentationTimingGOOGLE(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint32_t* pPresentationTimingCount,
- VkPastPresentationTimingGOOGLE* pPresentationTimings)
-{
+ VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount,
+ VkPastPresentationTimingGOOGLE* pPresentationTimings) {
AEMU_SCOPED_TRACE("vkGetPastPresentationTimingGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPastPresentationTimingGOOGLE_VkResult_return = (VkResult)0;
- vkGetPastPresentationTimingGOOGLE_VkResult_return = vkEnc->vkGetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings, true /* do lock */);
+ vkGetPastPresentationTimingGOOGLE_VkResult_return = vkEnc->vkGetPastPresentationTimingGOOGLE(
+ device, swapchain, pPresentationTimingCount, pPresentationTimings, true /* do lock */);
return vkGetPastPresentationTimingGOOGLE_VkResult_return;
}
static VkResult dynCheck_entry_vkGetPastPresentationTimingGOOGLE(
- VkDevice device,
- VkSwapchainKHR swapchain,
- uint32_t* pPresentationTimingCount,
- VkPastPresentationTimingGOOGLE* pPresentationTimings)
-{
+ VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount,
+ VkPastPresentationTimingGOOGLE* pPresentationTimings) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_display_timing"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetPastPresentationTimingGOOGLE", "VK_GOOGLE_display_timing");
+ if (!resources->hasDeviceExtension(device, "VK_GOOGLE_display_timing")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetPastPresentationTimingGOOGLE",
+ "VK_GOOGLE_display_timing");
}
AEMU_SCOPED_TRACE("vkGetPastPresentationTimingGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPastPresentationTimingGOOGLE_VkResult_return = (VkResult)0;
- vkGetPastPresentationTimingGOOGLE_VkResult_return = vkEnc->vkGetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings, true /* do lock */);
+ vkGetPastPresentationTimingGOOGLE_VkResult_return = vkEnc->vkGetPastPresentationTimingGOOGLE(
+ device, swapchain, pPresentationTimingCount, pPresentationTimings, true /* do lock */);
return vkGetPastPresentationTimingGOOGLE_VkResult_return;
}
#endif
@@ -6568,31 +5418,30 @@
#ifdef VK_NV_viewport_swizzle
#endif
#ifdef VK_EXT_discard_rectangles
-static void entry_vkCmdSetDiscardRectangleEXT(
- VkCommandBuffer commandBuffer,
- uint32_t firstDiscardRectangle,
- uint32_t discardRectangleCount,
- const VkRect2D* pDiscardRectangles)
-{
+static void entry_vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer,
+ uint32_t firstDiscardRectangle,
+ uint32_t discardRectangleCount,
+ const VkRect2D* pDiscardRectangles) {
AEMU_SCOPED_TRACE("vkCmdSetDiscardRectangleEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles, true /* do lock */);
+ vkEnc->vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount,
+ pDiscardRectangles, true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetDiscardRectangleEXT(
- VkCommandBuffer commandBuffer,
- uint32_t firstDiscardRectangle,
- uint32_t discardRectangleCount,
- const VkRect2D* pDiscardRectangles)
-{
+static void dynCheck_entry_vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer,
+ uint32_t firstDiscardRectangle,
+ uint32_t discardRectangleCount,
+ const VkRect2D* pDiscardRectangles) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_discard_rectangles"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetDiscardRectangleEXT", "VK_EXT_discard_rectangles");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_discard_rectangles")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetDiscardRectangleEXT",
+ "VK_EXT_discard_rectangles");
}
AEMU_SCOPED_TRACE("vkCmdSetDiscardRectangleEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles, true /* do lock */);
+ vkEnc->vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount,
+ pDiscardRectangles, true /* do lock */);
}
#endif
#ifdef VK_EXT_conservative_rasterization
@@ -6602,25 +5451,18 @@
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
-static void entry_vkSetHdrMetadataEXT(
- VkDevice device,
- uint32_t swapchainCount,
- const VkSwapchainKHR* pSwapchains,
- const VkHdrMetadataEXT* pMetadata)
-{
+static void entry_vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount,
+ const VkSwapchainKHR* pSwapchains,
+ const VkHdrMetadataEXT* pMetadata) {
AEMU_SCOPED_TRACE("vkSetHdrMetadataEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkSetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata, true /* do lock */);
}
-static void dynCheck_entry_vkSetHdrMetadataEXT(
- VkDevice device,
- uint32_t swapchainCount,
- const VkSwapchainKHR* pSwapchains,
- const VkHdrMetadataEXT* pMetadata)
-{
+static void dynCheck_entry_vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount,
+ const VkSwapchainKHR* pSwapchains,
+ const VkHdrMetadataEXT* pMetadata) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_hdr_metadata"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_EXT_hdr_metadata")) {
sOnInvalidDynamicallyCheckedCall("vkSetHdrMetadataEXT", "VK_EXT_hdr_metadata");
}
AEMU_SCOPED_TRACE("vkSetHdrMetadataEXT");
@@ -6629,82 +5471,64 @@
}
#endif
#ifdef VK_MVK_ios_surface
-static VkResult entry_vkCreateIOSSurfaceMVK(
- VkInstance instance,
- const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface)
-{
+static VkResult entry_vkCreateIOSSurfaceMVK(VkInstance instance,
+ const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateIOSSurfaceMVK");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateIOSSurfaceMVK_VkResult_return = (VkResult)0;
- vkCreateIOSSurfaceMVK_VkResult_return = vkEnc->vkCreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
+ vkCreateIOSSurfaceMVK_VkResult_return = vkEnc->vkCreateIOSSurfaceMVK(
+ instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateIOSSurfaceMVK_VkResult_return;
}
#endif
#ifdef VK_MVK_macos_surface
-static VkResult entry_vkCreateMacOSSurfaceMVK(
- VkInstance instance,
- const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface)
-{
+static VkResult entry_vkCreateMacOSSurfaceMVK(VkInstance instance,
+ const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateMacOSSurfaceMVK");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateMacOSSurfaceMVK_VkResult_return = (VkResult)0;
- vkCreateMacOSSurfaceMVK_VkResult_return = vkEnc->vkCreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
+ vkCreateMacOSSurfaceMVK_VkResult_return = vkEnc->vkCreateMacOSSurfaceMVK(
+ instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateMacOSSurfaceMVK_VkResult_return;
}
#endif
#ifdef VK_MVK_moltenvk
-static void entry_vkGetMTLDeviceMVK(
- VkPhysicalDevice physicalDevice,
- void** pMTLDevice)
-{
+static void entry_vkGetMTLDeviceMVK(VkPhysicalDevice physicalDevice, void** pMTLDevice) {
AEMU_SCOPED_TRACE("vkGetMTLDeviceMVK");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetMTLDeviceMVK(physicalDevice, pMTLDevice, true /* do lock */);
}
-static VkResult entry_vkSetMTLTextureMVK(
- VkImage image,
- void* mtlTexture)
-{
+static VkResult entry_vkSetMTLTextureMVK(VkImage image, void* mtlTexture) {
AEMU_SCOPED_TRACE("vkSetMTLTextureMVK");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSetMTLTextureMVK_VkResult_return = (VkResult)0;
- vkSetMTLTextureMVK_VkResult_return = vkEnc->vkSetMTLTextureMVK(image, mtlTexture, true /* do lock */);
+ vkSetMTLTextureMVK_VkResult_return =
+ vkEnc->vkSetMTLTextureMVK(image, mtlTexture, true /* do lock */);
return vkSetMTLTextureMVK_VkResult_return;
}
-static void entry_vkGetMTLTextureMVK(
- VkImage image,
- void** pMTLTexture)
-{
+static void entry_vkGetMTLTextureMVK(VkImage image, void** pMTLTexture) {
AEMU_SCOPED_TRACE("vkGetMTLTextureMVK");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetMTLTextureMVK(image, pMTLTexture, true /* do lock */);
}
-static void entry_vkGetMTLBufferMVK(
- VkBuffer buffer,
- void** pMTLBuffer)
-{
+static void entry_vkGetMTLBufferMVK(VkBuffer buffer, void** pMTLBuffer) {
AEMU_SCOPED_TRACE("vkGetMTLBufferMVK");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetMTLBufferMVK(buffer, pMTLBuffer, true /* do lock */);
}
-static VkResult entry_vkUseIOSurfaceMVK(
- VkImage image,
- void* ioSurface)
-{
+static VkResult entry_vkUseIOSurfaceMVK(VkImage image, void* ioSurface) {
AEMU_SCOPED_TRACE("vkUseIOSurfaceMVK");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkUseIOSurfaceMVK_VkResult_return = (VkResult)0;
- vkUseIOSurfaceMVK_VkResult_return = vkEnc->vkUseIOSurfaceMVK(image, ioSurface, true /* do lock */);
+ vkUseIOSurfaceMVK_VkResult_return =
+ vkEnc->vkUseIOSurfaceMVK(image, ioSurface, true /* do lock */);
return vkUseIOSurfaceMVK_VkResult_return;
}
-static void entry_vkGetIOSurfaceMVK(
- VkImage image,
- void** pIOSurface)
-{
+static void entry_vkGetIOSurfaceMVK(VkImage image, void** pIOSurface) {
AEMU_SCOPED_TRACE("vkGetIOSurfaceMVK");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkGetIOSurfaceMVK(image, pIOSurface, true /* do lock */);
@@ -6715,230 +5539,168 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
-static VkResult entry_vkSetDebugUtilsObjectNameEXT(
- VkDevice device,
- const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
-{
+static VkResult entry_vkSetDebugUtilsObjectNameEXT(VkDevice device,
+ const VkDebugUtilsObjectNameInfoEXT* pNameInfo) {
AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectNameEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSetDebugUtilsObjectNameEXT_VkResult_return = (VkResult)0;
- vkSetDebugUtilsObjectNameEXT_VkResult_return = vkEnc->vkSetDebugUtilsObjectNameEXT(device, pNameInfo, true /* do lock */);
+ vkSetDebugUtilsObjectNameEXT_VkResult_return =
+ vkEnc->vkSetDebugUtilsObjectNameEXT(device, pNameInfo, true /* do lock */);
return vkSetDebugUtilsObjectNameEXT_VkResult_return;
}
static VkResult dynCheck_entry_vkSetDebugUtilsObjectNameEXT(
- VkDevice device,
- const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
-{
+ VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_debug_utils"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_EXT_debug_utils")) {
sOnInvalidDynamicallyCheckedCall("vkSetDebugUtilsObjectNameEXT", "VK_EXT_debug_utils");
}
AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectNameEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSetDebugUtilsObjectNameEXT_VkResult_return = (VkResult)0;
- vkSetDebugUtilsObjectNameEXT_VkResult_return = vkEnc->vkSetDebugUtilsObjectNameEXT(device, pNameInfo, true /* do lock */);
+ vkSetDebugUtilsObjectNameEXT_VkResult_return =
+ vkEnc->vkSetDebugUtilsObjectNameEXT(device, pNameInfo, true /* do lock */);
return vkSetDebugUtilsObjectNameEXT_VkResult_return;
}
-static VkResult entry_vkSetDebugUtilsObjectTagEXT(
- VkDevice device,
- const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
-{
+static VkResult entry_vkSetDebugUtilsObjectTagEXT(VkDevice device,
+ const VkDebugUtilsObjectTagInfoEXT* pTagInfo) {
AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectTagEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSetDebugUtilsObjectTagEXT_VkResult_return = (VkResult)0;
- vkSetDebugUtilsObjectTagEXT_VkResult_return = vkEnc->vkSetDebugUtilsObjectTagEXT(device, pTagInfo, true /* do lock */);
+ vkSetDebugUtilsObjectTagEXT_VkResult_return =
+ vkEnc->vkSetDebugUtilsObjectTagEXT(device, pTagInfo, true /* do lock */);
return vkSetDebugUtilsObjectTagEXT_VkResult_return;
}
static VkResult dynCheck_entry_vkSetDebugUtilsObjectTagEXT(
- VkDevice device,
- const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
-{
+ VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_debug_utils"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_EXT_debug_utils")) {
sOnInvalidDynamicallyCheckedCall("vkSetDebugUtilsObjectTagEXT", "VK_EXT_debug_utils");
}
AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectTagEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSetDebugUtilsObjectTagEXT_VkResult_return = (VkResult)0;
- vkSetDebugUtilsObjectTagEXT_VkResult_return = vkEnc->vkSetDebugUtilsObjectTagEXT(device, pTagInfo, true /* do lock */);
+ vkSetDebugUtilsObjectTagEXT_VkResult_return =
+ vkEnc->vkSetDebugUtilsObjectTagEXT(device, pTagInfo, true /* do lock */);
return vkSetDebugUtilsObjectTagEXT_VkResult_return;
}
-static void entry_vkQueueBeginDebugUtilsLabelEXT(
- VkQueue queue,
- const VkDebugUtilsLabelEXT* pLabelInfo)
-{
+static void entry_vkQueueBeginDebugUtilsLabelEXT(VkQueue queue,
+ const VkDebugUtilsLabelEXT* pLabelInfo) {
AEMU_SCOPED_TRACE("vkQueueBeginDebugUtilsLabelEXT");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
vkEnc->vkQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo, true /* do lock */);
}
-static void entry_vkQueueEndDebugUtilsLabelEXT(
- VkQueue queue)
-{
+static void entry_vkQueueEndDebugUtilsLabelEXT(VkQueue queue) {
AEMU_SCOPED_TRACE("vkQueueEndDebugUtilsLabelEXT");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
vkEnc->vkQueueEndDebugUtilsLabelEXT(queue, true /* do lock */);
}
-static void entry_vkQueueInsertDebugUtilsLabelEXT(
- VkQueue queue,
- const VkDebugUtilsLabelEXT* pLabelInfo)
-{
+static void entry_vkQueueInsertDebugUtilsLabelEXT(VkQueue queue,
+ const VkDebugUtilsLabelEXT* pLabelInfo) {
AEMU_SCOPED_TRACE("vkQueueInsertDebugUtilsLabelEXT");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
vkEnc->vkQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo, true /* do lock */);
}
-static void entry_vkCmdBeginDebugUtilsLabelEXT(
- VkCommandBuffer commandBuffer,
- const VkDebugUtilsLabelEXT* pLabelInfo)
-{
+static void entry_vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo) {
AEMU_SCOPED_TRACE("vkCmdBeginDebugUtilsLabelEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo, true /* do lock */);
}
-static void dynCheck_entry_vkCmdBeginDebugUtilsLabelEXT(
- VkCommandBuffer commandBuffer,
- const VkDebugUtilsLabelEXT* pLabelInfo)
-{
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_debug_utils"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdBeginDebugUtilsLabelEXT", "VK_EXT_debug_utils");
- }
- AEMU_SCOPED_TRACE("vkCmdBeginDebugUtilsLabelEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo, true /* do lock */);
-}
-static void entry_vkCmdEndDebugUtilsLabelEXT(
- VkCommandBuffer commandBuffer)
-{
+static void entry_vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) {
AEMU_SCOPED_TRACE("vkCmdEndDebugUtilsLabelEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdEndDebugUtilsLabelEXT(commandBuffer, true /* do lock */);
}
-static void dynCheck_entry_vkCmdEndDebugUtilsLabelEXT(
- VkCommandBuffer commandBuffer)
-{
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_debug_utils"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdEndDebugUtilsLabelEXT", "VK_EXT_debug_utils");
- }
- AEMU_SCOPED_TRACE("vkCmdEndDebugUtilsLabelEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdEndDebugUtilsLabelEXT(commandBuffer, true /* do lock */);
-}
-static void entry_vkCmdInsertDebugUtilsLabelEXT(
- VkCommandBuffer commandBuffer,
- const VkDebugUtilsLabelEXT* pLabelInfo)
-{
- AEMU_SCOPED_TRACE("vkCmdInsertDebugUtilsLabelEXT");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdInsertDebugUtilsLabelEXT(
- VkCommandBuffer commandBuffer,
- const VkDebugUtilsLabelEXT* pLabelInfo)
-{
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_debug_utils"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdInsertDebugUtilsLabelEXT", "VK_EXT_debug_utils");
- }
+static void entry_vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo) {
AEMU_SCOPED_TRACE("vkCmdInsertDebugUtilsLabelEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo, true /* do lock */);
}
static VkResult entry_vkCreateDebugUtilsMessengerEXT(
- VkInstance instance,
- const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkDebugUtilsMessengerEXT* pMessenger)
-{
+ VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) {
AEMU_SCOPED_TRACE("vkCreateDebugUtilsMessengerEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDebugUtilsMessengerEXT_VkResult_return = (VkResult)0;
- vkCreateDebugUtilsMessengerEXT_VkResult_return = vkEnc->vkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger, true /* do lock */);
+ vkCreateDebugUtilsMessengerEXT_VkResult_return = vkEnc->vkCreateDebugUtilsMessengerEXT(
+ instance, pCreateInfo, pAllocator, pMessenger, true /* do lock */);
return vkCreateDebugUtilsMessengerEXT_VkResult_return;
}
-static void entry_vkDestroyDebugUtilsMessengerEXT(
- VkInstance instance,
- VkDebugUtilsMessengerEXT messenger,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyDebugUtilsMessengerEXT(VkInstance instance,
+ VkDebugUtilsMessengerEXT messenger,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyDebugUtilsMessengerEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator, true /* do lock */);
}
static void entry_vkSubmitDebugUtilsMessageEXT(
- VkInstance instance,
- VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+ VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
VkDebugUtilsMessageTypeFlagsEXT messageTypes,
- const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData)
-{
+ const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) {
AEMU_SCOPED_TRACE("vkSubmitDebugUtilsMessageEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkSubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData, true /* do lock */);
+ vkEnc->vkSubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData,
+ true /* do lock */);
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
static VkResult entry_vkGetAndroidHardwareBufferPropertiesANDROID(
- VkDevice device,
- const AHardwareBuffer* buffer,
- VkAndroidHardwareBufferPropertiesANDROID* pProperties)
-{
+ VkDevice device, const AHardwareBuffer* buffer,
+ VkAndroidHardwareBufferPropertiesANDROID* pProperties) {
AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = resources->on_vkGetAndroidHardwareBufferPropertiesANDROID(vkEnc, VK_SUCCESS, device, buffer, pProperties);
+ vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return =
+ resources->on_vkGetAndroidHardwareBufferPropertiesANDROID(vkEnc, VK_SUCCESS, device, buffer,
+ pProperties);
return vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return;
}
static VkResult dynCheck_entry_vkGetAndroidHardwareBufferPropertiesANDROID(
- VkDevice device,
- const AHardwareBuffer* buffer,
- VkAndroidHardwareBufferPropertiesANDROID* pProperties)
-{
+ VkDevice device, const AHardwareBuffer* buffer,
+ VkAndroidHardwareBufferPropertiesANDROID* pProperties) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_ANDROID_external_memory_android_hardware_buffer"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetAndroidHardwareBufferPropertiesANDROID", "VK_ANDROID_external_memory_android_hardware_buffer");
+ if (!resources->hasDeviceExtension(device,
+ "VK_ANDROID_external_memory_android_hardware_buffer")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetAndroidHardwareBufferPropertiesANDROID",
+ "VK_ANDROID_external_memory_android_hardware_buffer");
}
AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
- vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = resources->on_vkGetAndroidHardwareBufferPropertiesANDROID(vkEnc, VK_SUCCESS, device, buffer, pProperties);
+ vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return =
+ resources->on_vkGetAndroidHardwareBufferPropertiesANDROID(vkEnc, VK_SUCCESS, device, buffer,
+ pProperties);
return vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return;
}
static VkResult entry_vkGetMemoryAndroidHardwareBufferANDROID(
- VkDevice device,
- const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
- AHardwareBuffer** pBuffer)
-{
+ VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
+ AHardwareBuffer** pBuffer) {
AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
auto resources = ResourceTracker::get();
- vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = resources->on_vkGetMemoryAndroidHardwareBufferANDROID(vkEnc, VK_SUCCESS, device, pInfo, pBuffer);
+ vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return =
+ resources->on_vkGetMemoryAndroidHardwareBufferANDROID(vkEnc, VK_SUCCESS, device, pInfo,
+ pBuffer);
return vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return;
}
static VkResult dynCheck_entry_vkGetMemoryAndroidHardwareBufferANDROID(
- VkDevice device,
- const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
- AHardwareBuffer** pBuffer)
-{
+ VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
+ AHardwareBuffer** pBuffer) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_ANDROID_external_memory_android_hardware_buffer"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetMemoryAndroidHardwareBufferANDROID", "VK_ANDROID_external_memory_android_hardware_buffer");
+ if (!resources->hasDeviceExtension(device,
+ "VK_ANDROID_external_memory_android_hardware_buffer")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetMemoryAndroidHardwareBufferANDROID",
+ "VK_ANDROID_external_memory_android_hardware_buffer");
}
AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
- vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = resources->on_vkGetMemoryAndroidHardwareBufferANDROID(vkEnc, VK_SUCCESS, device, pInfo, pBuffer);
+ vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return =
+ resources->on_vkGetMemoryAndroidHardwareBufferANDROID(vkEnc, VK_SUCCESS, device, pInfo,
+ pBuffer);
return vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return;
}
#endif
@@ -6955,22 +5717,18 @@
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
-static void entry_vkCmdSetSampleLocationsEXT(
- VkCommandBuffer commandBuffer,
- const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
-{
+static void entry_vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer,
+ const VkSampleLocationsInfoEXT* pSampleLocationsInfo) {
AEMU_SCOPED_TRACE("vkCmdSetSampleLocationsEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo, true /* do lock */);
}
static void dynCheck_entry_vkCmdSetSampleLocationsEXT(
- VkCommandBuffer commandBuffer,
- const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
-{
+ VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_sample_locations"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_sample_locations")) {
sOnInvalidDynamicallyCheckedCall("vkCmdSetSampleLocationsEXT", "VK_EXT_sample_locations");
}
AEMU_SCOPED_TRACE("vkCmdSetSampleLocationsEXT");
@@ -6978,13 +5736,12 @@
vkEnc->vkCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceMultisamplePropertiesEXT(
- VkPhysicalDevice physicalDevice,
- VkSampleCountFlagBits samples,
- VkMultisamplePropertiesEXT* pMultisampleProperties)
-{
+ VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples,
+ VkMultisamplePropertiesEXT* pMultisampleProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMultisamplePropertiesEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties, true /* do lock */);
+ vkEnc->vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples,
+ pMultisampleProperties, true /* do lock */);
}
#endif
#ifdef VK_EXT_blend_operation_advanced
@@ -7001,142 +5758,121 @@
#endif
#ifdef VK_EXT_image_drm_format_modifier
static VkResult entry_vkGetImageDrmFormatModifierPropertiesEXT(
- VkDevice device,
- VkImage image,
- VkImageDrmFormatModifierPropertiesEXT* pProperties)
-{
+ VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) {
AEMU_SCOPED_TRACE("vkGetImageDrmFormatModifierPropertiesEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetImageDrmFormatModifierPropertiesEXT_VkResult_return = (VkResult)0;
- vkGetImageDrmFormatModifierPropertiesEXT_VkResult_return = vkEnc->vkGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties, true /* do lock */);
+ vkGetImageDrmFormatModifierPropertiesEXT_VkResult_return =
+ vkEnc->vkGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties,
+ true /* do lock */);
return vkGetImageDrmFormatModifierPropertiesEXT_VkResult_return;
}
static VkResult dynCheck_entry_vkGetImageDrmFormatModifierPropertiesEXT(
- VkDevice device,
- VkImage image,
- VkImageDrmFormatModifierPropertiesEXT* pProperties)
-{
+ VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_image_drm_format_modifier"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetImageDrmFormatModifierPropertiesEXT", "VK_EXT_image_drm_format_modifier");
+ if (!resources->hasDeviceExtension(device, "VK_EXT_image_drm_format_modifier")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetImageDrmFormatModifierPropertiesEXT",
+ "VK_EXT_image_drm_format_modifier");
}
AEMU_SCOPED_TRACE("vkGetImageDrmFormatModifierPropertiesEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetImageDrmFormatModifierPropertiesEXT_VkResult_return = (VkResult)0;
- vkGetImageDrmFormatModifierPropertiesEXT_VkResult_return = vkEnc->vkGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties, true /* do lock */);
+ vkGetImageDrmFormatModifierPropertiesEXT_VkResult_return =
+ vkEnc->vkGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties,
+ true /* do lock */);
return vkGetImageDrmFormatModifierPropertiesEXT_VkResult_return;
}
#endif
#ifdef VK_EXT_validation_cache
-static VkResult entry_vkCreateValidationCacheEXT(
- VkDevice device,
- const VkValidationCacheCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkValidationCacheEXT* pValidationCache)
-{
+static VkResult entry_vkCreateValidationCacheEXT(VkDevice device,
+ const VkValidationCacheCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkValidationCacheEXT* pValidationCache) {
AEMU_SCOPED_TRACE("vkCreateValidationCacheEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateValidationCacheEXT_VkResult_return = (VkResult)0;
- vkCreateValidationCacheEXT_VkResult_return = vkEnc->vkCreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache, true /* do lock */);
+ vkCreateValidationCacheEXT_VkResult_return = vkEnc->vkCreateValidationCacheEXT(
+ device, pCreateInfo, pAllocator, pValidationCache, true /* do lock */);
return vkCreateValidationCacheEXT_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateValidationCacheEXT(
- VkDevice device,
- const VkValidationCacheCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkValidationCacheEXT* pValidationCache)
-{
+ VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_validation_cache"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_EXT_validation_cache")) {
sOnInvalidDynamicallyCheckedCall("vkCreateValidationCacheEXT", "VK_EXT_validation_cache");
}
AEMU_SCOPED_TRACE("vkCreateValidationCacheEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateValidationCacheEXT_VkResult_return = (VkResult)0;
- vkCreateValidationCacheEXT_VkResult_return = vkEnc->vkCreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache, true /* do lock */);
+ vkCreateValidationCacheEXT_VkResult_return = vkEnc->vkCreateValidationCacheEXT(
+ device, pCreateInfo, pAllocator, pValidationCache, true /* do lock */);
return vkCreateValidationCacheEXT_VkResult_return;
}
-static void entry_vkDestroyValidationCacheEXT(
- VkDevice device,
- VkValidationCacheEXT validationCache,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyValidationCacheEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyValidationCacheEXT(device, validationCache, pAllocator, true /* do lock */);
}
-static void dynCheck_entry_vkDestroyValidationCacheEXT(
- VkDevice device,
- VkValidationCacheEXT validationCache,
- const VkAllocationCallbacks* pAllocator)
-{
+static void dynCheck_entry_vkDestroyValidationCacheEXT(VkDevice device,
+ VkValidationCacheEXT validationCache,
+ const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_validation_cache"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_EXT_validation_cache")) {
sOnInvalidDynamicallyCheckedCall("vkDestroyValidationCacheEXT", "VK_EXT_validation_cache");
}
AEMU_SCOPED_TRACE("vkDestroyValidationCacheEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyValidationCacheEXT(device, validationCache, pAllocator, true /* do lock */);
}
-static VkResult entry_vkMergeValidationCachesEXT(
- VkDevice device,
- VkValidationCacheEXT dstCache,
- uint32_t srcCacheCount,
- const VkValidationCacheEXT* pSrcCaches)
-{
+static VkResult entry_vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache,
+ uint32_t srcCacheCount,
+ const VkValidationCacheEXT* pSrcCaches) {
AEMU_SCOPED_TRACE("vkMergeValidationCachesEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkMergeValidationCachesEXT_VkResult_return = (VkResult)0;
- vkMergeValidationCachesEXT_VkResult_return = vkEnc->vkMergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches, true /* do lock */);
+ vkMergeValidationCachesEXT_VkResult_return = vkEnc->vkMergeValidationCachesEXT(
+ device, dstCache, srcCacheCount, pSrcCaches, true /* do lock */);
return vkMergeValidationCachesEXT_VkResult_return;
}
-static VkResult dynCheck_entry_vkMergeValidationCachesEXT(
- VkDevice device,
- VkValidationCacheEXT dstCache,
- uint32_t srcCacheCount,
- const VkValidationCacheEXT* pSrcCaches)
-{
+static VkResult dynCheck_entry_vkMergeValidationCachesEXT(VkDevice device,
+ VkValidationCacheEXT dstCache,
+ uint32_t srcCacheCount,
+ const VkValidationCacheEXT* pSrcCaches) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_validation_cache"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_EXT_validation_cache")) {
sOnInvalidDynamicallyCheckedCall("vkMergeValidationCachesEXT", "VK_EXT_validation_cache");
}
AEMU_SCOPED_TRACE("vkMergeValidationCachesEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkMergeValidationCachesEXT_VkResult_return = (VkResult)0;
- vkMergeValidationCachesEXT_VkResult_return = vkEnc->vkMergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches, true /* do lock */);
+ vkMergeValidationCachesEXT_VkResult_return = vkEnc->vkMergeValidationCachesEXT(
+ device, dstCache, srcCacheCount, pSrcCaches, true /* do lock */);
return vkMergeValidationCachesEXT_VkResult_return;
}
-static VkResult entry_vkGetValidationCacheDataEXT(
- VkDevice device,
- VkValidationCacheEXT validationCache,
- size_t* pDataSize,
- void* pData)
-{
+static VkResult entry_vkGetValidationCacheDataEXT(VkDevice device,
+ VkValidationCacheEXT validationCache,
+ size_t* pDataSize, void* pData) {
AEMU_SCOPED_TRACE("vkGetValidationCacheDataEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetValidationCacheDataEXT_VkResult_return = (VkResult)0;
- vkGetValidationCacheDataEXT_VkResult_return = vkEnc->vkGetValidationCacheDataEXT(device, validationCache, pDataSize, pData, true /* do lock */);
+ vkGetValidationCacheDataEXT_VkResult_return = vkEnc->vkGetValidationCacheDataEXT(
+ device, validationCache, pDataSize, pData, true /* do lock */);
return vkGetValidationCacheDataEXT_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetValidationCacheDataEXT(
- VkDevice device,
- VkValidationCacheEXT validationCache,
- size_t* pDataSize,
- void* pData)
-{
+static VkResult dynCheck_entry_vkGetValidationCacheDataEXT(VkDevice device,
+ VkValidationCacheEXT validationCache,
+ size_t* pDataSize, void* pData) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_validation_cache"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_EXT_validation_cache")) {
sOnInvalidDynamicallyCheckedCall("vkGetValidationCacheDataEXT", "VK_EXT_validation_cache");
}
AEMU_SCOPED_TRACE("vkGetValidationCacheDataEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetValidationCacheDataEXT_VkResult_return = (VkResult)0;
- vkGetValidationCacheDataEXT_VkResult_return = vkEnc->vkGetValidationCacheDataEXT(device, validationCache, pDataSize, pData, true /* do lock */);
+ vkGetValidationCacheDataEXT_VkResult_return = vkEnc->vkGetValidationCacheDataEXT(
+ device, validationCache, pDataSize, pData, true /* do lock */);
return vkGetValidationCacheDataEXT_VkResult_return;
}
#endif
@@ -7145,24 +5881,19 @@
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_NV_shading_rate_image
-static void entry_vkCmdBindShadingRateImageNV(
- VkCommandBuffer commandBuffer,
- VkImageView imageView,
- VkImageLayout imageLayout)
-{
+static void entry_vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView,
+ VkImageLayout imageLayout) {
AEMU_SCOPED_TRACE("vkCmdBindShadingRateImageNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout, true /* do lock */);
}
-static void dynCheck_entry_vkCmdBindShadingRateImageNV(
- VkCommandBuffer commandBuffer,
- VkImageView imageView,
- VkImageLayout imageLayout)
-{
+static void dynCheck_entry_vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer,
+ VkImageView imageView,
+ VkImageLayout imageLayout) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_NV_shading_rate_image"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_NV_shading_rate_image")) {
sOnInvalidDynamicallyCheckedCall("vkCmdBindShadingRateImageNV", "VK_NV_shading_rate_image");
}
AEMU_SCOPED_TRACE("vkCmdBindShadingRateImageNV");
@@ -7170,217 +5901,189 @@
vkEnc->vkCmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout, true /* do lock */);
}
static void entry_vkCmdSetViewportShadingRatePaletteNV(
- VkCommandBuffer commandBuffer,
- uint32_t firstViewport,
- uint32_t viewportCount,
- const VkShadingRatePaletteNV* pShadingRatePalettes)
-{
+ VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount,
+ const VkShadingRatePaletteNV* pShadingRatePalettes) {
AEMU_SCOPED_TRACE("vkCmdSetViewportShadingRatePaletteNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes, true /* do lock */);
+ vkEnc->vkCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount,
+ pShadingRatePalettes, true /* do lock */);
}
static void dynCheck_entry_vkCmdSetViewportShadingRatePaletteNV(
- VkCommandBuffer commandBuffer,
- uint32_t firstViewport,
- uint32_t viewportCount,
- const VkShadingRatePaletteNV* pShadingRatePalettes)
-{
+ VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount,
+ const VkShadingRatePaletteNV* pShadingRatePalettes) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_NV_shading_rate_image"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetViewportShadingRatePaletteNV", "VK_NV_shading_rate_image");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_NV_shading_rate_image")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetViewportShadingRatePaletteNV",
+ "VK_NV_shading_rate_image");
}
AEMU_SCOPED_TRACE("vkCmdSetViewportShadingRatePaletteNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes, true /* do lock */);
+ vkEnc->vkCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount,
+ pShadingRatePalettes, true /* do lock */);
}
static void entry_vkCmdSetCoarseSampleOrderNV(
- VkCommandBuffer commandBuffer,
- VkCoarseSampleOrderTypeNV sampleOrderType,
- uint32_t customSampleOrderCount,
- const VkCoarseSampleOrderCustomNV* pCustomSampleOrders)
-{
+ VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType,
+ uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) {
AEMU_SCOPED_TRACE("vkCmdSetCoarseSampleOrderNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders, true /* do lock */);
+ vkEnc->vkCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount,
+ pCustomSampleOrders, true /* do lock */);
}
static void dynCheck_entry_vkCmdSetCoarseSampleOrderNV(
- VkCommandBuffer commandBuffer,
- VkCoarseSampleOrderTypeNV sampleOrderType,
- uint32_t customSampleOrderCount,
- const VkCoarseSampleOrderCustomNV* pCustomSampleOrders)
-{
+ VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType,
+ uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_NV_shading_rate_image"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_NV_shading_rate_image")) {
sOnInvalidDynamicallyCheckedCall("vkCmdSetCoarseSampleOrderNV", "VK_NV_shading_rate_image");
}
AEMU_SCOPED_TRACE("vkCmdSetCoarseSampleOrderNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders, true /* do lock */);
+ vkEnc->vkCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount,
+ pCustomSampleOrders, true /* do lock */);
}
#endif
#ifdef VK_NV_ray_tracing
static VkResult entry_vkCreateAccelerationStructureNV(
- VkDevice device,
- const VkAccelerationStructureCreateInfoNV* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkAccelerationStructureNV* pAccelerationStructure)
-{
+ VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) {
AEMU_SCOPED_TRACE("vkCreateAccelerationStructureNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateAccelerationStructureNV_VkResult_return = (VkResult)0;
- vkCreateAccelerationStructureNV_VkResult_return = vkEnc->vkCreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure, true /* do lock */);
+ vkCreateAccelerationStructureNV_VkResult_return = vkEnc->vkCreateAccelerationStructureNV(
+ device, pCreateInfo, pAllocator, pAccelerationStructure, true /* do lock */);
return vkCreateAccelerationStructureNV_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateAccelerationStructureNV(
- VkDevice device,
- const VkAccelerationStructureCreateInfoNV* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkAccelerationStructureNV* pAccelerationStructure)
-{
+ VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing")) {
sOnInvalidDynamicallyCheckedCall("vkCreateAccelerationStructureNV", "VK_NV_ray_tracing");
}
AEMU_SCOPED_TRACE("vkCreateAccelerationStructureNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateAccelerationStructureNV_VkResult_return = (VkResult)0;
- vkCreateAccelerationStructureNV_VkResult_return = vkEnc->vkCreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure, true /* do lock */);
+ vkCreateAccelerationStructureNV_VkResult_return = vkEnc->vkCreateAccelerationStructureNV(
+ device, pCreateInfo, pAllocator, pAccelerationStructure, true /* do lock */);
return vkCreateAccelerationStructureNV_VkResult_return;
}
-static void entry_vkDestroyAccelerationStructureNV(
- VkDevice device,
- VkAccelerationStructureNV accelerationStructure,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyAccelerationStructureNV(VkDevice device,
+ VkAccelerationStructureNV accelerationStructure,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyAccelerationStructureNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyAccelerationStructureNV(device, accelerationStructure, pAllocator, true /* do lock */);
+ vkEnc->vkDestroyAccelerationStructureNV(device, accelerationStructure, pAllocator,
+ true /* do lock */);
}
static void dynCheck_entry_vkDestroyAccelerationStructureNV(
- VkDevice device,
- VkAccelerationStructureNV accelerationStructure,
- const VkAllocationCallbacks* pAllocator)
-{
+ VkDevice device, VkAccelerationStructureNV accelerationStructure,
+ const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing")) {
sOnInvalidDynamicallyCheckedCall("vkDestroyAccelerationStructureNV", "VK_NV_ray_tracing");
}
AEMU_SCOPED_TRACE("vkDestroyAccelerationStructureNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyAccelerationStructureNV(device, accelerationStructure, pAllocator, true /* do lock */);
+ vkEnc->vkDestroyAccelerationStructureNV(device, accelerationStructure, pAllocator,
+ true /* do lock */);
}
static void entry_vkGetAccelerationStructureMemoryRequirementsNV(
- VkDevice device,
- const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
- VkMemoryRequirements2KHR* pMemoryRequirements)
-{
+ VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
+ VkMemoryRequirements2KHR* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetAccelerationStructureMemoryRequirementsNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements, true /* do lock */);
+ vkEnc->vkGetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements,
+ true /* do lock */);
}
static void dynCheck_entry_vkGetAccelerationStructureMemoryRequirementsNV(
- VkDevice device,
- const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
- VkMemoryRequirements2KHR* pMemoryRequirements)
-{
+ VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
+ VkMemoryRequirements2KHR* pMemoryRequirements) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetAccelerationStructureMemoryRequirementsNV", "VK_NV_ray_tracing");
+ if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetAccelerationStructureMemoryRequirementsNV",
+ "VK_NV_ray_tracing");
}
AEMU_SCOPED_TRACE("vkGetAccelerationStructureMemoryRequirementsNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements, true /* do lock */);
+ vkEnc->vkGetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements,
+ true /* do lock */);
}
static VkResult entry_vkBindAccelerationStructureMemoryNV(
- VkDevice device,
- uint32_t bindInfoCount,
- const VkBindAccelerationStructureMemoryInfoNV* pBindInfos)
-{
+ VkDevice device, uint32_t bindInfoCount,
+ const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) {
AEMU_SCOPED_TRACE("vkBindAccelerationStructureMemoryNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindAccelerationStructureMemoryNV_VkResult_return = (VkResult)0;
- vkBindAccelerationStructureMemoryNV_VkResult_return = vkEnc->vkBindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos, true /* do lock */);
+ vkBindAccelerationStructureMemoryNV_VkResult_return =
+ vkEnc->vkBindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos,
+ true /* do lock */);
return vkBindAccelerationStructureMemoryNV_VkResult_return;
}
static VkResult dynCheck_entry_vkBindAccelerationStructureMemoryNV(
- VkDevice device,
- uint32_t bindInfoCount,
- const VkBindAccelerationStructureMemoryInfoNV* pBindInfos)
-{
+ VkDevice device, uint32_t bindInfoCount,
+ const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing"))
- {
- sOnInvalidDynamicallyCheckedCall("vkBindAccelerationStructureMemoryNV", "VK_NV_ray_tracing");
+ if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing")) {
+ sOnInvalidDynamicallyCheckedCall("vkBindAccelerationStructureMemoryNV",
+ "VK_NV_ray_tracing");
}
AEMU_SCOPED_TRACE("vkBindAccelerationStructureMemoryNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBindAccelerationStructureMemoryNV_VkResult_return = (VkResult)0;
- vkBindAccelerationStructureMemoryNV_VkResult_return = vkEnc->vkBindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos, true /* do lock */);
+ vkBindAccelerationStructureMemoryNV_VkResult_return =
+ vkEnc->vkBindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos,
+ true /* do lock */);
return vkBindAccelerationStructureMemoryNV_VkResult_return;
}
-static void entry_vkCmdBuildAccelerationStructureNV(
- VkCommandBuffer commandBuffer,
- const VkAccelerationStructureInfoNV* pInfo,
- VkBuffer instanceData,
- VkDeviceSize instanceOffset,
- VkBool32 update,
- VkAccelerationStructureNV dst,
- VkAccelerationStructureNV src,
- VkBuffer scratch,
- VkDeviceSize scratchOffset)
-{
+static void entry_vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer,
+ const VkAccelerationStructureInfoNV* pInfo,
+ VkBuffer instanceData,
+ VkDeviceSize instanceOffset, VkBool32 update,
+ VkAccelerationStructureNV dst,
+ VkAccelerationStructureNV src, VkBuffer scratch,
+ VkDeviceSize scratchOffset) {
AEMU_SCOPED_TRACE("vkCmdBuildAccelerationStructureNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset, true /* do lock */);
+ vkEnc->vkCmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset,
+ update, dst, src, scratch, scratchOffset,
+ true /* do lock */);
}
static void dynCheck_entry_vkCmdBuildAccelerationStructureNV(
- VkCommandBuffer commandBuffer,
- const VkAccelerationStructureInfoNV* pInfo,
- VkBuffer instanceData,
- VkDeviceSize instanceOffset,
- VkBool32 update,
- VkAccelerationStructureNV dst,
- VkAccelerationStructureNV src,
- VkBuffer scratch,
- VkDeviceSize scratchOffset)
-{
+ VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo,
+ VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update,
+ VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch,
+ VkDeviceSize scratchOffset) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing")) {
sOnInvalidDynamicallyCheckedCall("vkCmdBuildAccelerationStructureNV", "VK_NV_ray_tracing");
}
AEMU_SCOPED_TRACE("vkCmdBuildAccelerationStructureNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset, true /* do lock */);
+ vkEnc->vkCmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset,
+ update, dst, src, scratch, scratchOffset,
+ true /* do lock */);
}
-static void entry_vkCmdCopyAccelerationStructureNV(
- VkCommandBuffer commandBuffer,
- VkAccelerationStructureNV dst,
- VkAccelerationStructureNV src,
- VkCopyAccelerationStructureModeKHR mode)
-{
+static void entry_vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer,
+ VkAccelerationStructureNV dst,
+ VkAccelerationStructureNV src,
+ VkCopyAccelerationStructureModeKHR mode) {
AEMU_SCOPED_TRACE("vkCmdCopyAccelerationStructureNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode, true /* do lock */);
}
static void dynCheck_entry_vkCmdCopyAccelerationStructureNV(
- VkCommandBuffer commandBuffer,
- VkAccelerationStructureNV dst,
- VkAccelerationStructureNV src,
- VkCopyAccelerationStructureModeKHR mode)
-{
+ VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src,
+ VkCopyAccelerationStructureModeKHR mode) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing")) {
sOnInvalidDynamicallyCheckedCall("vkCmdCopyAccelerationStructureNV", "VK_NV_ray_tracing");
}
AEMU_SCOPED_TRACE("vkCmdCopyAccelerationStructureNV");
@@ -7388,236 +6091,201 @@
vkEnc->vkCmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode, true /* do lock */);
}
static void entry_vkCmdTraceRaysNV(
- VkCommandBuffer commandBuffer,
- VkBuffer raygenShaderBindingTableBuffer,
- VkDeviceSize raygenShaderBindingOffset,
- VkBuffer missShaderBindingTableBuffer,
- VkDeviceSize missShaderBindingOffset,
- VkDeviceSize missShaderBindingStride,
- VkBuffer hitShaderBindingTableBuffer,
- VkDeviceSize hitShaderBindingOffset,
- VkDeviceSize hitShaderBindingStride,
- VkBuffer callableShaderBindingTableBuffer,
- VkDeviceSize callableShaderBindingOffset,
- VkDeviceSize callableShaderBindingStride,
- uint32_t width,
- uint32_t height,
- uint32_t depth)
-{
+ VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer,
+ VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer,
+ VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride,
+ VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset,
+ VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer,
+ VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride,
+ uint32_t width, uint32_t height, uint32_t depth) {
AEMU_SCOPED_TRACE("vkCmdTraceRaysNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth, true /* do lock */);
+ vkEnc->vkCmdTraceRaysNV(
+ commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset,
+ missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride,
+ hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride,
+ callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride,
+ width, height, depth, true /* do lock */);
}
static void dynCheck_entry_vkCmdTraceRaysNV(
- VkCommandBuffer commandBuffer,
- VkBuffer raygenShaderBindingTableBuffer,
- VkDeviceSize raygenShaderBindingOffset,
- VkBuffer missShaderBindingTableBuffer,
- VkDeviceSize missShaderBindingOffset,
- VkDeviceSize missShaderBindingStride,
- VkBuffer hitShaderBindingTableBuffer,
- VkDeviceSize hitShaderBindingOffset,
- VkDeviceSize hitShaderBindingStride,
- VkBuffer callableShaderBindingTableBuffer,
- VkDeviceSize callableShaderBindingOffset,
- VkDeviceSize callableShaderBindingStride,
- uint32_t width,
- uint32_t height,
- uint32_t depth)
-{
+ VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer,
+ VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer,
+ VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride,
+ VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset,
+ VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer,
+ VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride,
+ uint32_t width, uint32_t height, uint32_t depth) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing")) {
sOnInvalidDynamicallyCheckedCall("vkCmdTraceRaysNV", "VK_NV_ray_tracing");
}
AEMU_SCOPED_TRACE("vkCmdTraceRaysNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth, true /* do lock */);
+ vkEnc->vkCmdTraceRaysNV(
+ commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset,
+ missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride,
+ hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride,
+ callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride,
+ width, height, depth, true /* do lock */);
}
static VkResult entry_vkCreateRayTracingPipelinesNV(
- VkDevice device,
- VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines)
-{
+ VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount,
+ const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines) {
AEMU_SCOPED_TRACE("vkCreateRayTracingPipelinesNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateRayTracingPipelinesNV_VkResult_return = (VkResult)0;
- vkCreateRayTracingPipelinesNV_VkResult_return = vkEnc->vkCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, true /* do lock */);
+ vkCreateRayTracingPipelinesNV_VkResult_return =
+ vkEnc->vkCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos,
+ pAllocator, pPipelines, true /* do lock */);
return vkCreateRayTracingPipelinesNV_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateRayTracingPipelinesNV(
- VkDevice device,
- VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines)
-{
+ VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount,
+ const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator,
+ VkPipeline* pPipelines) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing")) {
sOnInvalidDynamicallyCheckedCall("vkCreateRayTracingPipelinesNV", "VK_NV_ray_tracing");
}
AEMU_SCOPED_TRACE("vkCreateRayTracingPipelinesNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateRayTracingPipelinesNV_VkResult_return = (VkResult)0;
- vkCreateRayTracingPipelinesNV_VkResult_return = vkEnc->vkCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, true /* do lock */);
+ vkCreateRayTracingPipelinesNV_VkResult_return =
+ vkEnc->vkCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos,
+ pAllocator, pPipelines, true /* do lock */);
return vkCreateRayTracingPipelinesNV_VkResult_return;
}
-static VkResult entry_vkGetRayTracingShaderGroupHandlesKHR(
- VkDevice device,
- VkPipeline pipeline,
- uint32_t firstGroup,
- uint32_t groupCount,
- size_t dataSize,
- void* pData)
-{
+static VkResult entry_vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline,
+ uint32_t firstGroup, uint32_t groupCount,
+ size_t dataSize, void* pData) {
AEMU_SCOPED_TRACE("vkGetRayTracingShaderGroupHandlesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetRayTracingShaderGroupHandlesKHR_VkResult_return = (VkResult)0;
- vkGetRayTracingShaderGroupHandlesKHR_VkResult_return = vkEnc->vkGetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData, true /* do lock */);
+ vkGetRayTracingShaderGroupHandlesKHR_VkResult_return =
+ vkEnc->vkGetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount,
+ dataSize, pData, true /* do lock */);
return vkGetRayTracingShaderGroupHandlesKHR_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetRayTracingShaderGroupHandlesKHR(
- VkDevice device,
- VkPipeline pipeline,
- uint32_t firstGroup,
- uint32_t groupCount,
- size_t dataSize,
- void* pData)
-{
+static VkResult dynCheck_entry_vkGetRayTracingShaderGroupHandlesKHR(VkDevice device,
+ VkPipeline pipeline,
+ uint32_t firstGroup,
+ uint32_t groupCount,
+ size_t dataSize, void* pData) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetRayTracingShaderGroupHandlesKHR", "VK_NV_ray_tracing");
+ if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetRayTracingShaderGroupHandlesKHR",
+ "VK_NV_ray_tracing");
}
AEMU_SCOPED_TRACE("vkGetRayTracingShaderGroupHandlesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetRayTracingShaderGroupHandlesKHR_VkResult_return = (VkResult)0;
- vkGetRayTracingShaderGroupHandlesKHR_VkResult_return = vkEnc->vkGetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData, true /* do lock */);
+ vkGetRayTracingShaderGroupHandlesKHR_VkResult_return =
+ vkEnc->vkGetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount,
+ dataSize, pData, true /* do lock */);
return vkGetRayTracingShaderGroupHandlesKHR_VkResult_return;
}
-static VkResult entry_vkGetRayTracingShaderGroupHandlesNV(
- VkDevice device,
- VkPipeline pipeline,
- uint32_t firstGroup,
- uint32_t groupCount,
- size_t dataSize,
- void* pData)
-{
+static VkResult entry_vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline,
+ uint32_t firstGroup, uint32_t groupCount,
+ size_t dataSize, void* pData) {
AEMU_SCOPED_TRACE("vkGetRayTracingShaderGroupHandlesNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetRayTracingShaderGroupHandlesNV_VkResult_return = (VkResult)0;
- vkGetRayTracingShaderGroupHandlesNV_VkResult_return = vkEnc->vkGetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData, true /* do lock */);
+ vkGetRayTracingShaderGroupHandlesNV_VkResult_return =
+ vkEnc->vkGetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount,
+ dataSize, pData, true /* do lock */);
return vkGetRayTracingShaderGroupHandlesNV_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetRayTracingShaderGroupHandlesNV(
- VkDevice device,
- VkPipeline pipeline,
- uint32_t firstGroup,
- uint32_t groupCount,
- size_t dataSize,
- void* pData)
-{
+static VkResult dynCheck_entry_vkGetRayTracingShaderGroupHandlesNV(VkDevice device,
+ VkPipeline pipeline,
+ uint32_t firstGroup,
+ uint32_t groupCount,
+ size_t dataSize, void* pData) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetRayTracingShaderGroupHandlesNV", "VK_NV_ray_tracing");
+ if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetRayTracingShaderGroupHandlesNV",
+ "VK_NV_ray_tracing");
}
AEMU_SCOPED_TRACE("vkGetRayTracingShaderGroupHandlesNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetRayTracingShaderGroupHandlesNV_VkResult_return = (VkResult)0;
- vkGetRayTracingShaderGroupHandlesNV_VkResult_return = vkEnc->vkGetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData, true /* do lock */);
+ vkGetRayTracingShaderGroupHandlesNV_VkResult_return =
+ vkEnc->vkGetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount,
+ dataSize, pData, true /* do lock */);
return vkGetRayTracingShaderGroupHandlesNV_VkResult_return;
}
static VkResult entry_vkGetAccelerationStructureHandleNV(
- VkDevice device,
- VkAccelerationStructureNV accelerationStructure,
- size_t dataSize,
- void* pData)
-{
+ VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize,
+ void* pData) {
AEMU_SCOPED_TRACE("vkGetAccelerationStructureHandleNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetAccelerationStructureHandleNV_VkResult_return = (VkResult)0;
- vkGetAccelerationStructureHandleNV_VkResult_return = vkEnc->vkGetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData, true /* do lock */);
+ vkGetAccelerationStructureHandleNV_VkResult_return = vkEnc->vkGetAccelerationStructureHandleNV(
+ device, accelerationStructure, dataSize, pData, true /* do lock */);
return vkGetAccelerationStructureHandleNV_VkResult_return;
}
static VkResult dynCheck_entry_vkGetAccelerationStructureHandleNV(
- VkDevice device,
- VkAccelerationStructureNV accelerationStructure,
- size_t dataSize,
- void* pData)
-{
+ VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize,
+ void* pData) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing")) {
sOnInvalidDynamicallyCheckedCall("vkGetAccelerationStructureHandleNV", "VK_NV_ray_tracing");
}
AEMU_SCOPED_TRACE("vkGetAccelerationStructureHandleNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetAccelerationStructureHandleNV_VkResult_return = (VkResult)0;
- vkGetAccelerationStructureHandleNV_VkResult_return = vkEnc->vkGetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData, true /* do lock */);
+ vkGetAccelerationStructureHandleNV_VkResult_return = vkEnc->vkGetAccelerationStructureHandleNV(
+ device, accelerationStructure, dataSize, pData, true /* do lock */);
return vkGetAccelerationStructureHandleNV_VkResult_return;
}
static void entry_vkCmdWriteAccelerationStructuresPropertiesNV(
- VkCommandBuffer commandBuffer,
- uint32_t accelerationStructureCount,
- const VkAccelerationStructureNV* pAccelerationStructures,
- VkQueryType queryType,
- VkQueryPool queryPool,
- uint32_t firstQuery)
-{
+ VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount,
+ const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType,
+ VkQueryPool queryPool, uint32_t firstQuery) {
AEMU_SCOPED_TRACE("vkCmdWriteAccelerationStructuresPropertiesNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery, true /* do lock */);
+ vkEnc->vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount,
+ pAccelerationStructures, queryType,
+ queryPool, firstQuery, true /* do lock */);
}
static void dynCheck_entry_vkCmdWriteAccelerationStructuresPropertiesNV(
- VkCommandBuffer commandBuffer,
- uint32_t accelerationStructureCount,
- const VkAccelerationStructureNV* pAccelerationStructures,
- VkQueryType queryType,
- VkQueryPool queryPool,
- uint32_t firstQuery)
-{
+ VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount,
+ const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType,
+ VkQueryPool queryPool, uint32_t firstQuery) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdWriteAccelerationStructuresPropertiesNV", "VK_NV_ray_tracing");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdWriteAccelerationStructuresPropertiesNV",
+ "VK_NV_ray_tracing");
}
AEMU_SCOPED_TRACE("vkCmdWriteAccelerationStructuresPropertiesNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery, true /* do lock */);
+ vkEnc->vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount,
+ pAccelerationStructures, queryType,
+ queryPool, firstQuery, true /* do lock */);
}
-static VkResult entry_vkCompileDeferredNV(
- VkDevice device,
- VkPipeline pipeline,
- uint32_t shader)
-{
+static VkResult entry_vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) {
AEMU_SCOPED_TRACE("vkCompileDeferredNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCompileDeferredNV_VkResult_return = (VkResult)0;
- vkCompileDeferredNV_VkResult_return = vkEnc->vkCompileDeferredNV(device, pipeline, shader, true /* do lock */);
+ vkCompileDeferredNV_VkResult_return =
+ vkEnc->vkCompileDeferredNV(device, pipeline, shader, true /* do lock */);
return vkCompileDeferredNV_VkResult_return;
}
-static VkResult dynCheck_entry_vkCompileDeferredNV(
- VkDevice device,
- VkPipeline pipeline,
- uint32_t shader)
-{
+static VkResult dynCheck_entry_vkCompileDeferredNV(VkDevice device, VkPipeline pipeline,
+ uint32_t shader) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_NV_ray_tracing")) {
sOnInvalidDynamicallyCheckedCall("vkCompileDeferredNV", "VK_NV_ray_tracing");
}
AEMU_SCOPED_TRACE("vkCompileDeferredNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCompileDeferredNV_VkResult_return = (VkResult)0;
- vkCompileDeferredNV_VkResult_return = vkEnc->vkCompileDeferredNV(device, pipeline, shader, true /* do lock */);
+ vkCompileDeferredNV_VkResult_return =
+ vkEnc->vkCompileDeferredNV(device, pipeline, shader, true /* do lock */);
return vkCompileDeferredNV_VkResult_return;
}
#endif
@@ -7631,108 +6299,95 @@
#endif
#ifdef VK_EXT_external_memory_host
static VkResult entry_vkGetMemoryHostPointerPropertiesEXT(
- VkDevice device,
- VkExternalMemoryHandleTypeFlagBits handleType,
- const void* pHostPointer,
- VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
-{
+ VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer,
+ VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) {
AEMU_SCOPED_TRACE("vkGetMemoryHostPointerPropertiesEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryHostPointerPropertiesEXT_VkResult_return = (VkResult)0;
- vkGetMemoryHostPointerPropertiesEXT_VkResult_return = vkEnc->vkGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties, true /* do lock */);
+ vkGetMemoryHostPointerPropertiesEXT_VkResult_return =
+ vkEnc->vkGetMemoryHostPointerPropertiesEXT(
+ device, handleType, pHostPointer, pMemoryHostPointerProperties, true /* do lock */);
return vkGetMemoryHostPointerPropertiesEXT_VkResult_return;
}
static VkResult dynCheck_entry_vkGetMemoryHostPointerPropertiesEXT(
- VkDevice device,
- VkExternalMemoryHandleTypeFlagBits handleType,
- const void* pHostPointer,
- VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
-{
+ VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer,
+ VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_external_memory_host"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetMemoryHostPointerPropertiesEXT", "VK_EXT_external_memory_host");
+ if (!resources->hasDeviceExtension(device, "VK_EXT_external_memory_host")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetMemoryHostPointerPropertiesEXT",
+ "VK_EXT_external_memory_host");
}
AEMU_SCOPED_TRACE("vkGetMemoryHostPointerPropertiesEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryHostPointerPropertiesEXT_VkResult_return = (VkResult)0;
- vkGetMemoryHostPointerPropertiesEXT_VkResult_return = vkEnc->vkGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties, true /* do lock */);
+ vkGetMemoryHostPointerPropertiesEXT_VkResult_return =
+ vkEnc->vkGetMemoryHostPointerPropertiesEXT(
+ device, handleType, pHostPointer, pMemoryHostPointerProperties, true /* do lock */);
return vkGetMemoryHostPointerPropertiesEXT_VkResult_return;
}
#endif
#ifdef VK_AMD_buffer_marker
-static void entry_vkCmdWriteBufferMarkerAMD(
- VkCommandBuffer commandBuffer,
- VkPipelineStageFlagBits pipelineStage,
- VkBuffer dstBuffer,
- VkDeviceSize dstOffset,
- uint32_t marker)
-{
+static void entry_vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkBuffer dstBuffer, VkDeviceSize dstOffset,
+ uint32_t marker) {
AEMU_SCOPED_TRACE("vkCmdWriteBufferMarkerAMD");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker, true /* do lock */);
+ vkEnc->vkCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker,
+ true /* do lock */);
}
-static void dynCheck_entry_vkCmdWriteBufferMarkerAMD(
- VkCommandBuffer commandBuffer,
- VkPipelineStageFlagBits pipelineStage,
- VkBuffer dstBuffer,
- VkDeviceSize dstOffset,
- uint32_t marker)
-{
+static void dynCheck_entry_vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkBuffer dstBuffer, VkDeviceSize dstOffset,
+ uint32_t marker) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_AMD_buffer_marker"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_AMD_buffer_marker")) {
sOnInvalidDynamicallyCheckedCall("vkCmdWriteBufferMarkerAMD", "VK_AMD_buffer_marker");
}
AEMU_SCOPED_TRACE("vkCmdWriteBufferMarkerAMD");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker, true /* do lock */);
+ vkEnc->vkCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker,
+ true /* do lock */);
}
#endif
#ifdef VK_AMD_pipeline_compiler_control
#endif
#ifdef VK_EXT_calibrated_timestamps
static VkResult entry_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
- VkPhysicalDevice physicalDevice,
- uint32_t* pTimeDomainCount,
- VkTimeDomainEXT* pTimeDomains)
-{
+ VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceCalibrateableTimeDomainsEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_VkResult_return = vkEnc->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains, true /* do lock */);
+ vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount,
+ pTimeDomains, true /* do lock */);
return vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_VkResult_return;
}
static VkResult entry_vkGetCalibratedTimestampsEXT(
- VkDevice device,
- uint32_t timestampCount,
- const VkCalibratedTimestampInfoEXT* pTimestampInfos,
- uint64_t* pTimestamps,
- uint64_t* pMaxDeviation)
-{
+ VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos,
+ uint64_t* pTimestamps, uint64_t* pMaxDeviation) {
AEMU_SCOPED_TRACE("vkGetCalibratedTimestampsEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetCalibratedTimestampsEXT_VkResult_return = (VkResult)0;
- vkGetCalibratedTimestampsEXT_VkResult_return = vkEnc->vkGetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation, true /* do lock */);
+ vkGetCalibratedTimestampsEXT_VkResult_return = vkEnc->vkGetCalibratedTimestampsEXT(
+ device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation, true /* do lock */);
return vkGetCalibratedTimestampsEXT_VkResult_return;
}
static VkResult dynCheck_entry_vkGetCalibratedTimestampsEXT(
- VkDevice device,
- uint32_t timestampCount,
- const VkCalibratedTimestampInfoEXT* pTimestampInfos,
- uint64_t* pTimestamps,
- uint64_t* pMaxDeviation)
-{
+ VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos,
+ uint64_t* pTimestamps, uint64_t* pMaxDeviation) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_calibrated_timestamps"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetCalibratedTimestampsEXT", "VK_EXT_calibrated_timestamps");
+ if (!resources->hasDeviceExtension(device, "VK_EXT_calibrated_timestamps")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetCalibratedTimestampsEXT",
+ "VK_EXT_calibrated_timestamps");
}
AEMU_SCOPED_TRACE("vkGetCalibratedTimestampsEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetCalibratedTimestampsEXT_VkResult_return = (VkResult)0;
- vkGetCalibratedTimestampsEXT_VkResult_return = vkEnc->vkGetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation, true /* do lock */);
+ vkGetCalibratedTimestampsEXT_VkResult_return = vkEnc->vkGetCalibratedTimestampsEXT(
+ device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation, true /* do lock */);
return vkGetCalibratedTimestampsEXT_VkResult_return;
}
#endif
@@ -7753,89 +6408,70 @@
#ifdef VK_NV_compute_shader_derivatives
#endif
#ifdef VK_NV_mesh_shader
-static void entry_vkCmdDrawMeshTasksNV(
- VkCommandBuffer commandBuffer,
- uint32_t taskCount,
- uint32_t firstTask)
-{
+static void entry_vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount,
+ uint32_t firstTask) {
AEMU_SCOPED_TRACE("vkCmdDrawMeshTasksNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask, true /* do lock */);
}
-static void dynCheck_entry_vkCmdDrawMeshTasksNV(
- VkCommandBuffer commandBuffer,
- uint32_t taskCount,
- uint32_t firstTask)
-{
+static void dynCheck_entry_vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount,
+ uint32_t firstTask) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_NV_mesh_shader"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_NV_mesh_shader")) {
sOnInvalidDynamicallyCheckedCall("vkCmdDrawMeshTasksNV", "VK_NV_mesh_shader");
}
AEMU_SCOPED_TRACE("vkCmdDrawMeshTasksNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask, true /* do lock */);
}
-static void entry_vkCmdDrawMeshTasksIndirectNV(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- uint32_t drawCount,
- uint32_t stride)
-{
+static void entry_vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, uint32_t drawCount,
+ uint32_t stride) {
AEMU_SCOPED_TRACE("vkCmdDrawMeshTasksIndirectNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride, true /* do lock */);
+ vkEnc->vkCmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride,
+ true /* do lock */);
}
-static void dynCheck_entry_vkCmdDrawMeshTasksIndirectNV(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- uint32_t drawCount,
- uint32_t stride)
-{
+static void dynCheck_entry_vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer,
+ VkBuffer buffer, VkDeviceSize offset,
+ uint32_t drawCount, uint32_t stride) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_NV_mesh_shader"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_NV_mesh_shader")) {
sOnInvalidDynamicallyCheckedCall("vkCmdDrawMeshTasksIndirectNV", "VK_NV_mesh_shader");
}
AEMU_SCOPED_TRACE("vkCmdDrawMeshTasksIndirectNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride, true /* do lock */);
+ vkEnc->vkCmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride,
+ true /* do lock */);
}
-static void entry_vkCmdDrawMeshTasksIndirectCountNV(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride)
-{
+static void entry_vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer,
+ VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount, uint32_t stride) {
AEMU_SCOPED_TRACE("vkCmdDrawMeshTasksIndirectCountNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, true /* do lock */);
+ vkEnc->vkCmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer,
+ countBufferOffset, maxDrawCount, stride,
+ true /* do lock */);
}
static void dynCheck_entry_vkCmdDrawMeshTasksIndirectCountNV(
- VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride)
-{
+ VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_NV_mesh_shader"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_NV_mesh_shader")) {
sOnInvalidDynamicallyCheckedCall("vkCmdDrawMeshTasksIndirectCountNV", "VK_NV_mesh_shader");
}
AEMU_SCOPED_TRACE("vkCmdDrawMeshTasksIndirectCountNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, true /* do lock */);
+ vkEnc->vkCmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer,
+ countBufferOffset, maxDrawCount, stride,
+ true /* do lock */);
}
#endif
#ifdef VK_NV_fragment_shader_barycentric
@@ -7843,301 +6479,272 @@
#ifdef VK_NV_shader_image_footprint
#endif
#ifdef VK_NV_scissor_exclusive
-static void entry_vkCmdSetExclusiveScissorNV(
- VkCommandBuffer commandBuffer,
- uint32_t firstExclusiveScissor,
- uint32_t exclusiveScissorCount,
- const VkRect2D* pExclusiveScissors)
-{
+static void entry_vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer,
+ uint32_t firstExclusiveScissor,
+ uint32_t exclusiveScissorCount,
+ const VkRect2D* pExclusiveScissors) {
AEMU_SCOPED_TRACE("vkCmdSetExclusiveScissorNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors, true /* do lock */);
+ vkEnc->vkCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount,
+ pExclusiveScissors, true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetExclusiveScissorNV(
- VkCommandBuffer commandBuffer,
- uint32_t firstExclusiveScissor,
- uint32_t exclusiveScissorCount,
- const VkRect2D* pExclusiveScissors)
-{
+static void dynCheck_entry_vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer,
+ uint32_t firstExclusiveScissor,
+ uint32_t exclusiveScissorCount,
+ const VkRect2D* pExclusiveScissors) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_NV_scissor_exclusive"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_NV_scissor_exclusive")) {
sOnInvalidDynamicallyCheckedCall("vkCmdSetExclusiveScissorNV", "VK_NV_scissor_exclusive");
}
AEMU_SCOPED_TRACE("vkCmdSetExclusiveScissorNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors, true /* do lock */);
+ vkEnc->vkCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount,
+ pExclusiveScissors, true /* do lock */);
}
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
-static void entry_vkCmdSetCheckpointNV(
- VkCommandBuffer commandBuffer,
- const void* pCheckpointMarker)
-{
+static void entry_vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer,
+ const void* pCheckpointMarker) {
AEMU_SCOPED_TRACE("vkCmdSetCheckpointNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetCheckpointNV(commandBuffer, pCheckpointMarker, true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetCheckpointNV(
- VkCommandBuffer commandBuffer,
- const void* pCheckpointMarker)
-{
+static void dynCheck_entry_vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer,
+ const void* pCheckpointMarker) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_NV_device_diagnostic_checkpoints"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetCheckpointNV", "VK_NV_device_diagnostic_checkpoints");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_NV_device_diagnostic_checkpoints")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetCheckpointNV",
+ "VK_NV_device_diagnostic_checkpoints");
}
AEMU_SCOPED_TRACE("vkCmdSetCheckpointNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetCheckpointNV(commandBuffer, pCheckpointMarker, true /* do lock */);
}
-static void entry_vkGetQueueCheckpointDataNV(
- VkQueue queue,
- uint32_t* pCheckpointDataCount,
- VkCheckpointDataNV* pCheckpointData)
-{
+static void entry_vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount,
+ VkCheckpointDataNV* pCheckpointData) {
AEMU_SCOPED_TRACE("vkGetQueueCheckpointDataNV");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkGetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData, true /* do lock */);
+ vkEnc->vkGetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData,
+ true /* do lock */);
}
#endif
#ifdef VK_INTEL_shader_integer_functions2
#endif
#ifdef VK_INTEL_performance_query
static VkResult entry_vkInitializePerformanceApiINTEL(
- VkDevice device,
- const VkInitializePerformanceApiInfoINTEL* pInitializeInfo)
-{
+ VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) {
AEMU_SCOPED_TRACE("vkInitializePerformanceApiINTEL");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkInitializePerformanceApiINTEL_VkResult_return = (VkResult)0;
- vkInitializePerformanceApiINTEL_VkResult_return = vkEnc->vkInitializePerformanceApiINTEL(device, pInitializeInfo, true /* do lock */);
+ vkInitializePerformanceApiINTEL_VkResult_return =
+ vkEnc->vkInitializePerformanceApiINTEL(device, pInitializeInfo, true /* do lock */);
return vkInitializePerformanceApiINTEL_VkResult_return;
}
static VkResult dynCheck_entry_vkInitializePerformanceApiINTEL(
- VkDevice device,
- const VkInitializePerformanceApiInfoINTEL* pInitializeInfo)
-{
+ VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_INTEL_performance_query"))
- {
- sOnInvalidDynamicallyCheckedCall("vkInitializePerformanceApiINTEL", "VK_INTEL_performance_query");
+ if (!resources->hasDeviceExtension(device, "VK_INTEL_performance_query")) {
+ sOnInvalidDynamicallyCheckedCall("vkInitializePerformanceApiINTEL",
+ "VK_INTEL_performance_query");
}
AEMU_SCOPED_TRACE("vkInitializePerformanceApiINTEL");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkInitializePerformanceApiINTEL_VkResult_return = (VkResult)0;
- vkInitializePerformanceApiINTEL_VkResult_return = vkEnc->vkInitializePerformanceApiINTEL(device, pInitializeInfo, true /* do lock */);
+ vkInitializePerformanceApiINTEL_VkResult_return =
+ vkEnc->vkInitializePerformanceApiINTEL(device, pInitializeInfo, true /* do lock */);
return vkInitializePerformanceApiINTEL_VkResult_return;
}
-static void entry_vkUninitializePerformanceApiINTEL(
- VkDevice device)
-{
+static void entry_vkUninitializePerformanceApiINTEL(VkDevice device) {
AEMU_SCOPED_TRACE("vkUninitializePerformanceApiINTEL");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkUninitializePerformanceApiINTEL(device, true /* do lock */);
}
-static void dynCheck_entry_vkUninitializePerformanceApiINTEL(
- VkDevice device)
-{
+static void dynCheck_entry_vkUninitializePerformanceApiINTEL(VkDevice device) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_INTEL_performance_query"))
- {
- sOnInvalidDynamicallyCheckedCall("vkUninitializePerformanceApiINTEL", "VK_INTEL_performance_query");
+ if (!resources->hasDeviceExtension(device, "VK_INTEL_performance_query")) {
+ sOnInvalidDynamicallyCheckedCall("vkUninitializePerformanceApiINTEL",
+ "VK_INTEL_performance_query");
}
AEMU_SCOPED_TRACE("vkUninitializePerformanceApiINTEL");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkUninitializePerformanceApiINTEL(device, true /* do lock */);
}
static VkResult entry_vkCmdSetPerformanceMarkerINTEL(
- VkCommandBuffer commandBuffer,
- const VkPerformanceMarkerInfoINTEL* pMarkerInfo)
-{
+ VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) {
AEMU_SCOPED_TRACE("vkCmdSetPerformanceMarkerINTEL");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
VkResult vkCmdSetPerformanceMarkerINTEL_VkResult_return = (VkResult)0;
- vkCmdSetPerformanceMarkerINTEL_VkResult_return = vkEnc->vkCmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo, true /* do lock */);
+ vkCmdSetPerformanceMarkerINTEL_VkResult_return =
+ vkEnc->vkCmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo, true /* do lock */);
return vkCmdSetPerformanceMarkerINTEL_VkResult_return;
}
static VkResult dynCheck_entry_vkCmdSetPerformanceMarkerINTEL(
- VkCommandBuffer commandBuffer,
- const VkPerformanceMarkerInfoINTEL* pMarkerInfo)
-{
+ VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_INTEL_performance_query"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetPerformanceMarkerINTEL", "VK_INTEL_performance_query");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_INTEL_performance_query")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetPerformanceMarkerINTEL",
+ "VK_INTEL_performance_query");
}
AEMU_SCOPED_TRACE("vkCmdSetPerformanceMarkerINTEL");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
VkResult vkCmdSetPerformanceMarkerINTEL_VkResult_return = (VkResult)0;
- vkCmdSetPerformanceMarkerINTEL_VkResult_return = vkEnc->vkCmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo, true /* do lock */);
+ vkCmdSetPerformanceMarkerINTEL_VkResult_return =
+ vkEnc->vkCmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo, true /* do lock */);
return vkCmdSetPerformanceMarkerINTEL_VkResult_return;
}
static VkResult entry_vkCmdSetPerformanceStreamMarkerINTEL(
- VkCommandBuffer commandBuffer,
- const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo)
-{
+ VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) {
AEMU_SCOPED_TRACE("vkCmdSetPerformanceStreamMarkerINTEL");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
VkResult vkCmdSetPerformanceStreamMarkerINTEL_VkResult_return = (VkResult)0;
- vkCmdSetPerformanceStreamMarkerINTEL_VkResult_return = vkEnc->vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo, true /* do lock */);
+ vkCmdSetPerformanceStreamMarkerINTEL_VkResult_return =
+ vkEnc->vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo, true /* do lock */);
return vkCmdSetPerformanceStreamMarkerINTEL_VkResult_return;
}
static VkResult dynCheck_entry_vkCmdSetPerformanceStreamMarkerINTEL(
- VkCommandBuffer commandBuffer,
- const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo)
-{
+ VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_INTEL_performance_query"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetPerformanceStreamMarkerINTEL", "VK_INTEL_performance_query");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_INTEL_performance_query")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetPerformanceStreamMarkerINTEL",
+ "VK_INTEL_performance_query");
}
AEMU_SCOPED_TRACE("vkCmdSetPerformanceStreamMarkerINTEL");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
VkResult vkCmdSetPerformanceStreamMarkerINTEL_VkResult_return = (VkResult)0;
- vkCmdSetPerformanceStreamMarkerINTEL_VkResult_return = vkEnc->vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo, true /* do lock */);
+ vkCmdSetPerformanceStreamMarkerINTEL_VkResult_return =
+ vkEnc->vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo, true /* do lock */);
return vkCmdSetPerformanceStreamMarkerINTEL_VkResult_return;
}
static VkResult entry_vkCmdSetPerformanceOverrideINTEL(
- VkCommandBuffer commandBuffer,
- const VkPerformanceOverrideInfoINTEL* pOverrideInfo)
-{
+ VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) {
AEMU_SCOPED_TRACE("vkCmdSetPerformanceOverrideINTEL");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
VkResult vkCmdSetPerformanceOverrideINTEL_VkResult_return = (VkResult)0;
- vkCmdSetPerformanceOverrideINTEL_VkResult_return = vkEnc->vkCmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo, true /* do lock */);
+ vkCmdSetPerformanceOverrideINTEL_VkResult_return =
+ vkEnc->vkCmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo, true /* do lock */);
return vkCmdSetPerformanceOverrideINTEL_VkResult_return;
}
static VkResult dynCheck_entry_vkCmdSetPerformanceOverrideINTEL(
- VkCommandBuffer commandBuffer,
- const VkPerformanceOverrideInfoINTEL* pOverrideInfo)
-{
+ VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_INTEL_performance_query"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetPerformanceOverrideINTEL", "VK_INTEL_performance_query");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_INTEL_performance_query")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetPerformanceOverrideINTEL",
+ "VK_INTEL_performance_query");
}
AEMU_SCOPED_TRACE("vkCmdSetPerformanceOverrideINTEL");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
VkResult vkCmdSetPerformanceOverrideINTEL_VkResult_return = (VkResult)0;
- vkCmdSetPerformanceOverrideINTEL_VkResult_return = vkEnc->vkCmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo, true /* do lock */);
+ vkCmdSetPerformanceOverrideINTEL_VkResult_return =
+ vkEnc->vkCmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo, true /* do lock */);
return vkCmdSetPerformanceOverrideINTEL_VkResult_return;
}
static VkResult entry_vkAcquirePerformanceConfigurationINTEL(
- VkDevice device,
- const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
- VkPerformanceConfigurationINTEL* pConfiguration)
-{
+ VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
+ VkPerformanceConfigurationINTEL* pConfiguration) {
AEMU_SCOPED_TRACE("vkAcquirePerformanceConfigurationINTEL");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquirePerformanceConfigurationINTEL_VkResult_return = (VkResult)0;
- vkAcquirePerformanceConfigurationINTEL_VkResult_return = vkEnc->vkAcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration, true /* do lock */);
+ vkAcquirePerformanceConfigurationINTEL_VkResult_return =
+ vkEnc->vkAcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration,
+ true /* do lock */);
return vkAcquirePerformanceConfigurationINTEL_VkResult_return;
}
static VkResult dynCheck_entry_vkAcquirePerformanceConfigurationINTEL(
- VkDevice device,
- const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
- VkPerformanceConfigurationINTEL* pConfiguration)
-{
+ VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
+ VkPerformanceConfigurationINTEL* pConfiguration) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_INTEL_performance_query"))
- {
- sOnInvalidDynamicallyCheckedCall("vkAcquirePerformanceConfigurationINTEL", "VK_INTEL_performance_query");
+ if (!resources->hasDeviceExtension(device, "VK_INTEL_performance_query")) {
+ sOnInvalidDynamicallyCheckedCall("vkAcquirePerformanceConfigurationINTEL",
+ "VK_INTEL_performance_query");
}
AEMU_SCOPED_TRACE("vkAcquirePerformanceConfigurationINTEL");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquirePerformanceConfigurationINTEL_VkResult_return = (VkResult)0;
- vkAcquirePerformanceConfigurationINTEL_VkResult_return = vkEnc->vkAcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration, true /* do lock */);
+ vkAcquirePerformanceConfigurationINTEL_VkResult_return =
+ vkEnc->vkAcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration,
+ true /* do lock */);
return vkAcquirePerformanceConfigurationINTEL_VkResult_return;
}
static VkResult entry_vkReleasePerformanceConfigurationINTEL(
- VkDevice device,
- VkPerformanceConfigurationINTEL configuration)
-{
+ VkDevice device, VkPerformanceConfigurationINTEL configuration) {
AEMU_SCOPED_TRACE("vkReleasePerformanceConfigurationINTEL");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkReleasePerformanceConfigurationINTEL_VkResult_return = (VkResult)0;
- vkReleasePerformanceConfigurationINTEL_VkResult_return = vkEnc->vkReleasePerformanceConfigurationINTEL(device, configuration, true /* do lock */);
+ vkReleasePerformanceConfigurationINTEL_VkResult_return =
+ vkEnc->vkReleasePerformanceConfigurationINTEL(device, configuration, true /* do lock */);
return vkReleasePerformanceConfigurationINTEL_VkResult_return;
}
static VkResult dynCheck_entry_vkReleasePerformanceConfigurationINTEL(
- VkDevice device,
- VkPerformanceConfigurationINTEL configuration)
-{
+ VkDevice device, VkPerformanceConfigurationINTEL configuration) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_INTEL_performance_query"))
- {
- sOnInvalidDynamicallyCheckedCall("vkReleasePerformanceConfigurationINTEL", "VK_INTEL_performance_query");
+ if (!resources->hasDeviceExtension(device, "VK_INTEL_performance_query")) {
+ sOnInvalidDynamicallyCheckedCall("vkReleasePerformanceConfigurationINTEL",
+ "VK_INTEL_performance_query");
}
AEMU_SCOPED_TRACE("vkReleasePerformanceConfigurationINTEL");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkReleasePerformanceConfigurationINTEL_VkResult_return = (VkResult)0;
- vkReleasePerformanceConfigurationINTEL_VkResult_return = vkEnc->vkReleasePerformanceConfigurationINTEL(device, configuration, true /* do lock */);
+ vkReleasePerformanceConfigurationINTEL_VkResult_return =
+ vkEnc->vkReleasePerformanceConfigurationINTEL(device, configuration, true /* do lock */);
return vkReleasePerformanceConfigurationINTEL_VkResult_return;
}
static VkResult entry_vkQueueSetPerformanceConfigurationINTEL(
- VkQueue queue,
- VkPerformanceConfigurationINTEL configuration)
-{
+ VkQueue queue, VkPerformanceConfigurationINTEL configuration) {
AEMU_SCOPED_TRACE("vkQueueSetPerformanceConfigurationINTEL");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
VkResult vkQueueSetPerformanceConfigurationINTEL_VkResult_return = (VkResult)0;
- vkQueueSetPerformanceConfigurationINTEL_VkResult_return = vkEnc->vkQueueSetPerformanceConfigurationINTEL(queue, configuration, true /* do lock */);
+ vkQueueSetPerformanceConfigurationINTEL_VkResult_return =
+ vkEnc->vkQueueSetPerformanceConfigurationINTEL(queue, configuration, true /* do lock */);
return vkQueueSetPerformanceConfigurationINTEL_VkResult_return;
}
-static VkResult entry_vkGetPerformanceParameterINTEL(
- VkDevice device,
- VkPerformanceParameterTypeINTEL parameter,
- VkPerformanceValueINTEL* pValue)
-{
+static VkResult entry_vkGetPerformanceParameterINTEL(VkDevice device,
+ VkPerformanceParameterTypeINTEL parameter,
+ VkPerformanceValueINTEL* pValue) {
AEMU_SCOPED_TRACE("vkGetPerformanceParameterINTEL");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPerformanceParameterINTEL_VkResult_return = (VkResult)0;
- vkGetPerformanceParameterINTEL_VkResult_return = vkEnc->vkGetPerformanceParameterINTEL(device, parameter, pValue, true /* do lock */);
+ vkGetPerformanceParameterINTEL_VkResult_return =
+ vkEnc->vkGetPerformanceParameterINTEL(device, parameter, pValue, true /* do lock */);
return vkGetPerformanceParameterINTEL_VkResult_return;
}
static VkResult dynCheck_entry_vkGetPerformanceParameterINTEL(
- VkDevice device,
- VkPerformanceParameterTypeINTEL parameter,
- VkPerformanceValueINTEL* pValue)
-{
+ VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_INTEL_performance_query"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetPerformanceParameterINTEL", "VK_INTEL_performance_query");
+ if (!resources->hasDeviceExtension(device, "VK_INTEL_performance_query")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetPerformanceParameterINTEL",
+ "VK_INTEL_performance_query");
}
AEMU_SCOPED_TRACE("vkGetPerformanceParameterINTEL");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPerformanceParameterINTEL_VkResult_return = (VkResult)0;
- vkGetPerformanceParameterINTEL_VkResult_return = vkEnc->vkGetPerformanceParameterINTEL(device, parameter, pValue, true /* do lock */);
+ vkGetPerformanceParameterINTEL_VkResult_return =
+ vkEnc->vkGetPerformanceParameterINTEL(device, parameter, pValue, true /* do lock */);
return vkGetPerformanceParameterINTEL_VkResult_return;
}
#endif
#ifdef VK_EXT_pci_bus_info
#endif
#ifdef VK_AMD_display_native_hdr
-static void entry_vkSetLocalDimmingAMD(
- VkDevice device,
- VkSwapchainKHR swapChain,
- VkBool32 localDimmingEnable)
-{
+static void entry_vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain,
+ VkBool32 localDimmingEnable) {
AEMU_SCOPED_TRACE("vkSetLocalDimmingAMD");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkSetLocalDimmingAMD(device, swapChain, localDimmingEnable, true /* do lock */);
}
-static void dynCheck_entry_vkSetLocalDimmingAMD(
- VkDevice device,
- VkSwapchainKHR swapChain,
- VkBool32 localDimmingEnable)
-{
+static void dynCheck_entry_vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain,
+ VkBool32 localDimmingEnable) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_AMD_display_native_hdr"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_AMD_display_native_hdr")) {
sOnInvalidDynamicallyCheckedCall("vkSetLocalDimmingAMD", "VK_AMD_display_native_hdr");
}
AEMU_SCOPED_TRACE("vkSetLocalDimmingAMD");
@@ -8147,29 +6754,26 @@
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
static VkResult entry_vkCreateImagePipeSurfaceFUCHSIA(
- VkInstance instance,
- const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface)
-{
+ VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateImagePipeSurfaceFUCHSIA");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateImagePipeSurfaceFUCHSIA_VkResult_return = (VkResult)0;
- vkCreateImagePipeSurfaceFUCHSIA_VkResult_return = vkEnc->vkCreateImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
+ vkCreateImagePipeSurfaceFUCHSIA_VkResult_return = vkEnc->vkCreateImagePipeSurfaceFUCHSIA(
+ instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateImagePipeSurfaceFUCHSIA_VkResult_return;
}
#endif
#ifdef VK_EXT_metal_surface
-static VkResult entry_vkCreateMetalSurfaceEXT(
- VkInstance instance,
- const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface)
-{
+static VkResult entry_vkCreateMetalSurfaceEXT(VkInstance instance,
+ const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateMetalSurfaceEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateMetalSurfaceEXT_VkResult_return = (VkResult)0;
- vkCreateMetalSurfaceEXT_VkResult_return = vkEnc->vkCreateMetalSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
+ vkCreateMetalSurfaceEXT_VkResult_return = vkEnc->vkCreateMetalSurfaceEXT(
+ instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateMetalSurfaceEXT_VkResult_return;
}
#endif
@@ -8196,42 +6800,40 @@
#ifdef VK_NV_dedicated_allocation_image_aliasing
#endif
#ifdef VK_EXT_buffer_device_address
-static VkDeviceAddress entry_vkGetBufferDeviceAddressEXT(
- VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo)
-{
+static VkDeviceAddress entry_vkGetBufferDeviceAddressEXT(VkDevice device,
+ const VkBufferDeviceAddressInfo* pInfo) {
AEMU_SCOPED_TRACE("vkGetBufferDeviceAddressEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkDeviceAddress vkGetBufferDeviceAddressEXT_VkDeviceAddress_return = (VkDeviceAddress)0;
- vkGetBufferDeviceAddressEXT_VkDeviceAddress_return = vkEnc->vkGetBufferDeviceAddressEXT(device, pInfo, true /* do lock */);
+ vkGetBufferDeviceAddressEXT_VkDeviceAddress_return =
+ vkEnc->vkGetBufferDeviceAddressEXT(device, pInfo, true /* do lock */);
return vkGetBufferDeviceAddressEXT_VkDeviceAddress_return;
}
static VkDeviceAddress dynCheck_entry_vkGetBufferDeviceAddressEXT(
- VkDevice device,
- const VkBufferDeviceAddressInfo* pInfo)
-{
+ VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_buffer_device_address"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetBufferDeviceAddressEXT", "VK_EXT_buffer_device_address");
+ if (!resources->hasDeviceExtension(device, "VK_EXT_buffer_device_address")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetBufferDeviceAddressEXT",
+ "VK_EXT_buffer_device_address");
}
AEMU_SCOPED_TRACE("vkGetBufferDeviceAddressEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkDeviceAddress vkGetBufferDeviceAddressEXT_VkDeviceAddress_return = (VkDeviceAddress)0;
- vkGetBufferDeviceAddressEXT_VkDeviceAddress_return = vkEnc->vkGetBufferDeviceAddressEXT(device, pInfo, true /* do lock */);
+ vkGetBufferDeviceAddressEXT_VkDeviceAddress_return =
+ vkEnc->vkGetBufferDeviceAddressEXT(device, pInfo, true /* do lock */);
return vkGetBufferDeviceAddressEXT_VkDeviceAddress_return;
}
#endif
#ifdef VK_EXT_tooling_info
static VkResult entry_vkGetPhysicalDeviceToolPropertiesEXT(
- VkPhysicalDevice physicalDevice,
- uint32_t* pToolCount,
- VkPhysicalDeviceToolPropertiesEXT* pToolProperties)
-{
+ VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
+ VkPhysicalDeviceToolPropertiesEXT* pToolProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceToolPropertiesEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return = vkEnc->vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice, pToolCount, pToolProperties, true /* do lock */);
+ vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice, pToolCount, pToolProperties,
+ true /* do lock */);
return vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return;
}
#endif
@@ -8241,27 +6843,28 @@
#endif
#ifdef VK_NV_cooperative_matrix
static VkResult entry_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
- VkPhysicalDevice physicalDevice,
- uint32_t* pPropertyCount,
- VkCooperativeMatrixPropertiesNV* pProperties)
-{
+ VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount,
+ VkCooperativeMatrixPropertiesNV* pProperties) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceCooperativeMatrixPropertiesNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_VkResult_return = vkEnc->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, pPropertyCount, pProperties, true /* do lock */);
+ vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, pPropertyCount,
+ pProperties, true /* do lock */);
return vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_VkResult_return;
}
#endif
#ifdef VK_NV_coverage_reduction_mode
static VkResult entry_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
- VkPhysicalDevice physicalDevice,
- uint32_t* pCombinationCount,
- VkFramebufferMixedSamplesCombinationNV* pCombinations)
-{
+ VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount,
+ VkFramebufferMixedSamplesCombinationNV* pCombinations) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_VkResult_return = vkEnc->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice, pCombinationCount, pCombinations, true /* do lock */);
+ VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_VkResult_return =
+ (VkResult)0;
+ vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
+ physicalDevice, pCombinationCount, pCombinations, true /* do lock */);
return vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_VkResult_return;
}
#endif
@@ -8273,157 +6876,139 @@
#endif
#ifdef VK_EXT_full_screen_exclusive
static VkResult entry_vkGetPhysicalDeviceSurfacePresentModes2EXT(
- VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
- uint32_t* pPresentModeCount,
- VkPresentModeKHR* pPresentModes)
-{
+ VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfacePresentModes2EXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT_VkResult_return = (VkResult)0;
- vkGetPhysicalDeviceSurfacePresentModes2EXT_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfacePresentModes2EXT(physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes, true /* do lock */);
+ vkGetPhysicalDeviceSurfacePresentModes2EXT_VkResult_return =
+ vkEnc->vkGetPhysicalDeviceSurfacePresentModes2EXT(
+ physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes, true /* do lock */);
return vkGetPhysicalDeviceSurfacePresentModes2EXT_VkResult_return;
}
-static VkResult entry_vkAcquireFullScreenExclusiveModeEXT(
- VkDevice device,
- VkSwapchainKHR swapchain)
-{
+static VkResult entry_vkAcquireFullScreenExclusiveModeEXT(VkDevice device,
+ VkSwapchainKHR swapchain) {
AEMU_SCOPED_TRACE("vkAcquireFullScreenExclusiveModeEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquireFullScreenExclusiveModeEXT_VkResult_return = (VkResult)0;
- vkAcquireFullScreenExclusiveModeEXT_VkResult_return = vkEnc->vkAcquireFullScreenExclusiveModeEXT(device, swapchain, true /* do lock */);
+ vkAcquireFullScreenExclusiveModeEXT_VkResult_return =
+ vkEnc->vkAcquireFullScreenExclusiveModeEXT(device, swapchain, true /* do lock */);
return vkAcquireFullScreenExclusiveModeEXT_VkResult_return;
}
-static VkResult dynCheck_entry_vkAcquireFullScreenExclusiveModeEXT(
- VkDevice device,
- VkSwapchainKHR swapchain)
-{
+static VkResult dynCheck_entry_vkAcquireFullScreenExclusiveModeEXT(VkDevice device,
+ VkSwapchainKHR swapchain) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_full_screen_exclusive"))
- {
- sOnInvalidDynamicallyCheckedCall("vkAcquireFullScreenExclusiveModeEXT", "VK_EXT_full_screen_exclusive");
+ if (!resources->hasDeviceExtension(device, "VK_EXT_full_screen_exclusive")) {
+ sOnInvalidDynamicallyCheckedCall("vkAcquireFullScreenExclusiveModeEXT",
+ "VK_EXT_full_screen_exclusive");
}
AEMU_SCOPED_TRACE("vkAcquireFullScreenExclusiveModeEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquireFullScreenExclusiveModeEXT_VkResult_return = (VkResult)0;
- vkAcquireFullScreenExclusiveModeEXT_VkResult_return = vkEnc->vkAcquireFullScreenExclusiveModeEXT(device, swapchain, true /* do lock */);
+ vkAcquireFullScreenExclusiveModeEXT_VkResult_return =
+ vkEnc->vkAcquireFullScreenExclusiveModeEXT(device, swapchain, true /* do lock */);
return vkAcquireFullScreenExclusiveModeEXT_VkResult_return;
}
-static VkResult entry_vkReleaseFullScreenExclusiveModeEXT(
- VkDevice device,
- VkSwapchainKHR swapchain)
-{
+static VkResult entry_vkReleaseFullScreenExclusiveModeEXT(VkDevice device,
+ VkSwapchainKHR swapchain) {
AEMU_SCOPED_TRACE("vkReleaseFullScreenExclusiveModeEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkReleaseFullScreenExclusiveModeEXT_VkResult_return = (VkResult)0;
- vkReleaseFullScreenExclusiveModeEXT_VkResult_return = vkEnc->vkReleaseFullScreenExclusiveModeEXT(device, swapchain, true /* do lock */);
+ vkReleaseFullScreenExclusiveModeEXT_VkResult_return =
+ vkEnc->vkReleaseFullScreenExclusiveModeEXT(device, swapchain, true /* do lock */);
return vkReleaseFullScreenExclusiveModeEXT_VkResult_return;
}
-static VkResult dynCheck_entry_vkReleaseFullScreenExclusiveModeEXT(
- VkDevice device,
- VkSwapchainKHR swapchain)
-{
+static VkResult dynCheck_entry_vkReleaseFullScreenExclusiveModeEXT(VkDevice device,
+ VkSwapchainKHR swapchain) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_full_screen_exclusive"))
- {
- sOnInvalidDynamicallyCheckedCall("vkReleaseFullScreenExclusiveModeEXT", "VK_EXT_full_screen_exclusive");
+ if (!resources->hasDeviceExtension(device, "VK_EXT_full_screen_exclusive")) {
+ sOnInvalidDynamicallyCheckedCall("vkReleaseFullScreenExclusiveModeEXT",
+ "VK_EXT_full_screen_exclusive");
}
AEMU_SCOPED_TRACE("vkReleaseFullScreenExclusiveModeEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkReleaseFullScreenExclusiveModeEXT_VkResult_return = (VkResult)0;
- vkReleaseFullScreenExclusiveModeEXT_VkResult_return = vkEnc->vkReleaseFullScreenExclusiveModeEXT(device, swapchain, true /* do lock */);
+ vkReleaseFullScreenExclusiveModeEXT_VkResult_return =
+ vkEnc->vkReleaseFullScreenExclusiveModeEXT(device, swapchain, true /* do lock */);
return vkReleaseFullScreenExclusiveModeEXT_VkResult_return;
}
static VkResult entry_vkGetDeviceGroupSurfacePresentModes2EXT(
- VkDevice device,
- const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
- VkDeviceGroupPresentModeFlagsKHR* pModes)
-{
+ VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ VkDeviceGroupPresentModeFlagsKHR* pModes) {
AEMU_SCOPED_TRACE("vkGetDeviceGroupSurfacePresentModes2EXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDeviceGroupSurfacePresentModes2EXT_VkResult_return = (VkResult)0;
- vkGetDeviceGroupSurfacePresentModes2EXT_VkResult_return = vkEnc->vkGetDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo, pModes, true /* do lock */);
+ vkGetDeviceGroupSurfacePresentModes2EXT_VkResult_return =
+ vkEnc->vkGetDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo, pModes,
+ true /* do lock */);
return vkGetDeviceGroupSurfacePresentModes2EXT_VkResult_return;
}
static VkResult dynCheck_entry_vkGetDeviceGroupSurfacePresentModes2EXT(
- VkDevice device,
- const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
- VkDeviceGroupPresentModeFlagsKHR* pModes)
-{
+ VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+ VkDeviceGroupPresentModeFlagsKHR* pModes) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_full_screen_exclusive"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceGroupSurfacePresentModes2EXT", "VK_EXT_full_screen_exclusive");
+ if (!resources->hasDeviceExtension(device, "VK_EXT_full_screen_exclusive")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetDeviceGroupSurfacePresentModes2EXT",
+ "VK_EXT_full_screen_exclusive");
}
AEMU_SCOPED_TRACE("vkGetDeviceGroupSurfacePresentModes2EXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDeviceGroupSurfacePresentModes2EXT_VkResult_return = (VkResult)0;
- vkGetDeviceGroupSurfacePresentModes2EXT_VkResult_return = vkEnc->vkGetDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo, pModes, true /* do lock */);
+ vkGetDeviceGroupSurfacePresentModes2EXT_VkResult_return =
+ vkEnc->vkGetDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo, pModes,
+ true /* do lock */);
return vkGetDeviceGroupSurfacePresentModes2EXT_VkResult_return;
}
#endif
#ifdef VK_EXT_headless_surface
-static VkResult entry_vkCreateHeadlessSurfaceEXT(
- VkInstance instance,
- const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface)
-{
+static VkResult entry_vkCreateHeadlessSurfaceEXT(VkInstance instance,
+ const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateHeadlessSurfaceEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateHeadlessSurfaceEXT_VkResult_return = (VkResult)0;
- vkCreateHeadlessSurfaceEXT_VkResult_return = vkEnc->vkCreateHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
+ vkCreateHeadlessSurfaceEXT_VkResult_return = vkEnc->vkCreateHeadlessSurfaceEXT(
+ instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateHeadlessSurfaceEXT_VkResult_return;
}
#endif
#ifdef VK_EXT_line_rasterization
-static void entry_vkCmdSetLineStippleEXT(
- VkCommandBuffer commandBuffer,
- uint32_t lineStippleFactor,
- uint16_t lineStipplePattern)
-{
+static void entry_vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+ uint16_t lineStipplePattern) {
AEMU_SCOPED_TRACE("vkCmdSetLineStippleEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern, true /* do lock */);
+ vkEnc->vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern,
+ true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetLineStippleEXT(
- VkCommandBuffer commandBuffer,
- uint32_t lineStippleFactor,
- uint16_t lineStipplePattern)
-{
+static void dynCheck_entry_vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer,
+ uint32_t lineStippleFactor,
+ uint16_t lineStipplePattern) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_line_rasterization"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_line_rasterization")) {
sOnInvalidDynamicallyCheckedCall("vkCmdSetLineStippleEXT", "VK_EXT_line_rasterization");
}
AEMU_SCOPED_TRACE("vkCmdSetLineStippleEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern, true /* do lock */);
+ vkEnc->vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern,
+ true /* do lock */);
}
#endif
#ifdef VK_EXT_shader_atomic_float
#endif
#ifdef VK_EXT_host_query_reset
-static void entry_vkResetQueryPoolEXT(
- VkDevice device,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t queryCount)
-{
+static void entry_vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
+ uint32_t queryCount) {
AEMU_SCOPED_TRACE("vkResetQueryPoolEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkResetQueryPoolEXT(device, queryPool, firstQuery, queryCount, true /* do lock */);
}
-static void dynCheck_entry_vkResetQueryPoolEXT(
- VkDevice device,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t queryCount)
-{
+static void dynCheck_entry_vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool,
+ uint32_t firstQuery, uint32_t queryCount) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_host_query_reset"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_EXT_host_query_reset")) {
sOnInvalidDynamicallyCheckedCall("vkResetQueryPoolEXT", "VK_EXT_host_query_reset");
}
AEMU_SCOPED_TRACE("vkResetQueryPoolEXT");
@@ -8434,291 +7019,249 @@
#ifdef VK_EXT_index_type_uint8
#endif
#ifdef VK_EXT_extended_dynamic_state
-static void entry_vkCmdSetCullModeEXT(
- VkCommandBuffer commandBuffer,
- VkCullModeFlags cullMode)
-{
+static void entry_vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
AEMU_SCOPED_TRACE("vkCmdSetCullModeEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetCullModeEXT(commandBuffer, cullMode, true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetCullModeEXT(
- VkCommandBuffer commandBuffer,
- VkCullModeFlags cullMode)
-{
+static void dynCheck_entry_vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer,
+ VkCullModeFlags cullMode) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
sOnInvalidDynamicallyCheckedCall("vkCmdSetCullModeEXT", "VK_EXT_extended_dynamic_state");
}
AEMU_SCOPED_TRACE("vkCmdSetCullModeEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetCullModeEXT(commandBuffer, cullMode, true /* do lock */);
}
-static void entry_vkCmdSetFrontFaceEXT(
- VkCommandBuffer commandBuffer,
- VkFrontFace frontFace)
-{
+static void entry_vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
AEMU_SCOPED_TRACE("vkCmdSetFrontFaceEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetFrontFaceEXT(commandBuffer, frontFace, true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetFrontFaceEXT(
- VkCommandBuffer commandBuffer,
- VkFrontFace frontFace)
-{
+static void dynCheck_entry_vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer,
+ VkFrontFace frontFace) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
sOnInvalidDynamicallyCheckedCall("vkCmdSetFrontFaceEXT", "VK_EXT_extended_dynamic_state");
}
AEMU_SCOPED_TRACE("vkCmdSetFrontFaceEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetFrontFaceEXT(commandBuffer, frontFace, true /* do lock */);
}
-static void entry_vkCmdSetPrimitiveTopologyEXT(
- VkCommandBuffer commandBuffer,
- VkPrimitiveTopology primitiveTopology)
-{
+static void entry_vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
+ VkPrimitiveTopology primitiveTopology) {
AEMU_SCOPED_TRACE("vkCmdSetPrimitiveTopologyEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology, true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetPrimitiveTopologyEXT(
- VkCommandBuffer commandBuffer,
- VkPrimitiveTopology primitiveTopology)
-{
+static void dynCheck_entry_vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
+ VkPrimitiveTopology primitiveTopology) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetPrimitiveTopologyEXT", "VK_EXT_extended_dynamic_state");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetPrimitiveTopologyEXT",
+ "VK_EXT_extended_dynamic_state");
}
AEMU_SCOPED_TRACE("vkCmdSetPrimitiveTopologyEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology, true /* do lock */);
}
-static void entry_vkCmdSetViewportWithCountEXT(
- VkCommandBuffer commandBuffer,
- uint32_t viewportCount,
- const VkViewport* pViewports)
-{
+static void entry_vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer,
+ uint32_t viewportCount,
+ const VkViewport* pViewports) {
AEMU_SCOPED_TRACE("vkCmdSetViewportWithCountEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports, true /* do lock */);
+ vkEnc->vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports,
+ true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetViewportWithCountEXT(
- VkCommandBuffer commandBuffer,
- uint32_t viewportCount,
- const VkViewport* pViewports)
-{
+static void dynCheck_entry_vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer,
+ uint32_t viewportCount,
+ const VkViewport* pViewports) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetViewportWithCountEXT", "VK_EXT_extended_dynamic_state");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetViewportWithCountEXT",
+ "VK_EXT_extended_dynamic_state");
}
AEMU_SCOPED_TRACE("vkCmdSetViewportWithCountEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports, true /* do lock */);
+ vkEnc->vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports,
+ true /* do lock */);
}
-static void entry_vkCmdSetScissorWithCountEXT(
- VkCommandBuffer commandBuffer,
- uint32_t scissorCount,
- const VkRect2D* pScissors)
-{
+static void entry_vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount,
+ const VkRect2D* pScissors) {
AEMU_SCOPED_TRACE("vkCmdSetScissorWithCountEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors, true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetScissorWithCountEXT(
- VkCommandBuffer commandBuffer,
- uint32_t scissorCount,
- const VkRect2D* pScissors)
-{
+static void dynCheck_entry_vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer,
+ uint32_t scissorCount,
+ const VkRect2D* pScissors) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetScissorWithCountEXT", "VK_EXT_extended_dynamic_state");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetScissorWithCountEXT",
+ "VK_EXT_extended_dynamic_state");
}
AEMU_SCOPED_TRACE("vkCmdSetScissorWithCountEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors, true /* do lock */);
}
-static void entry_vkCmdBindVertexBuffers2EXT(
- VkCommandBuffer commandBuffer,
- uint32_t firstBinding,
- uint32_t bindingCount,
- const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets,
- const VkDeviceSize* pSizes,
- const VkDeviceSize* pStrides)
-{
+static void entry_vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+ uint32_t bindingCount, const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets,
+ const VkDeviceSize* pSizes,
+ const VkDeviceSize* pStrides) {
AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers2EXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides, true /* do lock */);
+ vkEnc->vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets,
+ pSizes, pStrides, true /* do lock */);
}
-static void dynCheck_entry_vkCmdBindVertexBuffers2EXT(
- VkCommandBuffer commandBuffer,
- uint32_t firstBinding,
- uint32_t bindingCount,
- const VkBuffer* pBuffers,
- const VkDeviceSize* pOffsets,
- const VkDeviceSize* pSizes,
- const VkDeviceSize* pStrides)
-{
+static void dynCheck_entry_vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer,
+ uint32_t firstBinding, uint32_t bindingCount,
+ const VkBuffer* pBuffers,
+ const VkDeviceSize* pOffsets,
+ const VkDeviceSize* pSizes,
+ const VkDeviceSize* pStrides) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdBindVertexBuffers2EXT", "VK_EXT_extended_dynamic_state");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdBindVertexBuffers2EXT",
+ "VK_EXT_extended_dynamic_state");
}
AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers2EXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides, true /* do lock */);
+ vkEnc->vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets,
+ pSizes, pStrides, true /* do lock */);
}
-static void entry_vkCmdSetDepthTestEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 depthTestEnable)
-{
+static void entry_vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 depthTestEnable) {
AEMU_SCOPED_TRACE("vkCmdSetDepthTestEnableEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable, true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetDepthTestEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 depthTestEnable)
-{
+static void dynCheck_entry_vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 depthTestEnable) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthTestEnableEXT", "VK_EXT_extended_dynamic_state");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthTestEnableEXT",
+ "VK_EXT_extended_dynamic_state");
}
AEMU_SCOPED_TRACE("vkCmdSetDepthTestEnableEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable, true /* do lock */);
}
-static void entry_vkCmdSetDepthWriteEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 depthWriteEnable)
-{
+static void entry_vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 depthWriteEnable) {
AEMU_SCOPED_TRACE("vkCmdSetDepthWriteEnableEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable, true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetDepthWriteEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 depthWriteEnable)
-{
+static void dynCheck_entry_vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 depthWriteEnable) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthWriteEnableEXT", "VK_EXT_extended_dynamic_state");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthWriteEnableEXT",
+ "VK_EXT_extended_dynamic_state");
}
AEMU_SCOPED_TRACE("vkCmdSetDepthWriteEnableEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable, true /* do lock */);
}
-static void entry_vkCmdSetDepthCompareOpEXT(
- VkCommandBuffer commandBuffer,
- VkCompareOp depthCompareOp)
-{
+static void entry_vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer,
+ VkCompareOp depthCompareOp) {
AEMU_SCOPED_TRACE("vkCmdSetDepthCompareOpEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp, true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetDepthCompareOpEXT(
- VkCommandBuffer commandBuffer,
- VkCompareOp depthCompareOp)
-{
+static void dynCheck_entry_vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer,
+ VkCompareOp depthCompareOp) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthCompareOpEXT", "VK_EXT_extended_dynamic_state");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthCompareOpEXT",
+ "VK_EXT_extended_dynamic_state");
}
AEMU_SCOPED_TRACE("vkCmdSetDepthCompareOpEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp, true /* do lock */);
}
-static void entry_vkCmdSetDepthBoundsTestEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 depthBoundsTestEnable)
-{
+static void entry_vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 depthBoundsTestEnable) {
AEMU_SCOPED_TRACE("vkCmdSetDepthBoundsTestEnableEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable, true /* do lock */);
+ vkEnc->vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable,
+ true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetDepthBoundsTestEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 depthBoundsTestEnable)
-{
+static void dynCheck_entry_vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 depthBoundsTestEnable) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthBoundsTestEnableEXT", "VK_EXT_extended_dynamic_state");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthBoundsTestEnableEXT",
+ "VK_EXT_extended_dynamic_state");
}
AEMU_SCOPED_TRACE("vkCmdSetDepthBoundsTestEnableEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable, true /* do lock */);
+ vkEnc->vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable,
+ true /* do lock */);
}
-static void entry_vkCmdSetStencilTestEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 stencilTestEnable)
-{
+static void entry_vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 stencilTestEnable) {
AEMU_SCOPED_TRACE("vkCmdSetStencilTestEnableEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable, true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetStencilTestEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 stencilTestEnable)
-{
+static void dynCheck_entry_vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 stencilTestEnable) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetStencilTestEnableEXT", "VK_EXT_extended_dynamic_state");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetStencilTestEnableEXT",
+ "VK_EXT_extended_dynamic_state");
}
AEMU_SCOPED_TRACE("vkCmdSetStencilTestEnableEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable, true /* do lock */);
}
-static void entry_vkCmdSetStencilOpEXT(
- VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask,
- VkStencilOp failOp,
- VkStencilOp passOp,
- VkStencilOp depthFailOp,
- VkCompareOp compareOp)
-{
+static void entry_vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+ VkStencilOp failOp, VkStencilOp passOp,
+ VkStencilOp depthFailOp, VkCompareOp compareOp) {
AEMU_SCOPED_TRACE("vkCmdSetStencilOpEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp, true /* do lock */);
+ vkEnc->vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp,
+ true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetStencilOpEXT(
- VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask,
- VkStencilOp failOp,
- VkStencilOp passOp,
- VkStencilOp depthFailOp,
- VkCompareOp compareOp)
-{
+static void dynCheck_entry_vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask, VkStencilOp failOp,
+ VkStencilOp passOp, VkStencilOp depthFailOp,
+ VkCompareOp compareOp) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
sOnInvalidDynamicallyCheckedCall("vkCmdSetStencilOpEXT", "VK_EXT_extended_dynamic_state");
}
AEMU_SCOPED_TRACE("vkCmdSetStencilOpEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp, true /* do lock */);
+ vkEnc->vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp,
+ true /* do lock */);
}
#endif
#ifdef VK_EXT_shader_atomic_float2
@@ -8727,151 +7270,139 @@
#endif
#ifdef VK_NV_device_generated_commands
static void entry_vkGetGeneratedCommandsMemoryRequirementsNV(
- VkDevice device,
- const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,
- VkMemoryRequirements2* pMemoryRequirements)
-{
+ VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkGetGeneratedCommandsMemoryRequirementsNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetGeneratedCommandsMemoryRequirementsNV(device, pInfo, pMemoryRequirements, true /* do lock */);
+ vkEnc->vkGetGeneratedCommandsMemoryRequirementsNV(device, pInfo, pMemoryRequirements,
+ true /* do lock */);
}
static void dynCheck_entry_vkGetGeneratedCommandsMemoryRequirementsNV(
- VkDevice device,
- const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,
- VkMemoryRequirements2* pMemoryRequirements)
-{
+ VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,
+ VkMemoryRequirements2* pMemoryRequirements) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_NV_device_generated_commands"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetGeneratedCommandsMemoryRequirementsNV", "VK_NV_device_generated_commands");
+ if (!resources->hasDeviceExtension(device, "VK_NV_device_generated_commands")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetGeneratedCommandsMemoryRequirementsNV",
+ "VK_NV_device_generated_commands");
}
AEMU_SCOPED_TRACE("vkGetGeneratedCommandsMemoryRequirementsNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetGeneratedCommandsMemoryRequirementsNV(device, pInfo, pMemoryRequirements, true /* do lock */);
+ vkEnc->vkGetGeneratedCommandsMemoryRequirementsNV(device, pInfo, pMemoryRequirements,
+ true /* do lock */);
}
static void entry_vkCmdPreprocessGeneratedCommandsNV(
- VkCommandBuffer commandBuffer,
- const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo)
-{
+ VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) {
AEMU_SCOPED_TRACE("vkCmdPreprocessGeneratedCommandsNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo, true /* do lock */);
+ vkEnc->vkCmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo,
+ true /* do lock */);
}
static void dynCheck_entry_vkCmdPreprocessGeneratedCommandsNV(
- VkCommandBuffer commandBuffer,
- const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo)
-{
+ VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_NV_device_generated_commands"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdPreprocessGeneratedCommandsNV", "VK_NV_device_generated_commands");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_NV_device_generated_commands")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdPreprocessGeneratedCommandsNV",
+ "VK_NV_device_generated_commands");
}
AEMU_SCOPED_TRACE("vkCmdPreprocessGeneratedCommandsNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo, true /* do lock */);
+ vkEnc->vkCmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo,
+ true /* do lock */);
}
static void entry_vkCmdExecuteGeneratedCommandsNV(
- VkCommandBuffer commandBuffer,
- VkBool32 isPreprocessed,
- const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo)
-{
+ VkCommandBuffer commandBuffer, VkBool32 isPreprocessed,
+ const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) {
AEMU_SCOPED_TRACE("vkCmdExecuteGeneratedCommandsNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo, true /* do lock */);
+ vkEnc->vkCmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo,
+ true /* do lock */);
}
static void dynCheck_entry_vkCmdExecuteGeneratedCommandsNV(
- VkCommandBuffer commandBuffer,
- VkBool32 isPreprocessed,
- const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo)
-{
+ VkCommandBuffer commandBuffer, VkBool32 isPreprocessed,
+ const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_NV_device_generated_commands"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdExecuteGeneratedCommandsNV", "VK_NV_device_generated_commands");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_NV_device_generated_commands")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdExecuteGeneratedCommandsNV",
+ "VK_NV_device_generated_commands");
}
AEMU_SCOPED_TRACE("vkCmdExecuteGeneratedCommandsNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo, true /* do lock */);
+ vkEnc->vkCmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo,
+ true /* do lock */);
}
-static void entry_vkCmdBindPipelineShaderGroupNV(
- VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipeline pipeline,
- uint32_t groupIndex)
-{
+static void entry_vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipeline pipeline, uint32_t groupIndex) {
AEMU_SCOPED_TRACE("vkCmdBindPipelineShaderGroupNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex, true /* do lock */);
+ vkEnc->vkCmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex,
+ true /* do lock */);
}
-static void dynCheck_entry_vkCmdBindPipelineShaderGroupNV(
- VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipeline pipeline,
- uint32_t groupIndex)
-{
+static void dynCheck_entry_vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipeline pipeline,
+ uint32_t groupIndex) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_NV_device_generated_commands"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdBindPipelineShaderGroupNV", "VK_NV_device_generated_commands");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_NV_device_generated_commands")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdBindPipelineShaderGroupNV",
+ "VK_NV_device_generated_commands");
}
AEMU_SCOPED_TRACE("vkCmdBindPipelineShaderGroupNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex, true /* do lock */);
+ vkEnc->vkCmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex,
+ true /* do lock */);
}
static VkResult entry_vkCreateIndirectCommandsLayoutNV(
- VkDevice device,
- const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkIndirectCommandsLayoutNV* pIndirectCommandsLayout)
-{
+ VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) {
AEMU_SCOPED_TRACE("vkCreateIndirectCommandsLayoutNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateIndirectCommandsLayoutNV_VkResult_return = (VkResult)0;
- vkCreateIndirectCommandsLayoutNV_VkResult_return = vkEnc->vkCreateIndirectCommandsLayoutNV(device, pCreateInfo, pAllocator, pIndirectCommandsLayout, true /* do lock */);
+ vkCreateIndirectCommandsLayoutNV_VkResult_return = vkEnc->vkCreateIndirectCommandsLayoutNV(
+ device, pCreateInfo, pAllocator, pIndirectCommandsLayout, true /* do lock */);
return vkCreateIndirectCommandsLayoutNV_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateIndirectCommandsLayoutNV(
- VkDevice device,
- const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkIndirectCommandsLayoutNV* pIndirectCommandsLayout)
-{
+ VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_NV_device_generated_commands"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCreateIndirectCommandsLayoutNV", "VK_NV_device_generated_commands");
+ if (!resources->hasDeviceExtension(device, "VK_NV_device_generated_commands")) {
+ sOnInvalidDynamicallyCheckedCall("vkCreateIndirectCommandsLayoutNV",
+ "VK_NV_device_generated_commands");
}
AEMU_SCOPED_TRACE("vkCreateIndirectCommandsLayoutNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateIndirectCommandsLayoutNV_VkResult_return = (VkResult)0;
- vkCreateIndirectCommandsLayoutNV_VkResult_return = vkEnc->vkCreateIndirectCommandsLayoutNV(device, pCreateInfo, pAllocator, pIndirectCommandsLayout, true /* do lock */);
+ vkCreateIndirectCommandsLayoutNV_VkResult_return = vkEnc->vkCreateIndirectCommandsLayoutNV(
+ device, pCreateInfo, pAllocator, pIndirectCommandsLayout, true /* do lock */);
return vkCreateIndirectCommandsLayoutNV_VkResult_return;
}
static void entry_vkDestroyIndirectCommandsLayoutNV(
- VkDevice device,
- VkIndirectCommandsLayoutNV indirectCommandsLayout,
- const VkAllocationCallbacks* pAllocator)
-{
+ VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyIndirectCommandsLayoutNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyIndirectCommandsLayoutNV(device, indirectCommandsLayout, pAllocator, true /* do lock */);
+ vkEnc->vkDestroyIndirectCommandsLayoutNV(device, indirectCommandsLayout, pAllocator,
+ true /* do lock */);
}
static void dynCheck_entry_vkDestroyIndirectCommandsLayoutNV(
- VkDevice device,
- VkIndirectCommandsLayoutNV indirectCommandsLayout,
- const VkAllocationCallbacks* pAllocator)
-{
+ VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout,
+ const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_NV_device_generated_commands"))
- {
- sOnInvalidDynamicallyCheckedCall("vkDestroyIndirectCommandsLayoutNV", "VK_NV_device_generated_commands");
+ if (!resources->hasDeviceExtension(device, "VK_NV_device_generated_commands")) {
+ sOnInvalidDynamicallyCheckedCall("vkDestroyIndirectCommandsLayoutNV",
+ "VK_NV_device_generated_commands");
}
AEMU_SCOPED_TRACE("vkDestroyIndirectCommandsLayoutNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyIndirectCommandsLayoutNV(device, indirectCommandsLayout, pAllocator, true /* do lock */);
+ vkEnc->vkDestroyIndirectCommandsLayoutNV(device, indirectCommandsLayout, pAllocator,
+ true /* do lock */);
}
#endif
#ifdef VK_NV_inherited_viewport_scissor
@@ -8883,27 +7414,22 @@
#ifdef VK_EXT_device_memory_report
#endif
#ifdef VK_EXT_acquire_drm_display
-static VkResult entry_vkAcquireDrmDisplayEXT(
- VkPhysicalDevice physicalDevice,
- int32_t drmFd,
- VkDisplayKHR display)
-{
+static VkResult entry_vkAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd,
+ VkDisplayKHR display) {
AEMU_SCOPED_TRACE("vkAcquireDrmDisplayEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquireDrmDisplayEXT_VkResult_return = (VkResult)0;
- vkAcquireDrmDisplayEXT_VkResult_return = vkEnc->vkAcquireDrmDisplayEXT(physicalDevice, drmFd, display, true /* do lock */);
+ vkAcquireDrmDisplayEXT_VkResult_return =
+ vkEnc->vkAcquireDrmDisplayEXT(physicalDevice, drmFd, display, true /* do lock */);
return vkAcquireDrmDisplayEXT_VkResult_return;
}
-static VkResult entry_vkGetDrmDisplayEXT(
- VkPhysicalDevice physicalDevice,
- int32_t drmFd,
- uint32_t connectorId,
- VkDisplayKHR* display)
-{
+static VkResult entry_vkGetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd,
+ uint32_t connectorId, VkDisplayKHR* display) {
AEMU_SCOPED_TRACE("vkGetDrmDisplayEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDrmDisplayEXT_VkResult_return = (VkResult)0;
- vkGetDrmDisplayEXT_VkResult_return = vkEnc->vkGetDrmDisplayEXT(physicalDevice, drmFd, connectorId, display, true /* do lock */);
+ vkGetDrmDisplayEXT_VkResult_return =
+ vkEnc->vkGetDrmDisplayEXT(physicalDevice, drmFd, connectorId, display, true /* do lock */);
return vkGetDrmDisplayEXT_VkResult_return;
}
#endif
@@ -8914,115 +7440,93 @@
#ifdef VK_GOOGLE_user_type
#endif
#ifdef VK_EXT_private_data
-static VkResult entry_vkCreatePrivateDataSlotEXT(
- VkDevice device,
- const VkPrivateDataSlotCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPrivateDataSlotEXT* pPrivateDataSlot)
-{
+static VkResult entry_vkCreatePrivateDataSlotEXT(VkDevice device,
+ const VkPrivateDataSlotCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkPrivateDataSlotEXT* pPrivateDataSlot) {
AEMU_SCOPED_TRACE("vkCreatePrivateDataSlotEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreatePrivateDataSlotEXT_VkResult_return = (VkResult)0;
- vkCreatePrivateDataSlotEXT_VkResult_return = vkEnc->vkCreatePrivateDataSlotEXT(device, pCreateInfo, pAllocator, pPrivateDataSlot, true /* do lock */);
+ vkCreatePrivateDataSlotEXT_VkResult_return = vkEnc->vkCreatePrivateDataSlotEXT(
+ device, pCreateInfo, pAllocator, pPrivateDataSlot, true /* do lock */);
return vkCreatePrivateDataSlotEXT_VkResult_return;
}
static VkResult dynCheck_entry_vkCreatePrivateDataSlotEXT(
- VkDevice device,
- const VkPrivateDataSlotCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkPrivateDataSlotEXT* pPrivateDataSlot)
-{
+ VkDevice device, const VkPrivateDataSlotCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkPrivateDataSlotEXT* pPrivateDataSlot) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_private_data"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_EXT_private_data")) {
sOnInvalidDynamicallyCheckedCall("vkCreatePrivateDataSlotEXT", "VK_EXT_private_data");
}
AEMU_SCOPED_TRACE("vkCreatePrivateDataSlotEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreatePrivateDataSlotEXT_VkResult_return = (VkResult)0;
- vkCreatePrivateDataSlotEXT_VkResult_return = vkEnc->vkCreatePrivateDataSlotEXT(device, pCreateInfo, pAllocator, pPrivateDataSlot, true /* do lock */);
+ vkCreatePrivateDataSlotEXT_VkResult_return = vkEnc->vkCreatePrivateDataSlotEXT(
+ device, pCreateInfo, pAllocator, pPrivateDataSlot, true /* do lock */);
return vkCreatePrivateDataSlotEXT_VkResult_return;
}
-static void entry_vkDestroyPrivateDataSlotEXT(
- VkDevice device,
- VkPrivateDataSlotEXT privateDataSlot,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlotEXT privateDataSlot,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyPrivateDataSlotEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator, true /* do lock */);
}
-static void dynCheck_entry_vkDestroyPrivateDataSlotEXT(
- VkDevice device,
- VkPrivateDataSlotEXT privateDataSlot,
- const VkAllocationCallbacks* pAllocator)
-{
+static void dynCheck_entry_vkDestroyPrivateDataSlotEXT(VkDevice device,
+ VkPrivateDataSlotEXT privateDataSlot,
+ const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_private_data"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_EXT_private_data")) {
sOnInvalidDynamicallyCheckedCall("vkDestroyPrivateDataSlotEXT", "VK_EXT_private_data");
}
AEMU_SCOPED_TRACE("vkDestroyPrivateDataSlotEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator, true /* do lock */);
}
-static VkResult entry_vkSetPrivateDataEXT(
- VkDevice device,
- VkObjectType objectType,
- uint64_t objectHandle,
- VkPrivateDataSlotEXT privateDataSlot,
- uint64_t data)
-{
+static VkResult entry_vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType,
+ uint64_t objectHandle,
+ VkPrivateDataSlotEXT privateDataSlot, uint64_t data) {
AEMU_SCOPED_TRACE("vkSetPrivateDataEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSetPrivateDataEXT_VkResult_return = (VkResult)0;
- vkSetPrivateDataEXT_VkResult_return = vkEnc->vkSetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, data, true /* do lock */);
+ vkSetPrivateDataEXT_VkResult_return = vkEnc->vkSetPrivateDataEXT(
+ device, objectType, objectHandle, privateDataSlot, data, true /* do lock */);
return vkSetPrivateDataEXT_VkResult_return;
}
-static VkResult dynCheck_entry_vkSetPrivateDataEXT(
- VkDevice device,
- VkObjectType objectType,
- uint64_t objectHandle,
- VkPrivateDataSlotEXT privateDataSlot,
- uint64_t data)
-{
+static VkResult dynCheck_entry_vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType,
+ uint64_t objectHandle,
+ VkPrivateDataSlotEXT privateDataSlot,
+ uint64_t data) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_private_data"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_EXT_private_data")) {
sOnInvalidDynamicallyCheckedCall("vkSetPrivateDataEXT", "VK_EXT_private_data");
}
AEMU_SCOPED_TRACE("vkSetPrivateDataEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSetPrivateDataEXT_VkResult_return = (VkResult)0;
- vkSetPrivateDataEXT_VkResult_return = vkEnc->vkSetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, data, true /* do lock */);
+ vkSetPrivateDataEXT_VkResult_return = vkEnc->vkSetPrivateDataEXT(
+ device, objectType, objectHandle, privateDataSlot, data, true /* do lock */);
return vkSetPrivateDataEXT_VkResult_return;
}
-static void entry_vkGetPrivateDataEXT(
- VkDevice device,
- VkObjectType objectType,
- uint64_t objectHandle,
- VkPrivateDataSlotEXT privateDataSlot,
- uint64_t* pData)
-{
+static void entry_vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType,
+ uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot,
+ uint64_t* pData) {
AEMU_SCOPED_TRACE("vkGetPrivateDataEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData, true /* do lock */);
+ vkEnc->vkGetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData,
+ true /* do lock */);
}
-static void dynCheck_entry_vkGetPrivateDataEXT(
- VkDevice device,
- VkObjectType objectType,
- uint64_t objectHandle,
- VkPrivateDataSlotEXT privateDataSlot,
- uint64_t* pData)
-{
+static void dynCheck_entry_vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType,
+ uint64_t objectHandle,
+ VkPrivateDataSlotEXT privateDataSlot,
+ uint64_t* pData) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_private_data"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_EXT_private_data")) {
sOnInvalidDynamicallyCheckedCall("vkGetPrivateDataEXT", "VK_EXT_private_data");
}
AEMU_SCOPED_TRACE("vkGetPrivateDataEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData, true /* do lock */);
+ vkEnc->vkGetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData,
+ true /* do lock */);
}
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
@@ -9033,28 +7537,27 @@
#endif
#ifdef VK_NV_fragment_shading_rate_enums
static void entry_vkCmdSetFragmentShadingRateEnumNV(
- VkCommandBuffer commandBuffer,
- VkFragmentShadingRateNV shadingRate,
- const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
-{
+ VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate,
+ const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) {
AEMU_SCOPED_TRACE("vkCmdSetFragmentShadingRateEnumNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps, true /* do lock */);
+ vkEnc->vkCmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps,
+ true /* do lock */);
}
static void dynCheck_entry_vkCmdSetFragmentShadingRateEnumNV(
- VkCommandBuffer commandBuffer,
- VkFragmentShadingRateNV shadingRate,
- const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
-{
+ VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate,
+ const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_NV_fragment_shading_rate_enums"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetFragmentShadingRateEnumNV", "VK_NV_fragment_shading_rate_enums");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_NV_fragment_shading_rate_enums")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetFragmentShadingRateEnumNV",
+ "VK_NV_fragment_shading_rate_enums");
}
AEMU_SCOPED_TRACE("vkCmdSetFragmentShadingRateEnumNV");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps, true /* do lock */);
+ vkEnc->vkCmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps,
+ true /* do lock */);
}
#endif
#ifdef VK_NV_ray_tracing_motion_blur
@@ -9072,50 +7575,45 @@
#ifdef VK_EXT_rgba10x6_formats
#endif
#ifdef VK_NV_acquire_winrt_display
-static VkResult entry_vkAcquireWinrtDisplayNV(
- VkPhysicalDevice physicalDevice,
- VkDisplayKHR display)
-{
+static VkResult entry_vkAcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display) {
AEMU_SCOPED_TRACE("vkAcquireWinrtDisplayNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkAcquireWinrtDisplayNV_VkResult_return = (VkResult)0;
- vkAcquireWinrtDisplayNV_VkResult_return = vkEnc->vkAcquireWinrtDisplayNV(physicalDevice, display, true /* do lock */);
+ vkAcquireWinrtDisplayNV_VkResult_return =
+ vkEnc->vkAcquireWinrtDisplayNV(physicalDevice, display, true /* do lock */);
return vkAcquireWinrtDisplayNV_VkResult_return;
}
-static VkResult entry_vkGetWinrtDisplayNV(
- VkPhysicalDevice physicalDevice,
- uint32_t deviceRelativeId,
- VkDisplayKHR* pDisplay)
-{
+static VkResult entry_vkGetWinrtDisplayNV(VkPhysicalDevice physicalDevice,
+ uint32_t deviceRelativeId, VkDisplayKHR* pDisplay) {
AEMU_SCOPED_TRACE("vkGetWinrtDisplayNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetWinrtDisplayNV_VkResult_return = (VkResult)0;
- vkGetWinrtDisplayNV_VkResult_return = vkEnc->vkGetWinrtDisplayNV(physicalDevice, deviceRelativeId, pDisplay, true /* do lock */);
+ vkGetWinrtDisplayNV_VkResult_return =
+ vkEnc->vkGetWinrtDisplayNV(physicalDevice, deviceRelativeId, pDisplay, true /* do lock */);
return vkGetWinrtDisplayNV_VkResult_return;
}
#endif
#ifdef VK_EXT_directfb_surface
-static VkResult entry_vkCreateDirectFBSurfaceEXT(
- VkInstance instance,
- const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface)
-{
+static VkResult entry_vkCreateDirectFBSurfaceEXT(VkInstance instance,
+ const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateDirectFBSurfaceEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateDirectFBSurfaceEXT_VkResult_return = (VkResult)0;
- vkCreateDirectFBSurfaceEXT_VkResult_return = vkEnc->vkCreateDirectFBSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
+ vkCreateDirectFBSurfaceEXT_VkResult_return = vkEnc->vkCreateDirectFBSurfaceEXT(
+ instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateDirectFBSurfaceEXT_VkResult_return;
}
static VkBool32 entry_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- IDirectFB* dfb)
-{
+ VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDirectFBPresentationSupportEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkBool32 vkGetPhysicalDeviceDirectFBPresentationSupportEXT_VkBool32_return = (VkBool32)0;
- vkGetPhysicalDeviceDirectFBPresentationSupportEXT_VkBool32_return = vkEnc->vkGetPhysicalDeviceDirectFBPresentationSupportEXT(physicalDevice, queueFamilyIndex, dfb, true /* do lock */);
+ vkGetPhysicalDeviceDirectFBPresentationSupportEXT_VkBool32_return =
+ vkEnc->vkGetPhysicalDeviceDirectFBPresentationSupportEXT(physicalDevice, queueFamilyIndex,
+ dfb, true /* do lock */);
return vkGetPhysicalDeviceDirectFBPresentationSupportEXT_VkBool32_return;
}
#endif
@@ -9123,32 +7621,33 @@
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
static void entry_vkCmdSetVertexInputEXT(
- VkCommandBuffer commandBuffer,
- uint32_t vertexBindingDescriptionCount,
+ VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount,
const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions,
uint32_t vertexAttributeDescriptionCount,
- const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions)
-{
+ const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) {
AEMU_SCOPED_TRACE("vkCmdSetVertexInputEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions, true /* do lock */);
+ vkEnc->vkCmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount,
+ pVertexBindingDescriptions, vertexAttributeDescriptionCount,
+ pVertexAttributeDescriptions, true /* do lock */);
}
static void dynCheck_entry_vkCmdSetVertexInputEXT(
- VkCommandBuffer commandBuffer,
- uint32_t vertexBindingDescriptionCount,
+ VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount,
const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions,
uint32_t vertexAttributeDescriptionCount,
- const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions)
-{
+ const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_vertex_input_dynamic_state"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetVertexInputEXT", "VK_EXT_vertex_input_dynamic_state");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_vertex_input_dynamic_state")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetVertexInputEXT",
+ "VK_EXT_vertex_input_dynamic_state");
}
AEMU_SCOPED_TRACE("vkCmdSetVertexInputEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions, true /* do lock */);
+ vkEnc->vkCmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount,
+ pVertexBindingDescriptions, vertexAttributeDescriptionCount,
+ pVertexAttributeDescriptions, true /* do lock */);
}
#endif
#ifdef VK_EXT_physical_device_drm
@@ -9157,293 +7656,275 @@
#endif
#ifdef VK_FUCHSIA_external_memory
static VkResult entry_vkGetMemoryZirconHandleFUCHSIA(
- VkDevice device,
- const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
- zx_handle_t* pZirconHandle)
-{
+ VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle) {
AEMU_SCOPED_TRACE("vkGetMemoryZirconHandleFUCHSIA");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryZirconHandleFUCHSIA_VkResult_return = (VkResult)0;
- vkGetMemoryZirconHandleFUCHSIA_VkResult_return = vkEnc->vkGetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle, true /* do lock */);
+ vkGetMemoryZirconHandleFUCHSIA_VkResult_return = vkEnc->vkGetMemoryZirconHandleFUCHSIA(
+ device, pGetZirconHandleInfo, pZirconHandle, true /* do lock */);
return vkGetMemoryZirconHandleFUCHSIA_VkResult_return;
}
static VkResult dynCheck_entry_vkGetMemoryZirconHandleFUCHSIA(
- VkDevice device,
- const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
- zx_handle_t* pZirconHandle)
-{
+ VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_FUCHSIA_external_memory"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetMemoryZirconHandleFUCHSIA", "VK_FUCHSIA_external_memory");
+ if (!resources->hasDeviceExtension(device, "VK_FUCHSIA_external_memory")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetMemoryZirconHandleFUCHSIA",
+ "VK_FUCHSIA_external_memory");
}
AEMU_SCOPED_TRACE("vkGetMemoryZirconHandleFUCHSIA");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryZirconHandleFUCHSIA_VkResult_return = (VkResult)0;
- vkGetMemoryZirconHandleFUCHSIA_VkResult_return = vkEnc->vkGetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle, true /* do lock */);
+ vkGetMemoryZirconHandleFUCHSIA_VkResult_return = vkEnc->vkGetMemoryZirconHandleFUCHSIA(
+ device, pGetZirconHandleInfo, pZirconHandle, true /* do lock */);
return vkGetMemoryZirconHandleFUCHSIA_VkResult_return;
}
static VkResult entry_vkGetMemoryZirconHandlePropertiesFUCHSIA(
- VkDevice device,
- VkExternalMemoryHandleTypeFlagBits handleType,
- zx_handle_t zirconHandle,
- VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties)
-{
+ VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle,
+ VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) {
AEMU_SCOPED_TRACE("vkGetMemoryZirconHandlePropertiesFUCHSIA");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA_VkResult_return = (VkResult)0;
- vkGetMemoryZirconHandlePropertiesFUCHSIA_VkResult_return = vkEnc->vkGetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, zirconHandle, pMemoryZirconHandleProperties, true /* do lock */);
+ vkGetMemoryZirconHandlePropertiesFUCHSIA_VkResult_return =
+ vkEnc->vkGetMemoryZirconHandlePropertiesFUCHSIA(
+ device, handleType, zirconHandle, pMemoryZirconHandleProperties, true /* do lock */);
return vkGetMemoryZirconHandlePropertiesFUCHSIA_VkResult_return;
}
static VkResult dynCheck_entry_vkGetMemoryZirconHandlePropertiesFUCHSIA(
- VkDevice device,
- VkExternalMemoryHandleTypeFlagBits handleType,
- zx_handle_t zirconHandle,
- VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties)
-{
+ VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle,
+ VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_FUCHSIA_external_memory"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetMemoryZirconHandlePropertiesFUCHSIA", "VK_FUCHSIA_external_memory");
+ if (!resources->hasDeviceExtension(device, "VK_FUCHSIA_external_memory")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetMemoryZirconHandlePropertiesFUCHSIA",
+ "VK_FUCHSIA_external_memory");
}
AEMU_SCOPED_TRACE("vkGetMemoryZirconHandlePropertiesFUCHSIA");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA_VkResult_return = (VkResult)0;
- vkGetMemoryZirconHandlePropertiesFUCHSIA_VkResult_return = vkEnc->vkGetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, zirconHandle, pMemoryZirconHandleProperties, true /* do lock */);
+ vkGetMemoryZirconHandlePropertiesFUCHSIA_VkResult_return =
+ vkEnc->vkGetMemoryZirconHandlePropertiesFUCHSIA(
+ device, handleType, zirconHandle, pMemoryZirconHandleProperties, true /* do lock */);
return vkGetMemoryZirconHandlePropertiesFUCHSIA_VkResult_return;
}
#endif
#ifdef VK_FUCHSIA_external_semaphore
static VkResult entry_vkImportSemaphoreZirconHandleFUCHSIA(
VkDevice device,
- const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo)
-{
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) {
AEMU_SCOPED_TRACE("vkImportSemaphoreZirconHandleFUCHSIA");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkImportSemaphoreZirconHandleFUCHSIA_VkResult_return = (VkResult)0;
- vkImportSemaphoreZirconHandleFUCHSIA_VkResult_return = vkEnc->vkImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo, true /* do lock */);
+ vkImportSemaphoreZirconHandleFUCHSIA_VkResult_return =
+ vkEnc->vkImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo,
+ true /* do lock */);
return vkImportSemaphoreZirconHandleFUCHSIA_VkResult_return;
}
static VkResult dynCheck_entry_vkImportSemaphoreZirconHandleFUCHSIA(
VkDevice device,
- const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo)
-{
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_FUCHSIA_external_semaphore"))
- {
- sOnInvalidDynamicallyCheckedCall("vkImportSemaphoreZirconHandleFUCHSIA", "VK_FUCHSIA_external_semaphore");
+ if (!resources->hasDeviceExtension(device, "VK_FUCHSIA_external_semaphore")) {
+ sOnInvalidDynamicallyCheckedCall("vkImportSemaphoreZirconHandleFUCHSIA",
+ "VK_FUCHSIA_external_semaphore");
}
AEMU_SCOPED_TRACE("vkImportSemaphoreZirconHandleFUCHSIA");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkImportSemaphoreZirconHandleFUCHSIA_VkResult_return = (VkResult)0;
- vkImportSemaphoreZirconHandleFUCHSIA_VkResult_return = vkEnc->vkImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo, true /* do lock */);
+ vkImportSemaphoreZirconHandleFUCHSIA_VkResult_return =
+ vkEnc->vkImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo,
+ true /* do lock */);
return vkImportSemaphoreZirconHandleFUCHSIA_VkResult_return;
}
static VkResult entry_vkGetSemaphoreZirconHandleFUCHSIA(
- VkDevice device,
- const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
- zx_handle_t* pZirconHandle)
-{
+ VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle) {
AEMU_SCOPED_TRACE("vkGetSemaphoreZirconHandleFUCHSIA");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSemaphoreZirconHandleFUCHSIA_VkResult_return = (VkResult)0;
- vkGetSemaphoreZirconHandleFUCHSIA_VkResult_return = vkEnc->vkGetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle, true /* do lock */);
+ vkGetSemaphoreZirconHandleFUCHSIA_VkResult_return = vkEnc->vkGetSemaphoreZirconHandleFUCHSIA(
+ device, pGetZirconHandleInfo, pZirconHandle, true /* do lock */);
return vkGetSemaphoreZirconHandleFUCHSIA_VkResult_return;
}
static VkResult dynCheck_entry_vkGetSemaphoreZirconHandleFUCHSIA(
- VkDevice device,
- const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
- zx_handle_t* pZirconHandle)
-{
+ VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
+ zx_handle_t* pZirconHandle) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_FUCHSIA_external_semaphore"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetSemaphoreZirconHandleFUCHSIA", "VK_FUCHSIA_external_semaphore");
+ if (!resources->hasDeviceExtension(device, "VK_FUCHSIA_external_semaphore")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetSemaphoreZirconHandleFUCHSIA",
+ "VK_FUCHSIA_external_semaphore");
}
AEMU_SCOPED_TRACE("vkGetSemaphoreZirconHandleFUCHSIA");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetSemaphoreZirconHandleFUCHSIA_VkResult_return = (VkResult)0;
- vkGetSemaphoreZirconHandleFUCHSIA_VkResult_return = vkEnc->vkGetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle, true /* do lock */);
+ vkGetSemaphoreZirconHandleFUCHSIA_VkResult_return = vkEnc->vkGetSemaphoreZirconHandleFUCHSIA(
+ device, pGetZirconHandleInfo, pZirconHandle, true /* do lock */);
return vkGetSemaphoreZirconHandleFUCHSIA_VkResult_return;
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
static VkResult entry_vkCreateBufferCollectionFUCHSIA(
- VkDevice device,
- const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkBufferCollectionFUCHSIA* pCollection)
-{
+ VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection) {
AEMU_SCOPED_TRACE("vkCreateBufferCollectionFUCHSIA");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateBufferCollectionFUCHSIA_VkResult_return = (VkResult)0;
- vkCreateBufferCollectionFUCHSIA_VkResult_return = vkEnc->vkCreateBufferCollectionFUCHSIA(device, pCreateInfo, pAllocator, pCollection, true /* do lock */);
+ vkCreateBufferCollectionFUCHSIA_VkResult_return = vkEnc->vkCreateBufferCollectionFUCHSIA(
+ device, pCreateInfo, pAllocator, pCollection, true /* do lock */);
return vkCreateBufferCollectionFUCHSIA_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateBufferCollectionFUCHSIA(
- VkDevice device,
- const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkBufferCollectionFUCHSIA* pCollection)
-{
+ VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_FUCHSIA_buffer_collection"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCreateBufferCollectionFUCHSIA", "VK_FUCHSIA_buffer_collection");
+ if (!resources->hasDeviceExtension(device, "VK_FUCHSIA_buffer_collection")) {
+ sOnInvalidDynamicallyCheckedCall("vkCreateBufferCollectionFUCHSIA",
+ "VK_FUCHSIA_buffer_collection");
}
AEMU_SCOPED_TRACE("vkCreateBufferCollectionFUCHSIA");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateBufferCollectionFUCHSIA_VkResult_return = (VkResult)0;
- vkCreateBufferCollectionFUCHSIA_VkResult_return = vkEnc->vkCreateBufferCollectionFUCHSIA(device, pCreateInfo, pAllocator, pCollection, true /* do lock */);
+ vkCreateBufferCollectionFUCHSIA_VkResult_return = vkEnc->vkCreateBufferCollectionFUCHSIA(
+ device, pCreateInfo, pAllocator, pCollection, true /* do lock */);
return vkCreateBufferCollectionFUCHSIA_VkResult_return;
}
static VkResult entry_vkSetBufferCollectionImageConstraintsFUCHSIA(
- VkDevice device,
- VkBufferCollectionFUCHSIA collection,
- const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo)
-{
+ VkDevice device, VkBufferCollectionFUCHSIA collection,
+ const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) {
AEMU_SCOPED_TRACE("vkSetBufferCollectionImageConstraintsFUCHSIA");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSetBufferCollectionImageConstraintsFUCHSIA_VkResult_return = (VkResult)0;
- vkSetBufferCollectionImageConstraintsFUCHSIA_VkResult_return = vkEnc->vkSetBufferCollectionImageConstraintsFUCHSIA(device, collection, pImageConstraintsInfo, true /* do lock */);
+ vkSetBufferCollectionImageConstraintsFUCHSIA_VkResult_return =
+ vkEnc->vkSetBufferCollectionImageConstraintsFUCHSIA(
+ device, collection, pImageConstraintsInfo, true /* do lock */);
return vkSetBufferCollectionImageConstraintsFUCHSIA_VkResult_return;
}
static VkResult dynCheck_entry_vkSetBufferCollectionImageConstraintsFUCHSIA(
- VkDevice device,
- VkBufferCollectionFUCHSIA collection,
- const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo)
-{
+ VkDevice device, VkBufferCollectionFUCHSIA collection,
+ const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_FUCHSIA_buffer_collection"))
- {
- sOnInvalidDynamicallyCheckedCall("vkSetBufferCollectionImageConstraintsFUCHSIA", "VK_FUCHSIA_buffer_collection");
+ if (!resources->hasDeviceExtension(device, "VK_FUCHSIA_buffer_collection")) {
+ sOnInvalidDynamicallyCheckedCall("vkSetBufferCollectionImageConstraintsFUCHSIA",
+ "VK_FUCHSIA_buffer_collection");
}
AEMU_SCOPED_TRACE("vkSetBufferCollectionImageConstraintsFUCHSIA");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSetBufferCollectionImageConstraintsFUCHSIA_VkResult_return = (VkResult)0;
- vkSetBufferCollectionImageConstraintsFUCHSIA_VkResult_return = vkEnc->vkSetBufferCollectionImageConstraintsFUCHSIA(device, collection, pImageConstraintsInfo, true /* do lock */);
+ vkSetBufferCollectionImageConstraintsFUCHSIA_VkResult_return =
+ vkEnc->vkSetBufferCollectionImageConstraintsFUCHSIA(
+ device, collection, pImageConstraintsInfo, true /* do lock */);
return vkSetBufferCollectionImageConstraintsFUCHSIA_VkResult_return;
}
static VkResult entry_vkSetBufferCollectionBufferConstraintsFUCHSIA(
- VkDevice device,
- VkBufferCollectionFUCHSIA collection,
- const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo)
-{
+ VkDevice device, VkBufferCollectionFUCHSIA collection,
+ const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) {
AEMU_SCOPED_TRACE("vkSetBufferCollectionBufferConstraintsFUCHSIA");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA_VkResult_return = (VkResult)0;
- vkSetBufferCollectionBufferConstraintsFUCHSIA_VkResult_return = vkEnc->vkSetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo, true /* do lock */);
+ vkSetBufferCollectionBufferConstraintsFUCHSIA_VkResult_return =
+ vkEnc->vkSetBufferCollectionBufferConstraintsFUCHSIA(
+ device, collection, pBufferConstraintsInfo, true /* do lock */);
return vkSetBufferCollectionBufferConstraintsFUCHSIA_VkResult_return;
}
static VkResult dynCheck_entry_vkSetBufferCollectionBufferConstraintsFUCHSIA(
- VkDevice device,
- VkBufferCollectionFUCHSIA collection,
- const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo)
-{
+ VkDevice device, VkBufferCollectionFUCHSIA collection,
+ const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_FUCHSIA_buffer_collection"))
- {
- sOnInvalidDynamicallyCheckedCall("vkSetBufferCollectionBufferConstraintsFUCHSIA", "VK_FUCHSIA_buffer_collection");
+ if (!resources->hasDeviceExtension(device, "VK_FUCHSIA_buffer_collection")) {
+ sOnInvalidDynamicallyCheckedCall("vkSetBufferCollectionBufferConstraintsFUCHSIA",
+ "VK_FUCHSIA_buffer_collection");
}
AEMU_SCOPED_TRACE("vkSetBufferCollectionBufferConstraintsFUCHSIA");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA_VkResult_return = (VkResult)0;
- vkSetBufferCollectionBufferConstraintsFUCHSIA_VkResult_return = vkEnc->vkSetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo, true /* do lock */);
+ vkSetBufferCollectionBufferConstraintsFUCHSIA_VkResult_return =
+ vkEnc->vkSetBufferCollectionBufferConstraintsFUCHSIA(
+ device, collection, pBufferConstraintsInfo, true /* do lock */);
return vkSetBufferCollectionBufferConstraintsFUCHSIA_VkResult_return;
}
-static void entry_vkDestroyBufferCollectionFUCHSIA(
- VkDevice device,
- VkBufferCollectionFUCHSIA collection,
- const VkAllocationCallbacks* pAllocator)
-{
+static void entry_vkDestroyBufferCollectionFUCHSIA(VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyBufferCollectionFUCHSIA");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyBufferCollectionFUCHSIA(device, collection, pAllocator, true /* do lock */);
}
static void dynCheck_entry_vkDestroyBufferCollectionFUCHSIA(
- VkDevice device,
- VkBufferCollectionFUCHSIA collection,
- const VkAllocationCallbacks* pAllocator)
-{
+ VkDevice device, VkBufferCollectionFUCHSIA collection,
+ const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_FUCHSIA_buffer_collection"))
- {
- sOnInvalidDynamicallyCheckedCall("vkDestroyBufferCollectionFUCHSIA", "VK_FUCHSIA_buffer_collection");
+ if (!resources->hasDeviceExtension(device, "VK_FUCHSIA_buffer_collection")) {
+ sOnInvalidDynamicallyCheckedCall("vkDestroyBufferCollectionFUCHSIA",
+ "VK_FUCHSIA_buffer_collection");
}
AEMU_SCOPED_TRACE("vkDestroyBufferCollectionFUCHSIA");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkDestroyBufferCollectionFUCHSIA(device, collection, pAllocator, true /* do lock */);
}
static VkResult entry_vkGetBufferCollectionPropertiesFUCHSIA(
- VkDevice device,
- VkBufferCollectionFUCHSIA collection,
- VkBufferCollectionPropertiesFUCHSIA* pProperties)
-{
+ VkDevice device, VkBufferCollectionFUCHSIA collection,
+ VkBufferCollectionPropertiesFUCHSIA* pProperties) {
AEMU_SCOPED_TRACE("vkGetBufferCollectionPropertiesFUCHSIA");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetBufferCollectionPropertiesFUCHSIA_VkResult_return = (VkResult)0;
- vkGetBufferCollectionPropertiesFUCHSIA_VkResult_return = vkEnc->vkGetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties, true /* do lock */);
+ vkGetBufferCollectionPropertiesFUCHSIA_VkResult_return =
+ vkEnc->vkGetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties,
+ true /* do lock */);
return vkGetBufferCollectionPropertiesFUCHSIA_VkResult_return;
}
static VkResult dynCheck_entry_vkGetBufferCollectionPropertiesFUCHSIA(
- VkDevice device,
- VkBufferCollectionFUCHSIA collection,
- VkBufferCollectionPropertiesFUCHSIA* pProperties)
-{
+ VkDevice device, VkBufferCollectionFUCHSIA collection,
+ VkBufferCollectionPropertiesFUCHSIA* pProperties) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_FUCHSIA_buffer_collection"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetBufferCollectionPropertiesFUCHSIA", "VK_FUCHSIA_buffer_collection");
+ if (!resources->hasDeviceExtension(device, "VK_FUCHSIA_buffer_collection")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetBufferCollectionPropertiesFUCHSIA",
+ "VK_FUCHSIA_buffer_collection");
}
AEMU_SCOPED_TRACE("vkGetBufferCollectionPropertiesFUCHSIA");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetBufferCollectionPropertiesFUCHSIA_VkResult_return = (VkResult)0;
- vkGetBufferCollectionPropertiesFUCHSIA_VkResult_return = vkEnc->vkGetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties, true /* do lock */);
+ vkGetBufferCollectionPropertiesFUCHSIA_VkResult_return =
+ vkEnc->vkGetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties,
+ true /* do lock */);
return vkGetBufferCollectionPropertiesFUCHSIA_VkResult_return;
}
#endif
#ifdef VK_HUAWEI_subpass_shading
static VkResult entry_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
- VkDevice device,
- VkRenderPass renderpass,
- VkExtent2D* pMaxWorkgroupSize)
-{
+ VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize) {
AEMU_SCOPED_TRACE("vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_VkResult_return = (VkResult)0;
- vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_VkResult_return = vkEnc->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device, renderpass, pMaxWorkgroupSize, true /* do lock */);
+ vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_VkResult_return =
+ vkEnc->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
+ device, renderpass, pMaxWorkgroupSize, true /* do lock */);
return vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_VkResult_return;
}
static VkResult dynCheck_entry_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
- VkDevice device,
- VkRenderPass renderpass,
- VkExtent2D* pMaxWorkgroupSize)
-{
+ VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_HUAWEI_subpass_shading"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI", "VK_HUAWEI_subpass_shading");
+ if (!resources->hasDeviceExtension(device, "VK_HUAWEI_subpass_shading")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI",
+ "VK_HUAWEI_subpass_shading");
}
AEMU_SCOPED_TRACE("vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_VkResult_return = (VkResult)0;
- vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_VkResult_return = vkEnc->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device, renderpass, pMaxWorkgroupSize, true /* do lock */);
+ vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_VkResult_return =
+ vkEnc->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
+ device, renderpass, pMaxWorkgroupSize, true /* do lock */);
return vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_VkResult_return;
}
-static void entry_vkCmdSubpassShadingHUAWEI(
- VkCommandBuffer commandBuffer)
-{
+static void entry_vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer) {
AEMU_SCOPED_TRACE("vkCmdSubpassShadingHUAWEI");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSubpassShadingHUAWEI(commandBuffer, true /* do lock */);
}
-static void dynCheck_entry_vkCmdSubpassShadingHUAWEI(
- VkCommandBuffer commandBuffer)
-{
+static void dynCheck_entry_vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_HUAWEI_subpass_shading"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_HUAWEI_subpass_shading")) {
sOnInvalidDynamicallyCheckedCall("vkCmdSubpassShadingHUAWEI", "VK_HUAWEI_subpass_shading");
}
AEMU_SCOPED_TRACE("vkCmdSubpassShadingHUAWEI");
@@ -9452,25 +7933,21 @@
}
#endif
#ifdef VK_HUAWEI_invocation_mask
-static void entry_vkCmdBindInvocationMaskHUAWEI(
- VkCommandBuffer commandBuffer,
- VkImageView imageView,
- VkImageLayout imageLayout)
-{
+static void entry_vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer,
+ VkImageView imageView, VkImageLayout imageLayout) {
AEMU_SCOPED_TRACE("vkCmdBindInvocationMaskHUAWEI");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdBindInvocationMaskHUAWEI(commandBuffer, imageView, imageLayout, true /* do lock */);
}
-static void dynCheck_entry_vkCmdBindInvocationMaskHUAWEI(
- VkCommandBuffer commandBuffer,
- VkImageView imageView,
- VkImageLayout imageLayout)
-{
+static void dynCheck_entry_vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer,
+ VkImageView imageView,
+ VkImageLayout imageLayout) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_HUAWEI_invocation_mask"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdBindInvocationMaskHUAWEI", "VK_HUAWEI_invocation_mask");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_HUAWEI_invocation_mask")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdBindInvocationMaskHUAWEI",
+ "VK_HUAWEI_invocation_mask");
}
AEMU_SCOPED_TRACE("vkCmdBindInvocationMaskHUAWEI");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
@@ -9479,740 +7956,571 @@
#endif
#ifdef VK_NV_external_memory_rdma
static VkResult entry_vkGetMemoryRemoteAddressNV(
- VkDevice device,
- const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo,
- VkRemoteAddressNV* pAddress)
-{
+ VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo,
+ VkRemoteAddressNV* pAddress) {
AEMU_SCOPED_TRACE("vkGetMemoryRemoteAddressNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryRemoteAddressNV_VkResult_return = (VkResult)0;
- vkGetMemoryRemoteAddressNV_VkResult_return = vkEnc->vkGetMemoryRemoteAddressNV(device, pMemoryGetRemoteAddressInfo, pAddress, true /* do lock */);
+ vkGetMemoryRemoteAddressNV_VkResult_return = vkEnc->vkGetMemoryRemoteAddressNV(
+ device, pMemoryGetRemoteAddressInfo, pAddress, true /* do lock */);
return vkGetMemoryRemoteAddressNV_VkResult_return;
}
static VkResult dynCheck_entry_vkGetMemoryRemoteAddressNV(
- VkDevice device,
- const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo,
- VkRemoteAddressNV* pAddress)
-{
+ VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo,
+ VkRemoteAddressNV* pAddress) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_NV_external_memory_rdma"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetMemoryRemoteAddressNV", "VK_NV_external_memory_rdma");
+ if (!resources->hasDeviceExtension(device, "VK_NV_external_memory_rdma")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetMemoryRemoteAddressNV",
+ "VK_NV_external_memory_rdma");
}
AEMU_SCOPED_TRACE("vkGetMemoryRemoteAddressNV");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryRemoteAddressNV_VkResult_return = (VkResult)0;
- vkGetMemoryRemoteAddressNV_VkResult_return = vkEnc->vkGetMemoryRemoteAddressNV(device, pMemoryGetRemoteAddressInfo, pAddress, true /* do lock */);
+ vkGetMemoryRemoteAddressNV_VkResult_return = vkEnc->vkGetMemoryRemoteAddressNV(
+ device, pMemoryGetRemoteAddressInfo, pAddress, true /* do lock */);
return vkGetMemoryRemoteAddressNV_VkResult_return;
}
#endif
#ifdef VK_EXT_extended_dynamic_state2
-static void entry_vkCmdSetPatchControlPointsEXT(
- VkCommandBuffer commandBuffer,
- uint32_t patchControlPoints)
-{
+static void entry_vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer,
+ uint32_t patchControlPoints) {
AEMU_SCOPED_TRACE("vkCmdSetPatchControlPointsEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints, true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetPatchControlPointsEXT(
- VkCommandBuffer commandBuffer,
- uint32_t patchControlPoints)
-{
+static void dynCheck_entry_vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer,
+ uint32_t patchControlPoints) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetPatchControlPointsEXT", "VK_EXT_extended_dynamic_state2");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetPatchControlPointsEXT",
+ "VK_EXT_extended_dynamic_state2");
}
AEMU_SCOPED_TRACE("vkCmdSetPatchControlPointsEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints, true /* do lock */);
}
-static void entry_vkCmdSetRasterizerDiscardEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 rasterizerDiscardEnable)
-{
+static void entry_vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 rasterizerDiscardEnable) {
AEMU_SCOPED_TRACE("vkCmdSetRasterizerDiscardEnableEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable, true /* do lock */);
+ vkEnc->vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable,
+ true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetRasterizerDiscardEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 rasterizerDiscardEnable)
-{
+static void dynCheck_entry_vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 rasterizerDiscardEnable) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetRasterizerDiscardEnableEXT", "VK_EXT_extended_dynamic_state2");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetRasterizerDiscardEnableEXT",
+ "VK_EXT_extended_dynamic_state2");
}
AEMU_SCOPED_TRACE("vkCmdSetRasterizerDiscardEnableEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable, true /* do lock */);
+ vkEnc->vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable,
+ true /* do lock */);
}
-static void entry_vkCmdSetDepthBiasEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 depthBiasEnable)
-{
+static void entry_vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 depthBiasEnable) {
AEMU_SCOPED_TRACE("vkCmdSetDepthBiasEnableEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable, true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetDepthBiasEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 depthBiasEnable)
-{
+static void dynCheck_entry_vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 depthBiasEnable) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthBiasEnableEXT", "VK_EXT_extended_dynamic_state2");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthBiasEnableEXT",
+ "VK_EXT_extended_dynamic_state2");
}
AEMU_SCOPED_TRACE("vkCmdSetDepthBiasEnableEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable, true /* do lock */);
}
-static void entry_vkCmdSetLogicOpEXT(
- VkCommandBuffer commandBuffer,
- VkLogicOp logicOp)
-{
+static void entry_vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) {
AEMU_SCOPED_TRACE("vkCmdSetLogicOpEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetLogicOpEXT(commandBuffer, logicOp, true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetLogicOpEXT(
- VkCommandBuffer commandBuffer,
- VkLogicOp logicOp)
-{
+static void dynCheck_entry_vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
sOnInvalidDynamicallyCheckedCall("vkCmdSetLogicOpEXT", "VK_EXT_extended_dynamic_state2");
}
AEMU_SCOPED_TRACE("vkCmdSetLogicOpEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdSetLogicOpEXT(commandBuffer, logicOp, true /* do lock */);
}
-static void entry_vkCmdSetPrimitiveRestartEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 primitiveRestartEnable)
-{
+static void entry_vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 primitiveRestartEnable) {
AEMU_SCOPED_TRACE("vkCmdSetPrimitiveRestartEnableEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable, true /* do lock */);
+ vkEnc->vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable,
+ true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetPrimitiveRestartEnableEXT(
- VkCommandBuffer commandBuffer,
- VkBool32 primitiveRestartEnable)
-{
+static void dynCheck_entry_vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,
+ VkBool32 primitiveRestartEnable) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetPrimitiveRestartEnableEXT", "VK_EXT_extended_dynamic_state2");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetPrimitiveRestartEnableEXT",
+ "VK_EXT_extended_dynamic_state2");
}
AEMU_SCOPED_TRACE("vkCmdSetPrimitiveRestartEnableEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable, true /* do lock */);
+ vkEnc->vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable,
+ true /* do lock */);
}
#endif
#ifdef VK_QNX_screen_surface
-static VkResult entry_vkCreateScreenSurfaceQNX(
- VkInstance instance,
- const VkScreenSurfaceCreateInfoQNX* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkSurfaceKHR* pSurface)
-{
+static VkResult entry_vkCreateScreenSurfaceQNX(VkInstance instance,
+ const VkScreenSurfaceCreateInfoQNX* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkSurfaceKHR* pSurface) {
AEMU_SCOPED_TRACE("vkCreateScreenSurfaceQNX");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateScreenSurfaceQNX_VkResult_return = (VkResult)0;
- vkCreateScreenSurfaceQNX_VkResult_return = vkEnc->vkCreateScreenSurfaceQNX(instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
+ vkCreateScreenSurfaceQNX_VkResult_return = vkEnc->vkCreateScreenSurfaceQNX(
+ instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
return vkCreateScreenSurfaceQNX_VkResult_return;
}
static VkBool32 entry_vkGetPhysicalDeviceScreenPresentationSupportQNX(
- VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- _screen_window* window)
-{
+ VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, _screen_window* window) {
AEMU_SCOPED_TRACE("vkGetPhysicalDeviceScreenPresentationSupportQNX");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX_VkBool32_return = (VkBool32)0;
- vkGetPhysicalDeviceScreenPresentationSupportQNX_VkBool32_return = vkEnc->vkGetPhysicalDeviceScreenPresentationSupportQNX(physicalDevice, queueFamilyIndex, window, true /* do lock */);
+ vkGetPhysicalDeviceScreenPresentationSupportQNX_VkBool32_return =
+ vkEnc->vkGetPhysicalDeviceScreenPresentationSupportQNX(physicalDevice, queueFamilyIndex,
+ window, true /* do lock */);
return vkGetPhysicalDeviceScreenPresentationSupportQNX_VkBool32_return;
}
#endif
#ifdef VK_EXT_color_write_enable
-static void entry_vkCmdSetColorWriteEnableEXT(
- VkCommandBuffer commandBuffer,
- uint32_t attachmentCount,
- const VkBool32* pColorWriteEnables)
-{
+static void entry_vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer,
+ uint32_t attachmentCount,
+ const VkBool32* pColorWriteEnables) {
AEMU_SCOPED_TRACE("vkCmdSetColorWriteEnableEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables, true /* do lock */);
+ vkEnc->vkCmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables,
+ true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetColorWriteEnableEXT(
- VkCommandBuffer commandBuffer,
- uint32_t attachmentCount,
- const VkBool32* pColorWriteEnables)
-{
+static void dynCheck_entry_vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer,
+ uint32_t attachmentCount,
+ const VkBool32* pColorWriteEnables) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_color_write_enable"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetColorWriteEnableEXT", "VK_EXT_color_write_enable");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_color_write_enable")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetColorWriteEnableEXT",
+ "VK_EXT_color_write_enable");
}
AEMU_SCOPED_TRACE("vkCmdSetColorWriteEnableEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables, true /* do lock */);
+ vkEnc->vkCmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables,
+ true /* do lock */);
}
#endif
#ifdef VK_GOOGLE_gfxstream
-static VkResult entry_vkRegisterImageColorBufferGOOGLE(
- VkDevice device,
- VkImage image,
- uint32_t colorBuffer)
-{
+static VkResult entry_vkRegisterImageColorBufferGOOGLE(VkDevice device, VkImage image,
+ uint32_t colorBuffer) {
AEMU_SCOPED_TRACE("vkRegisterImageColorBufferGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkRegisterImageColorBufferGOOGLE_VkResult_return = (VkResult)0;
- vkRegisterImageColorBufferGOOGLE_VkResult_return = vkEnc->vkRegisterImageColorBufferGOOGLE(device, image, colorBuffer, true /* do lock */);
+ vkRegisterImageColorBufferGOOGLE_VkResult_return =
+ vkEnc->vkRegisterImageColorBufferGOOGLE(device, image, colorBuffer, true /* do lock */);
return vkRegisterImageColorBufferGOOGLE_VkResult_return;
}
-static VkResult dynCheck_entry_vkRegisterImageColorBufferGOOGLE(
- VkDevice device,
- VkImage image,
- uint32_t colorBuffer)
-{
+static VkResult dynCheck_entry_vkRegisterImageColorBufferGOOGLE(VkDevice device, VkImage image,
+ uint32_t colorBuffer) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
sOnInvalidDynamicallyCheckedCall("vkRegisterImageColorBufferGOOGLE", "VK_GOOGLE_gfxstream");
}
AEMU_SCOPED_TRACE("vkRegisterImageColorBufferGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkRegisterImageColorBufferGOOGLE_VkResult_return = (VkResult)0;
- vkRegisterImageColorBufferGOOGLE_VkResult_return = vkEnc->vkRegisterImageColorBufferGOOGLE(device, image, colorBuffer, true /* do lock */);
+ vkRegisterImageColorBufferGOOGLE_VkResult_return =
+ vkEnc->vkRegisterImageColorBufferGOOGLE(device, image, colorBuffer, true /* do lock */);
return vkRegisterImageColorBufferGOOGLE_VkResult_return;
}
-static VkResult entry_vkRegisterBufferColorBufferGOOGLE(
- VkDevice device,
- VkBuffer buffer,
- uint32_t colorBuffer)
-{
+static VkResult entry_vkRegisterBufferColorBufferGOOGLE(VkDevice device, VkBuffer buffer,
+ uint32_t colorBuffer) {
AEMU_SCOPED_TRACE("vkRegisterBufferColorBufferGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkRegisterBufferColorBufferGOOGLE_VkResult_return = (VkResult)0;
- vkRegisterBufferColorBufferGOOGLE_VkResult_return = vkEnc->vkRegisterBufferColorBufferGOOGLE(device, buffer, colorBuffer, true /* do lock */);
+ vkRegisterBufferColorBufferGOOGLE_VkResult_return =
+ vkEnc->vkRegisterBufferColorBufferGOOGLE(device, buffer, colorBuffer, true /* do lock */);
return vkRegisterBufferColorBufferGOOGLE_VkResult_return;
}
-static VkResult dynCheck_entry_vkRegisterBufferColorBufferGOOGLE(
- VkDevice device,
- VkBuffer buffer,
- uint32_t colorBuffer)
-{
+static VkResult dynCheck_entry_vkRegisterBufferColorBufferGOOGLE(VkDevice device, VkBuffer buffer,
+ uint32_t colorBuffer) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream"))
- {
- sOnInvalidDynamicallyCheckedCall("vkRegisterBufferColorBufferGOOGLE", "VK_GOOGLE_gfxstream");
+ if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
+ sOnInvalidDynamicallyCheckedCall("vkRegisterBufferColorBufferGOOGLE",
+ "VK_GOOGLE_gfxstream");
}
AEMU_SCOPED_TRACE("vkRegisterBufferColorBufferGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkRegisterBufferColorBufferGOOGLE_VkResult_return = (VkResult)0;
- vkRegisterBufferColorBufferGOOGLE_VkResult_return = vkEnc->vkRegisterBufferColorBufferGOOGLE(device, buffer, colorBuffer, true /* do lock */);
+ vkRegisterBufferColorBufferGOOGLE_VkResult_return =
+ vkEnc->vkRegisterBufferColorBufferGOOGLE(device, buffer, colorBuffer, true /* do lock */);
return vkRegisterBufferColorBufferGOOGLE_VkResult_return;
}
-static VkResult entry_vkMapMemoryIntoAddressSpaceGOOGLE(
- VkDevice device,
- VkDeviceMemory memory,
- uint64_t* pAddress)
-{
+static VkResult entry_vkMapMemoryIntoAddressSpaceGOOGLE(VkDevice device, VkDeviceMemory memory,
+ uint64_t* pAddress) {
AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = (VkResult)0;
- vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = vkEnc->vkMapMemoryIntoAddressSpaceGOOGLE(device, memory, pAddress, true /* do lock */);
+ vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return =
+ vkEnc->vkMapMemoryIntoAddressSpaceGOOGLE(device, memory, pAddress, true /* do lock */);
return vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return;
}
-static VkResult dynCheck_entry_vkMapMemoryIntoAddressSpaceGOOGLE(
- VkDevice device,
- VkDeviceMemory memory,
- uint64_t* pAddress)
-{
+static VkResult dynCheck_entry_vkMapMemoryIntoAddressSpaceGOOGLE(VkDevice device,
+ VkDeviceMemory memory,
+ uint64_t* pAddress) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream"))
- {
- sOnInvalidDynamicallyCheckedCall("vkMapMemoryIntoAddressSpaceGOOGLE", "VK_GOOGLE_gfxstream");
+ if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
+ sOnInvalidDynamicallyCheckedCall("vkMapMemoryIntoAddressSpaceGOOGLE",
+ "VK_GOOGLE_gfxstream");
}
AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = (VkResult)0;
- vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = vkEnc->vkMapMemoryIntoAddressSpaceGOOGLE(device, memory, pAddress, true /* do lock */);
+ vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return =
+ vkEnc->vkMapMemoryIntoAddressSpaceGOOGLE(device, memory, pAddress, true /* do lock */);
return vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return;
}
static void entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
- VkDevice device,
- VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- uint32_t imageInfoCount,
- uint32_t bufferInfoCount,
- uint32_t bufferViewCount,
- const uint32_t* pImageInfoEntryIndices,
- const uint32_t* pBufferInfoEntryIndices,
- const uint32_t* pBufferViewEntryIndices,
- const VkDescriptorImageInfo* pImageInfos,
- const VkDescriptorBufferInfo* pBufferInfos,
- const VkBufferView* pBufferViews)
-{
+ VkDevice device, VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
+ uint32_t bufferInfoCount, uint32_t bufferViewCount, const uint32_t* pImageInfoEntryIndices,
+ const uint32_t* pBufferInfoEntryIndices, const uint32_t* pBufferViewEntryIndices,
+ const VkDescriptorImageInfo* pImageInfos, const VkDescriptorBufferInfo* pBufferInfos,
+ const VkBufferView* pBufferViews) {
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount, bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices, pImageInfos, pBufferInfos, pBufferViews, true /* do lock */);
+ vkEnc->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
+ device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount,
+ bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices,
+ pImageInfos, pBufferInfos, pBufferViews, true /* do lock */);
}
static void dynCheck_entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
- VkDevice device,
- VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- uint32_t imageInfoCount,
- uint32_t bufferInfoCount,
- uint32_t bufferViewCount,
- const uint32_t* pImageInfoEntryIndices,
- const uint32_t* pBufferInfoEntryIndices,
- const uint32_t* pBufferViewEntryIndices,
- const VkDescriptorImageInfo* pImageInfos,
- const VkDescriptorBufferInfo* pBufferInfos,
- const VkBufferView* pBufferViews)
-{
+ VkDevice device, VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
+ uint32_t bufferInfoCount, uint32_t bufferViewCount, const uint32_t* pImageInfoEntryIndices,
+ const uint32_t* pBufferInfoEntryIndices, const uint32_t* pBufferViewEntryIndices,
+ const VkDescriptorImageInfo* pImageInfos, const VkDescriptorBufferInfo* pBufferInfos,
+ const VkBufferView* pBufferViews) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream"))
- {
- sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplateSizedGOOGLE", "VK_GOOGLE_gfxstream");
+ if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
+ sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplateSizedGOOGLE",
+ "VK_GOOGLE_gfxstream");
}
AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount, bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices, pImageInfos, pBufferInfos, pBufferViews, true /* do lock */);
+ vkEnc->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
+ device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount,
+ bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices,
+ pImageInfos, pBufferInfos, pBufferViews, true /* do lock */);
}
-static void entry_vkBeginCommandBufferAsyncGOOGLE(
- VkCommandBuffer commandBuffer,
- const VkCommandBufferBeginInfo* pBeginInfo)
-{
+static void entry_vkBeginCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo) {
AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkBeginCommandBufferAsyncGOOGLE(commandBuffer, pBeginInfo, true /* do lock */);
}
-static void dynCheck_entry_vkBeginCommandBufferAsyncGOOGLE(
- VkCommandBuffer commandBuffer,
- const VkCommandBufferBeginInfo* pBeginInfo)
-{
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream"))
- {
- sOnInvalidDynamicallyCheckedCall("vkBeginCommandBufferAsyncGOOGLE", "VK_GOOGLE_gfxstream");
- }
- AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkBeginCommandBufferAsyncGOOGLE(commandBuffer, pBeginInfo, true /* do lock */);
-}
-static void entry_vkEndCommandBufferAsyncGOOGLE(
- VkCommandBuffer commandBuffer)
-{
+static void entry_vkEndCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer) {
AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkEndCommandBufferAsyncGOOGLE(commandBuffer, true /* do lock */);
}
-static void dynCheck_entry_vkEndCommandBufferAsyncGOOGLE(
- VkCommandBuffer commandBuffer)
-{
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream"))
- {
- sOnInvalidDynamicallyCheckedCall("vkEndCommandBufferAsyncGOOGLE", "VK_GOOGLE_gfxstream");
- }
- AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkEndCommandBufferAsyncGOOGLE(commandBuffer, true /* do lock */);
-}
-static void entry_vkResetCommandBufferAsyncGOOGLE(
- VkCommandBuffer commandBuffer,
- VkCommandBufferResetFlags flags)
-{
+static void entry_vkResetCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags) {
AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkResetCommandBufferAsyncGOOGLE(commandBuffer, flags, true /* do lock */);
}
-static void dynCheck_entry_vkResetCommandBufferAsyncGOOGLE(
- VkCommandBuffer commandBuffer,
- VkCommandBufferResetFlags flags)
-{
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream"))
- {
- sOnInvalidDynamicallyCheckedCall("vkResetCommandBufferAsyncGOOGLE", "VK_GOOGLE_gfxstream");
- }
- AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkResetCommandBufferAsyncGOOGLE(commandBuffer, flags, true /* do lock */);
-}
-static void entry_vkCommandBufferHostSyncGOOGLE(
- VkCommandBuffer commandBuffer,
- uint32_t needHostSync,
- uint32_t sequenceNumber)
-{
+static void entry_vkCommandBufferHostSyncGOOGLE(VkCommandBuffer commandBuffer,
+ uint32_t needHostSync, uint32_t sequenceNumber) {
AEMU_SCOPED_TRACE("vkCommandBufferHostSyncGOOGLE");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCommandBufferHostSyncGOOGLE(commandBuffer, needHostSync, sequenceNumber, true /* do lock */);
-}
-static void dynCheck_entry_vkCommandBufferHostSyncGOOGLE(
- VkCommandBuffer commandBuffer,
- uint32_t needHostSync,
- uint32_t sequenceNumber)
-{
- auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCommandBufferHostSyncGOOGLE", "VK_GOOGLE_gfxstream");
- }
- AEMU_SCOPED_TRACE("vkCommandBufferHostSyncGOOGLE");
- auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCommandBufferHostSyncGOOGLE(commandBuffer, needHostSync, sequenceNumber, true /* do lock */);
+ vkEnc->vkCommandBufferHostSyncGOOGLE(commandBuffer, needHostSync, sequenceNumber,
+ true /* do lock */);
}
static VkResult entry_vkCreateImageWithRequirementsGOOGLE(
- VkDevice device,
- const VkImageCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkImage* pImage,
- VkMemoryRequirements* pMemoryRequirements)
-{
+ VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage, VkMemoryRequirements* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateImageWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
- vkCreateImageWithRequirementsGOOGLE_VkResult_return = vkEnc->vkCreateImageWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pImage, pMemoryRequirements, true /* do lock */);
+ vkCreateImageWithRequirementsGOOGLE_VkResult_return =
+ vkEnc->vkCreateImageWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pImage,
+ pMemoryRequirements, true /* do lock */);
return vkCreateImageWithRequirementsGOOGLE_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateImageWithRequirementsGOOGLE(
- VkDevice device,
- const VkImageCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkImage* pImage,
- VkMemoryRequirements* pMemoryRequirements)
-{
+ VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage, VkMemoryRequirements* pMemoryRequirements) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCreateImageWithRequirementsGOOGLE", "VK_GOOGLE_gfxstream");
+ if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
+ sOnInvalidDynamicallyCheckedCall("vkCreateImageWithRequirementsGOOGLE",
+ "VK_GOOGLE_gfxstream");
}
AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateImageWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
- vkCreateImageWithRequirementsGOOGLE_VkResult_return = vkEnc->vkCreateImageWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pImage, pMemoryRequirements, true /* do lock */);
+ vkCreateImageWithRequirementsGOOGLE_VkResult_return =
+ vkEnc->vkCreateImageWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pImage,
+ pMemoryRequirements, true /* do lock */);
return vkCreateImageWithRequirementsGOOGLE_VkResult_return;
}
static VkResult entry_vkCreateBufferWithRequirementsGOOGLE(
- VkDevice device,
- const VkBufferCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkBuffer* pBuffer,
- VkMemoryRequirements* pMemoryRequirements)
-{
+ VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer, VkMemoryRequirements* pMemoryRequirements) {
AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateBufferWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
- vkCreateBufferWithRequirementsGOOGLE_VkResult_return = vkEnc->vkCreateBufferWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pBuffer, pMemoryRequirements, true /* do lock */);
+ vkCreateBufferWithRequirementsGOOGLE_VkResult_return =
+ vkEnc->vkCreateBufferWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pBuffer,
+ pMemoryRequirements, true /* do lock */);
return vkCreateBufferWithRequirementsGOOGLE_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateBufferWithRequirementsGOOGLE(
- VkDevice device,
- const VkBufferCreateInfo* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkBuffer* pBuffer,
- VkMemoryRequirements* pMemoryRequirements)
-{
+ VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer, VkMemoryRequirements* pMemoryRequirements) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCreateBufferWithRequirementsGOOGLE", "VK_GOOGLE_gfxstream");
+ if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
+ sOnInvalidDynamicallyCheckedCall("vkCreateBufferWithRequirementsGOOGLE",
+ "VK_GOOGLE_gfxstream");
}
AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateBufferWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
- vkCreateBufferWithRequirementsGOOGLE_VkResult_return = vkEnc->vkCreateBufferWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pBuffer, pMemoryRequirements, true /* do lock */);
+ vkCreateBufferWithRequirementsGOOGLE_VkResult_return =
+ vkEnc->vkCreateBufferWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pBuffer,
+ pMemoryRequirements, true /* do lock */);
return vkCreateBufferWithRequirementsGOOGLE_VkResult_return;
}
-static VkResult entry_vkGetMemoryHostAddressInfoGOOGLE(
- VkDevice device,
- VkDeviceMemory memory,
- uint64_t* pAddress,
- uint64_t* pSize,
- uint64_t* pHostmemId)
-{
+static VkResult entry_vkGetMemoryHostAddressInfoGOOGLE(VkDevice device, VkDeviceMemory memory,
+ uint64_t* pAddress, uint64_t* pSize,
+ uint64_t* pHostmemId) {
AEMU_SCOPED_TRACE("vkGetMemoryHostAddressInfoGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = (VkResult)0;
- vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = vkEnc->vkGetMemoryHostAddressInfoGOOGLE(device, memory, pAddress, pSize, pHostmemId, true /* do lock */);
+ vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = vkEnc->vkGetMemoryHostAddressInfoGOOGLE(
+ device, memory, pAddress, pSize, pHostmemId, true /* do lock */);
return vkGetMemoryHostAddressInfoGOOGLE_VkResult_return;
}
-static VkResult dynCheck_entry_vkGetMemoryHostAddressInfoGOOGLE(
- VkDevice device,
- VkDeviceMemory memory,
- uint64_t* pAddress,
- uint64_t* pSize,
- uint64_t* pHostmemId)
-{
+static VkResult dynCheck_entry_vkGetMemoryHostAddressInfoGOOGLE(VkDevice device,
+ VkDeviceMemory memory,
+ uint64_t* pAddress, uint64_t* pSize,
+ uint64_t* pHostmemId) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
sOnInvalidDynamicallyCheckedCall("vkGetMemoryHostAddressInfoGOOGLE", "VK_GOOGLE_gfxstream");
}
AEMU_SCOPED_TRACE("vkGetMemoryHostAddressInfoGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = (VkResult)0;
- vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = vkEnc->vkGetMemoryHostAddressInfoGOOGLE(device, memory, pAddress, pSize, pHostmemId, true /* do lock */);
+ vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = vkEnc->vkGetMemoryHostAddressInfoGOOGLE(
+ device, memory, pAddress, pSize, pHostmemId, true /* do lock */);
return vkGetMemoryHostAddressInfoGOOGLE_VkResult_return;
}
-static VkResult entry_vkFreeMemorySyncGOOGLE(
- VkDevice device,
- VkDeviceMemory memory,
- const VkAllocationCallbacks* pAllocator)
-{
+static VkResult entry_vkFreeMemorySyncGOOGLE(VkDevice device, VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkFreeMemorySyncGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkFreeMemorySyncGOOGLE_VkResult_return = (VkResult)0;
- vkFreeMemorySyncGOOGLE_VkResult_return = vkEnc->vkFreeMemorySyncGOOGLE(device, memory, pAllocator, true /* do lock */);
+ vkFreeMemorySyncGOOGLE_VkResult_return =
+ vkEnc->vkFreeMemorySyncGOOGLE(device, memory, pAllocator, true /* do lock */);
return vkFreeMemorySyncGOOGLE_VkResult_return;
}
-static VkResult dynCheck_entry_vkFreeMemorySyncGOOGLE(
- VkDevice device,
- VkDeviceMemory memory,
- const VkAllocationCallbacks* pAllocator)
-{
+static VkResult dynCheck_entry_vkFreeMemorySyncGOOGLE(VkDevice device, VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
sOnInvalidDynamicallyCheckedCall("vkFreeMemorySyncGOOGLE", "VK_GOOGLE_gfxstream");
}
AEMU_SCOPED_TRACE("vkFreeMemorySyncGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkFreeMemorySyncGOOGLE_VkResult_return = (VkResult)0;
- vkFreeMemorySyncGOOGLE_VkResult_return = vkEnc->vkFreeMemorySyncGOOGLE(device, memory, pAllocator, true /* do lock */);
+ vkFreeMemorySyncGOOGLE_VkResult_return =
+ vkEnc->vkFreeMemorySyncGOOGLE(device, memory, pAllocator, true /* do lock */);
return vkFreeMemorySyncGOOGLE_VkResult_return;
}
-static void entry_vkQueueHostSyncGOOGLE(
- VkQueue queue,
- uint32_t needHostSync,
- uint32_t sequenceNumber)
-{
+static void entry_vkQueueHostSyncGOOGLE(VkQueue queue, uint32_t needHostSync,
+ uint32_t sequenceNumber) {
AEMU_SCOPED_TRACE("vkQueueHostSyncGOOGLE");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
vkEnc->vkQueueHostSyncGOOGLE(queue, needHostSync, sequenceNumber, true /* do lock */);
}
-static void entry_vkQueueSubmitAsyncGOOGLE(
- VkQueue queue,
- uint32_t submitCount,
- const VkSubmitInfo* pSubmits,
- VkFence fence)
-{
+static void entry_vkQueueSubmitAsyncGOOGLE(VkQueue queue, uint32_t submitCount,
+ const VkSubmitInfo* pSubmits, VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueSubmitAsyncGOOGLE");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
vkEnc->vkQueueSubmitAsyncGOOGLE(queue, submitCount, pSubmits, fence, true /* do lock */);
}
-static void entry_vkQueueWaitIdleAsyncGOOGLE(
- VkQueue queue)
-{
+static void entry_vkQueueWaitIdleAsyncGOOGLE(VkQueue queue) {
AEMU_SCOPED_TRACE("vkQueueWaitIdleAsyncGOOGLE");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
vkEnc->vkQueueWaitIdleAsyncGOOGLE(queue, true /* do lock */);
}
-static void entry_vkQueueBindSparseAsyncGOOGLE(
- VkQueue queue,
- uint32_t bindInfoCount,
- const VkBindSparseInfo* pBindInfo,
- VkFence fence)
-{
+static void entry_vkQueueBindSparseAsyncGOOGLE(VkQueue queue, uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo, VkFence fence) {
AEMU_SCOPED_TRACE("vkQueueBindSparseAsyncGOOGLE");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
vkEnc->vkQueueBindSparseAsyncGOOGLE(queue, bindInfoCount, pBindInfo, fence, true /* do lock */);
}
-static void entry_vkGetLinearImageLayoutGOOGLE(
- VkDevice device,
- VkFormat format,
- VkDeviceSize* pOffset,
- VkDeviceSize* pRowPitchAlignment)
-{
+static void entry_vkGetLinearImageLayoutGOOGLE(VkDevice device, VkFormat format,
+ VkDeviceSize* pOffset,
+ VkDeviceSize* pRowPitchAlignment) {
AEMU_SCOPED_TRACE("vkGetLinearImageLayoutGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetLinearImageLayoutGOOGLE(device, format, pOffset, pRowPitchAlignment, true /* do lock */);
+ vkEnc->vkGetLinearImageLayoutGOOGLE(device, format, pOffset, pRowPitchAlignment,
+ true /* do lock */);
}
-static void dynCheck_entry_vkGetLinearImageLayoutGOOGLE(
- VkDevice device,
- VkFormat format,
- VkDeviceSize* pOffset,
- VkDeviceSize* pRowPitchAlignment)
-{
+static void dynCheck_entry_vkGetLinearImageLayoutGOOGLE(VkDevice device, VkFormat format,
+ VkDeviceSize* pOffset,
+ VkDeviceSize* pRowPitchAlignment) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
sOnInvalidDynamicallyCheckedCall("vkGetLinearImageLayoutGOOGLE", "VK_GOOGLE_gfxstream");
}
AEMU_SCOPED_TRACE("vkGetLinearImageLayoutGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetLinearImageLayoutGOOGLE(device, format, pOffset, pRowPitchAlignment, true /* do lock */);
+ vkEnc->vkGetLinearImageLayoutGOOGLE(device, format, pOffset, pRowPitchAlignment,
+ true /* do lock */);
}
-static void entry_vkGetLinearImageLayout2GOOGLE(
- VkDevice device,
- const VkImageCreateInfo* pCreateInfo,
- VkDeviceSize* pOffset,
- VkDeviceSize* pRowPitchAlignment)
-{
+static void entry_vkGetLinearImageLayout2GOOGLE(VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+ VkDeviceSize* pOffset,
+ VkDeviceSize* pRowPitchAlignment) {
AEMU_SCOPED_TRACE("vkGetLinearImageLayout2GOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetLinearImageLayout2GOOGLE(device, pCreateInfo, pOffset, pRowPitchAlignment, true /* do lock */);
+ vkEnc->vkGetLinearImageLayout2GOOGLE(device, pCreateInfo, pOffset, pRowPitchAlignment,
+ true /* do lock */);
}
-static void dynCheck_entry_vkGetLinearImageLayout2GOOGLE(
- VkDevice device,
- const VkImageCreateInfo* pCreateInfo,
- VkDeviceSize* pOffset,
- VkDeviceSize* pRowPitchAlignment)
-{
+static void dynCheck_entry_vkGetLinearImageLayout2GOOGLE(VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+ VkDeviceSize* pOffset,
+ VkDeviceSize* pRowPitchAlignment) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
sOnInvalidDynamicallyCheckedCall("vkGetLinearImageLayout2GOOGLE", "VK_GOOGLE_gfxstream");
}
AEMU_SCOPED_TRACE("vkGetLinearImageLayout2GOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetLinearImageLayout2GOOGLE(device, pCreateInfo, pOffset, pRowPitchAlignment, true /* do lock */);
+ vkEnc->vkGetLinearImageLayout2GOOGLE(device, pCreateInfo, pOffset, pRowPitchAlignment,
+ true /* do lock */);
}
-static void entry_vkQueueFlushCommandsGOOGLE(
- VkQueue queue,
- VkCommandBuffer commandBuffer,
- VkDeviceSize dataSize,
- const void* pData)
-{
+static void entry_vkQueueFlushCommandsGOOGLE(VkQueue queue, VkCommandBuffer commandBuffer,
+ VkDeviceSize dataSize, const void* pData) {
AEMU_SCOPED_TRACE("vkQueueFlushCommandsGOOGLE");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
vkEnc->vkQueueFlushCommandsGOOGLE(queue, commandBuffer, dataSize, pData, true /* do lock */);
}
static void entry_vkQueueCommitDescriptorSetUpdatesGOOGLE(
- VkQueue queue,
- uint32_t descriptorPoolCount,
- const VkDescriptorPool* pDescriptorPools,
- uint32_t descriptorSetCount,
- const VkDescriptorSetLayout* pSetLayouts,
- const uint64_t* pDescriptorSetPoolIds,
- const uint32_t* pDescriptorSetWhichPool,
+ VkQueue queue, uint32_t descriptorPoolCount, const VkDescriptorPool* pDescriptorPools,
+ uint32_t descriptorSetCount, const VkDescriptorSetLayout* pSetLayouts,
+ const uint64_t* pDescriptorSetPoolIds, const uint32_t* pDescriptorSetWhichPool,
const uint32_t* pDescriptorSetPendingAllocation,
- const uint32_t* pDescriptorWriteStartingIndices,
- uint32_t pendingDescriptorWriteCount,
- const VkWriteDescriptorSet* pPendingDescriptorWrites)
-{
+ const uint32_t* pDescriptorWriteStartingIndices, uint32_t pendingDescriptorWriteCount,
+ const VkWriteDescriptorSet* pPendingDescriptorWrites) {
AEMU_SCOPED_TRACE("vkQueueCommitDescriptorSetUpdatesGOOGLE");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkQueueCommitDescriptorSetUpdatesGOOGLE(queue, descriptorPoolCount, pDescriptorPools, descriptorSetCount, pSetLayouts, pDescriptorSetPoolIds, pDescriptorSetWhichPool, pDescriptorSetPendingAllocation, pDescriptorWriteStartingIndices, pendingDescriptorWriteCount, pPendingDescriptorWrites, true /* do lock */);
+ vkEnc->vkQueueCommitDescriptorSetUpdatesGOOGLE(
+ queue, descriptorPoolCount, pDescriptorPools, descriptorSetCount, pSetLayouts,
+ pDescriptorSetPoolIds, pDescriptorSetWhichPool, pDescriptorSetPendingAllocation,
+ pDescriptorWriteStartingIndices, pendingDescriptorWriteCount, pPendingDescriptorWrites,
+ true /* do lock */);
}
-static void entry_vkCollectDescriptorPoolIdsGOOGLE(
- VkDevice device,
- VkDescriptorPool descriptorPool,
- uint32_t* pPoolIdCount,
- uint64_t* pPoolIds)
-{
+static void entry_vkCollectDescriptorPoolIdsGOOGLE(VkDevice device, VkDescriptorPool descriptorPool,
+ uint32_t* pPoolIdCount, uint64_t* pPoolIds) {
AEMU_SCOPED_TRACE("vkCollectDescriptorPoolIdsGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkCollectDescriptorPoolIdsGOOGLE(device, descriptorPool, pPoolIdCount, pPoolIds, true /* do lock */);
+ vkEnc->vkCollectDescriptorPoolIdsGOOGLE(device, descriptorPool, pPoolIdCount, pPoolIds,
+ true /* do lock */);
}
-static void dynCheck_entry_vkCollectDescriptorPoolIdsGOOGLE(
- VkDevice device,
- VkDescriptorPool descriptorPool,
- uint32_t* pPoolIdCount,
- uint64_t* pPoolIds)
-{
+static void dynCheck_entry_vkCollectDescriptorPoolIdsGOOGLE(VkDevice device,
+ VkDescriptorPool descriptorPool,
+ uint32_t* pPoolIdCount,
+ uint64_t* pPoolIds) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream"))
- {
+ if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
sOnInvalidDynamicallyCheckedCall("vkCollectDescriptorPoolIdsGOOGLE", "VK_GOOGLE_gfxstream");
}
AEMU_SCOPED_TRACE("vkCollectDescriptorPoolIdsGOOGLE");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkCollectDescriptorPoolIdsGOOGLE(device, descriptorPool, pPoolIdCount, pPoolIds, true /* do lock */);
+ vkEnc->vkCollectDescriptorPoolIdsGOOGLE(device, descriptorPool, pPoolIdCount, pPoolIds,
+ true /* do lock */);
}
-static void entry_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(
- VkQueue queue,
- uint32_t waitSemaphoreCount,
- const VkSemaphore* pWaitSemaphores,
- VkImage image)
-{
+static void entry_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(VkQueue queue,
+ uint32_t waitSemaphoreCount,
+ const VkSemaphore* pWaitSemaphores,
+ VkImage image) {
AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROIDAsyncGOOGLE");
auto vkEnc = ResourceTracker::getQueueEncoder(queue);
- vkEnc->vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(queue, waitSemaphoreCount, pWaitSemaphores, image, true /* do lock */);
+ vkEnc->vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(queue, waitSemaphoreCount, pWaitSemaphores,
+ image, true /* do lock */);
}
#endif
#ifdef VK_EXT_global_priority_query
#endif
#ifdef VK_EXT_multi_draw
-static void entry_vkCmdDrawMultiEXT(
- VkCommandBuffer commandBuffer,
- uint32_t drawCount,
- const VkMultiDrawInfoEXT* pVertexInfo,
- uint32_t instanceCount,
- uint32_t firstInstance,
- uint32_t stride)
-{
+static void entry_vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount,
+ const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount,
+ uint32_t firstInstance, uint32_t stride) {
AEMU_SCOPED_TRACE("vkCmdDrawMultiEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride, true /* do lock */);
+ vkEnc->vkCmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance,
+ stride, true /* do lock */);
}
-static void dynCheck_entry_vkCmdDrawMultiEXT(
- VkCommandBuffer commandBuffer,
- uint32_t drawCount,
- const VkMultiDrawInfoEXT* pVertexInfo,
- uint32_t instanceCount,
- uint32_t firstInstance,
- uint32_t stride)
-{
+static void dynCheck_entry_vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount,
+ const VkMultiDrawInfoEXT* pVertexInfo,
+ uint32_t instanceCount, uint32_t firstInstance,
+ uint32_t stride) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_multi_draw"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_multi_draw")) {
sOnInvalidDynamicallyCheckedCall("vkCmdDrawMultiEXT", "VK_EXT_multi_draw");
}
AEMU_SCOPED_TRACE("vkCmdDrawMultiEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride, true /* do lock */);
+ vkEnc->vkCmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance,
+ stride, true /* do lock */);
}
-static void entry_vkCmdDrawMultiIndexedEXT(
- VkCommandBuffer commandBuffer,
- uint32_t drawCount,
- const VkMultiDrawIndexedInfoEXT* pIndexInfo,
- uint32_t instanceCount,
- uint32_t firstInstance,
- uint32_t stride,
- const int32_t* pVertexOffset)
-{
+static void entry_vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount,
+ const VkMultiDrawIndexedInfoEXT* pIndexInfo,
+ uint32_t instanceCount, uint32_t firstInstance,
+ uint32_t stride, const int32_t* pVertexOffset) {
AEMU_SCOPED_TRACE("vkCmdDrawMultiIndexedEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset, true /* do lock */);
+ vkEnc->vkCmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount,
+ firstInstance, stride, pVertexOffset, true /* do lock */);
}
-static void dynCheck_entry_vkCmdDrawMultiIndexedEXT(
- VkCommandBuffer commandBuffer,
- uint32_t drawCount,
- const VkMultiDrawIndexedInfoEXT* pIndexInfo,
- uint32_t instanceCount,
- uint32_t firstInstance,
- uint32_t stride,
- const int32_t* pVertexOffset)
-{
+static void dynCheck_entry_vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer,
+ uint32_t drawCount,
+ const VkMultiDrawIndexedInfoEXT* pIndexInfo,
+ uint32_t instanceCount, uint32_t firstInstance,
+ uint32_t stride, const int32_t* pVertexOffset) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_EXT_multi_draw"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_EXT_multi_draw")) {
sOnInvalidDynamicallyCheckedCall("vkCmdDrawMultiIndexedEXT", "VK_EXT_multi_draw");
}
AEMU_SCOPED_TRACE("vkCmdDrawMultiIndexedEXT");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset, true /* do lock */);
+ vkEnc->vkCmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount,
+ firstInstance, stride, pVertexOffset, true /* do lock */);
}
#endif
#ifdef VK_EXT_load_store_op_none
@@ -10220,24 +8528,18 @@
#ifdef VK_EXT_border_color_swizzle
#endif
#ifdef VK_EXT_pageable_device_local_memory
-static void entry_vkSetDeviceMemoryPriorityEXT(
- VkDevice device,
- VkDeviceMemory memory,
- float priority)
-{
+static void entry_vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory,
+ float priority) {
AEMU_SCOPED_TRACE("vkSetDeviceMemoryPriorityEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
vkEnc->vkSetDeviceMemoryPriorityEXT(device, memory, priority, true /* do lock */);
}
-static void dynCheck_entry_vkSetDeviceMemoryPriorityEXT(
- VkDevice device,
- VkDeviceMemory memory,
- float priority)
-{
+static void dynCheck_entry_vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory,
+ float priority) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_EXT_pageable_device_local_memory"))
- {
- sOnInvalidDynamicallyCheckedCall("vkSetDeviceMemoryPriorityEXT", "VK_EXT_pageable_device_local_memory");
+ if (!resources->hasDeviceExtension(device, "VK_EXT_pageable_device_local_memory")) {
+ sOnInvalidDynamicallyCheckedCall("vkSetDeviceMemoryPriorityEXT",
+ "VK_EXT_pageable_device_local_memory");
}
AEMU_SCOPED_TRACE("vkSetDeviceMemoryPriorityEXT");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
@@ -10246,8266 +8548,6894 @@
#endif
#ifdef VK_KHR_acceleration_structure
static VkResult entry_vkCreateAccelerationStructureKHR(
- VkDevice device,
- const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkAccelerationStructureKHR* pAccelerationStructure)
-{
+ VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) {
AEMU_SCOPED_TRACE("vkCreateAccelerationStructureKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateAccelerationStructureKHR_VkResult_return = (VkResult)0;
- vkCreateAccelerationStructureKHR_VkResult_return = vkEnc->vkCreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure, true /* do lock */);
+ vkCreateAccelerationStructureKHR_VkResult_return = vkEnc->vkCreateAccelerationStructureKHR(
+ device, pCreateInfo, pAllocator, pAccelerationStructure, true /* do lock */);
return vkCreateAccelerationStructureKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateAccelerationStructureKHR(
- VkDevice device,
- const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
- const VkAllocationCallbacks* pAllocator,
- VkAccelerationStructureKHR* pAccelerationStructure)
-{
+ VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCreateAccelerationStructureKHR", "VK_KHR_acceleration_structure");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure")) {
+ sOnInvalidDynamicallyCheckedCall("vkCreateAccelerationStructureKHR",
+ "VK_KHR_acceleration_structure");
}
AEMU_SCOPED_TRACE("vkCreateAccelerationStructureKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateAccelerationStructureKHR_VkResult_return = (VkResult)0;
- vkCreateAccelerationStructureKHR_VkResult_return = vkEnc->vkCreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure, true /* do lock */);
+ vkCreateAccelerationStructureKHR_VkResult_return = vkEnc->vkCreateAccelerationStructureKHR(
+ device, pCreateInfo, pAllocator, pAccelerationStructure, true /* do lock */);
return vkCreateAccelerationStructureKHR_VkResult_return;
}
static void entry_vkDestroyAccelerationStructureKHR(
- VkDevice device,
- VkAccelerationStructureKHR accelerationStructure,
- const VkAllocationCallbacks* pAllocator)
-{
+ VkDevice device, VkAccelerationStructureKHR accelerationStructure,
+ const VkAllocationCallbacks* pAllocator) {
AEMU_SCOPED_TRACE("vkDestroyAccelerationStructureKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator, true /* do lock */);
+ vkEnc->vkDestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator,
+ true /* do lock */);
}
static void dynCheck_entry_vkDestroyAccelerationStructureKHR(
- VkDevice device,
- VkAccelerationStructureKHR accelerationStructure,
- const VkAllocationCallbacks* pAllocator)
-{
+ VkDevice device, VkAccelerationStructureKHR accelerationStructure,
+ const VkAllocationCallbacks* pAllocator) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure"))
- {
- sOnInvalidDynamicallyCheckedCall("vkDestroyAccelerationStructureKHR", "VK_KHR_acceleration_structure");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure")) {
+ sOnInvalidDynamicallyCheckedCall("vkDestroyAccelerationStructureKHR",
+ "VK_KHR_acceleration_structure");
}
AEMU_SCOPED_TRACE("vkDestroyAccelerationStructureKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkDestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator, true /* do lock */);
+ vkEnc->vkDestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator,
+ true /* do lock */);
}
static void entry_vkCmdBuildAccelerationStructuresKHR(
- VkCommandBuffer commandBuffer,
- uint32_t infoCount,
+ VkCommandBuffer commandBuffer, uint32_t infoCount,
const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
- const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
-{
+ const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) {
AEMU_SCOPED_TRACE("vkCmdBuildAccelerationStructuresKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos, true /* do lock */);
+ vkEnc->vkCmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos,
+ true /* do lock */);
}
static void dynCheck_entry_vkCmdBuildAccelerationStructuresKHR(
- VkCommandBuffer commandBuffer,
- uint32_t infoCount,
+ VkCommandBuffer commandBuffer, uint32_t infoCount,
const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
- const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
-{
+ const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdBuildAccelerationStructuresKHR", "VK_KHR_acceleration_structure");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdBuildAccelerationStructuresKHR",
+ "VK_KHR_acceleration_structure");
}
AEMU_SCOPED_TRACE("vkCmdBuildAccelerationStructuresKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos, true /* do lock */);
+ vkEnc->vkCmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos,
+ true /* do lock */);
}
static void entry_vkCmdBuildAccelerationStructuresIndirectKHR(
- VkCommandBuffer commandBuffer,
- uint32_t infoCount,
+ VkCommandBuffer commandBuffer, uint32_t infoCount,
const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
- const VkDeviceAddress* pIndirectDeviceAddresses,
- const uint32_t* pIndirectStrides,
- const uint32_t* const* ppMaxPrimitiveCounts)
-{
+ const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides,
+ const uint32_t* const* ppMaxPrimitiveCounts) {
AEMU_SCOPED_TRACE("vkCmdBuildAccelerationStructuresIndirectKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts, true /* do lock */);
+ vkEnc->vkCmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos,
+ pIndirectDeviceAddresses, pIndirectStrides,
+ ppMaxPrimitiveCounts, true /* do lock */);
}
static void dynCheck_entry_vkCmdBuildAccelerationStructuresIndirectKHR(
- VkCommandBuffer commandBuffer,
- uint32_t infoCount,
+ VkCommandBuffer commandBuffer, uint32_t infoCount,
const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
- const VkDeviceAddress* pIndirectDeviceAddresses,
- const uint32_t* pIndirectStrides,
- const uint32_t* const* ppMaxPrimitiveCounts)
-{
+ const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides,
+ const uint32_t* const* ppMaxPrimitiveCounts) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdBuildAccelerationStructuresIndirectKHR", "VK_KHR_acceleration_structure");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdBuildAccelerationStructuresIndirectKHR",
+ "VK_KHR_acceleration_structure");
}
AEMU_SCOPED_TRACE("vkCmdBuildAccelerationStructuresIndirectKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts, true /* do lock */);
+ vkEnc->vkCmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos,
+ pIndirectDeviceAddresses, pIndirectStrides,
+ ppMaxPrimitiveCounts, true /* do lock */);
}
static VkResult entry_vkBuildAccelerationStructuresKHR(
- VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- uint32_t infoCount,
+ VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount,
const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
- const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
-{
+ const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) {
AEMU_SCOPED_TRACE("vkBuildAccelerationStructuresKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBuildAccelerationStructuresKHR_VkResult_return = (VkResult)0;
- vkBuildAccelerationStructuresKHR_VkResult_return = vkEnc->vkBuildAccelerationStructuresKHR(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos, true /* do lock */);
+ vkBuildAccelerationStructuresKHR_VkResult_return = vkEnc->vkBuildAccelerationStructuresKHR(
+ device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos, true /* do lock */);
return vkBuildAccelerationStructuresKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkBuildAccelerationStructuresKHR(
- VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- uint32_t infoCount,
+ VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount,
const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
- const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
-{
+ const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure"))
- {
- sOnInvalidDynamicallyCheckedCall("vkBuildAccelerationStructuresKHR", "VK_KHR_acceleration_structure");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure")) {
+ sOnInvalidDynamicallyCheckedCall("vkBuildAccelerationStructuresKHR",
+ "VK_KHR_acceleration_structure");
}
AEMU_SCOPED_TRACE("vkBuildAccelerationStructuresKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkBuildAccelerationStructuresKHR_VkResult_return = (VkResult)0;
- vkBuildAccelerationStructuresKHR_VkResult_return = vkEnc->vkBuildAccelerationStructuresKHR(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos, true /* do lock */);
+ vkBuildAccelerationStructuresKHR_VkResult_return = vkEnc->vkBuildAccelerationStructuresKHR(
+ device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos, true /* do lock */);
return vkBuildAccelerationStructuresKHR_VkResult_return;
}
static VkResult entry_vkCopyAccelerationStructureKHR(
- VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- const VkCopyAccelerationStructureInfoKHR* pInfo)
-{
+ VkDevice device, VkDeferredOperationKHR deferredOperation,
+ const VkCopyAccelerationStructureInfoKHR* pInfo) {
AEMU_SCOPED_TRACE("vkCopyAccelerationStructureKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCopyAccelerationStructureKHR_VkResult_return = (VkResult)0;
- vkCopyAccelerationStructureKHR_VkResult_return = vkEnc->vkCopyAccelerationStructureKHR(device, deferredOperation, pInfo, true /* do lock */);
+ vkCopyAccelerationStructureKHR_VkResult_return =
+ vkEnc->vkCopyAccelerationStructureKHR(device, deferredOperation, pInfo, true /* do lock */);
return vkCopyAccelerationStructureKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkCopyAccelerationStructureKHR(
- VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- const VkCopyAccelerationStructureInfoKHR* pInfo)
-{
+ VkDevice device, VkDeferredOperationKHR deferredOperation,
+ const VkCopyAccelerationStructureInfoKHR* pInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCopyAccelerationStructureKHR", "VK_KHR_acceleration_structure");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure")) {
+ sOnInvalidDynamicallyCheckedCall("vkCopyAccelerationStructureKHR",
+ "VK_KHR_acceleration_structure");
}
AEMU_SCOPED_TRACE("vkCopyAccelerationStructureKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCopyAccelerationStructureKHR_VkResult_return = (VkResult)0;
- vkCopyAccelerationStructureKHR_VkResult_return = vkEnc->vkCopyAccelerationStructureKHR(device, deferredOperation, pInfo, true /* do lock */);
+ vkCopyAccelerationStructureKHR_VkResult_return =
+ vkEnc->vkCopyAccelerationStructureKHR(device, deferredOperation, pInfo, true /* do lock */);
return vkCopyAccelerationStructureKHR_VkResult_return;
}
static VkResult entry_vkCopyAccelerationStructureToMemoryKHR(
- VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
-{
+ VkDevice device, VkDeferredOperationKHR deferredOperation,
+ const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) {
AEMU_SCOPED_TRACE("vkCopyAccelerationStructureToMemoryKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCopyAccelerationStructureToMemoryKHR_VkResult_return = (VkResult)0;
- vkCopyAccelerationStructureToMemoryKHR_VkResult_return = vkEnc->vkCopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo, true /* do lock */);
+ vkCopyAccelerationStructureToMemoryKHR_VkResult_return =
+ vkEnc->vkCopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo,
+ true /* do lock */);
return vkCopyAccelerationStructureToMemoryKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkCopyAccelerationStructureToMemoryKHR(
- VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
-{
+ VkDevice device, VkDeferredOperationKHR deferredOperation,
+ const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCopyAccelerationStructureToMemoryKHR", "VK_KHR_acceleration_structure");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure")) {
+ sOnInvalidDynamicallyCheckedCall("vkCopyAccelerationStructureToMemoryKHR",
+ "VK_KHR_acceleration_structure");
}
AEMU_SCOPED_TRACE("vkCopyAccelerationStructureToMemoryKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCopyAccelerationStructureToMemoryKHR_VkResult_return = (VkResult)0;
- vkCopyAccelerationStructureToMemoryKHR_VkResult_return = vkEnc->vkCopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo, true /* do lock */);
+ vkCopyAccelerationStructureToMemoryKHR_VkResult_return =
+ vkEnc->vkCopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo,
+ true /* do lock */);
return vkCopyAccelerationStructureToMemoryKHR_VkResult_return;
}
static VkResult entry_vkCopyMemoryToAccelerationStructureKHR(
- VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
-{
+ VkDevice device, VkDeferredOperationKHR deferredOperation,
+ const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) {
AEMU_SCOPED_TRACE("vkCopyMemoryToAccelerationStructureKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCopyMemoryToAccelerationStructureKHR_VkResult_return = (VkResult)0;
- vkCopyMemoryToAccelerationStructureKHR_VkResult_return = vkEnc->vkCopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo, true /* do lock */);
+ vkCopyMemoryToAccelerationStructureKHR_VkResult_return =
+ vkEnc->vkCopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo,
+ true /* do lock */);
return vkCopyMemoryToAccelerationStructureKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkCopyMemoryToAccelerationStructureKHR(
- VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
-{
+ VkDevice device, VkDeferredOperationKHR deferredOperation,
+ const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCopyMemoryToAccelerationStructureKHR", "VK_KHR_acceleration_structure");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure")) {
+ sOnInvalidDynamicallyCheckedCall("vkCopyMemoryToAccelerationStructureKHR",
+ "VK_KHR_acceleration_structure");
}
AEMU_SCOPED_TRACE("vkCopyMemoryToAccelerationStructureKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCopyMemoryToAccelerationStructureKHR_VkResult_return = (VkResult)0;
- vkCopyMemoryToAccelerationStructureKHR_VkResult_return = vkEnc->vkCopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo, true /* do lock */);
+ vkCopyMemoryToAccelerationStructureKHR_VkResult_return =
+ vkEnc->vkCopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo,
+ true /* do lock */);
return vkCopyMemoryToAccelerationStructureKHR_VkResult_return;
}
static VkResult entry_vkWriteAccelerationStructuresPropertiesKHR(
- VkDevice device,
- uint32_t accelerationStructureCount,
- const VkAccelerationStructureKHR* pAccelerationStructures,
- VkQueryType queryType,
- size_t dataSize,
- void* pData,
- size_t stride)
-{
+ VkDevice device, uint32_t accelerationStructureCount,
+ const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType,
+ size_t dataSize, void* pData, size_t stride) {
AEMU_SCOPED_TRACE("vkWriteAccelerationStructuresPropertiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkWriteAccelerationStructuresPropertiesKHR_VkResult_return = (VkResult)0;
- vkWriteAccelerationStructuresPropertiesKHR_VkResult_return = vkEnc->vkWriteAccelerationStructuresPropertiesKHR(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride, true /* do lock */);
+ vkWriteAccelerationStructuresPropertiesKHR_VkResult_return =
+ vkEnc->vkWriteAccelerationStructuresPropertiesKHR(
+ device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData,
+ stride, true /* do lock */);
return vkWriteAccelerationStructuresPropertiesKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkWriteAccelerationStructuresPropertiesKHR(
- VkDevice device,
- uint32_t accelerationStructureCount,
- const VkAccelerationStructureKHR* pAccelerationStructures,
- VkQueryType queryType,
- size_t dataSize,
- void* pData,
- size_t stride)
-{
+ VkDevice device, uint32_t accelerationStructureCount,
+ const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType,
+ size_t dataSize, void* pData, size_t stride) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure"))
- {
- sOnInvalidDynamicallyCheckedCall("vkWriteAccelerationStructuresPropertiesKHR", "VK_KHR_acceleration_structure");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure")) {
+ sOnInvalidDynamicallyCheckedCall("vkWriteAccelerationStructuresPropertiesKHR",
+ "VK_KHR_acceleration_structure");
}
AEMU_SCOPED_TRACE("vkWriteAccelerationStructuresPropertiesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkWriteAccelerationStructuresPropertiesKHR_VkResult_return = (VkResult)0;
- vkWriteAccelerationStructuresPropertiesKHR_VkResult_return = vkEnc->vkWriteAccelerationStructuresPropertiesKHR(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride, true /* do lock */);
+ vkWriteAccelerationStructuresPropertiesKHR_VkResult_return =
+ vkEnc->vkWriteAccelerationStructuresPropertiesKHR(
+ device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData,
+ stride, true /* do lock */);
return vkWriteAccelerationStructuresPropertiesKHR_VkResult_return;
}
static void entry_vkCmdCopyAccelerationStructureKHR(
- VkCommandBuffer commandBuffer,
- const VkCopyAccelerationStructureInfoKHR* pInfo)
-{
+ VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyAccelerationStructureKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdCopyAccelerationStructureKHR(commandBuffer, pInfo, true /* do lock */);
}
static void dynCheck_entry_vkCmdCopyAccelerationStructureKHR(
- VkCommandBuffer commandBuffer,
- const VkCopyAccelerationStructureInfoKHR* pInfo)
-{
+ VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdCopyAccelerationStructureKHR", "VK_KHR_acceleration_structure");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdCopyAccelerationStructureKHR",
+ "VK_KHR_acceleration_structure");
}
AEMU_SCOPED_TRACE("vkCmdCopyAccelerationStructureKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdCopyAccelerationStructureKHR(commandBuffer, pInfo, true /* do lock */);
}
static void entry_vkCmdCopyAccelerationStructureToMemoryKHR(
- VkCommandBuffer commandBuffer,
- const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
-{
+ VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyAccelerationStructureToMemoryKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo, true /* do lock */);
}
static void dynCheck_entry_vkCmdCopyAccelerationStructureToMemoryKHR(
- VkCommandBuffer commandBuffer,
- const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
-{
+ VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdCopyAccelerationStructureToMemoryKHR", "VK_KHR_acceleration_structure");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdCopyAccelerationStructureToMemoryKHR",
+ "VK_KHR_acceleration_structure");
}
AEMU_SCOPED_TRACE("vkCmdCopyAccelerationStructureToMemoryKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo, true /* do lock */);
}
static void entry_vkCmdCopyMemoryToAccelerationStructureKHR(
- VkCommandBuffer commandBuffer,
- const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
-{
+ VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) {
AEMU_SCOPED_TRACE("vkCmdCopyMemoryToAccelerationStructureKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo, true /* do lock */);
}
static void dynCheck_entry_vkCmdCopyMemoryToAccelerationStructureKHR(
- VkCommandBuffer commandBuffer,
- const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
-{
+ VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdCopyMemoryToAccelerationStructureKHR", "VK_KHR_acceleration_structure");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdCopyMemoryToAccelerationStructureKHR",
+ "VK_KHR_acceleration_structure");
}
AEMU_SCOPED_TRACE("vkCmdCopyMemoryToAccelerationStructureKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
vkEnc->vkCmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo, true /* do lock */);
}
static VkDeviceAddress entry_vkGetAccelerationStructureDeviceAddressKHR(
- VkDevice device,
- const VkAccelerationStructureDeviceAddressInfoKHR* pInfo)
-{
+ VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) {
AEMU_SCOPED_TRACE("vkGetAccelerationStructureDeviceAddressKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR_VkDeviceAddress_return = (VkDeviceAddress)0;
- vkGetAccelerationStructureDeviceAddressKHR_VkDeviceAddress_return = vkEnc->vkGetAccelerationStructureDeviceAddressKHR(device, pInfo, true /* do lock */);
+ VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR_VkDeviceAddress_return =
+ (VkDeviceAddress)0;
+ vkGetAccelerationStructureDeviceAddressKHR_VkDeviceAddress_return =
+ vkEnc->vkGetAccelerationStructureDeviceAddressKHR(device, pInfo, true /* do lock */);
return vkGetAccelerationStructureDeviceAddressKHR_VkDeviceAddress_return;
}
static VkDeviceAddress dynCheck_entry_vkGetAccelerationStructureDeviceAddressKHR(
- VkDevice device,
- const VkAccelerationStructureDeviceAddressInfoKHR* pInfo)
-{
+ VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetAccelerationStructureDeviceAddressKHR", "VK_KHR_acceleration_structure");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetAccelerationStructureDeviceAddressKHR",
+ "VK_KHR_acceleration_structure");
}
AEMU_SCOPED_TRACE("vkGetAccelerationStructureDeviceAddressKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR_VkDeviceAddress_return = (VkDeviceAddress)0;
- vkGetAccelerationStructureDeviceAddressKHR_VkDeviceAddress_return = vkEnc->vkGetAccelerationStructureDeviceAddressKHR(device, pInfo, true /* do lock */);
+ VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR_VkDeviceAddress_return =
+ (VkDeviceAddress)0;
+ vkGetAccelerationStructureDeviceAddressKHR_VkDeviceAddress_return =
+ vkEnc->vkGetAccelerationStructureDeviceAddressKHR(device, pInfo, true /* do lock */);
return vkGetAccelerationStructureDeviceAddressKHR_VkDeviceAddress_return;
}
static void entry_vkCmdWriteAccelerationStructuresPropertiesKHR(
- VkCommandBuffer commandBuffer,
- uint32_t accelerationStructureCount,
- const VkAccelerationStructureKHR* pAccelerationStructures,
- VkQueryType queryType,
- VkQueryPool queryPool,
- uint32_t firstQuery)
-{
+ VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount,
+ const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType,
+ VkQueryPool queryPool, uint32_t firstQuery) {
AEMU_SCOPED_TRACE("vkCmdWriteAccelerationStructuresPropertiesKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery, true /* do lock */);
+ vkEnc->vkCmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount,
+ pAccelerationStructures, queryType,
+ queryPool, firstQuery, true /* do lock */);
}
static void dynCheck_entry_vkCmdWriteAccelerationStructuresPropertiesKHR(
- VkCommandBuffer commandBuffer,
- uint32_t accelerationStructureCount,
- const VkAccelerationStructureKHR* pAccelerationStructures,
- VkQueryType queryType,
- VkQueryPool queryPool,
- uint32_t firstQuery)
-{
+ VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount,
+ const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType,
+ VkQueryPool queryPool, uint32_t firstQuery) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdWriteAccelerationStructuresPropertiesKHR", "VK_KHR_acceleration_structure");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdWriteAccelerationStructuresPropertiesKHR",
+ "VK_KHR_acceleration_structure");
}
AEMU_SCOPED_TRACE("vkCmdWriteAccelerationStructuresPropertiesKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery, true /* do lock */);
+ vkEnc->vkCmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount,
+ pAccelerationStructures, queryType,
+ queryPool, firstQuery, true /* do lock */);
}
static void entry_vkGetDeviceAccelerationStructureCompatibilityKHR(
- VkDevice device,
- const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
- VkAccelerationStructureCompatibilityKHR* pCompatibility)
-{
+ VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
+ VkAccelerationStructureCompatibilityKHR* pCompatibility) {
AEMU_SCOPED_TRACE("vkGetDeviceAccelerationStructureCompatibilityKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility, true /* do lock */);
+ vkEnc->vkGetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility,
+ true /* do lock */);
}
static void dynCheck_entry_vkGetDeviceAccelerationStructureCompatibilityKHR(
- VkDevice device,
- const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
- VkAccelerationStructureCompatibilityKHR* pCompatibility)
-{
+ VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
+ VkAccelerationStructureCompatibilityKHR* pCompatibility) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetDeviceAccelerationStructureCompatibilityKHR", "VK_KHR_acceleration_structure");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetDeviceAccelerationStructureCompatibilityKHR",
+ "VK_KHR_acceleration_structure");
}
AEMU_SCOPED_TRACE("vkGetDeviceAccelerationStructureCompatibilityKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility, true /* do lock */);
+ vkEnc->vkGetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility,
+ true /* do lock */);
}
static void entry_vkGetAccelerationStructureBuildSizesKHR(
- VkDevice device,
- VkAccelerationStructureBuildTypeKHR buildType,
+ VkDevice device, VkAccelerationStructureBuildTypeKHR buildType,
const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo,
- const uint32_t* pMaxPrimitiveCounts,
- VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo)
-{
+ const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) {
AEMU_SCOPED_TRACE("vkGetAccelerationStructureBuildSizesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetAccelerationStructureBuildSizesKHR(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo, true /* do lock */);
+ vkEnc->vkGetAccelerationStructureBuildSizesKHR(
+ device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo, true /* do lock */);
}
static void dynCheck_entry_vkGetAccelerationStructureBuildSizesKHR(
- VkDevice device,
- VkAccelerationStructureBuildTypeKHR buildType,
+ VkDevice device, VkAccelerationStructureBuildTypeKHR buildType,
const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo,
- const uint32_t* pMaxPrimitiveCounts,
- VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo)
-{
+ const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetAccelerationStructureBuildSizesKHR", "VK_KHR_acceleration_structure");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetAccelerationStructureBuildSizesKHR",
+ "VK_KHR_acceleration_structure");
}
AEMU_SCOPED_TRACE("vkGetAccelerationStructureBuildSizesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
- vkEnc->vkGetAccelerationStructureBuildSizesKHR(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo, true /* do lock */);
+ vkEnc->vkGetAccelerationStructureBuildSizesKHR(
+ device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo, true /* do lock */);
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
static void entry_vkCmdTraceRaysKHR(
- VkCommandBuffer commandBuffer,
- const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
+ VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
- const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
- uint32_t width,
- uint32_t height,
- uint32_t depth)
-{
+ const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width,
+ uint32_t height, uint32_t depth) {
AEMU_SCOPED_TRACE("vkCmdTraceRaysKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdTraceRaysKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth, true /* do lock */);
+ vkEnc->vkCmdTraceRaysKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable,
+ pHitShaderBindingTable, pCallableShaderBindingTable, width, height,
+ depth, true /* do lock */);
}
static void dynCheck_entry_vkCmdTraceRaysKHR(
- VkCommandBuffer commandBuffer,
- const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
+ VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
- const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
- uint32_t width,
- uint32_t height,
- uint32_t depth)
-{
+ const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width,
+ uint32_t height, uint32_t depth) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_ray_tracing_pipeline"))
- {
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_ray_tracing_pipeline")) {
sOnInvalidDynamicallyCheckedCall("vkCmdTraceRaysKHR", "VK_KHR_ray_tracing_pipeline");
}
AEMU_SCOPED_TRACE("vkCmdTraceRaysKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdTraceRaysKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth, true /* do lock */);
+ vkEnc->vkCmdTraceRaysKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable,
+ pHitShaderBindingTable, pCallableShaderBindingTable, width, height,
+ depth, true /* do lock */);
}
static VkResult entry_vkCreateRayTracingPipelinesKHR(
- VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines)
-{
+ VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache,
+ uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
AEMU_SCOPED_TRACE("vkCreateRayTracingPipelinesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateRayTracingPipelinesKHR_VkResult_return = (VkResult)0;
- vkCreateRayTracingPipelinesKHR_VkResult_return = vkEnc->vkCreateRayTracingPipelinesKHR(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, true /* do lock */);
+ vkCreateRayTracingPipelinesKHR_VkResult_return = vkEnc->vkCreateRayTracingPipelinesKHR(
+ device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator,
+ pPipelines, true /* do lock */);
return vkCreateRayTracingPipelinesKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateRayTracingPipelinesKHR(
- VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
- const VkAllocationCallbacks* pAllocator,
- VkPipeline* pPipelines)
-{
+ VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache,
+ uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
+ const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_ray_tracing_pipeline"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCreateRayTracingPipelinesKHR", "VK_KHR_ray_tracing_pipeline");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_ray_tracing_pipeline")) {
+ sOnInvalidDynamicallyCheckedCall("vkCreateRayTracingPipelinesKHR",
+ "VK_KHR_ray_tracing_pipeline");
}
AEMU_SCOPED_TRACE("vkCreateRayTracingPipelinesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkCreateRayTracingPipelinesKHR_VkResult_return = (VkResult)0;
- vkCreateRayTracingPipelinesKHR_VkResult_return = vkEnc->vkCreateRayTracingPipelinesKHR(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, true /* do lock */);
+ vkCreateRayTracingPipelinesKHR_VkResult_return = vkEnc->vkCreateRayTracingPipelinesKHR(
+ device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator,
+ pPipelines, true /* do lock */);
return vkCreateRayTracingPipelinesKHR_VkResult_return;
}
static VkResult entry_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
- VkDevice device,
- VkPipeline pipeline,
- uint32_t firstGroup,
- uint32_t groupCount,
- size_t dataSize,
- void* pData)
-{
+ VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize,
+ void* pData) {
AEMU_SCOPED_TRACE("vkGetRayTracingCaptureReplayShaderGroupHandlesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return = (VkResult)0;
- vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return = vkEnc->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData, true /* do lock */);
+ vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return =
+ vkEnc->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
+ device, pipeline, firstGroup, groupCount, dataSize, pData, true /* do lock */);
return vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
- VkDevice device,
- VkPipeline pipeline,
- uint32_t firstGroup,
- uint32_t groupCount,
- size_t dataSize,
- void* pData)
-{
+ VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize,
+ void* pData) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_ray_tracing_pipeline"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetRayTracingCaptureReplayShaderGroupHandlesKHR", "VK_KHR_ray_tracing_pipeline");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_ray_tracing_pipeline")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetRayTracingCaptureReplayShaderGroupHandlesKHR",
+ "VK_KHR_ray_tracing_pipeline");
}
AEMU_SCOPED_TRACE("vkGetRayTracingCaptureReplayShaderGroupHandlesKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return = (VkResult)0;
- vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return = vkEnc->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData, true /* do lock */);
+ vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return =
+ vkEnc->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
+ device, pipeline, firstGroup, groupCount, dataSize, pData, true /* do lock */);
return vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_VkResult_return;
}
static void entry_vkCmdTraceRaysIndirectKHR(
- VkCommandBuffer commandBuffer,
- const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
+ VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
- VkDeviceAddress indirectDeviceAddress)
-{
+ VkDeviceAddress indirectDeviceAddress) {
AEMU_SCOPED_TRACE("vkCmdTraceRaysIndirectKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdTraceRaysIndirectKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress, true /* do lock */);
+ vkEnc->vkCmdTraceRaysIndirectKHR(
+ commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable,
+ pCallableShaderBindingTable, indirectDeviceAddress, true /* do lock */);
}
static void dynCheck_entry_vkCmdTraceRaysIndirectKHR(
- VkCommandBuffer commandBuffer,
- const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
+ VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
- VkDeviceAddress indirectDeviceAddress)
-{
+ VkDeviceAddress indirectDeviceAddress) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_ray_tracing_pipeline"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdTraceRaysIndirectKHR", "VK_KHR_ray_tracing_pipeline");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_ray_tracing_pipeline")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdTraceRaysIndirectKHR",
+ "VK_KHR_ray_tracing_pipeline");
}
AEMU_SCOPED_TRACE("vkCmdTraceRaysIndirectKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdTraceRaysIndirectKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress, true /* do lock */);
+ vkEnc->vkCmdTraceRaysIndirectKHR(
+ commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable,
+ pCallableShaderBindingTable, indirectDeviceAddress, true /* do lock */);
}
static VkDeviceSize entry_vkGetRayTracingShaderGroupStackSizeKHR(
- VkDevice device,
- VkPipeline pipeline,
- uint32_t group,
- VkShaderGroupShaderKHR groupShader)
-{
+ VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader) {
AEMU_SCOPED_TRACE("vkGetRayTracingShaderGroupStackSizeKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR_VkDeviceSize_return = (VkDeviceSize)0;
- vkGetRayTracingShaderGroupStackSizeKHR_VkDeviceSize_return = vkEnc->vkGetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader, true /* do lock */);
+ vkGetRayTracingShaderGroupStackSizeKHR_VkDeviceSize_return =
+ vkEnc->vkGetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader,
+ true /* do lock */);
return vkGetRayTracingShaderGroupStackSizeKHR_VkDeviceSize_return;
}
static VkDeviceSize dynCheck_entry_vkGetRayTracingShaderGroupStackSizeKHR(
- VkDevice device,
- VkPipeline pipeline,
- uint32_t group,
- VkShaderGroupShaderKHR groupShader)
-{
+ VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader) {
auto resources = ResourceTracker::get();
- if (!resources->hasDeviceExtension(device, "VK_KHR_ray_tracing_pipeline"))
- {
- sOnInvalidDynamicallyCheckedCall("vkGetRayTracingShaderGroupStackSizeKHR", "VK_KHR_ray_tracing_pipeline");
+ if (!resources->hasDeviceExtension(device, "VK_KHR_ray_tracing_pipeline")) {
+ sOnInvalidDynamicallyCheckedCall("vkGetRayTracingShaderGroupStackSizeKHR",
+ "VK_KHR_ray_tracing_pipeline");
}
AEMU_SCOPED_TRACE("vkGetRayTracingShaderGroupStackSizeKHR");
auto vkEnc = ResourceTracker::getThreadLocalEncoder();
VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR_VkDeviceSize_return = (VkDeviceSize)0;
- vkGetRayTracingShaderGroupStackSizeKHR_VkDeviceSize_return = vkEnc->vkGetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader, true /* do lock */);
+ vkGetRayTracingShaderGroupStackSizeKHR_VkDeviceSize_return =
+ vkEnc->vkGetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader,
+ true /* do lock */);
return vkGetRayTracingShaderGroupStackSizeKHR_VkDeviceSize_return;
}
-static void entry_vkCmdSetRayTracingPipelineStackSizeKHR(
- VkCommandBuffer commandBuffer,
- uint32_t pipelineStackSize)
-{
+static void entry_vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer,
+ uint32_t pipelineStackSize) {
AEMU_SCOPED_TRACE("vkCmdSetRayTracingPipelineStackSizeKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize, true /* do lock */);
+ vkEnc->vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize,
+ true /* do lock */);
}
-static void dynCheck_entry_vkCmdSetRayTracingPipelineStackSizeKHR(
- VkCommandBuffer commandBuffer,
- uint32_t pipelineStackSize)
-{
+static void dynCheck_entry_vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer,
+ uint32_t pipelineStackSize) {
auto resources = ResourceTracker::get();
- VkDevice device = resources->getDevice(commandBuffer);;
- if (!resources->hasDeviceExtension(device, "VK_KHR_ray_tracing_pipeline"))
- {
- sOnInvalidDynamicallyCheckedCall("vkCmdSetRayTracingPipelineStackSizeKHR", "VK_KHR_ray_tracing_pipeline");
+ VkDevice device = resources->getDevice(commandBuffer);
+ ;
+ if (!resources->hasDeviceExtension(device, "VK_KHR_ray_tracing_pipeline")) {
+ sOnInvalidDynamicallyCheckedCall("vkCmdSetRayTracingPipelineStackSizeKHR",
+ "VK_KHR_ray_tracing_pipeline");
}
AEMU_SCOPED_TRACE("vkCmdSetRayTracingPipelineStackSizeKHR");
auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
- vkEnc->vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize, true /* do lock */);
+ vkEnc->vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize,
+ true /* do lock */);
}
#endif
#ifdef VK_KHR_ray_query
#endif
-void* goldfish_vulkan_get_proc_address(const char* name){
+void* goldfish_vulkan_get_proc_address(const char* name) {
#ifdef VK_VERSION_1_0
- if (!strcmp(name, "vkCreateInstance"))
- {
+ if (!strcmp(name, "vkCreateInstance")) {
return (void*)entry_vkCreateInstance;
}
- if (!strcmp(name, "vkDestroyInstance"))
- {
+ if (!strcmp(name, "vkDestroyInstance")) {
return (void*)entry_vkDestroyInstance;
}
- if (!strcmp(name, "vkEnumeratePhysicalDevices"))
- {
+ if (!strcmp(name, "vkEnumeratePhysicalDevices")) {
return (void*)entry_vkEnumeratePhysicalDevices;
}
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceFeatures")) {
return (void*)entry_vkGetPhysicalDeviceFeatures;
}
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties")) {
return (void*)entry_vkGetPhysicalDeviceFormatProperties;
}
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties")) {
return (void*)entry_vkGetPhysicalDeviceImageFormatProperties;
}
- if (!strcmp(name, "vkGetPhysicalDeviceProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceProperties")) {
return (void*)entry_vkGetPhysicalDeviceProperties;
}
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties")) {
return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties;
}
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties")) {
return (void*)entry_vkGetPhysicalDeviceMemoryProperties;
}
- if (!strcmp(name, "vkGetInstanceProcAddr"))
- {
+ if (!strcmp(name, "vkGetInstanceProcAddr")) {
return (void*)entry_vkGetInstanceProcAddr;
}
- if (!strcmp(name, "vkGetDeviceProcAddr"))
- {
+ if (!strcmp(name, "vkGetDeviceProcAddr")) {
return (void*)entry_vkGetDeviceProcAddr;
}
- if (!strcmp(name, "vkCreateDevice"))
- {
+ if (!strcmp(name, "vkCreateDevice")) {
return (void*)entry_vkCreateDevice;
}
- if (!strcmp(name, "vkDestroyDevice"))
- {
+ if (!strcmp(name, "vkDestroyDevice")) {
return (void*)entry_vkDestroyDevice;
}
- if (!strcmp(name, "vkEnumerateInstanceExtensionProperties"))
- {
+ if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) {
return (void*)entry_vkEnumerateInstanceExtensionProperties;
}
- if (!strcmp(name, "vkEnumerateDeviceExtensionProperties"))
- {
+ if (!strcmp(name, "vkEnumerateDeviceExtensionProperties")) {
return (void*)entry_vkEnumerateDeviceExtensionProperties;
}
- if (!strcmp(name, "vkEnumerateInstanceLayerProperties"))
- {
+ if (!strcmp(name, "vkEnumerateInstanceLayerProperties")) {
return (void*)entry_vkEnumerateInstanceLayerProperties;
}
- if (!strcmp(name, "vkEnumerateDeviceLayerProperties"))
- {
+ if (!strcmp(name, "vkEnumerateDeviceLayerProperties")) {
return (void*)entry_vkEnumerateDeviceLayerProperties;
}
- if (!strcmp(name, "vkGetDeviceQueue"))
- {
+ if (!strcmp(name, "vkGetDeviceQueue")) {
return (void*)entry_vkGetDeviceQueue;
}
- if (!strcmp(name, "vkQueueSubmit"))
- {
+ if (!strcmp(name, "vkQueueSubmit")) {
return (void*)entry_vkQueueSubmit;
}
- if (!strcmp(name, "vkQueueWaitIdle"))
- {
+ if (!strcmp(name, "vkQueueWaitIdle")) {
return (void*)entry_vkQueueWaitIdle;
}
- if (!strcmp(name, "vkDeviceWaitIdle"))
- {
+ if (!strcmp(name, "vkDeviceWaitIdle")) {
return (void*)entry_vkDeviceWaitIdle;
}
- if (!strcmp(name, "vkAllocateMemory"))
- {
+ if (!strcmp(name, "vkAllocateMemory")) {
return (void*)entry_vkAllocateMemory;
}
- if (!strcmp(name, "vkFreeMemory"))
- {
+ if (!strcmp(name, "vkFreeMemory")) {
return (void*)entry_vkFreeMemory;
}
- if (!strcmp(name, "vkMapMemory"))
- {
+ if (!strcmp(name, "vkMapMemory")) {
return (void*)entry_vkMapMemory;
}
- if (!strcmp(name, "vkUnmapMemory"))
- {
+ if (!strcmp(name, "vkUnmapMemory")) {
return (void*)entry_vkUnmapMemory;
}
- if (!strcmp(name, "vkFlushMappedMemoryRanges"))
- {
+ if (!strcmp(name, "vkFlushMappedMemoryRanges")) {
return (void*)entry_vkFlushMappedMemoryRanges;
}
- if (!strcmp(name, "vkInvalidateMappedMemoryRanges"))
- {
+ if (!strcmp(name, "vkInvalidateMappedMemoryRanges")) {
return (void*)entry_vkInvalidateMappedMemoryRanges;
}
- if (!strcmp(name, "vkGetDeviceMemoryCommitment"))
- {
+ if (!strcmp(name, "vkGetDeviceMemoryCommitment")) {
return (void*)entry_vkGetDeviceMemoryCommitment;
}
- if (!strcmp(name, "vkBindBufferMemory"))
- {
+ if (!strcmp(name, "vkBindBufferMemory")) {
return (void*)entry_vkBindBufferMemory;
}
- if (!strcmp(name, "vkBindImageMemory"))
- {
+ if (!strcmp(name, "vkBindImageMemory")) {
return (void*)entry_vkBindImageMemory;
}
- if (!strcmp(name, "vkGetBufferMemoryRequirements"))
- {
+ if (!strcmp(name, "vkGetBufferMemoryRequirements")) {
return (void*)entry_vkGetBufferMemoryRequirements;
}
- if (!strcmp(name, "vkGetImageMemoryRequirements"))
- {
+ if (!strcmp(name, "vkGetImageMemoryRequirements")) {
return (void*)entry_vkGetImageMemoryRequirements;
}
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements"))
- {
+ if (!strcmp(name, "vkGetImageSparseMemoryRequirements")) {
return (void*)entry_vkGetImageSparseMemoryRequirements;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties")) {
return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties;
}
- if (!strcmp(name, "vkQueueBindSparse"))
- {
+ if (!strcmp(name, "vkQueueBindSparse")) {
return (void*)entry_vkQueueBindSparse;
}
- if (!strcmp(name, "vkCreateFence"))
- {
+ if (!strcmp(name, "vkCreateFence")) {
return (void*)entry_vkCreateFence;
}
- if (!strcmp(name, "vkDestroyFence"))
- {
+ if (!strcmp(name, "vkDestroyFence")) {
return (void*)entry_vkDestroyFence;
}
- if (!strcmp(name, "vkResetFences"))
- {
+ if (!strcmp(name, "vkResetFences")) {
return (void*)entry_vkResetFences;
}
- if (!strcmp(name, "vkGetFenceStatus"))
- {
+ if (!strcmp(name, "vkGetFenceStatus")) {
return (void*)entry_vkGetFenceStatus;
}
- if (!strcmp(name, "vkWaitForFences"))
- {
+ if (!strcmp(name, "vkWaitForFences")) {
return (void*)entry_vkWaitForFences;
}
- if (!strcmp(name, "vkCreateSemaphore"))
- {
+ if (!strcmp(name, "vkCreateSemaphore")) {
return (void*)entry_vkCreateSemaphore;
}
- if (!strcmp(name, "vkDestroySemaphore"))
- {
+ if (!strcmp(name, "vkDestroySemaphore")) {
return (void*)entry_vkDestroySemaphore;
}
- if (!strcmp(name, "vkCreateEvent"))
- {
+ if (!strcmp(name, "vkCreateEvent")) {
return (void*)entry_vkCreateEvent;
}
- if (!strcmp(name, "vkDestroyEvent"))
- {
+ if (!strcmp(name, "vkDestroyEvent")) {
return (void*)entry_vkDestroyEvent;
}
- if (!strcmp(name, "vkGetEventStatus"))
- {
+ if (!strcmp(name, "vkGetEventStatus")) {
return (void*)entry_vkGetEventStatus;
}
- if (!strcmp(name, "vkSetEvent"))
- {
+ if (!strcmp(name, "vkSetEvent")) {
return (void*)entry_vkSetEvent;
}
- if (!strcmp(name, "vkResetEvent"))
- {
+ if (!strcmp(name, "vkResetEvent")) {
return (void*)entry_vkResetEvent;
}
- if (!strcmp(name, "vkCreateQueryPool"))
- {
+ if (!strcmp(name, "vkCreateQueryPool")) {
return (void*)entry_vkCreateQueryPool;
}
- if (!strcmp(name, "vkDestroyQueryPool"))
- {
+ if (!strcmp(name, "vkDestroyQueryPool")) {
return (void*)entry_vkDestroyQueryPool;
}
- if (!strcmp(name, "vkGetQueryPoolResults"))
- {
+ if (!strcmp(name, "vkGetQueryPoolResults")) {
return (void*)entry_vkGetQueryPoolResults;
}
- if (!strcmp(name, "vkCreateBuffer"))
- {
+ if (!strcmp(name, "vkCreateBuffer")) {
return (void*)entry_vkCreateBuffer;
}
- if (!strcmp(name, "vkDestroyBuffer"))
- {
+ if (!strcmp(name, "vkDestroyBuffer")) {
return (void*)entry_vkDestroyBuffer;
}
- if (!strcmp(name, "vkCreateBufferView"))
- {
+ if (!strcmp(name, "vkCreateBufferView")) {
return (void*)entry_vkCreateBufferView;
}
- if (!strcmp(name, "vkDestroyBufferView"))
- {
+ if (!strcmp(name, "vkDestroyBufferView")) {
return (void*)entry_vkDestroyBufferView;
}
- if (!strcmp(name, "vkCreateImage"))
- {
+ if (!strcmp(name, "vkCreateImage")) {
return (void*)entry_vkCreateImage;
}
- if (!strcmp(name, "vkDestroyImage"))
- {
+ if (!strcmp(name, "vkDestroyImage")) {
return (void*)entry_vkDestroyImage;
}
- if (!strcmp(name, "vkGetImageSubresourceLayout"))
- {
+ if (!strcmp(name, "vkGetImageSubresourceLayout")) {
return (void*)entry_vkGetImageSubresourceLayout;
}
- if (!strcmp(name, "vkCreateImageView"))
- {
+ if (!strcmp(name, "vkCreateImageView")) {
return (void*)entry_vkCreateImageView;
}
- if (!strcmp(name, "vkDestroyImageView"))
- {
+ if (!strcmp(name, "vkDestroyImageView")) {
return (void*)entry_vkDestroyImageView;
}
- if (!strcmp(name, "vkCreateShaderModule"))
- {
+ if (!strcmp(name, "vkCreateShaderModule")) {
return (void*)entry_vkCreateShaderModule;
}
- if (!strcmp(name, "vkDestroyShaderModule"))
- {
+ if (!strcmp(name, "vkDestroyShaderModule")) {
return (void*)entry_vkDestroyShaderModule;
}
- if (!strcmp(name, "vkCreatePipelineCache"))
- {
+ if (!strcmp(name, "vkCreatePipelineCache")) {
return (void*)entry_vkCreatePipelineCache;
}
- if (!strcmp(name, "vkDestroyPipelineCache"))
- {
+ if (!strcmp(name, "vkDestroyPipelineCache")) {
return (void*)entry_vkDestroyPipelineCache;
}
- if (!strcmp(name, "vkGetPipelineCacheData"))
- {
+ if (!strcmp(name, "vkGetPipelineCacheData")) {
return (void*)entry_vkGetPipelineCacheData;
}
- if (!strcmp(name, "vkMergePipelineCaches"))
- {
+ if (!strcmp(name, "vkMergePipelineCaches")) {
return (void*)entry_vkMergePipelineCaches;
}
- if (!strcmp(name, "vkCreateGraphicsPipelines"))
- {
+ if (!strcmp(name, "vkCreateGraphicsPipelines")) {
return (void*)entry_vkCreateGraphicsPipelines;
}
- if (!strcmp(name, "vkCreateComputePipelines"))
- {
+ if (!strcmp(name, "vkCreateComputePipelines")) {
return (void*)entry_vkCreateComputePipelines;
}
- if (!strcmp(name, "vkDestroyPipeline"))
- {
+ if (!strcmp(name, "vkDestroyPipeline")) {
return (void*)entry_vkDestroyPipeline;
}
- if (!strcmp(name, "vkCreatePipelineLayout"))
- {
+ if (!strcmp(name, "vkCreatePipelineLayout")) {
return (void*)entry_vkCreatePipelineLayout;
}
- if (!strcmp(name, "vkDestroyPipelineLayout"))
- {
+ if (!strcmp(name, "vkDestroyPipelineLayout")) {
return (void*)entry_vkDestroyPipelineLayout;
}
- if (!strcmp(name, "vkCreateSampler"))
- {
+ if (!strcmp(name, "vkCreateSampler")) {
return (void*)entry_vkCreateSampler;
}
- if (!strcmp(name, "vkDestroySampler"))
- {
+ if (!strcmp(name, "vkDestroySampler")) {
return (void*)entry_vkDestroySampler;
}
- if (!strcmp(name, "vkCreateDescriptorSetLayout"))
- {
+ if (!strcmp(name, "vkCreateDescriptorSetLayout")) {
return (void*)entry_vkCreateDescriptorSetLayout;
}
- if (!strcmp(name, "vkDestroyDescriptorSetLayout"))
- {
+ if (!strcmp(name, "vkDestroyDescriptorSetLayout")) {
return (void*)entry_vkDestroyDescriptorSetLayout;
}
- if (!strcmp(name, "vkCreateDescriptorPool"))
- {
+ if (!strcmp(name, "vkCreateDescriptorPool")) {
return (void*)entry_vkCreateDescriptorPool;
}
- if (!strcmp(name, "vkDestroyDescriptorPool"))
- {
+ if (!strcmp(name, "vkDestroyDescriptorPool")) {
return (void*)entry_vkDestroyDescriptorPool;
}
- if (!strcmp(name, "vkResetDescriptorPool"))
- {
+ if (!strcmp(name, "vkResetDescriptorPool")) {
return (void*)entry_vkResetDescriptorPool;
}
- if (!strcmp(name, "vkAllocateDescriptorSets"))
- {
+ if (!strcmp(name, "vkAllocateDescriptorSets")) {
return (void*)entry_vkAllocateDescriptorSets;
}
- if (!strcmp(name, "vkFreeDescriptorSets"))
- {
+ if (!strcmp(name, "vkFreeDescriptorSets")) {
return (void*)entry_vkFreeDescriptorSets;
}
- if (!strcmp(name, "vkUpdateDescriptorSets"))
- {
+ if (!strcmp(name, "vkUpdateDescriptorSets")) {
return (void*)entry_vkUpdateDescriptorSets;
}
- if (!strcmp(name, "vkCreateFramebuffer"))
- {
+ if (!strcmp(name, "vkCreateFramebuffer")) {
return (void*)entry_vkCreateFramebuffer;
}
- if (!strcmp(name, "vkDestroyFramebuffer"))
- {
+ if (!strcmp(name, "vkDestroyFramebuffer")) {
return (void*)entry_vkDestroyFramebuffer;
}
- if (!strcmp(name, "vkCreateRenderPass"))
- {
+ if (!strcmp(name, "vkCreateRenderPass")) {
return (void*)entry_vkCreateRenderPass;
}
- if (!strcmp(name, "vkDestroyRenderPass"))
- {
+ if (!strcmp(name, "vkDestroyRenderPass")) {
return (void*)entry_vkDestroyRenderPass;
}
- if (!strcmp(name, "vkGetRenderAreaGranularity"))
- {
+ if (!strcmp(name, "vkGetRenderAreaGranularity")) {
return (void*)entry_vkGetRenderAreaGranularity;
}
- if (!strcmp(name, "vkCreateCommandPool"))
- {
+ if (!strcmp(name, "vkCreateCommandPool")) {
return (void*)entry_vkCreateCommandPool;
}
- if (!strcmp(name, "vkDestroyCommandPool"))
- {
+ if (!strcmp(name, "vkDestroyCommandPool")) {
return (void*)entry_vkDestroyCommandPool;
}
- if (!strcmp(name, "vkResetCommandPool"))
- {
+ if (!strcmp(name, "vkResetCommandPool")) {
return (void*)entry_vkResetCommandPool;
}
- if (!strcmp(name, "vkAllocateCommandBuffers"))
- {
+ if (!strcmp(name, "vkAllocateCommandBuffers")) {
return (void*)entry_vkAllocateCommandBuffers;
}
- if (!strcmp(name, "vkFreeCommandBuffers"))
- {
+ if (!strcmp(name, "vkFreeCommandBuffers")) {
return (void*)entry_vkFreeCommandBuffers;
}
- if (!strcmp(name, "vkBeginCommandBuffer"))
- {
+ if (!strcmp(name, "vkBeginCommandBuffer")) {
return (void*)entry_vkBeginCommandBuffer;
}
- if (!strcmp(name, "vkEndCommandBuffer"))
- {
+ if (!strcmp(name, "vkEndCommandBuffer")) {
return (void*)entry_vkEndCommandBuffer;
}
- if (!strcmp(name, "vkResetCommandBuffer"))
- {
+ if (!strcmp(name, "vkResetCommandBuffer")) {
return (void*)entry_vkResetCommandBuffer;
}
- if (!strcmp(name, "vkCmdBindPipeline"))
- {
+ if (!strcmp(name, "vkCmdBindPipeline")) {
return (void*)entry_vkCmdBindPipeline;
}
- if (!strcmp(name, "vkCmdSetViewport"))
- {
+ if (!strcmp(name, "vkCmdSetViewport")) {
return (void*)entry_vkCmdSetViewport;
}
- if (!strcmp(name, "vkCmdSetScissor"))
- {
+ if (!strcmp(name, "vkCmdSetScissor")) {
return (void*)entry_vkCmdSetScissor;
}
- if (!strcmp(name, "vkCmdSetLineWidth"))
- {
+ if (!strcmp(name, "vkCmdSetLineWidth")) {
return (void*)entry_vkCmdSetLineWidth;
}
- if (!strcmp(name, "vkCmdSetDepthBias"))
- {
+ if (!strcmp(name, "vkCmdSetDepthBias")) {
return (void*)entry_vkCmdSetDepthBias;
}
- if (!strcmp(name, "vkCmdSetBlendConstants"))
- {
+ if (!strcmp(name, "vkCmdSetBlendConstants")) {
return (void*)entry_vkCmdSetBlendConstants;
}
- if (!strcmp(name, "vkCmdSetDepthBounds"))
- {
+ if (!strcmp(name, "vkCmdSetDepthBounds")) {
return (void*)entry_vkCmdSetDepthBounds;
}
- if (!strcmp(name, "vkCmdSetStencilCompareMask"))
- {
+ if (!strcmp(name, "vkCmdSetStencilCompareMask")) {
return (void*)entry_vkCmdSetStencilCompareMask;
}
- if (!strcmp(name, "vkCmdSetStencilWriteMask"))
- {
+ if (!strcmp(name, "vkCmdSetStencilWriteMask")) {
return (void*)entry_vkCmdSetStencilWriteMask;
}
- if (!strcmp(name, "vkCmdSetStencilReference"))
- {
+ if (!strcmp(name, "vkCmdSetStencilReference")) {
return (void*)entry_vkCmdSetStencilReference;
}
- if (!strcmp(name, "vkCmdBindDescriptorSets"))
- {
+ if (!strcmp(name, "vkCmdBindDescriptorSets")) {
return (void*)entry_vkCmdBindDescriptorSets;
}
- if (!strcmp(name, "vkCmdBindIndexBuffer"))
- {
+ if (!strcmp(name, "vkCmdBindIndexBuffer")) {
return (void*)entry_vkCmdBindIndexBuffer;
}
- if (!strcmp(name, "vkCmdBindVertexBuffers"))
- {
+ if (!strcmp(name, "vkCmdBindVertexBuffers")) {
return (void*)entry_vkCmdBindVertexBuffers;
}
- if (!strcmp(name, "vkCmdDraw"))
- {
+ if (!strcmp(name, "vkCmdDraw")) {
return (void*)entry_vkCmdDraw;
}
- if (!strcmp(name, "vkCmdDrawIndexed"))
- {
+ if (!strcmp(name, "vkCmdDrawIndexed")) {
return (void*)entry_vkCmdDrawIndexed;
}
- if (!strcmp(name, "vkCmdDrawIndirect"))
- {
+ if (!strcmp(name, "vkCmdDrawIndirect")) {
return (void*)entry_vkCmdDrawIndirect;
}
- if (!strcmp(name, "vkCmdDrawIndexedIndirect"))
- {
+ if (!strcmp(name, "vkCmdDrawIndexedIndirect")) {
return (void*)entry_vkCmdDrawIndexedIndirect;
}
- if (!strcmp(name, "vkCmdDispatch"))
- {
+ if (!strcmp(name, "vkCmdDispatch")) {
return (void*)entry_vkCmdDispatch;
}
- if (!strcmp(name, "vkCmdDispatchIndirect"))
- {
+ if (!strcmp(name, "vkCmdDispatchIndirect")) {
return (void*)entry_vkCmdDispatchIndirect;
}
- if (!strcmp(name, "vkCmdCopyBuffer"))
- {
+ if (!strcmp(name, "vkCmdCopyBuffer")) {
return (void*)entry_vkCmdCopyBuffer;
}
- if (!strcmp(name, "vkCmdCopyImage"))
- {
+ if (!strcmp(name, "vkCmdCopyImage")) {
return (void*)entry_vkCmdCopyImage;
}
- if (!strcmp(name, "vkCmdBlitImage"))
- {
+ if (!strcmp(name, "vkCmdBlitImage")) {
return (void*)entry_vkCmdBlitImage;
}
- if (!strcmp(name, "vkCmdCopyBufferToImage"))
- {
+ if (!strcmp(name, "vkCmdCopyBufferToImage")) {
return (void*)entry_vkCmdCopyBufferToImage;
}
- if (!strcmp(name, "vkCmdCopyImageToBuffer"))
- {
+ if (!strcmp(name, "vkCmdCopyImageToBuffer")) {
return (void*)entry_vkCmdCopyImageToBuffer;
}
- if (!strcmp(name, "vkCmdUpdateBuffer"))
- {
+ if (!strcmp(name, "vkCmdUpdateBuffer")) {
return (void*)entry_vkCmdUpdateBuffer;
}
- if (!strcmp(name, "vkCmdFillBuffer"))
- {
+ if (!strcmp(name, "vkCmdFillBuffer")) {
return (void*)entry_vkCmdFillBuffer;
}
- if (!strcmp(name, "vkCmdClearColorImage"))
- {
+ if (!strcmp(name, "vkCmdClearColorImage")) {
return (void*)entry_vkCmdClearColorImage;
}
- if (!strcmp(name, "vkCmdClearDepthStencilImage"))
- {
+ if (!strcmp(name, "vkCmdClearDepthStencilImage")) {
return (void*)entry_vkCmdClearDepthStencilImage;
}
- if (!strcmp(name, "vkCmdClearAttachments"))
- {
+ if (!strcmp(name, "vkCmdClearAttachments")) {
return (void*)entry_vkCmdClearAttachments;
}
- if (!strcmp(name, "vkCmdResolveImage"))
- {
+ if (!strcmp(name, "vkCmdResolveImage")) {
return (void*)entry_vkCmdResolveImage;
}
- if (!strcmp(name, "vkCmdSetEvent"))
- {
+ if (!strcmp(name, "vkCmdSetEvent")) {
return (void*)entry_vkCmdSetEvent;
}
- if (!strcmp(name, "vkCmdResetEvent"))
- {
+ if (!strcmp(name, "vkCmdResetEvent")) {
return (void*)entry_vkCmdResetEvent;
}
- if (!strcmp(name, "vkCmdWaitEvents"))
- {
+ if (!strcmp(name, "vkCmdWaitEvents")) {
return (void*)entry_vkCmdWaitEvents;
}
- if (!strcmp(name, "vkCmdPipelineBarrier"))
- {
+ if (!strcmp(name, "vkCmdPipelineBarrier")) {
return (void*)entry_vkCmdPipelineBarrier;
}
- if (!strcmp(name, "vkCmdBeginQuery"))
- {
+ if (!strcmp(name, "vkCmdBeginQuery")) {
return (void*)entry_vkCmdBeginQuery;
}
- if (!strcmp(name, "vkCmdEndQuery"))
- {
+ if (!strcmp(name, "vkCmdEndQuery")) {
return (void*)entry_vkCmdEndQuery;
}
- if (!strcmp(name, "vkCmdResetQueryPool"))
- {
+ if (!strcmp(name, "vkCmdResetQueryPool")) {
return (void*)entry_vkCmdResetQueryPool;
}
- if (!strcmp(name, "vkCmdWriteTimestamp"))
- {
+ if (!strcmp(name, "vkCmdWriteTimestamp")) {
return (void*)entry_vkCmdWriteTimestamp;
}
- if (!strcmp(name, "vkCmdCopyQueryPoolResults"))
- {
+ if (!strcmp(name, "vkCmdCopyQueryPoolResults")) {
return (void*)entry_vkCmdCopyQueryPoolResults;
}
- if (!strcmp(name, "vkCmdPushConstants"))
- {
+ if (!strcmp(name, "vkCmdPushConstants")) {
return (void*)entry_vkCmdPushConstants;
}
- if (!strcmp(name, "vkCmdBeginRenderPass"))
- {
+ if (!strcmp(name, "vkCmdBeginRenderPass")) {
return (void*)entry_vkCmdBeginRenderPass;
}
- if (!strcmp(name, "vkCmdNextSubpass"))
- {
+ if (!strcmp(name, "vkCmdNextSubpass")) {
return (void*)entry_vkCmdNextSubpass;
}
- if (!strcmp(name, "vkCmdEndRenderPass"))
- {
+ if (!strcmp(name, "vkCmdEndRenderPass")) {
return (void*)entry_vkCmdEndRenderPass;
}
- if (!strcmp(name, "vkCmdExecuteCommands"))
- {
+ if (!strcmp(name, "vkCmdExecuteCommands")) {
return (void*)entry_vkCmdExecuteCommands;
}
#endif
#ifdef VK_VERSION_1_1
- if (!strcmp(name, "vkEnumerateInstanceVersion"))
- {
+ if (!strcmp(name, "vkEnumerateInstanceVersion")) {
return nullptr;
}
- if (!strcmp(name, "vkBindBufferMemory2"))
- {
+ if (!strcmp(name, "vkBindBufferMemory2")) {
return nullptr;
}
- if (!strcmp(name, "vkBindImageMemory2"))
- {
+ if (!strcmp(name, "vkBindImageMemory2")) {
return nullptr;
}
- if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures"))
- {
+ if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetDeviceMask"))
- {
+ if (!strcmp(name, "vkCmdSetDeviceMask")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdDispatchBase"))
- {
+ if (!strcmp(name, "vkCmdDispatchBase")) {
return nullptr;
}
- if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups"))
- {
+ if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups")) {
return nullptr;
}
- if (!strcmp(name, "vkGetImageMemoryRequirements2"))
- {
+ if (!strcmp(name, "vkGetImageMemoryRequirements2")) {
return nullptr;
}
- if (!strcmp(name, "vkGetBufferMemoryRequirements2"))
- {
+ if (!strcmp(name, "vkGetBufferMemoryRequirements2")) {
return nullptr;
}
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements2"))
- {
+ if (!strcmp(name, "vkGetImageSparseMemoryRequirements2")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures2"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceFeatures2")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceProperties2"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceProperties2")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2")) {
return nullptr;
}
- if (!strcmp(name, "vkTrimCommandPool"))
- {
+ if (!strcmp(name, "vkTrimCommandPool")) {
return nullptr;
}
- if (!strcmp(name, "vkGetDeviceQueue2"))
- {
+ if (!strcmp(name, "vkGetDeviceQueue2")) {
return nullptr;
}
- if (!strcmp(name, "vkCreateSamplerYcbcrConversion"))
- {
+ if (!strcmp(name, "vkCreateSamplerYcbcrConversion")) {
return nullptr;
}
- if (!strcmp(name, "vkDestroySamplerYcbcrConversion"))
- {
+ if (!strcmp(name, "vkDestroySamplerYcbcrConversion")) {
return nullptr;
}
- if (!strcmp(name, "vkCreateDescriptorUpdateTemplate"))
- {
+ if (!strcmp(name, "vkCreateDescriptorUpdateTemplate")) {
return nullptr;
}
- if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate"))
- {
+ if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate")) {
return nullptr;
}
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate"))
- {
+ if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties")) {
return nullptr;
}
- if (!strcmp(name, "vkGetDescriptorSetLayoutSupport"))
- {
+ if (!strcmp(name, "vkGetDescriptorSetLayoutSupport")) {
return nullptr;
}
#endif
#ifdef VK_VERSION_1_2
- if (!strcmp(name, "vkCmdDrawIndirectCount"))
- {
+ if (!strcmp(name, "vkCmdDrawIndirectCount")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdDrawIndexedIndirectCount"))
- {
+ if (!strcmp(name, "vkCmdDrawIndexedIndirectCount")) {
return nullptr;
}
- if (!strcmp(name, "vkCreateRenderPass2"))
- {
+ if (!strcmp(name, "vkCreateRenderPass2")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdBeginRenderPass2"))
- {
+ if (!strcmp(name, "vkCmdBeginRenderPass2")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdNextSubpass2"))
- {
+ if (!strcmp(name, "vkCmdNextSubpass2")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdEndRenderPass2"))
- {
+ if (!strcmp(name, "vkCmdEndRenderPass2")) {
return nullptr;
}
- if (!strcmp(name, "vkResetQueryPool"))
- {
+ if (!strcmp(name, "vkResetQueryPool")) {
return nullptr;
}
- if (!strcmp(name, "vkGetSemaphoreCounterValue"))
- {
+ if (!strcmp(name, "vkGetSemaphoreCounterValue")) {
return nullptr;
}
- if (!strcmp(name, "vkWaitSemaphores"))
- {
+ if (!strcmp(name, "vkWaitSemaphores")) {
return nullptr;
}
- if (!strcmp(name, "vkSignalSemaphore"))
- {
+ if (!strcmp(name, "vkSignalSemaphore")) {
return nullptr;
}
- if (!strcmp(name, "vkGetBufferDeviceAddress"))
- {
+ if (!strcmp(name, "vkGetBufferDeviceAddress")) {
return nullptr;
}
- if (!strcmp(name, "vkGetBufferOpaqueCaptureAddress"))
- {
+ if (!strcmp(name, "vkGetBufferOpaqueCaptureAddress")) {
return nullptr;
}
- if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddress"))
- {
+ if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddress")) {
return nullptr;
}
#endif
#ifdef VK_KHR_surface
- if (!strcmp(name, "vkDestroySurfaceKHR"))
- {
+ if (!strcmp(name, "vkDestroySurfaceKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSurfaceSupportKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceSupportKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormatsKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormatsKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSurfacePresentModesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfacePresentModesKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_swapchain
- if (!strcmp(name, "vkCreateSwapchainKHR"))
- {
+ if (!strcmp(name, "vkCreateSwapchainKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkDestroySwapchainKHR"))
- {
+ if (!strcmp(name, "vkDestroySwapchainKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetSwapchainImagesKHR"))
- {
+ if (!strcmp(name, "vkGetSwapchainImagesKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkAcquireNextImageKHR"))
- {
+ if (!strcmp(name, "vkAcquireNextImageKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkQueuePresentKHR"))
- {
+ if (!strcmp(name, "vkQueuePresentKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetDeviceGroupPresentCapabilitiesKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceGroupPresentCapabilitiesKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModesKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModesKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDevicePresentRectanglesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDevicePresentRectanglesKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkAcquireNextImage2KHR"))
- {
+ if (!strcmp(name, "vkAcquireNextImage2KHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_display
- if (!strcmp(name, "vkGetPhysicalDeviceDisplayPropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayPropertiesKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetDisplayPlaneSupportedDisplaysKHR"))
- {
+ if (!strcmp(name, "vkGetDisplayPlaneSupportedDisplaysKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetDisplayModePropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetDisplayModePropertiesKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCreateDisplayModeKHR"))
- {
+ if (!strcmp(name, "vkCreateDisplayModeKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetDisplayPlaneCapabilitiesKHR"))
- {
+ if (!strcmp(name, "vkGetDisplayPlaneCapabilitiesKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCreateDisplayPlaneSurfaceKHR"))
- {
+ if (!strcmp(name, "vkCreateDisplayPlaneSurfaceKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_display_swapchain
- if (!strcmp(name, "vkCreateSharedSwapchainsKHR"))
- {
+ if (!strcmp(name, "vkCreateSharedSwapchainsKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_xlib_surface
- if (!strcmp(name, "vkCreateXlibSurfaceKHR"))
- {
+ if (!strcmp(name, "vkCreateXlibSurfaceKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceXlibPresentationSupportKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceXlibPresentationSupportKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_xcb_surface
- if (!strcmp(name, "vkCreateXcbSurfaceKHR"))
- {
+ if (!strcmp(name, "vkCreateXcbSurfaceKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceXcbPresentationSupportKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceXcbPresentationSupportKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_wayland_surface
- if (!strcmp(name, "vkCreateWaylandSurfaceKHR"))
- {
+ if (!strcmp(name, "vkCreateWaylandSurfaceKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceWaylandPresentationSupportKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceWaylandPresentationSupportKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_android_surface
- if (!strcmp(name, "vkCreateAndroidSurfaceKHR"))
- {
+ if (!strcmp(name, "vkCreateAndroidSurfaceKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_win32_surface
- if (!strcmp(name, "vkCreateWin32SurfaceKHR"))
- {
+ if (!strcmp(name, "vkCreateWin32SurfaceKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceWin32PresentationSupportKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceWin32PresentationSupportKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_video_queue
- if (!strcmp(name, "vkGetPhysicalDeviceVideoCapabilitiesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceVideoCapabilitiesKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceVideoFormatPropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceVideoFormatPropertiesKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCreateVideoSessionKHR"))
- {
+ if (!strcmp(name, "vkCreateVideoSessionKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkDestroyVideoSessionKHR"))
- {
+ if (!strcmp(name, "vkDestroyVideoSessionKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetVideoSessionMemoryRequirementsKHR"))
- {
+ if (!strcmp(name, "vkGetVideoSessionMemoryRequirementsKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkBindVideoSessionMemoryKHR"))
- {
+ if (!strcmp(name, "vkBindVideoSessionMemoryKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCreateVideoSessionParametersKHR"))
- {
+ if (!strcmp(name, "vkCreateVideoSessionParametersKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkUpdateVideoSessionParametersKHR"))
- {
+ if (!strcmp(name, "vkUpdateVideoSessionParametersKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkDestroyVideoSessionParametersKHR"))
- {
+ if (!strcmp(name, "vkDestroyVideoSessionParametersKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdBeginVideoCodingKHR"))
- {
+ if (!strcmp(name, "vkCmdBeginVideoCodingKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdEndVideoCodingKHR"))
- {
+ if (!strcmp(name, "vkCmdEndVideoCodingKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdControlVideoCodingKHR"))
- {
+ if (!strcmp(name, "vkCmdControlVideoCodingKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_video_decode_queue
- if (!strcmp(name, "vkCmdDecodeVideoKHR"))
- {
+ if (!strcmp(name, "vkCmdDecodeVideoKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_dynamic_rendering
- if (!strcmp(name, "vkCmdBeginRenderingKHR"))
- {
+ if (!strcmp(name, "vkCmdBeginRenderingKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdEndRenderingKHR"))
- {
+ if (!strcmp(name, "vkCmdEndRenderingKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_get_physical_device_properties2
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_device_group
- if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeaturesKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeaturesKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetDeviceMaskKHR"))
- {
+ if (!strcmp(name, "vkCmdSetDeviceMaskKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdDispatchBaseKHR"))
- {
+ if (!strcmp(name, "vkCmdDispatchBaseKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_maintenance1
- if (!strcmp(name, "vkTrimCommandPoolKHR"))
- {
+ if (!strcmp(name, "vkTrimCommandPoolKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_device_group_creation
- if (!strcmp(name, "vkEnumeratePhysicalDeviceGroupsKHR"))
- {
+ if (!strcmp(name, "vkEnumeratePhysicalDeviceGroupsKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_external_memory_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_external_memory_win32
- if (!strcmp(name, "vkGetMemoryWin32HandleKHR"))
- {
+ if (!strcmp(name, "vkGetMemoryWin32HandleKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetMemoryWin32HandlePropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetMemoryWin32HandlePropertiesKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_external_memory_fd
- if (!strcmp(name, "vkGetMemoryFdKHR"))
- {
+ if (!strcmp(name, "vkGetMemoryFdKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetMemoryFdPropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetMemoryFdPropertiesKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_external_semaphore_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_external_semaphore_win32
- if (!strcmp(name, "vkImportSemaphoreWin32HandleKHR"))
- {
+ if (!strcmp(name, "vkImportSemaphoreWin32HandleKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetSemaphoreWin32HandleKHR"))
- {
+ if (!strcmp(name, "vkGetSemaphoreWin32HandleKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_external_semaphore_fd
- if (!strcmp(name, "vkImportSemaphoreFdKHR"))
- {
+ if (!strcmp(name, "vkImportSemaphoreFdKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetSemaphoreFdKHR"))
- {
+ if (!strcmp(name, "vkGetSemaphoreFdKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_push_descriptor
- if (!strcmp(name, "vkCmdPushDescriptorSetKHR"))
- {
+ if (!strcmp(name, "vkCmdPushDescriptorSetKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdPushDescriptorSetWithTemplateKHR"))
- {
+ if (!strcmp(name, "vkCmdPushDescriptorSetWithTemplateKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_descriptor_update_template
- if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR"))
- {
+ if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR"))
- {
+ if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR"))
- {
+ if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_create_renderpass2
- if (!strcmp(name, "vkCreateRenderPass2KHR"))
- {
+ if (!strcmp(name, "vkCreateRenderPass2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdBeginRenderPass2KHR"))
- {
+ if (!strcmp(name, "vkCmdBeginRenderPass2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdNextSubpass2KHR"))
- {
+ if (!strcmp(name, "vkCmdNextSubpass2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdEndRenderPass2KHR"))
- {
+ if (!strcmp(name, "vkCmdEndRenderPass2KHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_shared_presentable_image
- if (!strcmp(name, "vkGetSwapchainStatusKHR"))
- {
+ if (!strcmp(name, "vkGetSwapchainStatusKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_external_fence_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_external_fence_win32
- if (!strcmp(name, "vkImportFenceWin32HandleKHR"))
- {
+ if (!strcmp(name, "vkImportFenceWin32HandleKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetFenceWin32HandleKHR"))
- {
+ if (!strcmp(name, "vkGetFenceWin32HandleKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_external_fence_fd
- if (!strcmp(name, "vkImportFenceFdKHR"))
- {
+ if (!strcmp(name, "vkImportFenceFdKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetFenceFdKHR"))
- {
+ if (!strcmp(name, "vkGetFenceFdKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_performance_query
- if (!strcmp(name, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"))
- {
+ if (!strcmp(name, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkAcquireProfilingLockKHR"))
- {
+ if (!strcmp(name, "vkAcquireProfilingLockKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkReleaseProfilingLockKHR"))
- {
+ if (!strcmp(name, "vkReleaseProfilingLockKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_get_surface_capabilities2
- if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2KHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormats2KHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormats2KHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_get_display_properties2
- if (!strcmp(name, "vkGetPhysicalDeviceDisplayProperties2KHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayProperties2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetDisplayModeProperties2KHR"))
- {
+ if (!strcmp(name, "vkGetDisplayModeProperties2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetDisplayPlaneCapabilities2KHR"))
- {
+ if (!strcmp(name, "vkGetDisplayPlaneCapabilities2KHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_get_memory_requirements2
- if (!strcmp(name, "vkGetImageMemoryRequirements2KHR"))
- {
+ if (!strcmp(name, "vkGetImageMemoryRequirements2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR"))
- {
+ if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR"))
- {
+ if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
- if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR"))
- {
+ if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR"))
- {
+ if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_bind_memory2
- if (!strcmp(name, "vkBindBufferMemory2KHR"))
- {
+ if (!strcmp(name, "vkBindBufferMemory2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkBindImageMemory2KHR"))
- {
+ if (!strcmp(name, "vkBindImageMemory2KHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_maintenance3
- if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR"))
- {
+ if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_draw_indirect_count
- if (!strcmp(name, "vkCmdDrawIndirectCountKHR"))
- {
+ if (!strcmp(name, "vkCmdDrawIndirectCountKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdDrawIndexedIndirectCountKHR"))
- {
+ if (!strcmp(name, "vkCmdDrawIndexedIndirectCountKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_timeline_semaphore
- if (!strcmp(name, "vkGetSemaphoreCounterValueKHR"))
- {
+ if (!strcmp(name, "vkGetSemaphoreCounterValueKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkWaitSemaphoresKHR"))
- {
+ if (!strcmp(name, "vkWaitSemaphoresKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkSignalSemaphoreKHR"))
- {
+ if (!strcmp(name, "vkSignalSemaphoreKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_fragment_shading_rate
- if (!strcmp(name, "vkGetPhysicalDeviceFragmentShadingRatesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceFragmentShadingRatesKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetFragmentShadingRateKHR"))
- {
+ if (!strcmp(name, "vkCmdSetFragmentShadingRateKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_present_wait
- if (!strcmp(name, "vkWaitForPresentKHR"))
- {
+ if (!strcmp(name, "vkWaitForPresentKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_buffer_device_address
- if (!strcmp(name, "vkGetBufferDeviceAddressKHR"))
- {
+ if (!strcmp(name, "vkGetBufferDeviceAddressKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetBufferOpaqueCaptureAddressKHR"))
- {
+ if (!strcmp(name, "vkGetBufferOpaqueCaptureAddressKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddressKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddressKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_deferred_host_operations
- if (!strcmp(name, "vkCreateDeferredOperationKHR"))
- {
+ if (!strcmp(name, "vkCreateDeferredOperationKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkDestroyDeferredOperationKHR"))
- {
+ if (!strcmp(name, "vkDestroyDeferredOperationKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetDeferredOperationMaxConcurrencyKHR"))
- {
+ if (!strcmp(name, "vkGetDeferredOperationMaxConcurrencyKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetDeferredOperationResultKHR"))
- {
+ if (!strcmp(name, "vkGetDeferredOperationResultKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkDeferredOperationJoinKHR"))
- {
+ if (!strcmp(name, "vkDeferredOperationJoinKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
- if (!strcmp(name, "vkGetPipelineExecutablePropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetPipelineExecutablePropertiesKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPipelineExecutableStatisticsKHR"))
- {
+ if (!strcmp(name, "vkGetPipelineExecutableStatisticsKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPipelineExecutableInternalRepresentationsKHR"))
- {
+ if (!strcmp(name, "vkGetPipelineExecutableInternalRepresentationsKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_video_encode_queue
- if (!strcmp(name, "vkCmdEncodeVideoKHR"))
- {
+ if (!strcmp(name, "vkCmdEncodeVideoKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_synchronization2
- if (!strcmp(name, "vkCmdSetEvent2KHR"))
- {
+ if (!strcmp(name, "vkCmdSetEvent2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdResetEvent2KHR"))
- {
+ if (!strcmp(name, "vkCmdResetEvent2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdWaitEvents2KHR"))
- {
+ if (!strcmp(name, "vkCmdWaitEvents2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdPipelineBarrier2KHR"))
- {
+ if (!strcmp(name, "vkCmdPipelineBarrier2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdWriteTimestamp2KHR"))
- {
+ if (!strcmp(name, "vkCmdWriteTimestamp2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkQueueSubmit2KHR"))
- {
+ if (!strcmp(name, "vkQueueSubmit2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdWriteBufferMarker2AMD"))
- {
+ if (!strcmp(name, "vkCmdWriteBufferMarker2AMD")) {
return nullptr;
}
- if (!strcmp(name, "vkGetQueueCheckpointData2NV"))
- {
+ if (!strcmp(name, "vkGetQueueCheckpointData2NV")) {
return nullptr;
}
#endif
#ifdef VK_KHR_copy_commands2
- if (!strcmp(name, "vkCmdCopyBuffer2KHR"))
- {
+ if (!strcmp(name, "vkCmdCopyBuffer2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdCopyImage2KHR"))
- {
+ if (!strcmp(name, "vkCmdCopyImage2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdCopyBufferToImage2KHR"))
- {
+ if (!strcmp(name, "vkCmdCopyBufferToImage2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdCopyImageToBuffer2KHR"))
- {
+ if (!strcmp(name, "vkCmdCopyImageToBuffer2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdBlitImage2KHR"))
- {
+ if (!strcmp(name, "vkCmdBlitImage2KHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdResolveImage2KHR"))
- {
+ if (!strcmp(name, "vkCmdResolveImage2KHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_maintenance4
- if (!strcmp(name, "vkGetDeviceBufferMemoryRequirementsKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceBufferMemoryRequirementsKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetDeviceImageMemoryRequirementsKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceImageMemoryRequirementsKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirementsKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirementsKHR")) {
return nullptr;
}
#endif
#ifdef VK_ANDROID_native_buffer
- if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID"))
- {
+ if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID")) {
return nullptr;
}
- if (!strcmp(name, "vkAcquireImageANDROID"))
- {
+ if (!strcmp(name, "vkAcquireImageANDROID")) {
return nullptr;
}
- if (!strcmp(name, "vkQueueSignalReleaseImageANDROID"))
- {
+ if (!strcmp(name, "vkQueueSignalReleaseImageANDROID")) {
return nullptr;
}
#endif
#ifdef VK_EXT_debug_report
- if (!strcmp(name, "vkCreateDebugReportCallbackEXT"))
- {
+ if (!strcmp(name, "vkCreateDebugReportCallbackEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkDestroyDebugReportCallbackEXT"))
- {
+ if (!strcmp(name, "vkDestroyDebugReportCallbackEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkDebugReportMessageEXT"))
- {
+ if (!strcmp(name, "vkDebugReportMessageEXT")) {
return nullptr;
}
#endif
#ifdef VK_EXT_debug_marker
- if (!strcmp(name, "vkDebugMarkerSetObjectTagEXT"))
- {
+ if (!strcmp(name, "vkDebugMarkerSetObjectTagEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkDebugMarkerSetObjectNameEXT"))
- {
+ if (!strcmp(name, "vkDebugMarkerSetObjectNameEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdDebugMarkerBeginEXT"))
- {
+ if (!strcmp(name, "vkCmdDebugMarkerBeginEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdDebugMarkerEndEXT"))
- {
+ if (!strcmp(name, "vkCmdDebugMarkerEndEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdDebugMarkerInsertEXT"))
- {
+ if (!strcmp(name, "vkCmdDebugMarkerInsertEXT")) {
return nullptr;
}
#endif
#ifdef VK_EXT_transform_feedback
- if (!strcmp(name, "vkCmdBindTransformFeedbackBuffersEXT"))
- {
+ if (!strcmp(name, "vkCmdBindTransformFeedbackBuffersEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdBeginTransformFeedbackEXT"))
- {
+ if (!strcmp(name, "vkCmdBeginTransformFeedbackEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdEndTransformFeedbackEXT"))
- {
+ if (!strcmp(name, "vkCmdEndTransformFeedbackEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdBeginQueryIndexedEXT"))
- {
+ if (!strcmp(name, "vkCmdBeginQueryIndexedEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdEndQueryIndexedEXT"))
- {
+ if (!strcmp(name, "vkCmdEndQueryIndexedEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdDrawIndirectByteCountEXT"))
- {
+ if (!strcmp(name, "vkCmdDrawIndirectByteCountEXT")) {
return nullptr;
}
#endif
#ifdef VK_NVX_binary_import
- if (!strcmp(name, "vkCreateCuModuleNVX"))
- {
+ if (!strcmp(name, "vkCreateCuModuleNVX")) {
return nullptr;
}
- if (!strcmp(name, "vkCreateCuFunctionNVX"))
- {
+ if (!strcmp(name, "vkCreateCuFunctionNVX")) {
return nullptr;
}
- if (!strcmp(name, "vkDestroyCuModuleNVX"))
- {
+ if (!strcmp(name, "vkDestroyCuModuleNVX")) {
return nullptr;
}
- if (!strcmp(name, "vkDestroyCuFunctionNVX"))
- {
+ if (!strcmp(name, "vkDestroyCuFunctionNVX")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdCuLaunchKernelNVX"))
- {
+ if (!strcmp(name, "vkCmdCuLaunchKernelNVX")) {
return nullptr;
}
#endif
#ifdef VK_NVX_image_view_handle
- if (!strcmp(name, "vkGetImageViewHandleNVX"))
- {
+ if (!strcmp(name, "vkGetImageViewHandleNVX")) {
return nullptr;
}
- if (!strcmp(name, "vkGetImageViewAddressNVX"))
- {
+ if (!strcmp(name, "vkGetImageViewAddressNVX")) {
return nullptr;
}
#endif
#ifdef VK_AMD_draw_indirect_count
- if (!strcmp(name, "vkCmdDrawIndirectCountAMD"))
- {
+ if (!strcmp(name, "vkCmdDrawIndirectCountAMD")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdDrawIndexedIndirectCountAMD"))
- {
+ if (!strcmp(name, "vkCmdDrawIndexedIndirectCountAMD")) {
return nullptr;
}
#endif
#ifdef VK_AMD_shader_info
- if (!strcmp(name, "vkGetShaderInfoAMD"))
- {
+ if (!strcmp(name, "vkGetShaderInfoAMD")) {
return nullptr;
}
#endif
#ifdef VK_GGP_stream_descriptor_surface
- if (!strcmp(name, "vkCreateStreamDescriptorSurfaceGGP"))
- {
+ if (!strcmp(name, "vkCreateStreamDescriptorSurfaceGGP")) {
return nullptr;
}
#endif
#ifdef VK_NV_external_memory_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV")) {
return nullptr;
}
#endif
#ifdef VK_NV_external_memory_win32
- if (!strcmp(name, "vkGetMemoryWin32HandleNV"))
- {
+ if (!strcmp(name, "vkGetMemoryWin32HandleNV")) {
return nullptr;
}
#endif
#ifdef VK_NN_vi_surface
- if (!strcmp(name, "vkCreateViSurfaceNN"))
- {
+ if (!strcmp(name, "vkCreateViSurfaceNN")) {
return nullptr;
}
#endif
#ifdef VK_EXT_conditional_rendering
- if (!strcmp(name, "vkCmdBeginConditionalRenderingEXT"))
- {
+ if (!strcmp(name, "vkCmdBeginConditionalRenderingEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdEndConditionalRenderingEXT"))
- {
+ if (!strcmp(name, "vkCmdEndConditionalRenderingEXT")) {
return nullptr;
}
#endif
#ifdef VK_NV_clip_space_w_scaling
- if (!strcmp(name, "vkCmdSetViewportWScalingNV"))
- {
+ if (!strcmp(name, "vkCmdSetViewportWScalingNV")) {
return nullptr;
}
#endif
#ifdef VK_EXT_direct_mode_display
- if (!strcmp(name, "vkReleaseDisplayEXT"))
- {
+ if (!strcmp(name, "vkReleaseDisplayEXT")) {
return nullptr;
}
#endif
#ifdef VK_EXT_acquire_xlib_display
- if (!strcmp(name, "vkAcquireXlibDisplayEXT"))
- {
+ if (!strcmp(name, "vkAcquireXlibDisplayEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkGetRandROutputDisplayEXT"))
- {
+ if (!strcmp(name, "vkGetRandROutputDisplayEXT")) {
return nullptr;
}
#endif
#ifdef VK_EXT_display_surface_counter
- if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")) {
return nullptr;
}
#endif
#ifdef VK_EXT_display_control
- if (!strcmp(name, "vkDisplayPowerControlEXT"))
- {
+ if (!strcmp(name, "vkDisplayPowerControlEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkRegisterDeviceEventEXT"))
- {
+ if (!strcmp(name, "vkRegisterDeviceEventEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkRegisterDisplayEventEXT"))
- {
+ if (!strcmp(name, "vkRegisterDisplayEventEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkGetSwapchainCounterEXT"))
- {
+ if (!strcmp(name, "vkGetSwapchainCounterEXT")) {
return nullptr;
}
#endif
#ifdef VK_GOOGLE_display_timing
- if (!strcmp(name, "vkGetRefreshCycleDurationGOOGLE"))
- {
+ if (!strcmp(name, "vkGetRefreshCycleDurationGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPastPresentationTimingGOOGLE"))
- {
+ if (!strcmp(name, "vkGetPastPresentationTimingGOOGLE")) {
return nullptr;
}
#endif
#ifdef VK_EXT_discard_rectangles
- if (!strcmp(name, "vkCmdSetDiscardRectangleEXT"))
- {
+ if (!strcmp(name, "vkCmdSetDiscardRectangleEXT")) {
return nullptr;
}
#endif
#ifdef VK_EXT_hdr_metadata
- if (!strcmp(name, "vkSetHdrMetadataEXT"))
- {
+ if (!strcmp(name, "vkSetHdrMetadataEXT")) {
return nullptr;
}
#endif
#ifdef VK_MVK_ios_surface
- if (!strcmp(name, "vkCreateIOSSurfaceMVK"))
- {
+ if (!strcmp(name, "vkCreateIOSSurfaceMVK")) {
return nullptr;
}
#endif
#ifdef VK_MVK_macos_surface
- if (!strcmp(name, "vkCreateMacOSSurfaceMVK"))
- {
+ if (!strcmp(name, "vkCreateMacOSSurfaceMVK")) {
return nullptr;
}
#endif
#ifdef VK_MVK_moltenvk
- if (!strcmp(name, "vkGetMTLDeviceMVK"))
- {
+ if (!strcmp(name, "vkGetMTLDeviceMVK")) {
return nullptr;
}
- if (!strcmp(name, "vkSetMTLTextureMVK"))
- {
+ if (!strcmp(name, "vkSetMTLTextureMVK")) {
return nullptr;
}
- if (!strcmp(name, "vkGetMTLTextureMVK"))
- {
+ if (!strcmp(name, "vkGetMTLTextureMVK")) {
return nullptr;
}
- if (!strcmp(name, "vkGetMTLBufferMVK"))
- {
+ if (!strcmp(name, "vkGetMTLBufferMVK")) {
return nullptr;
}
- if (!strcmp(name, "vkUseIOSurfaceMVK"))
- {
+ if (!strcmp(name, "vkUseIOSurfaceMVK")) {
return nullptr;
}
- if (!strcmp(name, "vkGetIOSurfaceMVK"))
- {
+ if (!strcmp(name, "vkGetIOSurfaceMVK")) {
return nullptr;
}
#endif
#ifdef VK_EXT_debug_utils
- if (!strcmp(name, "vkSetDebugUtilsObjectNameEXT"))
- {
+ if (!strcmp(name, "vkSetDebugUtilsObjectNameEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkSetDebugUtilsObjectTagEXT"))
- {
+ if (!strcmp(name, "vkSetDebugUtilsObjectTagEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkQueueBeginDebugUtilsLabelEXT"))
- {
+ if (!strcmp(name, "vkQueueBeginDebugUtilsLabelEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkQueueEndDebugUtilsLabelEXT"))
- {
+ if (!strcmp(name, "vkQueueEndDebugUtilsLabelEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkQueueInsertDebugUtilsLabelEXT"))
- {
+ if (!strcmp(name, "vkQueueInsertDebugUtilsLabelEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdBeginDebugUtilsLabelEXT"))
- {
+ if (!strcmp(name, "vkCmdBeginDebugUtilsLabelEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdEndDebugUtilsLabelEXT"))
- {
+ if (!strcmp(name, "vkCmdEndDebugUtilsLabelEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdInsertDebugUtilsLabelEXT"))
- {
+ if (!strcmp(name, "vkCmdInsertDebugUtilsLabelEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCreateDebugUtilsMessengerEXT"))
- {
+ if (!strcmp(name, "vkCreateDebugUtilsMessengerEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkDestroyDebugUtilsMessengerEXT"))
- {
+ if (!strcmp(name, "vkDestroyDebugUtilsMessengerEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkSubmitDebugUtilsMessageEXT"))
- {
+ if (!strcmp(name, "vkSubmitDebugUtilsMessageEXT")) {
return nullptr;
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
- if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID"))
- {
+ if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID")) {
return nullptr;
}
- if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID"))
- {
+ if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID")) {
return nullptr;
}
#endif
#ifdef VK_EXT_sample_locations
- if (!strcmp(name, "vkCmdSetSampleLocationsEXT"))
- {
+ if (!strcmp(name, "vkCmdSetSampleLocationsEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceMultisamplePropertiesEXT"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceMultisamplePropertiesEXT")) {
return nullptr;
}
#endif
#ifdef VK_EXT_image_drm_format_modifier
- if (!strcmp(name, "vkGetImageDrmFormatModifierPropertiesEXT"))
- {
+ if (!strcmp(name, "vkGetImageDrmFormatModifierPropertiesEXT")) {
return nullptr;
}
#endif
#ifdef VK_EXT_validation_cache
- if (!strcmp(name, "vkCreateValidationCacheEXT"))
- {
+ if (!strcmp(name, "vkCreateValidationCacheEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkDestroyValidationCacheEXT"))
- {
+ if (!strcmp(name, "vkDestroyValidationCacheEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkMergeValidationCachesEXT"))
- {
+ if (!strcmp(name, "vkMergeValidationCachesEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkGetValidationCacheDataEXT"))
- {
+ if (!strcmp(name, "vkGetValidationCacheDataEXT")) {
return nullptr;
}
#endif
#ifdef VK_NV_shading_rate_image
- if (!strcmp(name, "vkCmdBindShadingRateImageNV"))
- {
+ if (!strcmp(name, "vkCmdBindShadingRateImageNV")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetViewportShadingRatePaletteNV"))
- {
+ if (!strcmp(name, "vkCmdSetViewportShadingRatePaletteNV")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetCoarseSampleOrderNV"))
- {
+ if (!strcmp(name, "vkCmdSetCoarseSampleOrderNV")) {
return nullptr;
}
#endif
#ifdef VK_NV_ray_tracing
- if (!strcmp(name, "vkCreateAccelerationStructureNV"))
- {
+ if (!strcmp(name, "vkCreateAccelerationStructureNV")) {
return nullptr;
}
- if (!strcmp(name, "vkDestroyAccelerationStructureNV"))
- {
+ if (!strcmp(name, "vkDestroyAccelerationStructureNV")) {
return nullptr;
}
- if (!strcmp(name, "vkGetAccelerationStructureMemoryRequirementsNV"))
- {
+ if (!strcmp(name, "vkGetAccelerationStructureMemoryRequirementsNV")) {
return nullptr;
}
- if (!strcmp(name, "vkBindAccelerationStructureMemoryNV"))
- {
+ if (!strcmp(name, "vkBindAccelerationStructureMemoryNV")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdBuildAccelerationStructureNV"))
- {
+ if (!strcmp(name, "vkCmdBuildAccelerationStructureNV")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdCopyAccelerationStructureNV"))
- {
+ if (!strcmp(name, "vkCmdCopyAccelerationStructureNV")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdTraceRaysNV"))
- {
+ if (!strcmp(name, "vkCmdTraceRaysNV")) {
return nullptr;
}
- if (!strcmp(name, "vkCreateRayTracingPipelinesNV"))
- {
+ if (!strcmp(name, "vkCreateRayTracingPipelinesNV")) {
return nullptr;
}
- if (!strcmp(name, "vkGetRayTracingShaderGroupHandlesKHR"))
- {
+ if (!strcmp(name, "vkGetRayTracingShaderGroupHandlesKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetRayTracingShaderGroupHandlesNV"))
- {
+ if (!strcmp(name, "vkGetRayTracingShaderGroupHandlesNV")) {
return nullptr;
}
- if (!strcmp(name, "vkGetAccelerationStructureHandleNV"))
- {
+ if (!strcmp(name, "vkGetAccelerationStructureHandleNV")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdWriteAccelerationStructuresPropertiesNV"))
- {
+ if (!strcmp(name, "vkCmdWriteAccelerationStructuresPropertiesNV")) {
return nullptr;
}
- if (!strcmp(name, "vkCompileDeferredNV"))
- {
+ if (!strcmp(name, "vkCompileDeferredNV")) {
return nullptr;
}
#endif
#ifdef VK_EXT_external_memory_host
- if (!strcmp(name, "vkGetMemoryHostPointerPropertiesEXT"))
- {
+ if (!strcmp(name, "vkGetMemoryHostPointerPropertiesEXT")) {
return nullptr;
}
#endif
#ifdef VK_AMD_buffer_marker
- if (!strcmp(name, "vkCmdWriteBufferMarkerAMD"))
- {
+ if (!strcmp(name, "vkCmdWriteBufferMarkerAMD")) {
return nullptr;
}
#endif
#ifdef VK_EXT_calibrated_timestamps
- if (!strcmp(name, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkGetCalibratedTimestampsEXT"))
- {
+ if (!strcmp(name, "vkGetCalibratedTimestampsEXT")) {
return nullptr;
}
#endif
#ifdef VK_NV_mesh_shader
- if (!strcmp(name, "vkCmdDrawMeshTasksNV"))
- {
+ if (!strcmp(name, "vkCmdDrawMeshTasksNV")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdDrawMeshTasksIndirectNV"))
- {
+ if (!strcmp(name, "vkCmdDrawMeshTasksIndirectNV")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdDrawMeshTasksIndirectCountNV"))
- {
+ if (!strcmp(name, "vkCmdDrawMeshTasksIndirectCountNV")) {
return nullptr;
}
#endif
#ifdef VK_NV_scissor_exclusive
- if (!strcmp(name, "vkCmdSetExclusiveScissorNV"))
- {
+ if (!strcmp(name, "vkCmdSetExclusiveScissorNV")) {
return nullptr;
}
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
- if (!strcmp(name, "vkCmdSetCheckpointNV"))
- {
+ if (!strcmp(name, "vkCmdSetCheckpointNV")) {
return nullptr;
}
- if (!strcmp(name, "vkGetQueueCheckpointDataNV"))
- {
+ if (!strcmp(name, "vkGetQueueCheckpointDataNV")) {
return nullptr;
}
#endif
#ifdef VK_INTEL_performance_query
- if (!strcmp(name, "vkInitializePerformanceApiINTEL"))
- {
+ if (!strcmp(name, "vkInitializePerformanceApiINTEL")) {
return nullptr;
}
- if (!strcmp(name, "vkUninitializePerformanceApiINTEL"))
- {
+ if (!strcmp(name, "vkUninitializePerformanceApiINTEL")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetPerformanceMarkerINTEL"))
- {
+ if (!strcmp(name, "vkCmdSetPerformanceMarkerINTEL")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetPerformanceStreamMarkerINTEL"))
- {
+ if (!strcmp(name, "vkCmdSetPerformanceStreamMarkerINTEL")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetPerformanceOverrideINTEL"))
- {
+ if (!strcmp(name, "vkCmdSetPerformanceOverrideINTEL")) {
return nullptr;
}
- if (!strcmp(name, "vkAcquirePerformanceConfigurationINTEL"))
- {
+ if (!strcmp(name, "vkAcquirePerformanceConfigurationINTEL")) {
return nullptr;
}
- if (!strcmp(name, "vkReleasePerformanceConfigurationINTEL"))
- {
+ if (!strcmp(name, "vkReleasePerformanceConfigurationINTEL")) {
return nullptr;
}
- if (!strcmp(name, "vkQueueSetPerformanceConfigurationINTEL"))
- {
+ if (!strcmp(name, "vkQueueSetPerformanceConfigurationINTEL")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPerformanceParameterINTEL"))
- {
+ if (!strcmp(name, "vkGetPerformanceParameterINTEL")) {
return nullptr;
}
#endif
#ifdef VK_AMD_display_native_hdr
- if (!strcmp(name, "vkSetLocalDimmingAMD"))
- {
+ if (!strcmp(name, "vkSetLocalDimmingAMD")) {
return nullptr;
}
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
- if (!strcmp(name, "vkCreateImagePipeSurfaceFUCHSIA"))
- {
+ if (!strcmp(name, "vkCreateImagePipeSurfaceFUCHSIA")) {
return nullptr;
}
#endif
#ifdef VK_EXT_metal_surface
- if (!strcmp(name, "vkCreateMetalSurfaceEXT"))
- {
+ if (!strcmp(name, "vkCreateMetalSurfaceEXT")) {
return nullptr;
}
#endif
#ifdef VK_EXT_buffer_device_address
- if (!strcmp(name, "vkGetBufferDeviceAddressEXT"))
- {
+ if (!strcmp(name, "vkGetBufferDeviceAddressEXT")) {
return nullptr;
}
#endif
#ifdef VK_EXT_tooling_info
- if (!strcmp(name, "vkGetPhysicalDeviceToolPropertiesEXT"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceToolPropertiesEXT")) {
return nullptr;
}
#endif
#ifdef VK_NV_cooperative_matrix
- if (!strcmp(name, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV")) {
return nullptr;
}
#endif
#ifdef VK_NV_coverage_reduction_mode
- if (!strcmp(name, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV")) {
return nullptr;
}
#endif
#ifdef VK_EXT_full_screen_exclusive
- if (!strcmp(name, "vkGetPhysicalDeviceSurfacePresentModes2EXT"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfacePresentModes2EXT")) {
return nullptr;
}
- if (!strcmp(name, "vkAcquireFullScreenExclusiveModeEXT"))
- {
+ if (!strcmp(name, "vkAcquireFullScreenExclusiveModeEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkReleaseFullScreenExclusiveModeEXT"))
- {
+ if (!strcmp(name, "vkReleaseFullScreenExclusiveModeEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModes2EXT"))
- {
+ if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModes2EXT")) {
return nullptr;
}
#endif
#ifdef VK_EXT_headless_surface
- if (!strcmp(name, "vkCreateHeadlessSurfaceEXT"))
- {
+ if (!strcmp(name, "vkCreateHeadlessSurfaceEXT")) {
return nullptr;
}
#endif
#ifdef VK_EXT_line_rasterization
- if (!strcmp(name, "vkCmdSetLineStippleEXT"))
- {
+ if (!strcmp(name, "vkCmdSetLineStippleEXT")) {
return nullptr;
}
#endif
#ifdef VK_EXT_host_query_reset
- if (!strcmp(name, "vkResetQueryPoolEXT"))
- {
+ if (!strcmp(name, "vkResetQueryPoolEXT")) {
return nullptr;
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- if (!strcmp(name, "vkCmdSetCullModeEXT"))
- {
+ if (!strcmp(name, "vkCmdSetCullModeEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetFrontFaceEXT"))
- {
+ if (!strcmp(name, "vkCmdSetFrontFaceEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetPrimitiveTopologyEXT"))
- {
+ if (!strcmp(name, "vkCmdSetPrimitiveTopologyEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetViewportWithCountEXT"))
- {
+ if (!strcmp(name, "vkCmdSetViewportWithCountEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetScissorWithCountEXT"))
- {
+ if (!strcmp(name, "vkCmdSetScissorWithCountEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdBindVertexBuffers2EXT"))
- {
+ if (!strcmp(name, "vkCmdBindVertexBuffers2EXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetDepthTestEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetDepthTestEnableEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetDepthWriteEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetDepthWriteEnableEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetDepthCompareOpEXT"))
- {
+ if (!strcmp(name, "vkCmdSetDepthCompareOpEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetDepthBoundsTestEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetDepthBoundsTestEnableEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetStencilTestEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetStencilTestEnableEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetStencilOpEXT"))
- {
+ if (!strcmp(name, "vkCmdSetStencilOpEXT")) {
return nullptr;
}
#endif
#ifdef VK_NV_device_generated_commands
- if (!strcmp(name, "vkGetGeneratedCommandsMemoryRequirementsNV"))
- {
+ if (!strcmp(name, "vkGetGeneratedCommandsMemoryRequirementsNV")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdPreprocessGeneratedCommandsNV"))
- {
+ if (!strcmp(name, "vkCmdPreprocessGeneratedCommandsNV")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdExecuteGeneratedCommandsNV"))
- {
+ if (!strcmp(name, "vkCmdExecuteGeneratedCommandsNV")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdBindPipelineShaderGroupNV"))
- {
+ if (!strcmp(name, "vkCmdBindPipelineShaderGroupNV")) {
return nullptr;
}
- if (!strcmp(name, "vkCreateIndirectCommandsLayoutNV"))
- {
+ if (!strcmp(name, "vkCreateIndirectCommandsLayoutNV")) {
return nullptr;
}
- if (!strcmp(name, "vkDestroyIndirectCommandsLayoutNV"))
- {
+ if (!strcmp(name, "vkDestroyIndirectCommandsLayoutNV")) {
return nullptr;
}
#endif
#ifdef VK_EXT_acquire_drm_display
- if (!strcmp(name, "vkAcquireDrmDisplayEXT"))
- {
+ if (!strcmp(name, "vkAcquireDrmDisplayEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkGetDrmDisplayEXT"))
- {
+ if (!strcmp(name, "vkGetDrmDisplayEXT")) {
return nullptr;
}
#endif
#ifdef VK_EXT_private_data
- if (!strcmp(name, "vkCreatePrivateDataSlotEXT"))
- {
+ if (!strcmp(name, "vkCreatePrivateDataSlotEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkDestroyPrivateDataSlotEXT"))
- {
+ if (!strcmp(name, "vkDestroyPrivateDataSlotEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkSetPrivateDataEXT"))
- {
+ if (!strcmp(name, "vkSetPrivateDataEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPrivateDataEXT"))
- {
+ if (!strcmp(name, "vkGetPrivateDataEXT")) {
return nullptr;
}
#endif
#ifdef VK_NV_fragment_shading_rate_enums
- if (!strcmp(name, "vkCmdSetFragmentShadingRateEnumNV"))
- {
+ if (!strcmp(name, "vkCmdSetFragmentShadingRateEnumNV")) {
return nullptr;
}
#endif
#ifdef VK_NV_acquire_winrt_display
- if (!strcmp(name, "vkAcquireWinrtDisplayNV"))
- {
+ if (!strcmp(name, "vkAcquireWinrtDisplayNV")) {
return nullptr;
}
- if (!strcmp(name, "vkGetWinrtDisplayNV"))
- {
+ if (!strcmp(name, "vkGetWinrtDisplayNV")) {
return nullptr;
}
#endif
#ifdef VK_EXT_directfb_surface
- if (!strcmp(name, "vkCreateDirectFBSurfaceEXT"))
- {
+ if (!strcmp(name, "vkCreateDirectFBSurfaceEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT")) {
return nullptr;
}
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
- if (!strcmp(name, "vkCmdSetVertexInputEXT"))
- {
+ if (!strcmp(name, "vkCmdSetVertexInputEXT")) {
return nullptr;
}
#endif
#ifdef VK_FUCHSIA_external_memory
- if (!strcmp(name, "vkGetMemoryZirconHandleFUCHSIA"))
- {
+ if (!strcmp(name, "vkGetMemoryZirconHandleFUCHSIA")) {
return nullptr;
}
- if (!strcmp(name, "vkGetMemoryZirconHandlePropertiesFUCHSIA"))
- {
+ if (!strcmp(name, "vkGetMemoryZirconHandlePropertiesFUCHSIA")) {
return nullptr;
}
#endif
#ifdef VK_FUCHSIA_external_semaphore
- if (!strcmp(name, "vkImportSemaphoreZirconHandleFUCHSIA"))
- {
+ if (!strcmp(name, "vkImportSemaphoreZirconHandleFUCHSIA")) {
return nullptr;
}
- if (!strcmp(name, "vkGetSemaphoreZirconHandleFUCHSIA"))
- {
+ if (!strcmp(name, "vkGetSemaphoreZirconHandleFUCHSIA")) {
return nullptr;
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
- if (!strcmp(name, "vkCreateBufferCollectionFUCHSIA"))
- {
+ if (!strcmp(name, "vkCreateBufferCollectionFUCHSIA")) {
return nullptr;
}
- if (!strcmp(name, "vkSetBufferCollectionImageConstraintsFUCHSIA"))
- {
+ if (!strcmp(name, "vkSetBufferCollectionImageConstraintsFUCHSIA")) {
return nullptr;
}
- if (!strcmp(name, "vkSetBufferCollectionBufferConstraintsFUCHSIA"))
- {
+ if (!strcmp(name, "vkSetBufferCollectionBufferConstraintsFUCHSIA")) {
return nullptr;
}
- if (!strcmp(name, "vkDestroyBufferCollectionFUCHSIA"))
- {
+ if (!strcmp(name, "vkDestroyBufferCollectionFUCHSIA")) {
return nullptr;
}
- if (!strcmp(name, "vkGetBufferCollectionPropertiesFUCHSIA"))
- {
+ if (!strcmp(name, "vkGetBufferCollectionPropertiesFUCHSIA")) {
return nullptr;
}
#endif
#ifdef VK_HUAWEI_subpass_shading
- if (!strcmp(name, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI"))
- {
+ if (!strcmp(name, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSubpassShadingHUAWEI"))
- {
+ if (!strcmp(name, "vkCmdSubpassShadingHUAWEI")) {
return nullptr;
}
#endif
#ifdef VK_HUAWEI_invocation_mask
- if (!strcmp(name, "vkCmdBindInvocationMaskHUAWEI"))
- {
+ if (!strcmp(name, "vkCmdBindInvocationMaskHUAWEI")) {
return nullptr;
}
#endif
#ifdef VK_NV_external_memory_rdma
- if (!strcmp(name, "vkGetMemoryRemoteAddressNV"))
- {
+ if (!strcmp(name, "vkGetMemoryRemoteAddressNV")) {
return nullptr;
}
#endif
#ifdef VK_EXT_extended_dynamic_state2
- if (!strcmp(name, "vkCmdSetPatchControlPointsEXT"))
- {
+ if (!strcmp(name, "vkCmdSetPatchControlPointsEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetRasterizerDiscardEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetRasterizerDiscardEnableEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetDepthBiasEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetDepthBiasEnableEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetLogicOpEXT"))
- {
+ if (!strcmp(name, "vkCmdSetLogicOpEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetPrimitiveRestartEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetPrimitiveRestartEnableEXT")) {
return nullptr;
}
#endif
#ifdef VK_QNX_screen_surface
- if (!strcmp(name, "vkCreateScreenSurfaceQNX"))
- {
+ if (!strcmp(name, "vkCreateScreenSurfaceQNX")) {
return nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceScreenPresentationSupportQNX"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceScreenPresentationSupportQNX")) {
return nullptr;
}
#endif
#ifdef VK_EXT_color_write_enable
- if (!strcmp(name, "vkCmdSetColorWriteEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetColorWriteEnableEXT")) {
return nullptr;
}
#endif
#ifdef VK_GOOGLE_gfxstream
- if (!strcmp(name, "vkRegisterImageColorBufferGOOGLE"))
- {
+ if (!strcmp(name, "vkRegisterImageColorBufferGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkRegisterBufferColorBufferGOOGLE"))
- {
+ if (!strcmp(name, "vkRegisterBufferColorBufferGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE"))
- {
+ if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE"))
- {
+ if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE"))
- {
+ if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE"))
- {
+ if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE"))
- {
+ if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE"))
- {
+ if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE"))
- {
+ if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE"))
- {
+ if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkGetMemoryHostAddressInfoGOOGLE"))
- {
+ if (!strcmp(name, "vkGetMemoryHostAddressInfoGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkFreeMemorySyncGOOGLE"))
- {
+ if (!strcmp(name, "vkFreeMemorySyncGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkQueueHostSyncGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueHostSyncGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE"))
- {
+ if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkGetLinearImageLayout2GOOGLE"))
- {
+ if (!strcmp(name, "vkGetLinearImageLayout2GOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkQueueFlushCommandsGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueFlushCommandsGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkQueueCommitDescriptorSetUpdatesGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueCommitDescriptorSetUpdatesGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkCollectDescriptorPoolIdsGOOGLE"))
- {
+ if (!strcmp(name, "vkCollectDescriptorPoolIdsGOOGLE")) {
return nullptr;
}
- if (!strcmp(name, "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE")) {
return nullptr;
}
#endif
#ifdef VK_EXT_multi_draw
- if (!strcmp(name, "vkCmdDrawMultiEXT"))
- {
+ if (!strcmp(name, "vkCmdDrawMultiEXT")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdDrawMultiIndexedEXT"))
- {
+ if (!strcmp(name, "vkCmdDrawMultiIndexedEXT")) {
return nullptr;
}
#endif
#ifdef VK_EXT_pageable_device_local_memory
- if (!strcmp(name, "vkSetDeviceMemoryPriorityEXT"))
- {
+ if (!strcmp(name, "vkSetDeviceMemoryPriorityEXT")) {
return nullptr;
}
#endif
#ifdef VK_KHR_acceleration_structure
- if (!strcmp(name, "vkCreateAccelerationStructureKHR"))
- {
+ if (!strcmp(name, "vkCreateAccelerationStructureKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkDestroyAccelerationStructureKHR"))
- {
+ if (!strcmp(name, "vkDestroyAccelerationStructureKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdBuildAccelerationStructuresKHR"))
- {
+ if (!strcmp(name, "vkCmdBuildAccelerationStructuresKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdBuildAccelerationStructuresIndirectKHR"))
- {
+ if (!strcmp(name, "vkCmdBuildAccelerationStructuresIndirectKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkBuildAccelerationStructuresKHR"))
- {
+ if (!strcmp(name, "vkBuildAccelerationStructuresKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCopyAccelerationStructureKHR"))
- {
+ if (!strcmp(name, "vkCopyAccelerationStructureKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCopyAccelerationStructureToMemoryKHR"))
- {
+ if (!strcmp(name, "vkCopyAccelerationStructureToMemoryKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCopyMemoryToAccelerationStructureKHR"))
- {
+ if (!strcmp(name, "vkCopyMemoryToAccelerationStructureKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkWriteAccelerationStructuresPropertiesKHR"))
- {
+ if (!strcmp(name, "vkWriteAccelerationStructuresPropertiesKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdCopyAccelerationStructureKHR"))
- {
+ if (!strcmp(name, "vkCmdCopyAccelerationStructureKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdCopyAccelerationStructureToMemoryKHR"))
- {
+ if (!strcmp(name, "vkCmdCopyAccelerationStructureToMemoryKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdCopyMemoryToAccelerationStructureKHR"))
- {
+ if (!strcmp(name, "vkCmdCopyMemoryToAccelerationStructureKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetAccelerationStructureDeviceAddressKHR"))
- {
+ if (!strcmp(name, "vkGetAccelerationStructureDeviceAddressKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdWriteAccelerationStructuresPropertiesKHR"))
- {
+ if (!strcmp(name, "vkCmdWriteAccelerationStructuresPropertiesKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetDeviceAccelerationStructureCompatibilityKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceAccelerationStructureCompatibilityKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetAccelerationStructureBuildSizesKHR"))
- {
+ if (!strcmp(name, "vkGetAccelerationStructureBuildSizesKHR")) {
return nullptr;
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
- if (!strcmp(name, "vkCmdTraceRaysKHR"))
- {
+ if (!strcmp(name, "vkCmdTraceRaysKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCreateRayTracingPipelinesKHR"))
- {
+ if (!strcmp(name, "vkCreateRayTracingPipelinesKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR"))
- {
+ if (!strcmp(name, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdTraceRaysIndirectKHR"))
- {
+ if (!strcmp(name, "vkCmdTraceRaysIndirectKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkGetRayTracingShaderGroupStackSizeKHR"))
- {
+ if (!strcmp(name, "vkGetRayTracingShaderGroupStackSizeKHR")) {
return nullptr;
}
- if (!strcmp(name, "vkCmdSetRayTracingPipelineStackSizeKHR"))
- {
+ if (!strcmp(name, "vkCmdSetRayTracingPipelineStackSizeKHR")) {
return nullptr;
}
#endif
return nullptr;
}
-void* goldfish_vulkan_get_instance_proc_address(VkInstance instance, const char* name){
+void* goldfish_vulkan_get_instance_proc_address(VkInstance instance, const char* name) {
auto resources = ResourceTracker::get();
bool has1_1OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_1;
+ bool has1_2OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_2;
#ifdef VK_VERSION_1_0
- if (!strcmp(name, "vkCreateInstance"))
- {
+ if (!strcmp(name, "vkCreateInstance")) {
return (void*)entry_vkCreateInstance;
}
- if (!strcmp(name, "vkDestroyInstance"))
- {
+ if (!strcmp(name, "vkDestroyInstance")) {
return (void*)entry_vkDestroyInstance;
}
- if (!strcmp(name, "vkEnumeratePhysicalDevices"))
- {
+ if (!strcmp(name, "vkEnumeratePhysicalDevices")) {
return (void*)entry_vkEnumeratePhysicalDevices;
}
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceFeatures")) {
return (void*)entry_vkGetPhysicalDeviceFeatures;
}
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties")) {
return (void*)entry_vkGetPhysicalDeviceFormatProperties;
}
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties")) {
return (void*)entry_vkGetPhysicalDeviceImageFormatProperties;
}
- if (!strcmp(name, "vkGetPhysicalDeviceProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceProperties")) {
return (void*)entry_vkGetPhysicalDeviceProperties;
}
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties")) {
return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties;
}
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties")) {
return (void*)entry_vkGetPhysicalDeviceMemoryProperties;
}
- if (!strcmp(name, "vkGetInstanceProcAddr"))
- {
+ if (!strcmp(name, "vkGetInstanceProcAddr")) {
return (void*)entry_vkGetInstanceProcAddr;
}
- if (!strcmp(name, "vkGetDeviceProcAddr"))
- {
+ if (!strcmp(name, "vkGetDeviceProcAddr")) {
return (void*)entry_vkGetDeviceProcAddr;
}
- if (!strcmp(name, "vkCreateDevice"))
- {
+ if (!strcmp(name, "vkCreateDevice")) {
return (void*)entry_vkCreateDevice;
}
- if (!strcmp(name, "vkDestroyDevice"))
- {
+ if (!strcmp(name, "vkDestroyDevice")) {
return (void*)entry_vkDestroyDevice;
}
- if (!strcmp(name, "vkEnumerateInstanceExtensionProperties"))
- {
+ if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) {
return (void*)entry_vkEnumerateInstanceExtensionProperties;
}
- if (!strcmp(name, "vkEnumerateDeviceExtensionProperties"))
- {
+ if (!strcmp(name, "vkEnumerateDeviceExtensionProperties")) {
return (void*)entry_vkEnumerateDeviceExtensionProperties;
}
- if (!strcmp(name, "vkEnumerateInstanceLayerProperties"))
- {
+ if (!strcmp(name, "vkEnumerateInstanceLayerProperties")) {
return (void*)entry_vkEnumerateInstanceLayerProperties;
}
- if (!strcmp(name, "vkEnumerateDeviceLayerProperties"))
- {
+ if (!strcmp(name, "vkEnumerateDeviceLayerProperties")) {
return (void*)entry_vkEnumerateDeviceLayerProperties;
}
- if (!strcmp(name, "vkGetDeviceQueue"))
- {
+ if (!strcmp(name, "vkGetDeviceQueue")) {
return (void*)entry_vkGetDeviceQueue;
}
- if (!strcmp(name, "vkQueueSubmit"))
- {
+ if (!strcmp(name, "vkQueueSubmit")) {
return (void*)entry_vkQueueSubmit;
}
- if (!strcmp(name, "vkQueueWaitIdle"))
- {
+ if (!strcmp(name, "vkQueueWaitIdle")) {
return (void*)entry_vkQueueWaitIdle;
}
- if (!strcmp(name, "vkDeviceWaitIdle"))
- {
+ if (!strcmp(name, "vkDeviceWaitIdle")) {
return (void*)entry_vkDeviceWaitIdle;
}
- if (!strcmp(name, "vkAllocateMemory"))
- {
+ if (!strcmp(name, "vkAllocateMemory")) {
return (void*)entry_vkAllocateMemory;
}
- if (!strcmp(name, "vkFreeMemory"))
- {
+ if (!strcmp(name, "vkFreeMemory")) {
return (void*)entry_vkFreeMemory;
}
- if (!strcmp(name, "vkMapMemory"))
- {
+ if (!strcmp(name, "vkMapMemory")) {
return (void*)entry_vkMapMemory;
}
- if (!strcmp(name, "vkUnmapMemory"))
- {
+ if (!strcmp(name, "vkUnmapMemory")) {
return (void*)entry_vkUnmapMemory;
}
- if (!strcmp(name, "vkFlushMappedMemoryRanges"))
- {
+ if (!strcmp(name, "vkFlushMappedMemoryRanges")) {
return (void*)entry_vkFlushMappedMemoryRanges;
}
- if (!strcmp(name, "vkInvalidateMappedMemoryRanges"))
- {
+ if (!strcmp(name, "vkInvalidateMappedMemoryRanges")) {
return (void*)entry_vkInvalidateMappedMemoryRanges;
}
- if (!strcmp(name, "vkGetDeviceMemoryCommitment"))
- {
+ if (!strcmp(name, "vkGetDeviceMemoryCommitment")) {
return (void*)entry_vkGetDeviceMemoryCommitment;
}
- if (!strcmp(name, "vkBindBufferMemory"))
- {
+ if (!strcmp(name, "vkBindBufferMemory")) {
return (void*)entry_vkBindBufferMemory;
}
- if (!strcmp(name, "vkBindImageMemory"))
- {
+ if (!strcmp(name, "vkBindImageMemory")) {
return (void*)entry_vkBindImageMemory;
}
- if (!strcmp(name, "vkGetBufferMemoryRequirements"))
- {
+ if (!strcmp(name, "vkGetBufferMemoryRequirements")) {
return (void*)entry_vkGetBufferMemoryRequirements;
}
- if (!strcmp(name, "vkGetImageMemoryRequirements"))
- {
+ if (!strcmp(name, "vkGetImageMemoryRequirements")) {
return (void*)entry_vkGetImageMemoryRequirements;
}
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements"))
- {
+ if (!strcmp(name, "vkGetImageSparseMemoryRequirements")) {
return (void*)entry_vkGetImageSparseMemoryRequirements;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties")) {
return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties;
}
- if (!strcmp(name, "vkQueueBindSparse"))
- {
+ if (!strcmp(name, "vkQueueBindSparse")) {
return (void*)entry_vkQueueBindSparse;
}
- if (!strcmp(name, "vkCreateFence"))
- {
+ if (!strcmp(name, "vkCreateFence")) {
return (void*)entry_vkCreateFence;
}
- if (!strcmp(name, "vkDestroyFence"))
- {
+ if (!strcmp(name, "vkDestroyFence")) {
return (void*)entry_vkDestroyFence;
}
- if (!strcmp(name, "vkResetFences"))
- {
+ if (!strcmp(name, "vkResetFences")) {
return (void*)entry_vkResetFences;
}
- if (!strcmp(name, "vkGetFenceStatus"))
- {
+ if (!strcmp(name, "vkGetFenceStatus")) {
return (void*)entry_vkGetFenceStatus;
}
- if (!strcmp(name, "vkWaitForFences"))
- {
+ if (!strcmp(name, "vkWaitForFences")) {
return (void*)entry_vkWaitForFences;
}
- if (!strcmp(name, "vkCreateSemaphore"))
- {
+ if (!strcmp(name, "vkCreateSemaphore")) {
return (void*)entry_vkCreateSemaphore;
}
- if (!strcmp(name, "vkDestroySemaphore"))
- {
+ if (!strcmp(name, "vkDestroySemaphore")) {
return (void*)entry_vkDestroySemaphore;
}
- if (!strcmp(name, "vkCreateEvent"))
- {
+ if (!strcmp(name, "vkCreateEvent")) {
return (void*)entry_vkCreateEvent;
}
- if (!strcmp(name, "vkDestroyEvent"))
- {
+ if (!strcmp(name, "vkDestroyEvent")) {
return (void*)entry_vkDestroyEvent;
}
- if (!strcmp(name, "vkGetEventStatus"))
- {
+ if (!strcmp(name, "vkGetEventStatus")) {
return (void*)entry_vkGetEventStatus;
}
- if (!strcmp(name, "vkSetEvent"))
- {
+ if (!strcmp(name, "vkSetEvent")) {
return (void*)entry_vkSetEvent;
}
- if (!strcmp(name, "vkResetEvent"))
- {
+ if (!strcmp(name, "vkResetEvent")) {
return (void*)entry_vkResetEvent;
}
- if (!strcmp(name, "vkCreateQueryPool"))
- {
+ if (!strcmp(name, "vkCreateQueryPool")) {
return (void*)entry_vkCreateQueryPool;
}
- if (!strcmp(name, "vkDestroyQueryPool"))
- {
+ if (!strcmp(name, "vkDestroyQueryPool")) {
return (void*)entry_vkDestroyQueryPool;
}
- if (!strcmp(name, "vkGetQueryPoolResults"))
- {
+ if (!strcmp(name, "vkGetQueryPoolResults")) {
return (void*)entry_vkGetQueryPoolResults;
}
- if (!strcmp(name, "vkCreateBuffer"))
- {
+ if (!strcmp(name, "vkCreateBuffer")) {
return (void*)entry_vkCreateBuffer;
}
- if (!strcmp(name, "vkDestroyBuffer"))
- {
+ if (!strcmp(name, "vkDestroyBuffer")) {
return (void*)entry_vkDestroyBuffer;
}
- if (!strcmp(name, "vkCreateBufferView"))
- {
+ if (!strcmp(name, "vkCreateBufferView")) {
return (void*)entry_vkCreateBufferView;
}
- if (!strcmp(name, "vkDestroyBufferView"))
- {
+ if (!strcmp(name, "vkDestroyBufferView")) {
return (void*)entry_vkDestroyBufferView;
}
- if (!strcmp(name, "vkCreateImage"))
- {
+ if (!strcmp(name, "vkCreateImage")) {
return (void*)entry_vkCreateImage;
}
- if (!strcmp(name, "vkDestroyImage"))
- {
+ if (!strcmp(name, "vkDestroyImage")) {
return (void*)entry_vkDestroyImage;
}
- if (!strcmp(name, "vkGetImageSubresourceLayout"))
- {
+ if (!strcmp(name, "vkGetImageSubresourceLayout")) {
return (void*)entry_vkGetImageSubresourceLayout;
}
- if (!strcmp(name, "vkCreateImageView"))
- {
+ if (!strcmp(name, "vkCreateImageView")) {
return (void*)entry_vkCreateImageView;
}
- if (!strcmp(name, "vkDestroyImageView"))
- {
+ if (!strcmp(name, "vkDestroyImageView")) {
return (void*)entry_vkDestroyImageView;
}
- if (!strcmp(name, "vkCreateShaderModule"))
- {
+ if (!strcmp(name, "vkCreateShaderModule")) {
return (void*)entry_vkCreateShaderModule;
}
- if (!strcmp(name, "vkDestroyShaderModule"))
- {
+ if (!strcmp(name, "vkDestroyShaderModule")) {
return (void*)entry_vkDestroyShaderModule;
}
- if (!strcmp(name, "vkCreatePipelineCache"))
- {
+ if (!strcmp(name, "vkCreatePipelineCache")) {
return (void*)entry_vkCreatePipelineCache;
}
- if (!strcmp(name, "vkDestroyPipelineCache"))
- {
+ if (!strcmp(name, "vkDestroyPipelineCache")) {
return (void*)entry_vkDestroyPipelineCache;
}
- if (!strcmp(name, "vkGetPipelineCacheData"))
- {
+ if (!strcmp(name, "vkGetPipelineCacheData")) {
return (void*)entry_vkGetPipelineCacheData;
}
- if (!strcmp(name, "vkMergePipelineCaches"))
- {
+ if (!strcmp(name, "vkMergePipelineCaches")) {
return (void*)entry_vkMergePipelineCaches;
}
- if (!strcmp(name, "vkCreateGraphicsPipelines"))
- {
+ if (!strcmp(name, "vkCreateGraphicsPipelines")) {
return (void*)entry_vkCreateGraphicsPipelines;
}
- if (!strcmp(name, "vkCreateComputePipelines"))
- {
+ if (!strcmp(name, "vkCreateComputePipelines")) {
return (void*)entry_vkCreateComputePipelines;
}
- if (!strcmp(name, "vkDestroyPipeline"))
- {
+ if (!strcmp(name, "vkDestroyPipeline")) {
return (void*)entry_vkDestroyPipeline;
}
- if (!strcmp(name, "vkCreatePipelineLayout"))
- {
+ if (!strcmp(name, "vkCreatePipelineLayout")) {
return (void*)entry_vkCreatePipelineLayout;
}
- if (!strcmp(name, "vkDestroyPipelineLayout"))
- {
+ if (!strcmp(name, "vkDestroyPipelineLayout")) {
return (void*)entry_vkDestroyPipelineLayout;
}
- if (!strcmp(name, "vkCreateSampler"))
- {
+ if (!strcmp(name, "vkCreateSampler")) {
return (void*)entry_vkCreateSampler;
}
- if (!strcmp(name, "vkDestroySampler"))
- {
+ if (!strcmp(name, "vkDestroySampler")) {
return (void*)entry_vkDestroySampler;
}
- if (!strcmp(name, "vkCreateDescriptorSetLayout"))
- {
+ if (!strcmp(name, "vkCreateDescriptorSetLayout")) {
return (void*)entry_vkCreateDescriptorSetLayout;
}
- if (!strcmp(name, "vkDestroyDescriptorSetLayout"))
- {
+ if (!strcmp(name, "vkDestroyDescriptorSetLayout")) {
return (void*)entry_vkDestroyDescriptorSetLayout;
}
- if (!strcmp(name, "vkCreateDescriptorPool"))
- {
+ if (!strcmp(name, "vkCreateDescriptorPool")) {
return (void*)entry_vkCreateDescriptorPool;
}
- if (!strcmp(name, "vkDestroyDescriptorPool"))
- {
+ if (!strcmp(name, "vkDestroyDescriptorPool")) {
return (void*)entry_vkDestroyDescriptorPool;
}
- if (!strcmp(name, "vkResetDescriptorPool"))
- {
+ if (!strcmp(name, "vkResetDescriptorPool")) {
return (void*)entry_vkResetDescriptorPool;
}
- if (!strcmp(name, "vkAllocateDescriptorSets"))
- {
+ if (!strcmp(name, "vkAllocateDescriptorSets")) {
return (void*)entry_vkAllocateDescriptorSets;
}
- if (!strcmp(name, "vkFreeDescriptorSets"))
- {
+ if (!strcmp(name, "vkFreeDescriptorSets")) {
return (void*)entry_vkFreeDescriptorSets;
}
- if (!strcmp(name, "vkUpdateDescriptorSets"))
- {
+ if (!strcmp(name, "vkUpdateDescriptorSets")) {
return (void*)entry_vkUpdateDescriptorSets;
}
- if (!strcmp(name, "vkCreateFramebuffer"))
- {
+ if (!strcmp(name, "vkCreateFramebuffer")) {
return (void*)entry_vkCreateFramebuffer;
}
- if (!strcmp(name, "vkDestroyFramebuffer"))
- {
+ if (!strcmp(name, "vkDestroyFramebuffer")) {
return (void*)entry_vkDestroyFramebuffer;
}
- if (!strcmp(name, "vkCreateRenderPass"))
- {
+ if (!strcmp(name, "vkCreateRenderPass")) {
return (void*)entry_vkCreateRenderPass;
}
- if (!strcmp(name, "vkDestroyRenderPass"))
- {
+ if (!strcmp(name, "vkDestroyRenderPass")) {
return (void*)entry_vkDestroyRenderPass;
}
- if (!strcmp(name, "vkGetRenderAreaGranularity"))
- {
+ if (!strcmp(name, "vkGetRenderAreaGranularity")) {
return (void*)entry_vkGetRenderAreaGranularity;
}
- if (!strcmp(name, "vkCreateCommandPool"))
- {
+ if (!strcmp(name, "vkCreateCommandPool")) {
return (void*)entry_vkCreateCommandPool;
}
- if (!strcmp(name, "vkDestroyCommandPool"))
- {
+ if (!strcmp(name, "vkDestroyCommandPool")) {
return (void*)entry_vkDestroyCommandPool;
}
- if (!strcmp(name, "vkResetCommandPool"))
- {
+ if (!strcmp(name, "vkResetCommandPool")) {
return (void*)entry_vkResetCommandPool;
}
- if (!strcmp(name, "vkAllocateCommandBuffers"))
- {
+ if (!strcmp(name, "vkAllocateCommandBuffers")) {
return (void*)entry_vkAllocateCommandBuffers;
}
- if (!strcmp(name, "vkFreeCommandBuffers"))
- {
+ if (!strcmp(name, "vkFreeCommandBuffers")) {
return (void*)entry_vkFreeCommandBuffers;
}
- if (!strcmp(name, "vkBeginCommandBuffer"))
- {
+ if (!strcmp(name, "vkBeginCommandBuffer")) {
return (void*)entry_vkBeginCommandBuffer;
}
- if (!strcmp(name, "vkEndCommandBuffer"))
- {
+ if (!strcmp(name, "vkEndCommandBuffer")) {
return (void*)entry_vkEndCommandBuffer;
}
- if (!strcmp(name, "vkResetCommandBuffer"))
- {
+ if (!strcmp(name, "vkResetCommandBuffer")) {
return (void*)entry_vkResetCommandBuffer;
}
- if (!strcmp(name, "vkCmdBindPipeline"))
- {
+ if (!strcmp(name, "vkCmdBindPipeline")) {
return (void*)entry_vkCmdBindPipeline;
}
- if (!strcmp(name, "vkCmdSetViewport"))
- {
+ if (!strcmp(name, "vkCmdSetViewport")) {
return (void*)entry_vkCmdSetViewport;
}
- if (!strcmp(name, "vkCmdSetScissor"))
- {
+ if (!strcmp(name, "vkCmdSetScissor")) {
return (void*)entry_vkCmdSetScissor;
}
- if (!strcmp(name, "vkCmdSetLineWidth"))
- {
+ if (!strcmp(name, "vkCmdSetLineWidth")) {
return (void*)entry_vkCmdSetLineWidth;
}
- if (!strcmp(name, "vkCmdSetDepthBias"))
- {
+ if (!strcmp(name, "vkCmdSetDepthBias")) {
return (void*)entry_vkCmdSetDepthBias;
}
- if (!strcmp(name, "vkCmdSetBlendConstants"))
- {
+ if (!strcmp(name, "vkCmdSetBlendConstants")) {
return (void*)entry_vkCmdSetBlendConstants;
}
- if (!strcmp(name, "vkCmdSetDepthBounds"))
- {
+ if (!strcmp(name, "vkCmdSetDepthBounds")) {
return (void*)entry_vkCmdSetDepthBounds;
}
- if (!strcmp(name, "vkCmdSetStencilCompareMask"))
- {
+ if (!strcmp(name, "vkCmdSetStencilCompareMask")) {
return (void*)entry_vkCmdSetStencilCompareMask;
}
- if (!strcmp(name, "vkCmdSetStencilWriteMask"))
- {
+ if (!strcmp(name, "vkCmdSetStencilWriteMask")) {
return (void*)entry_vkCmdSetStencilWriteMask;
}
- if (!strcmp(name, "vkCmdSetStencilReference"))
- {
+ if (!strcmp(name, "vkCmdSetStencilReference")) {
return (void*)entry_vkCmdSetStencilReference;
}
- if (!strcmp(name, "vkCmdBindDescriptorSets"))
- {
+ if (!strcmp(name, "vkCmdBindDescriptorSets")) {
return (void*)entry_vkCmdBindDescriptorSets;
}
- if (!strcmp(name, "vkCmdBindIndexBuffer"))
- {
+ if (!strcmp(name, "vkCmdBindIndexBuffer")) {
return (void*)entry_vkCmdBindIndexBuffer;
}
- if (!strcmp(name, "vkCmdBindVertexBuffers"))
- {
+ if (!strcmp(name, "vkCmdBindVertexBuffers")) {
return (void*)entry_vkCmdBindVertexBuffers;
}
- if (!strcmp(name, "vkCmdDraw"))
- {
+ if (!strcmp(name, "vkCmdDraw")) {
return (void*)entry_vkCmdDraw;
}
- if (!strcmp(name, "vkCmdDrawIndexed"))
- {
+ if (!strcmp(name, "vkCmdDrawIndexed")) {
return (void*)entry_vkCmdDrawIndexed;
}
- if (!strcmp(name, "vkCmdDrawIndirect"))
- {
+ if (!strcmp(name, "vkCmdDrawIndirect")) {
return (void*)entry_vkCmdDrawIndirect;
}
- if (!strcmp(name, "vkCmdDrawIndexedIndirect"))
- {
+ if (!strcmp(name, "vkCmdDrawIndexedIndirect")) {
return (void*)entry_vkCmdDrawIndexedIndirect;
}
- if (!strcmp(name, "vkCmdDispatch"))
- {
+ if (!strcmp(name, "vkCmdDispatch")) {
return (void*)entry_vkCmdDispatch;
}
- if (!strcmp(name, "vkCmdDispatchIndirect"))
- {
+ if (!strcmp(name, "vkCmdDispatchIndirect")) {
return (void*)entry_vkCmdDispatchIndirect;
}
- if (!strcmp(name, "vkCmdCopyBuffer"))
- {
+ if (!strcmp(name, "vkCmdCopyBuffer")) {
return (void*)entry_vkCmdCopyBuffer;
}
- if (!strcmp(name, "vkCmdCopyImage"))
- {
+ if (!strcmp(name, "vkCmdCopyImage")) {
return (void*)entry_vkCmdCopyImage;
}
- if (!strcmp(name, "vkCmdBlitImage"))
- {
+ if (!strcmp(name, "vkCmdBlitImage")) {
return (void*)entry_vkCmdBlitImage;
}
- if (!strcmp(name, "vkCmdCopyBufferToImage"))
- {
+ if (!strcmp(name, "vkCmdCopyBufferToImage")) {
return (void*)entry_vkCmdCopyBufferToImage;
}
- if (!strcmp(name, "vkCmdCopyImageToBuffer"))
- {
+ if (!strcmp(name, "vkCmdCopyImageToBuffer")) {
return (void*)entry_vkCmdCopyImageToBuffer;
}
- if (!strcmp(name, "vkCmdUpdateBuffer"))
- {
+ if (!strcmp(name, "vkCmdUpdateBuffer")) {
return (void*)entry_vkCmdUpdateBuffer;
}
- if (!strcmp(name, "vkCmdFillBuffer"))
- {
+ if (!strcmp(name, "vkCmdFillBuffer")) {
return (void*)entry_vkCmdFillBuffer;
}
- if (!strcmp(name, "vkCmdClearColorImage"))
- {
+ if (!strcmp(name, "vkCmdClearColorImage")) {
return (void*)entry_vkCmdClearColorImage;
}
- if (!strcmp(name, "vkCmdClearDepthStencilImage"))
- {
+ if (!strcmp(name, "vkCmdClearDepthStencilImage")) {
return (void*)entry_vkCmdClearDepthStencilImage;
}
- if (!strcmp(name, "vkCmdClearAttachments"))
- {
+ if (!strcmp(name, "vkCmdClearAttachments")) {
return (void*)entry_vkCmdClearAttachments;
}
- if (!strcmp(name, "vkCmdResolveImage"))
- {
+ if (!strcmp(name, "vkCmdResolveImage")) {
return (void*)entry_vkCmdResolveImage;
}
- if (!strcmp(name, "vkCmdSetEvent"))
- {
+ if (!strcmp(name, "vkCmdSetEvent")) {
return (void*)entry_vkCmdSetEvent;
}
- if (!strcmp(name, "vkCmdResetEvent"))
- {
+ if (!strcmp(name, "vkCmdResetEvent")) {
return (void*)entry_vkCmdResetEvent;
}
- if (!strcmp(name, "vkCmdWaitEvents"))
- {
+ if (!strcmp(name, "vkCmdWaitEvents")) {
return (void*)entry_vkCmdWaitEvents;
}
- if (!strcmp(name, "vkCmdPipelineBarrier"))
- {
+ if (!strcmp(name, "vkCmdPipelineBarrier")) {
return (void*)entry_vkCmdPipelineBarrier;
}
- if (!strcmp(name, "vkCmdBeginQuery"))
- {
+ if (!strcmp(name, "vkCmdBeginQuery")) {
return (void*)entry_vkCmdBeginQuery;
}
- if (!strcmp(name, "vkCmdEndQuery"))
- {
+ if (!strcmp(name, "vkCmdEndQuery")) {
return (void*)entry_vkCmdEndQuery;
}
- if (!strcmp(name, "vkCmdResetQueryPool"))
- {
+ if (!strcmp(name, "vkCmdResetQueryPool")) {
return (void*)entry_vkCmdResetQueryPool;
}
- if (!strcmp(name, "vkCmdWriteTimestamp"))
- {
+ if (!strcmp(name, "vkCmdWriteTimestamp")) {
return (void*)entry_vkCmdWriteTimestamp;
}
- if (!strcmp(name, "vkCmdCopyQueryPoolResults"))
- {
+ if (!strcmp(name, "vkCmdCopyQueryPoolResults")) {
return (void*)entry_vkCmdCopyQueryPoolResults;
}
- if (!strcmp(name, "vkCmdPushConstants"))
- {
+ if (!strcmp(name, "vkCmdPushConstants")) {
return (void*)entry_vkCmdPushConstants;
}
- if (!strcmp(name, "vkCmdBeginRenderPass"))
- {
+ if (!strcmp(name, "vkCmdBeginRenderPass")) {
return (void*)entry_vkCmdBeginRenderPass;
}
- if (!strcmp(name, "vkCmdNextSubpass"))
- {
+ if (!strcmp(name, "vkCmdNextSubpass")) {
return (void*)entry_vkCmdNextSubpass;
}
- if (!strcmp(name, "vkCmdEndRenderPass"))
- {
+ if (!strcmp(name, "vkCmdEndRenderPass")) {
return (void*)entry_vkCmdEndRenderPass;
}
- if (!strcmp(name, "vkCmdExecuteCommands"))
- {
+ if (!strcmp(name, "vkCmdExecuteCommands")) {
return (void*)entry_vkCmdExecuteCommands;
}
#endif
#ifdef VK_VERSION_1_1
- if (!strcmp(name, "vkEnumerateInstanceVersion"))
- {
+ if (!strcmp(name, "vkEnumerateInstanceVersion")) {
return has1_1OrHigher ? (void*)entry_vkEnumerateInstanceVersion : nullptr;
}
- if (!strcmp(name, "vkBindBufferMemory2"))
- {
+ if (!strcmp(name, "vkBindBufferMemory2")) {
return (void*)dynCheck_entry_vkBindBufferMemory2;
}
- if (!strcmp(name, "vkBindImageMemory2"))
- {
+ if (!strcmp(name, "vkBindImageMemory2")) {
return (void*)dynCheck_entry_vkBindImageMemory2;
}
- if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures"))
- {
+ if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures")) {
return (void*)dynCheck_entry_vkGetDeviceGroupPeerMemoryFeatures;
}
- if (!strcmp(name, "vkCmdSetDeviceMask"))
- {
- return (void*)dynCheck_entry_vkCmdSetDeviceMask;
+ if (!strcmp(name, "vkCmdSetDeviceMask")) {
+ return has1_1OrHigher ? (void*)entry_vkCmdSetDeviceMask : nullptr;
}
- if (!strcmp(name, "vkCmdDispatchBase"))
- {
- return (void*)dynCheck_entry_vkCmdDispatchBase;
+ if (!strcmp(name, "vkCmdDispatchBase")) {
+ return has1_1OrHigher ? (void*)entry_vkCmdDispatchBase : nullptr;
}
- if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups"))
- {
+ if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups")) {
return nullptr;
}
- if (!strcmp(name, "vkGetImageMemoryRequirements2"))
- {
+ if (!strcmp(name, "vkGetImageMemoryRequirements2")) {
return (void*)dynCheck_entry_vkGetImageMemoryRequirements2;
}
- if (!strcmp(name, "vkGetBufferMemoryRequirements2"))
- {
+ if (!strcmp(name, "vkGetBufferMemoryRequirements2")) {
return (void*)dynCheck_entry_vkGetBufferMemoryRequirements2;
}
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements2"))
- {
+ if (!strcmp(name, "vkGetImageSparseMemoryRequirements2")) {
return (void*)dynCheck_entry_vkGetImageSparseMemoryRequirements2;
}
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures2"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceFeatures2")) {
return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFeatures2 : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceProperties2"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceProperties2")) {
return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceProperties2 : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2")) {
return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFormatProperties2 : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2")) {
return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2 : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2")) {
return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2 : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2")) {
return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2 : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2"))
- {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2 : nullptr;
+ if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2")) {
+ return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2
+ : nullptr;
}
- if (!strcmp(name, "vkTrimCommandPool"))
- {
+ if (!strcmp(name, "vkTrimCommandPool")) {
return (void*)dynCheck_entry_vkTrimCommandPool;
}
- if (!strcmp(name, "vkGetDeviceQueue2"))
- {
+ if (!strcmp(name, "vkGetDeviceQueue2")) {
return (void*)dynCheck_entry_vkGetDeviceQueue2;
}
- if (!strcmp(name, "vkCreateSamplerYcbcrConversion"))
- {
+ if (!strcmp(name, "vkCreateSamplerYcbcrConversion")) {
return (void*)dynCheck_entry_vkCreateSamplerYcbcrConversion;
}
- if (!strcmp(name, "vkDestroySamplerYcbcrConversion"))
- {
+ if (!strcmp(name, "vkDestroySamplerYcbcrConversion")) {
return (void*)dynCheck_entry_vkDestroySamplerYcbcrConversion;
}
- if (!strcmp(name, "vkCreateDescriptorUpdateTemplate"))
- {
+ if (!strcmp(name, "vkCreateDescriptorUpdateTemplate")) {
return (void*)dynCheck_entry_vkCreateDescriptorUpdateTemplate;
}
- if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate"))
- {
+ if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate")) {
return (void*)dynCheck_entry_vkDestroyDescriptorUpdateTemplate;
}
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate"))
- {
+ if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate")) {
return (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplate;
}
- if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties")) {
return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalBufferProperties : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties")) {
return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalFenceProperties : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties"))
- {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalSemaphoreProperties : nullptr;
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties")) {
+ return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalSemaphoreProperties
+ : nullptr;
}
- if (!strcmp(name, "vkGetDescriptorSetLayoutSupport"))
- {
+ if (!strcmp(name, "vkGetDescriptorSetLayoutSupport")) {
return (void*)dynCheck_entry_vkGetDescriptorSetLayoutSupport;
}
#endif
#ifdef VK_VERSION_1_2
- if (!strcmp(name, "vkCmdDrawIndirectCount"))
- {
- return (void*)dynCheck_entry_vkCmdDrawIndirectCount;
+ if (!strcmp(name, "vkCmdDrawIndirectCount")) {
+ return has1_2OrHigher ? (void*)entry_vkCmdDrawIndirectCount : nullptr;
}
- if (!strcmp(name, "vkCmdDrawIndexedIndirectCount"))
- {
- return (void*)dynCheck_entry_vkCmdDrawIndexedIndirectCount;
+ if (!strcmp(name, "vkCmdDrawIndexedIndirectCount")) {
+ return has1_2OrHigher ? (void*)entry_vkCmdDrawIndexedIndirectCount : nullptr;
}
- if (!strcmp(name, "vkCreateRenderPass2"))
- {
+ if (!strcmp(name, "vkCreateRenderPass2")) {
return (void*)dynCheck_entry_vkCreateRenderPass2;
}
- if (!strcmp(name, "vkCmdBeginRenderPass2"))
- {
- return (void*)dynCheck_entry_vkCmdBeginRenderPass2;
+ if (!strcmp(name, "vkCmdBeginRenderPass2")) {
+ return has1_2OrHigher ? (void*)entry_vkCmdBeginRenderPass2 : nullptr;
}
- if (!strcmp(name, "vkCmdNextSubpass2"))
- {
- return (void*)dynCheck_entry_vkCmdNextSubpass2;
+ if (!strcmp(name, "vkCmdNextSubpass2")) {
+ return has1_2OrHigher ? (void*)entry_vkCmdNextSubpass2 : nullptr;
}
- if (!strcmp(name, "vkCmdEndRenderPass2"))
- {
- return (void*)dynCheck_entry_vkCmdEndRenderPass2;
+ if (!strcmp(name, "vkCmdEndRenderPass2")) {
+ return has1_2OrHigher ? (void*)entry_vkCmdEndRenderPass2 : nullptr;
}
- if (!strcmp(name, "vkResetQueryPool"))
- {
+ if (!strcmp(name, "vkResetQueryPool")) {
return (void*)dynCheck_entry_vkResetQueryPool;
}
- if (!strcmp(name, "vkGetSemaphoreCounterValue"))
- {
+ if (!strcmp(name, "vkGetSemaphoreCounterValue")) {
return (void*)dynCheck_entry_vkGetSemaphoreCounterValue;
}
- if (!strcmp(name, "vkWaitSemaphores"))
- {
+ if (!strcmp(name, "vkWaitSemaphores")) {
return (void*)dynCheck_entry_vkWaitSemaphores;
}
- if (!strcmp(name, "vkSignalSemaphore"))
- {
+ if (!strcmp(name, "vkSignalSemaphore")) {
return (void*)dynCheck_entry_vkSignalSemaphore;
}
- if (!strcmp(name, "vkGetBufferDeviceAddress"))
- {
+ if (!strcmp(name, "vkGetBufferDeviceAddress")) {
return (void*)dynCheck_entry_vkGetBufferDeviceAddress;
}
- if (!strcmp(name, "vkGetBufferOpaqueCaptureAddress"))
- {
+ if (!strcmp(name, "vkGetBufferOpaqueCaptureAddress")) {
return (void*)dynCheck_entry_vkGetBufferOpaqueCaptureAddress;
}
- if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddress"))
- {
+ if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddress")) {
return (void*)dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddress;
}
#endif
#ifdef VK_KHR_surface
- if (!strcmp(name, "vkDestroySurfaceKHR"))
- {
+ if (!strcmp(name, "vkDestroySurfaceKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_surface");
return hasExt ? (void*)entry_vkDestroySurfaceKHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSurfaceSupportKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceSupportKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_surface");
return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceSupportKHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_surface");
return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceCapabilitiesKHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormatsKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormatsKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_surface");
return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceFormatsKHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSurfacePresentModesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfacePresentModesKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_surface");
return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfacePresentModesKHR : nullptr;
}
#endif
#ifdef VK_KHR_swapchain
- if (!strcmp(name, "vkCreateSwapchainKHR"))
- {
+ if (!strcmp(name, "vkCreateSwapchainKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCreateSwapchainKHR;
}
- if (!strcmp(name, "vkDestroySwapchainKHR"))
- {
+ if (!strcmp(name, "vkDestroySwapchainKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkDestroySwapchainKHR;
}
- if (!strcmp(name, "vkGetSwapchainImagesKHR"))
- {
+ if (!strcmp(name, "vkGetSwapchainImagesKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetSwapchainImagesKHR;
}
- if (!strcmp(name, "vkAcquireNextImageKHR"))
- {
+ if (!strcmp(name, "vkAcquireNextImageKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkAcquireNextImageKHR;
}
- if (!strcmp(name, "vkQueuePresentKHR"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_swapchain");
- return hasExt ? (void*)entry_vkQueuePresentKHR : nullptr;
+ if (!strcmp(name, "vkQueuePresentKHR")) {
+ // TODO(b/236246382): Check support for device extension;
+ return (void*)entry_vkQueuePresentKHR;
}
- if (!strcmp(name, "vkGetDeviceGroupPresentCapabilitiesKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceGroupPresentCapabilitiesKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetDeviceGroupPresentCapabilitiesKHR;
}
- if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModesKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModesKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetDeviceGroupSurfacePresentModesKHR;
}
- if (!strcmp(name, "vkGetPhysicalDevicePresentRectanglesKHR"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_swapchain");
- return hasExt ? (void*)entry_vkGetPhysicalDevicePresentRectanglesKHR : nullptr;
+ if (!strcmp(name, "vkGetPhysicalDevicePresentRectanglesKHR")) {
+ // TODO(b/236246382): Check support for device extension;
+ return (void*)entry_vkGetPhysicalDevicePresentRectanglesKHR;
}
- if (!strcmp(name, "vkAcquireNextImage2KHR"))
- {
+ if (!strcmp(name, "vkAcquireNextImage2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkAcquireNextImage2KHR;
}
#endif
#ifdef VK_KHR_display
- if (!strcmp(name, "vkGetPhysicalDeviceDisplayPropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayPropertiesKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_display");
return hasExt ? (void*)entry_vkGetPhysicalDeviceDisplayPropertiesKHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_display");
return hasExt ? (void*)entry_vkGetPhysicalDeviceDisplayPlanePropertiesKHR : nullptr;
}
- if (!strcmp(name, "vkGetDisplayPlaneSupportedDisplaysKHR"))
- {
+ if (!strcmp(name, "vkGetDisplayPlaneSupportedDisplaysKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_display");
return hasExt ? (void*)entry_vkGetDisplayPlaneSupportedDisplaysKHR : nullptr;
}
- if (!strcmp(name, "vkGetDisplayModePropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetDisplayModePropertiesKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_display");
return hasExt ? (void*)entry_vkGetDisplayModePropertiesKHR : nullptr;
}
- if (!strcmp(name, "vkCreateDisplayModeKHR"))
- {
+ if (!strcmp(name, "vkCreateDisplayModeKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_display");
return hasExt ? (void*)entry_vkCreateDisplayModeKHR : nullptr;
}
- if (!strcmp(name, "vkGetDisplayPlaneCapabilitiesKHR"))
- {
+ if (!strcmp(name, "vkGetDisplayPlaneCapabilitiesKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_display");
return hasExt ? (void*)entry_vkGetDisplayPlaneCapabilitiesKHR : nullptr;
}
- if (!strcmp(name, "vkCreateDisplayPlaneSurfaceKHR"))
- {
+ if (!strcmp(name, "vkCreateDisplayPlaneSurfaceKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_display");
return hasExt ? (void*)entry_vkCreateDisplayPlaneSurfaceKHR : nullptr;
}
#endif
#ifdef VK_KHR_display_swapchain
- if (!strcmp(name, "vkCreateSharedSwapchainsKHR"))
- {
+ if (!strcmp(name, "vkCreateSharedSwapchainsKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCreateSharedSwapchainsKHR;
}
#endif
#ifdef VK_KHR_xlib_surface
- if (!strcmp(name, "vkCreateXlibSurfaceKHR"))
- {
+ if (!strcmp(name, "vkCreateXlibSurfaceKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_xlib_surface");
return hasExt ? (void*)entry_vkCreateXlibSurfaceKHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceXlibPresentationSupportKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceXlibPresentationSupportKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_xlib_surface");
return hasExt ? (void*)entry_vkGetPhysicalDeviceXlibPresentationSupportKHR : nullptr;
}
#endif
#ifdef VK_KHR_xcb_surface
- if (!strcmp(name, "vkCreateXcbSurfaceKHR"))
- {
+ if (!strcmp(name, "vkCreateXcbSurfaceKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_xcb_surface");
return hasExt ? (void*)entry_vkCreateXcbSurfaceKHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceXcbPresentationSupportKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceXcbPresentationSupportKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_xcb_surface");
return hasExt ? (void*)entry_vkGetPhysicalDeviceXcbPresentationSupportKHR : nullptr;
}
#endif
#ifdef VK_KHR_wayland_surface
- if (!strcmp(name, "vkCreateWaylandSurfaceKHR"))
- {
+ if (!strcmp(name, "vkCreateWaylandSurfaceKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_wayland_surface");
return hasExt ? (void*)entry_vkCreateWaylandSurfaceKHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceWaylandPresentationSupportKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceWaylandPresentationSupportKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_wayland_surface");
return hasExt ? (void*)entry_vkGetPhysicalDeviceWaylandPresentationSupportKHR : nullptr;
}
#endif
#ifdef VK_KHR_android_surface
- if (!strcmp(name, "vkCreateAndroidSurfaceKHR"))
- {
+ if (!strcmp(name, "vkCreateAndroidSurfaceKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_android_surface");
return hasExt ? (void*)entry_vkCreateAndroidSurfaceKHR : nullptr;
}
#endif
#ifdef VK_KHR_win32_surface
- if (!strcmp(name, "vkCreateWin32SurfaceKHR"))
- {
+ if (!strcmp(name, "vkCreateWin32SurfaceKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_win32_surface");
return hasExt ? (void*)entry_vkCreateWin32SurfaceKHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceWin32PresentationSupportKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceWin32PresentationSupportKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_win32_surface");
return hasExt ? (void*)entry_vkGetPhysicalDeviceWin32PresentationSupportKHR : nullptr;
}
#endif
#ifdef VK_KHR_video_queue
- if (!strcmp(name, "vkGetPhysicalDeviceVideoCapabilitiesKHR"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_video_queue");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceVideoCapabilitiesKHR : nullptr;
+ if (!strcmp(name, "vkGetPhysicalDeviceVideoCapabilitiesKHR")) {
+ // TODO(b/236246382): Check support for device extension;
+ return (void*)entry_vkGetPhysicalDeviceVideoCapabilitiesKHR;
}
- if (!strcmp(name, "vkGetPhysicalDeviceVideoFormatPropertiesKHR"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_video_queue");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceVideoFormatPropertiesKHR : nullptr;
+ if (!strcmp(name, "vkGetPhysicalDeviceVideoFormatPropertiesKHR")) {
+ // TODO(b/236246382): Check support for device extension;
+ return (void*)entry_vkGetPhysicalDeviceVideoFormatPropertiesKHR;
}
- if (!strcmp(name, "vkCreateVideoSessionKHR"))
- {
+ if (!strcmp(name, "vkCreateVideoSessionKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCreateVideoSessionKHR;
}
- if (!strcmp(name, "vkDestroyVideoSessionKHR"))
- {
+ if (!strcmp(name, "vkDestroyVideoSessionKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkDestroyVideoSessionKHR;
}
- if (!strcmp(name, "vkGetVideoSessionMemoryRequirementsKHR"))
- {
+ if (!strcmp(name, "vkGetVideoSessionMemoryRequirementsKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetVideoSessionMemoryRequirementsKHR;
}
- if (!strcmp(name, "vkBindVideoSessionMemoryKHR"))
- {
+ if (!strcmp(name, "vkBindVideoSessionMemoryKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkBindVideoSessionMemoryKHR;
}
- if (!strcmp(name, "vkCreateVideoSessionParametersKHR"))
- {
+ if (!strcmp(name, "vkCreateVideoSessionParametersKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCreateVideoSessionParametersKHR;
}
- if (!strcmp(name, "vkUpdateVideoSessionParametersKHR"))
- {
+ if (!strcmp(name, "vkUpdateVideoSessionParametersKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkUpdateVideoSessionParametersKHR;
}
- if (!strcmp(name, "vkDestroyVideoSessionParametersKHR"))
- {
+ if (!strcmp(name, "vkDestroyVideoSessionParametersKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkDestroyVideoSessionParametersKHR;
}
- if (!strcmp(name, "vkCmdBeginVideoCodingKHR"))
- {
+ if (!strcmp(name, "vkCmdBeginVideoCodingKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdBeginVideoCodingKHR;
}
- if (!strcmp(name, "vkCmdEndVideoCodingKHR"))
- {
+ if (!strcmp(name, "vkCmdEndVideoCodingKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdEndVideoCodingKHR;
}
- if (!strcmp(name, "vkCmdControlVideoCodingKHR"))
- {
+ if (!strcmp(name, "vkCmdControlVideoCodingKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdControlVideoCodingKHR;
}
#endif
#ifdef VK_KHR_video_decode_queue
- if (!strcmp(name, "vkCmdDecodeVideoKHR"))
- {
+ if (!strcmp(name, "vkCmdDecodeVideoKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdDecodeVideoKHR;
}
#endif
#ifdef VK_KHR_dynamic_rendering
- if (!strcmp(name, "vkCmdBeginRenderingKHR"))
- {
+ if (!strcmp(name, "vkCmdBeginRenderingKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdBeginRenderingKHR;
}
- if (!strcmp(name, "vkCmdEndRenderingKHR"))
- {
+ if (!strcmp(name, "vkCmdEndRenderingKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdEndRenderingKHR;
}
#endif
#ifdef VK_KHR_get_physical_device_properties2
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
+ if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR")) {
+ bool hasExt =
+ resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceFeatures2KHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
+ if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR")) {
+ bool hasExt =
+ resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceProperties2KHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
+ if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR")) {
+ bool hasExt =
+ resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceFormatProperties2KHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
+ if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR")) {
+ bool hasExt =
+ resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2KHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
+ if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")) {
+ bool hasExt =
+ resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
+ if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR")) {
+ bool hasExt =
+ resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2KHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
+ if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")) {
+ bool hasExt =
+ resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR : nullptr;
}
#endif
#ifdef VK_KHR_device_group
- if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeaturesKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeaturesKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetDeviceGroupPeerMemoryFeaturesKHR;
}
- if (!strcmp(name, "vkCmdSetDeviceMaskKHR"))
- {
+ if (!strcmp(name, "vkCmdSetDeviceMaskKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetDeviceMaskKHR;
}
- if (!strcmp(name, "vkCmdDispatchBaseKHR"))
- {
+ if (!strcmp(name, "vkCmdDispatchBaseKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdDispatchBaseKHR;
}
#endif
#ifdef VK_KHR_maintenance1
- if (!strcmp(name, "vkTrimCommandPoolKHR"))
- {
+ if (!strcmp(name, "vkTrimCommandPoolKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkTrimCommandPoolKHR;
}
#endif
#ifdef VK_KHR_device_group_creation
- if (!strcmp(name, "vkEnumeratePhysicalDeviceGroupsKHR"))
- {
+ if (!strcmp(name, "vkEnumeratePhysicalDeviceGroupsKHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_device_group_creation");
return hasExt ? (void*)entry_vkEnumeratePhysicalDeviceGroupsKHR : nullptr;
}
#endif
#ifdef VK_KHR_external_memory_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_memory_capabilities");
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")) {
+ bool hasExt =
+ resources->hasInstanceExtension(instance, "VK_KHR_external_memory_capabilities");
return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR : nullptr;
}
#endif
#ifdef VK_KHR_external_memory_win32
- if (!strcmp(name, "vkGetMemoryWin32HandleKHR"))
- {
+ if (!strcmp(name, "vkGetMemoryWin32HandleKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetMemoryWin32HandleKHR;
}
- if (!strcmp(name, "vkGetMemoryWin32HandlePropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetMemoryWin32HandlePropertiesKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetMemoryWin32HandlePropertiesKHR;
}
#endif
#ifdef VK_KHR_external_memory_fd
- if (!strcmp(name, "vkGetMemoryFdKHR"))
- {
+ if (!strcmp(name, "vkGetMemoryFdKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetMemoryFdKHR;
}
- if (!strcmp(name, "vkGetMemoryFdPropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetMemoryFdPropertiesKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetMemoryFdPropertiesKHR;
}
#endif
#ifdef VK_KHR_external_semaphore_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_semaphore_capabilities");
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")) {
+ bool hasExt =
+ resources->hasInstanceExtension(instance, "VK_KHR_external_semaphore_capabilities");
return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR : nullptr;
}
#endif
#ifdef VK_KHR_external_semaphore_win32
- if (!strcmp(name, "vkImportSemaphoreWin32HandleKHR"))
- {
+ if (!strcmp(name, "vkImportSemaphoreWin32HandleKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkImportSemaphoreWin32HandleKHR;
}
- if (!strcmp(name, "vkGetSemaphoreWin32HandleKHR"))
- {
+ if (!strcmp(name, "vkGetSemaphoreWin32HandleKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetSemaphoreWin32HandleKHR;
}
#endif
#ifdef VK_KHR_external_semaphore_fd
- if (!strcmp(name, "vkImportSemaphoreFdKHR"))
- {
+ if (!strcmp(name, "vkImportSemaphoreFdKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkImportSemaphoreFdKHR;
}
- if (!strcmp(name, "vkGetSemaphoreFdKHR"))
- {
+ if (!strcmp(name, "vkGetSemaphoreFdKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetSemaphoreFdKHR;
}
#endif
#ifdef VK_KHR_push_descriptor
- if (!strcmp(name, "vkCmdPushDescriptorSetKHR"))
- {
+ if (!strcmp(name, "vkCmdPushDescriptorSetKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdPushDescriptorSetKHR;
}
- if (!strcmp(name, "vkCmdPushDescriptorSetWithTemplateKHR"))
- {
+ if (!strcmp(name, "vkCmdPushDescriptorSetWithTemplateKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdPushDescriptorSetWithTemplateKHR;
}
#endif
#ifdef VK_KHR_descriptor_update_template
- if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR"))
- {
+ if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCreateDescriptorUpdateTemplateKHR;
}
- if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR"))
- {
+ if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkDestroyDescriptorUpdateTemplateKHR;
}
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR"))
- {
+ if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplateKHR;
}
#endif
#ifdef VK_KHR_create_renderpass2
- if (!strcmp(name, "vkCreateRenderPass2KHR"))
- {
+ if (!strcmp(name, "vkCreateRenderPass2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCreateRenderPass2KHR;
}
- if (!strcmp(name, "vkCmdBeginRenderPass2KHR"))
- {
+ if (!strcmp(name, "vkCmdBeginRenderPass2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdBeginRenderPass2KHR;
}
- if (!strcmp(name, "vkCmdNextSubpass2KHR"))
- {
+ if (!strcmp(name, "vkCmdNextSubpass2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdNextSubpass2KHR;
}
- if (!strcmp(name, "vkCmdEndRenderPass2KHR"))
- {
+ if (!strcmp(name, "vkCmdEndRenderPass2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdEndRenderPass2KHR;
}
#endif
#ifdef VK_KHR_shared_presentable_image
- if (!strcmp(name, "vkGetSwapchainStatusKHR"))
- {
+ if (!strcmp(name, "vkGetSwapchainStatusKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetSwapchainStatusKHR;
}
#endif
#ifdef VK_KHR_external_fence_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_fence_capabilities");
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR")) {
+ bool hasExt =
+ resources->hasInstanceExtension(instance, "VK_KHR_external_fence_capabilities");
return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalFencePropertiesKHR : nullptr;
}
#endif
#ifdef VK_KHR_external_fence_win32
- if (!strcmp(name, "vkImportFenceWin32HandleKHR"))
- {
+ if (!strcmp(name, "vkImportFenceWin32HandleKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkImportFenceWin32HandleKHR;
}
- if (!strcmp(name, "vkGetFenceWin32HandleKHR"))
- {
+ if (!strcmp(name, "vkGetFenceWin32HandleKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetFenceWin32HandleKHR;
}
#endif
#ifdef VK_KHR_external_fence_fd
- if (!strcmp(name, "vkImportFenceFdKHR"))
- {
+ if (!strcmp(name, "vkImportFenceFdKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkImportFenceFdKHR;
}
- if (!strcmp(name, "vkGetFenceFdKHR"))
- {
+ if (!strcmp(name, "vkGetFenceFdKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetFenceFdKHR;
}
#endif
#ifdef VK_KHR_performance_query
- if (!strcmp(name, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_performance_query");
- return hasExt ? (void*)entry_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR : nullptr;
+ if (!strcmp(name, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR")) {
+ // TODO(b/236246382): Check support for device extension;
+ return (void*)entry_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR;
}
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_performance_query");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR : nullptr;
+ if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR")) {
+ // TODO(b/236246382): Check support for device extension;
+ return (void*)entry_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR;
}
- if (!strcmp(name, "vkAcquireProfilingLockKHR"))
- {
+ if (!strcmp(name, "vkAcquireProfilingLockKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkAcquireProfilingLockKHR;
}
- if (!strcmp(name, "vkReleaseProfilingLockKHR"))
- {
+ if (!strcmp(name, "vkReleaseProfilingLockKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkReleaseProfilingLockKHR;
}
#endif
#ifdef VK_KHR_get_surface_capabilities2
- if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2KHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2KHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_surface_capabilities2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceCapabilities2KHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormats2KHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormats2KHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_surface_capabilities2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceFormats2KHR : nullptr;
}
#endif
#ifdef VK_KHR_get_display_properties2
- if (!strcmp(name, "vkGetPhysicalDeviceDisplayProperties2KHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayProperties2KHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_display_properties2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceDisplayProperties2KHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_display_properties2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceDisplayPlaneProperties2KHR : nullptr;
}
- if (!strcmp(name, "vkGetDisplayModeProperties2KHR"))
- {
+ if (!strcmp(name, "vkGetDisplayModeProperties2KHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_display_properties2");
return hasExt ? (void*)entry_vkGetDisplayModeProperties2KHR : nullptr;
}
- if (!strcmp(name, "vkGetDisplayPlaneCapabilities2KHR"))
- {
+ if (!strcmp(name, "vkGetDisplayPlaneCapabilities2KHR")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_display_properties2");
return hasExt ? (void*)entry_vkGetDisplayPlaneCapabilities2KHR : nullptr;
}
#endif
#ifdef VK_KHR_get_memory_requirements2
- if (!strcmp(name, "vkGetImageMemoryRequirements2KHR"))
- {
+ if (!strcmp(name, "vkGetImageMemoryRequirements2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetImageMemoryRequirements2KHR;
}
- if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR"))
- {
+ if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetBufferMemoryRequirements2KHR;
}
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR"))
- {
+ if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetImageSparseMemoryRequirements2KHR;
}
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
- if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR"))
- {
+ if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCreateSamplerYcbcrConversionKHR;
}
- if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR"))
- {
+ if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkDestroySamplerYcbcrConversionKHR;
}
#endif
#ifdef VK_KHR_bind_memory2
- if (!strcmp(name, "vkBindBufferMemory2KHR"))
- {
+ if (!strcmp(name, "vkBindBufferMemory2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkBindBufferMemory2KHR;
}
- if (!strcmp(name, "vkBindImageMemory2KHR"))
- {
+ if (!strcmp(name, "vkBindImageMemory2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkBindImageMemory2KHR;
}
#endif
#ifdef VK_KHR_maintenance3
- if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR"))
- {
+ if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetDescriptorSetLayoutSupportKHR;
}
#endif
#ifdef VK_KHR_draw_indirect_count
- if (!strcmp(name, "vkCmdDrawIndirectCountKHR"))
- {
+ if (!strcmp(name, "vkCmdDrawIndirectCountKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdDrawIndirectCountKHR;
}
- if (!strcmp(name, "vkCmdDrawIndexedIndirectCountKHR"))
- {
+ if (!strcmp(name, "vkCmdDrawIndexedIndirectCountKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdDrawIndexedIndirectCountKHR;
}
#endif
#ifdef VK_KHR_timeline_semaphore
- if (!strcmp(name, "vkGetSemaphoreCounterValueKHR"))
- {
+ if (!strcmp(name, "vkGetSemaphoreCounterValueKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetSemaphoreCounterValueKHR;
}
- if (!strcmp(name, "vkWaitSemaphoresKHR"))
- {
+ if (!strcmp(name, "vkWaitSemaphoresKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkWaitSemaphoresKHR;
}
- if (!strcmp(name, "vkSignalSemaphoreKHR"))
- {
+ if (!strcmp(name, "vkSignalSemaphoreKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkSignalSemaphoreKHR;
}
#endif
#ifdef VK_KHR_fragment_shading_rate
- if (!strcmp(name, "vkGetPhysicalDeviceFragmentShadingRatesKHR"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_fragment_shading_rate");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceFragmentShadingRatesKHR : nullptr;
+ if (!strcmp(name, "vkGetPhysicalDeviceFragmentShadingRatesKHR")) {
+ // TODO(b/236246382): Check support for device extension;
+ return (void*)entry_vkGetPhysicalDeviceFragmentShadingRatesKHR;
}
- if (!strcmp(name, "vkCmdSetFragmentShadingRateKHR"))
- {
+ if (!strcmp(name, "vkCmdSetFragmentShadingRateKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetFragmentShadingRateKHR;
}
#endif
#ifdef VK_KHR_present_wait
- if (!strcmp(name, "vkWaitForPresentKHR"))
- {
+ if (!strcmp(name, "vkWaitForPresentKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkWaitForPresentKHR;
}
#endif
#ifdef VK_KHR_buffer_device_address
- if (!strcmp(name, "vkGetBufferDeviceAddressKHR"))
- {
+ if (!strcmp(name, "vkGetBufferDeviceAddressKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetBufferDeviceAddressKHR;
}
- if (!strcmp(name, "vkGetBufferOpaqueCaptureAddressKHR"))
- {
+ if (!strcmp(name, "vkGetBufferOpaqueCaptureAddressKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetBufferOpaqueCaptureAddressKHR;
}
- if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddressKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddressKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddressKHR;
}
#endif
#ifdef VK_KHR_deferred_host_operations
- if (!strcmp(name, "vkCreateDeferredOperationKHR"))
- {
+ if (!strcmp(name, "vkCreateDeferredOperationKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCreateDeferredOperationKHR;
}
- if (!strcmp(name, "vkDestroyDeferredOperationKHR"))
- {
+ if (!strcmp(name, "vkDestroyDeferredOperationKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkDestroyDeferredOperationKHR;
}
- if (!strcmp(name, "vkGetDeferredOperationMaxConcurrencyKHR"))
- {
+ if (!strcmp(name, "vkGetDeferredOperationMaxConcurrencyKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetDeferredOperationMaxConcurrencyKHR;
}
- if (!strcmp(name, "vkGetDeferredOperationResultKHR"))
- {
+ if (!strcmp(name, "vkGetDeferredOperationResultKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetDeferredOperationResultKHR;
}
- if (!strcmp(name, "vkDeferredOperationJoinKHR"))
- {
+ if (!strcmp(name, "vkDeferredOperationJoinKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkDeferredOperationJoinKHR;
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
- if (!strcmp(name, "vkGetPipelineExecutablePropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetPipelineExecutablePropertiesKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetPipelineExecutablePropertiesKHR;
}
- if (!strcmp(name, "vkGetPipelineExecutableStatisticsKHR"))
- {
+ if (!strcmp(name, "vkGetPipelineExecutableStatisticsKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetPipelineExecutableStatisticsKHR;
}
- if (!strcmp(name, "vkGetPipelineExecutableInternalRepresentationsKHR"))
- {
+ if (!strcmp(name, "vkGetPipelineExecutableInternalRepresentationsKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetPipelineExecutableInternalRepresentationsKHR;
}
#endif
#ifdef VK_KHR_video_encode_queue
- if (!strcmp(name, "vkCmdEncodeVideoKHR"))
- {
+ if (!strcmp(name, "vkCmdEncodeVideoKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdEncodeVideoKHR;
}
#endif
#ifdef VK_KHR_synchronization2
- if (!strcmp(name, "vkCmdSetEvent2KHR"))
- {
+ if (!strcmp(name, "vkCmdSetEvent2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetEvent2KHR;
}
- if (!strcmp(name, "vkCmdResetEvent2KHR"))
- {
+ if (!strcmp(name, "vkCmdResetEvent2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdResetEvent2KHR;
}
- if (!strcmp(name, "vkCmdWaitEvents2KHR"))
- {
+ if (!strcmp(name, "vkCmdWaitEvents2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdWaitEvents2KHR;
}
- if (!strcmp(name, "vkCmdPipelineBarrier2KHR"))
- {
+ if (!strcmp(name, "vkCmdPipelineBarrier2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdPipelineBarrier2KHR;
}
- if (!strcmp(name, "vkCmdWriteTimestamp2KHR"))
- {
+ if (!strcmp(name, "vkCmdWriteTimestamp2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdWriteTimestamp2KHR;
}
- if (!strcmp(name, "vkQueueSubmit2KHR"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_synchronization2");
- return hasExt ? (void*)entry_vkQueueSubmit2KHR : nullptr;
+ if (!strcmp(name, "vkQueueSubmit2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
+ return (void*)entry_vkQueueSubmit2KHR;
}
- if (!strcmp(name, "vkCmdWriteBufferMarker2AMD"))
- {
+ if (!strcmp(name, "vkCmdWriteBufferMarker2AMD")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdWriteBufferMarker2AMD;
}
- if (!strcmp(name, "vkGetQueueCheckpointData2NV"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_synchronization2");
- return hasExt ? (void*)entry_vkGetQueueCheckpointData2NV : nullptr;
+ if (!strcmp(name, "vkGetQueueCheckpointData2NV")) {
+ // TODO(b/236246382): Check support for device extension;
+ return (void*)entry_vkGetQueueCheckpointData2NV;
}
#endif
#ifdef VK_KHR_copy_commands2
- if (!strcmp(name, "vkCmdCopyBuffer2KHR"))
- {
+ if (!strcmp(name, "vkCmdCopyBuffer2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdCopyBuffer2KHR;
}
- if (!strcmp(name, "vkCmdCopyImage2KHR"))
- {
+ if (!strcmp(name, "vkCmdCopyImage2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdCopyImage2KHR;
}
- if (!strcmp(name, "vkCmdCopyBufferToImage2KHR"))
- {
+ if (!strcmp(name, "vkCmdCopyBufferToImage2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdCopyBufferToImage2KHR;
}
- if (!strcmp(name, "vkCmdCopyImageToBuffer2KHR"))
- {
+ if (!strcmp(name, "vkCmdCopyImageToBuffer2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdCopyImageToBuffer2KHR;
}
- if (!strcmp(name, "vkCmdBlitImage2KHR"))
- {
+ if (!strcmp(name, "vkCmdBlitImage2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdBlitImage2KHR;
}
- if (!strcmp(name, "vkCmdResolveImage2KHR"))
- {
+ if (!strcmp(name, "vkCmdResolveImage2KHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdResolveImage2KHR;
}
#endif
#ifdef VK_KHR_maintenance4
- if (!strcmp(name, "vkGetDeviceBufferMemoryRequirementsKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceBufferMemoryRequirementsKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetDeviceBufferMemoryRequirementsKHR;
}
- if (!strcmp(name, "vkGetDeviceImageMemoryRequirementsKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceImageMemoryRequirementsKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetDeviceImageMemoryRequirementsKHR;
}
- if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirementsKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirementsKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetDeviceImageSparseMemoryRequirementsKHR;
}
#endif
#ifdef VK_ANDROID_native_buffer
- if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID"))
- {
+ if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetSwapchainGrallocUsageANDROID;
}
- if (!strcmp(name, "vkAcquireImageANDROID"))
- {
+ if (!strcmp(name, "vkAcquireImageANDROID")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkAcquireImageANDROID;
}
- if (!strcmp(name, "vkQueueSignalReleaseImageANDROID"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_ANDROID_native_buffer");
- return hasExt ? (void*)entry_vkQueueSignalReleaseImageANDROID : nullptr;
+ if (!strcmp(name, "vkQueueSignalReleaseImageANDROID")) {
+ // TODO(b/236246382): Check support for device extension;
+ return (void*)entry_vkQueueSignalReleaseImageANDROID;
}
#endif
#ifdef VK_EXT_debug_report
- if (!strcmp(name, "vkCreateDebugReportCallbackEXT"))
- {
+ if (!strcmp(name, "vkCreateDebugReportCallbackEXT")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_report");
return hasExt ? (void*)entry_vkCreateDebugReportCallbackEXT : nullptr;
}
- if (!strcmp(name, "vkDestroyDebugReportCallbackEXT"))
- {
+ if (!strcmp(name, "vkDestroyDebugReportCallbackEXT")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_report");
return hasExt ? (void*)entry_vkDestroyDebugReportCallbackEXT : nullptr;
}
- if (!strcmp(name, "vkDebugReportMessageEXT"))
- {
+ if (!strcmp(name, "vkDebugReportMessageEXT")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_report");
return hasExt ? (void*)entry_vkDebugReportMessageEXT : nullptr;
}
#endif
#ifdef VK_EXT_debug_marker
- if (!strcmp(name, "vkDebugMarkerSetObjectTagEXT"))
- {
+ if (!strcmp(name, "vkDebugMarkerSetObjectTagEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkDebugMarkerSetObjectTagEXT;
}
- if (!strcmp(name, "vkDebugMarkerSetObjectNameEXT"))
- {
+ if (!strcmp(name, "vkDebugMarkerSetObjectNameEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkDebugMarkerSetObjectNameEXT;
}
- if (!strcmp(name, "vkCmdDebugMarkerBeginEXT"))
- {
+ if (!strcmp(name, "vkCmdDebugMarkerBeginEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdDebugMarkerBeginEXT;
}
- if (!strcmp(name, "vkCmdDebugMarkerEndEXT"))
- {
+ if (!strcmp(name, "vkCmdDebugMarkerEndEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdDebugMarkerEndEXT;
}
- if (!strcmp(name, "vkCmdDebugMarkerInsertEXT"))
- {
+ if (!strcmp(name, "vkCmdDebugMarkerInsertEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdDebugMarkerInsertEXT;
}
#endif
#ifdef VK_EXT_transform_feedback
- if (!strcmp(name, "vkCmdBindTransformFeedbackBuffersEXT"))
- {
+ if (!strcmp(name, "vkCmdBindTransformFeedbackBuffersEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdBindTransformFeedbackBuffersEXT;
}
- if (!strcmp(name, "vkCmdBeginTransformFeedbackEXT"))
- {
+ if (!strcmp(name, "vkCmdBeginTransformFeedbackEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdBeginTransformFeedbackEXT;
}
- if (!strcmp(name, "vkCmdEndTransformFeedbackEXT"))
- {
+ if (!strcmp(name, "vkCmdEndTransformFeedbackEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdEndTransformFeedbackEXT;
}
- if (!strcmp(name, "vkCmdBeginQueryIndexedEXT"))
- {
+ if (!strcmp(name, "vkCmdBeginQueryIndexedEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdBeginQueryIndexedEXT;
}
- if (!strcmp(name, "vkCmdEndQueryIndexedEXT"))
- {
+ if (!strcmp(name, "vkCmdEndQueryIndexedEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdEndQueryIndexedEXT;
}
- if (!strcmp(name, "vkCmdDrawIndirectByteCountEXT"))
- {
+ if (!strcmp(name, "vkCmdDrawIndirectByteCountEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdDrawIndirectByteCountEXT;
}
#endif
#ifdef VK_NVX_binary_import
- if (!strcmp(name, "vkCreateCuModuleNVX"))
- {
+ if (!strcmp(name, "vkCreateCuModuleNVX")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCreateCuModuleNVX;
}
- if (!strcmp(name, "vkCreateCuFunctionNVX"))
- {
+ if (!strcmp(name, "vkCreateCuFunctionNVX")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCreateCuFunctionNVX;
}
- if (!strcmp(name, "vkDestroyCuModuleNVX"))
- {
+ if (!strcmp(name, "vkDestroyCuModuleNVX")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkDestroyCuModuleNVX;
}
- if (!strcmp(name, "vkDestroyCuFunctionNVX"))
- {
+ if (!strcmp(name, "vkDestroyCuFunctionNVX")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkDestroyCuFunctionNVX;
}
- if (!strcmp(name, "vkCmdCuLaunchKernelNVX"))
- {
+ if (!strcmp(name, "vkCmdCuLaunchKernelNVX")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdCuLaunchKernelNVX;
}
#endif
#ifdef VK_NVX_image_view_handle
- if (!strcmp(name, "vkGetImageViewHandleNVX"))
- {
+ if (!strcmp(name, "vkGetImageViewHandleNVX")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetImageViewHandleNVX;
}
- if (!strcmp(name, "vkGetImageViewAddressNVX"))
- {
+ if (!strcmp(name, "vkGetImageViewAddressNVX")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetImageViewAddressNVX;
}
#endif
#ifdef VK_AMD_draw_indirect_count
- if (!strcmp(name, "vkCmdDrawIndirectCountAMD"))
- {
+ if (!strcmp(name, "vkCmdDrawIndirectCountAMD")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdDrawIndirectCountAMD;
}
- if (!strcmp(name, "vkCmdDrawIndexedIndirectCountAMD"))
- {
+ if (!strcmp(name, "vkCmdDrawIndexedIndirectCountAMD")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdDrawIndexedIndirectCountAMD;
}
#endif
#ifdef VK_AMD_shader_info
- if (!strcmp(name, "vkGetShaderInfoAMD"))
- {
+ if (!strcmp(name, "vkGetShaderInfoAMD")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetShaderInfoAMD;
}
#endif
#ifdef VK_GGP_stream_descriptor_surface
- if (!strcmp(name, "vkCreateStreamDescriptorSurfaceGGP"))
- {
+ if (!strcmp(name, "vkCreateStreamDescriptorSurfaceGGP")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_GGP_stream_descriptor_surface");
return hasExt ? (void*)entry_vkCreateStreamDescriptorSurfaceGGP : nullptr;
}
#endif
#ifdef VK_NV_external_memory_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_NV_external_memory_capabilities");
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV")) {
+ bool hasExt =
+ resources->hasInstanceExtension(instance, "VK_NV_external_memory_capabilities");
return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalImageFormatPropertiesNV : nullptr;
}
#endif
#ifdef VK_NV_external_memory_win32
- if (!strcmp(name, "vkGetMemoryWin32HandleNV"))
- {
+ if (!strcmp(name, "vkGetMemoryWin32HandleNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetMemoryWin32HandleNV;
}
#endif
#ifdef VK_NN_vi_surface
- if (!strcmp(name, "vkCreateViSurfaceNN"))
- {
+ if (!strcmp(name, "vkCreateViSurfaceNN")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_NN_vi_surface");
return hasExt ? (void*)entry_vkCreateViSurfaceNN : nullptr;
}
#endif
#ifdef VK_EXT_conditional_rendering
- if (!strcmp(name, "vkCmdBeginConditionalRenderingEXT"))
- {
+ if (!strcmp(name, "vkCmdBeginConditionalRenderingEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdBeginConditionalRenderingEXT;
}
- if (!strcmp(name, "vkCmdEndConditionalRenderingEXT"))
- {
+ if (!strcmp(name, "vkCmdEndConditionalRenderingEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdEndConditionalRenderingEXT;
}
#endif
#ifdef VK_NV_clip_space_w_scaling
- if (!strcmp(name, "vkCmdSetViewportWScalingNV"))
- {
+ if (!strcmp(name, "vkCmdSetViewportWScalingNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetViewportWScalingNV;
}
#endif
#ifdef VK_EXT_direct_mode_display
- if (!strcmp(name, "vkReleaseDisplayEXT"))
- {
+ if (!strcmp(name, "vkReleaseDisplayEXT")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_direct_mode_display");
return hasExt ? (void*)entry_vkReleaseDisplayEXT : nullptr;
}
#endif
#ifdef VK_EXT_acquire_xlib_display
- if (!strcmp(name, "vkAcquireXlibDisplayEXT"))
- {
+ if (!strcmp(name, "vkAcquireXlibDisplayEXT")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_acquire_xlib_display");
return hasExt ? (void*)entry_vkAcquireXlibDisplayEXT : nullptr;
}
- if (!strcmp(name, "vkGetRandROutputDisplayEXT"))
- {
+ if (!strcmp(name, "vkGetRandROutputDisplayEXT")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_acquire_xlib_display");
return hasExt ? (void*)entry_vkGetRandROutputDisplayEXT : nullptr;
}
#endif
#ifdef VK_EXT_display_surface_counter
- if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_display_surface_counter");
return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceCapabilities2EXT : nullptr;
}
#endif
#ifdef VK_EXT_display_control
- if (!strcmp(name, "vkDisplayPowerControlEXT"))
- {
+ if (!strcmp(name, "vkDisplayPowerControlEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkDisplayPowerControlEXT;
}
- if (!strcmp(name, "vkRegisterDeviceEventEXT"))
- {
+ if (!strcmp(name, "vkRegisterDeviceEventEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkRegisterDeviceEventEXT;
}
- if (!strcmp(name, "vkRegisterDisplayEventEXT"))
- {
+ if (!strcmp(name, "vkRegisterDisplayEventEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkRegisterDisplayEventEXT;
}
- if (!strcmp(name, "vkGetSwapchainCounterEXT"))
- {
+ if (!strcmp(name, "vkGetSwapchainCounterEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetSwapchainCounterEXT;
}
#endif
#ifdef VK_GOOGLE_display_timing
- if (!strcmp(name, "vkGetRefreshCycleDurationGOOGLE"))
- {
+ if (!strcmp(name, "vkGetRefreshCycleDurationGOOGLE")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetRefreshCycleDurationGOOGLE;
}
- if (!strcmp(name, "vkGetPastPresentationTimingGOOGLE"))
- {
+ if (!strcmp(name, "vkGetPastPresentationTimingGOOGLE")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetPastPresentationTimingGOOGLE;
}
#endif
#ifdef VK_EXT_discard_rectangles
- if (!strcmp(name, "vkCmdSetDiscardRectangleEXT"))
- {
+ if (!strcmp(name, "vkCmdSetDiscardRectangleEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetDiscardRectangleEXT;
}
#endif
#ifdef VK_EXT_hdr_metadata
- if (!strcmp(name, "vkSetHdrMetadataEXT"))
- {
+ if (!strcmp(name, "vkSetHdrMetadataEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkSetHdrMetadataEXT;
}
#endif
#ifdef VK_MVK_ios_surface
- if (!strcmp(name, "vkCreateIOSSurfaceMVK"))
- {
+ if (!strcmp(name, "vkCreateIOSSurfaceMVK")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_MVK_ios_surface");
return hasExt ? (void*)entry_vkCreateIOSSurfaceMVK : nullptr;
}
#endif
#ifdef VK_MVK_macos_surface
- if (!strcmp(name, "vkCreateMacOSSurfaceMVK"))
- {
+ if (!strcmp(name, "vkCreateMacOSSurfaceMVK")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_MVK_macos_surface");
return hasExt ? (void*)entry_vkCreateMacOSSurfaceMVK : nullptr;
}
#endif
#ifdef VK_MVK_moltenvk
- if (!strcmp(name, "vkGetMTLDeviceMVK"))
- {
+ if (!strcmp(name, "vkGetMTLDeviceMVK")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_MVK_moltenvk");
return hasExt ? (void*)entry_vkGetMTLDeviceMVK : nullptr;
}
- if (!strcmp(name, "vkSetMTLTextureMVK"))
- {
+ if (!strcmp(name, "vkSetMTLTextureMVK")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_MVK_moltenvk");
return hasExt ? (void*)entry_vkSetMTLTextureMVK : nullptr;
}
- if (!strcmp(name, "vkGetMTLTextureMVK"))
- {
+ if (!strcmp(name, "vkGetMTLTextureMVK")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_MVK_moltenvk");
return hasExt ? (void*)entry_vkGetMTLTextureMVK : nullptr;
}
- if (!strcmp(name, "vkGetMTLBufferMVK"))
- {
+ if (!strcmp(name, "vkGetMTLBufferMVK")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_MVK_moltenvk");
return hasExt ? (void*)entry_vkGetMTLBufferMVK : nullptr;
}
- if (!strcmp(name, "vkUseIOSurfaceMVK"))
- {
+ if (!strcmp(name, "vkUseIOSurfaceMVK")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_MVK_moltenvk");
return hasExt ? (void*)entry_vkUseIOSurfaceMVK : nullptr;
}
- if (!strcmp(name, "vkGetIOSurfaceMVK"))
- {
+ if (!strcmp(name, "vkGetIOSurfaceMVK")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_MVK_moltenvk");
return hasExt ? (void*)entry_vkGetIOSurfaceMVK : nullptr;
}
#endif
#ifdef VK_EXT_debug_utils
- if (!strcmp(name, "vkSetDebugUtilsObjectNameEXT"))
- {
- return (void*)dynCheck_entry_vkSetDebugUtilsObjectNameEXT;
+ if (!strcmp(name, "vkSetDebugUtilsObjectNameEXT")) {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils");
+ return hasExt ? (void*)dynCheck_entry_vkSetDebugUtilsObjectNameEXT : nullptr;
}
- if (!strcmp(name, "vkSetDebugUtilsObjectTagEXT"))
- {
- return (void*)dynCheck_entry_vkSetDebugUtilsObjectTagEXT;
+ if (!strcmp(name, "vkSetDebugUtilsObjectTagEXT")) {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils");
+ return hasExt ? (void*)dynCheck_entry_vkSetDebugUtilsObjectTagEXT : nullptr;
}
- if (!strcmp(name, "vkQueueBeginDebugUtilsLabelEXT"))
- {
+ if (!strcmp(name, "vkQueueBeginDebugUtilsLabelEXT")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils");
return hasExt ? (void*)entry_vkQueueBeginDebugUtilsLabelEXT : nullptr;
}
- if (!strcmp(name, "vkQueueEndDebugUtilsLabelEXT"))
- {
+ if (!strcmp(name, "vkQueueEndDebugUtilsLabelEXT")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils");
return hasExt ? (void*)entry_vkQueueEndDebugUtilsLabelEXT : nullptr;
}
- if (!strcmp(name, "vkQueueInsertDebugUtilsLabelEXT"))
- {
+ if (!strcmp(name, "vkQueueInsertDebugUtilsLabelEXT")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils");
return hasExt ? (void*)entry_vkQueueInsertDebugUtilsLabelEXT : nullptr;
}
- if (!strcmp(name, "vkCmdBeginDebugUtilsLabelEXT"))
- {
- return (void*)dynCheck_entry_vkCmdBeginDebugUtilsLabelEXT;
+ if (!strcmp(name, "vkCmdBeginDebugUtilsLabelEXT")) {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils");
+ return hasExt ? (void*)entry_vkCmdBeginDebugUtilsLabelEXT : nullptr;
}
- if (!strcmp(name, "vkCmdEndDebugUtilsLabelEXT"))
- {
- return (void*)dynCheck_entry_vkCmdEndDebugUtilsLabelEXT;
+ if (!strcmp(name, "vkCmdEndDebugUtilsLabelEXT")) {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils");
+ return hasExt ? (void*)entry_vkCmdEndDebugUtilsLabelEXT : nullptr;
}
- if (!strcmp(name, "vkCmdInsertDebugUtilsLabelEXT"))
- {
- return (void*)dynCheck_entry_vkCmdInsertDebugUtilsLabelEXT;
+ if (!strcmp(name, "vkCmdInsertDebugUtilsLabelEXT")) {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils");
+ return hasExt ? (void*)entry_vkCmdInsertDebugUtilsLabelEXT : nullptr;
}
- if (!strcmp(name, "vkCreateDebugUtilsMessengerEXT"))
- {
+ if (!strcmp(name, "vkCreateDebugUtilsMessengerEXT")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils");
return hasExt ? (void*)entry_vkCreateDebugUtilsMessengerEXT : nullptr;
}
- if (!strcmp(name, "vkDestroyDebugUtilsMessengerEXT"))
- {
+ if (!strcmp(name, "vkDestroyDebugUtilsMessengerEXT")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils");
return hasExt ? (void*)entry_vkDestroyDebugUtilsMessengerEXT : nullptr;
}
- if (!strcmp(name, "vkSubmitDebugUtilsMessageEXT"))
- {
+ if (!strcmp(name, "vkSubmitDebugUtilsMessageEXT")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils");
return hasExt ? (void*)entry_vkSubmitDebugUtilsMessageEXT : nullptr;
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
- if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID"))
- {
+ if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetAndroidHardwareBufferPropertiesANDROID;
}
- if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID"))
- {
+ if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetMemoryAndroidHardwareBufferANDROID;
}
#endif
#ifdef VK_EXT_sample_locations
- if (!strcmp(name, "vkCmdSetSampleLocationsEXT"))
- {
+ if (!strcmp(name, "vkCmdSetSampleLocationsEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetSampleLocationsEXT;
}
- if (!strcmp(name, "vkGetPhysicalDeviceMultisamplePropertiesEXT"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_sample_locations");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceMultisamplePropertiesEXT : nullptr;
+ if (!strcmp(name, "vkGetPhysicalDeviceMultisamplePropertiesEXT")) {
+ // TODO(b/236246382): Check support for device extension;
+ return (void*)entry_vkGetPhysicalDeviceMultisamplePropertiesEXT;
}
#endif
#ifdef VK_EXT_image_drm_format_modifier
- if (!strcmp(name, "vkGetImageDrmFormatModifierPropertiesEXT"))
- {
+ if (!strcmp(name, "vkGetImageDrmFormatModifierPropertiesEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetImageDrmFormatModifierPropertiesEXT;
}
#endif
#ifdef VK_EXT_validation_cache
- if (!strcmp(name, "vkCreateValidationCacheEXT"))
- {
+ if (!strcmp(name, "vkCreateValidationCacheEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCreateValidationCacheEXT;
}
- if (!strcmp(name, "vkDestroyValidationCacheEXT"))
- {
+ if (!strcmp(name, "vkDestroyValidationCacheEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkDestroyValidationCacheEXT;
}
- if (!strcmp(name, "vkMergeValidationCachesEXT"))
- {
+ if (!strcmp(name, "vkMergeValidationCachesEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkMergeValidationCachesEXT;
}
- if (!strcmp(name, "vkGetValidationCacheDataEXT"))
- {
+ if (!strcmp(name, "vkGetValidationCacheDataEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetValidationCacheDataEXT;
}
#endif
#ifdef VK_NV_shading_rate_image
- if (!strcmp(name, "vkCmdBindShadingRateImageNV"))
- {
+ if (!strcmp(name, "vkCmdBindShadingRateImageNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdBindShadingRateImageNV;
}
- if (!strcmp(name, "vkCmdSetViewportShadingRatePaletteNV"))
- {
+ if (!strcmp(name, "vkCmdSetViewportShadingRatePaletteNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetViewportShadingRatePaletteNV;
}
- if (!strcmp(name, "vkCmdSetCoarseSampleOrderNV"))
- {
+ if (!strcmp(name, "vkCmdSetCoarseSampleOrderNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetCoarseSampleOrderNV;
}
#endif
#ifdef VK_NV_ray_tracing
- if (!strcmp(name, "vkCreateAccelerationStructureNV"))
- {
+ if (!strcmp(name, "vkCreateAccelerationStructureNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCreateAccelerationStructureNV;
}
- if (!strcmp(name, "vkDestroyAccelerationStructureNV"))
- {
+ if (!strcmp(name, "vkDestroyAccelerationStructureNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkDestroyAccelerationStructureNV;
}
- if (!strcmp(name, "vkGetAccelerationStructureMemoryRequirementsNV"))
- {
+ if (!strcmp(name, "vkGetAccelerationStructureMemoryRequirementsNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetAccelerationStructureMemoryRequirementsNV;
}
- if (!strcmp(name, "vkBindAccelerationStructureMemoryNV"))
- {
+ if (!strcmp(name, "vkBindAccelerationStructureMemoryNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkBindAccelerationStructureMemoryNV;
}
- if (!strcmp(name, "vkCmdBuildAccelerationStructureNV"))
- {
+ if (!strcmp(name, "vkCmdBuildAccelerationStructureNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdBuildAccelerationStructureNV;
}
- if (!strcmp(name, "vkCmdCopyAccelerationStructureNV"))
- {
+ if (!strcmp(name, "vkCmdCopyAccelerationStructureNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdCopyAccelerationStructureNV;
}
- if (!strcmp(name, "vkCmdTraceRaysNV"))
- {
+ if (!strcmp(name, "vkCmdTraceRaysNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdTraceRaysNV;
}
- if (!strcmp(name, "vkCreateRayTracingPipelinesNV"))
- {
+ if (!strcmp(name, "vkCreateRayTracingPipelinesNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCreateRayTracingPipelinesNV;
}
- if (!strcmp(name, "vkGetRayTracingShaderGroupHandlesKHR"))
- {
+ if (!strcmp(name, "vkGetRayTracingShaderGroupHandlesKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetRayTracingShaderGroupHandlesKHR;
}
- if (!strcmp(name, "vkGetRayTracingShaderGroupHandlesNV"))
- {
+ if (!strcmp(name, "vkGetRayTracingShaderGroupHandlesNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetRayTracingShaderGroupHandlesNV;
}
- if (!strcmp(name, "vkGetAccelerationStructureHandleNV"))
- {
+ if (!strcmp(name, "vkGetAccelerationStructureHandleNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetAccelerationStructureHandleNV;
}
- if (!strcmp(name, "vkCmdWriteAccelerationStructuresPropertiesNV"))
- {
+ if (!strcmp(name, "vkCmdWriteAccelerationStructuresPropertiesNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdWriteAccelerationStructuresPropertiesNV;
}
- if (!strcmp(name, "vkCompileDeferredNV"))
- {
+ if (!strcmp(name, "vkCompileDeferredNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCompileDeferredNV;
}
#endif
#ifdef VK_EXT_external_memory_host
- if (!strcmp(name, "vkGetMemoryHostPointerPropertiesEXT"))
- {
+ if (!strcmp(name, "vkGetMemoryHostPointerPropertiesEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetMemoryHostPointerPropertiesEXT;
}
#endif
#ifdef VK_AMD_buffer_marker
- if (!strcmp(name, "vkCmdWriteBufferMarkerAMD"))
- {
+ if (!strcmp(name, "vkCmdWriteBufferMarkerAMD")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdWriteBufferMarkerAMD;
}
#endif
#ifdef VK_EXT_calibrated_timestamps
- if (!strcmp(name, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_calibrated_timestamps");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT : nullptr;
+ if (!strcmp(name, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT")) {
+ // TODO(b/236246382): Check support for device extension;
+ return (void*)entry_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT;
}
- if (!strcmp(name, "vkGetCalibratedTimestampsEXT"))
- {
+ if (!strcmp(name, "vkGetCalibratedTimestampsEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetCalibratedTimestampsEXT;
}
#endif
#ifdef VK_NV_mesh_shader
- if (!strcmp(name, "vkCmdDrawMeshTasksNV"))
- {
+ if (!strcmp(name, "vkCmdDrawMeshTasksNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdDrawMeshTasksNV;
}
- if (!strcmp(name, "vkCmdDrawMeshTasksIndirectNV"))
- {
+ if (!strcmp(name, "vkCmdDrawMeshTasksIndirectNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdDrawMeshTasksIndirectNV;
}
- if (!strcmp(name, "vkCmdDrawMeshTasksIndirectCountNV"))
- {
+ if (!strcmp(name, "vkCmdDrawMeshTasksIndirectCountNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdDrawMeshTasksIndirectCountNV;
}
#endif
#ifdef VK_NV_scissor_exclusive
- if (!strcmp(name, "vkCmdSetExclusiveScissorNV"))
- {
+ if (!strcmp(name, "vkCmdSetExclusiveScissorNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetExclusiveScissorNV;
}
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
- if (!strcmp(name, "vkCmdSetCheckpointNV"))
- {
+ if (!strcmp(name, "vkCmdSetCheckpointNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetCheckpointNV;
}
- if (!strcmp(name, "vkGetQueueCheckpointDataNV"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_NV_device_diagnostic_checkpoints");
- return hasExt ? (void*)entry_vkGetQueueCheckpointDataNV : nullptr;
+ if (!strcmp(name, "vkGetQueueCheckpointDataNV")) {
+ // TODO(b/236246382): Check support for device extension;
+ return (void*)entry_vkGetQueueCheckpointDataNV;
}
#endif
#ifdef VK_INTEL_performance_query
- if (!strcmp(name, "vkInitializePerformanceApiINTEL"))
- {
+ if (!strcmp(name, "vkInitializePerformanceApiINTEL")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkInitializePerformanceApiINTEL;
}
- if (!strcmp(name, "vkUninitializePerformanceApiINTEL"))
- {
+ if (!strcmp(name, "vkUninitializePerformanceApiINTEL")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkUninitializePerformanceApiINTEL;
}
- if (!strcmp(name, "vkCmdSetPerformanceMarkerINTEL"))
- {
+ if (!strcmp(name, "vkCmdSetPerformanceMarkerINTEL")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetPerformanceMarkerINTEL;
}
- if (!strcmp(name, "vkCmdSetPerformanceStreamMarkerINTEL"))
- {
+ if (!strcmp(name, "vkCmdSetPerformanceStreamMarkerINTEL")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetPerformanceStreamMarkerINTEL;
}
- if (!strcmp(name, "vkCmdSetPerformanceOverrideINTEL"))
- {
+ if (!strcmp(name, "vkCmdSetPerformanceOverrideINTEL")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetPerformanceOverrideINTEL;
}
- if (!strcmp(name, "vkAcquirePerformanceConfigurationINTEL"))
- {
+ if (!strcmp(name, "vkAcquirePerformanceConfigurationINTEL")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkAcquirePerformanceConfigurationINTEL;
}
- if (!strcmp(name, "vkReleasePerformanceConfigurationINTEL"))
- {
+ if (!strcmp(name, "vkReleasePerformanceConfigurationINTEL")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkReleasePerformanceConfigurationINTEL;
}
- if (!strcmp(name, "vkQueueSetPerformanceConfigurationINTEL"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_INTEL_performance_query");
- return hasExt ? (void*)entry_vkQueueSetPerformanceConfigurationINTEL : nullptr;
+ if (!strcmp(name, "vkQueueSetPerformanceConfigurationINTEL")) {
+ // TODO(b/236246382): Check support for device extension;
+ return (void*)entry_vkQueueSetPerformanceConfigurationINTEL;
}
- if (!strcmp(name, "vkGetPerformanceParameterINTEL"))
- {
+ if (!strcmp(name, "vkGetPerformanceParameterINTEL")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetPerformanceParameterINTEL;
}
#endif
#ifdef VK_AMD_display_native_hdr
- if (!strcmp(name, "vkSetLocalDimmingAMD"))
- {
+ if (!strcmp(name, "vkSetLocalDimmingAMD")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkSetLocalDimmingAMD;
}
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
- if (!strcmp(name, "vkCreateImagePipeSurfaceFUCHSIA"))
- {
+ if (!strcmp(name, "vkCreateImagePipeSurfaceFUCHSIA")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_FUCHSIA_imagepipe_surface");
return hasExt ? (void*)entry_vkCreateImagePipeSurfaceFUCHSIA : nullptr;
}
#endif
#ifdef VK_EXT_metal_surface
- if (!strcmp(name, "vkCreateMetalSurfaceEXT"))
- {
+ if (!strcmp(name, "vkCreateMetalSurfaceEXT")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_metal_surface");
return hasExt ? (void*)entry_vkCreateMetalSurfaceEXT : nullptr;
}
#endif
#ifdef VK_EXT_buffer_device_address
- if (!strcmp(name, "vkGetBufferDeviceAddressEXT"))
- {
+ if (!strcmp(name, "vkGetBufferDeviceAddressEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetBufferDeviceAddressEXT;
}
#endif
#ifdef VK_EXT_tooling_info
- if (!strcmp(name, "vkGetPhysicalDeviceToolPropertiesEXT"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_tooling_info");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceToolPropertiesEXT : nullptr;
+ if (!strcmp(name, "vkGetPhysicalDeviceToolPropertiesEXT")) {
+ // TODO(b/236246382): Check support for device extension;
+ return (void*)entry_vkGetPhysicalDeviceToolPropertiesEXT;
}
#endif
#ifdef VK_NV_cooperative_matrix
- if (!strcmp(name, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_NV_cooperative_matrix");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV : nullptr;
+ if (!strcmp(name, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV")) {
+ // TODO(b/236246382): Check support for device extension;
+ return (void*)entry_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV;
}
#endif
#ifdef VK_NV_coverage_reduction_mode
- if (!strcmp(name, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_NV_coverage_reduction_mode");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV : nullptr;
+ if (!strcmp(name, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV")) {
+ // TODO(b/236246382): Check support for device extension;
+ return (void*)entry_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV;
}
#endif
#ifdef VK_EXT_full_screen_exclusive
- if (!strcmp(name, "vkGetPhysicalDeviceSurfacePresentModes2EXT"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_full_screen_exclusive");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfacePresentModes2EXT : nullptr;
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfacePresentModes2EXT")) {
+ // TODO(b/236246382): Check support for device extension;
+ return (void*)entry_vkGetPhysicalDeviceSurfacePresentModes2EXT;
}
- if (!strcmp(name, "vkAcquireFullScreenExclusiveModeEXT"))
- {
+ if (!strcmp(name, "vkAcquireFullScreenExclusiveModeEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkAcquireFullScreenExclusiveModeEXT;
}
- if (!strcmp(name, "vkReleaseFullScreenExclusiveModeEXT"))
- {
+ if (!strcmp(name, "vkReleaseFullScreenExclusiveModeEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkReleaseFullScreenExclusiveModeEXT;
}
- if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModes2EXT"))
- {
+ if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModes2EXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetDeviceGroupSurfacePresentModes2EXT;
}
#endif
#ifdef VK_EXT_headless_surface
- if (!strcmp(name, "vkCreateHeadlessSurfaceEXT"))
- {
+ if (!strcmp(name, "vkCreateHeadlessSurfaceEXT")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_headless_surface");
return hasExt ? (void*)entry_vkCreateHeadlessSurfaceEXT : nullptr;
}
#endif
#ifdef VK_EXT_line_rasterization
- if (!strcmp(name, "vkCmdSetLineStippleEXT"))
- {
+ if (!strcmp(name, "vkCmdSetLineStippleEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetLineStippleEXT;
}
#endif
#ifdef VK_EXT_host_query_reset
- if (!strcmp(name, "vkResetQueryPoolEXT"))
- {
+ if (!strcmp(name, "vkResetQueryPoolEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkResetQueryPoolEXT;
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- if (!strcmp(name, "vkCmdSetCullModeEXT"))
- {
+ if (!strcmp(name, "vkCmdSetCullModeEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetCullModeEXT;
}
- if (!strcmp(name, "vkCmdSetFrontFaceEXT"))
- {
+ if (!strcmp(name, "vkCmdSetFrontFaceEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetFrontFaceEXT;
}
- if (!strcmp(name, "vkCmdSetPrimitiveTopologyEXT"))
- {
+ if (!strcmp(name, "vkCmdSetPrimitiveTopologyEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetPrimitiveTopologyEXT;
}
- if (!strcmp(name, "vkCmdSetViewportWithCountEXT"))
- {
+ if (!strcmp(name, "vkCmdSetViewportWithCountEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetViewportWithCountEXT;
}
- if (!strcmp(name, "vkCmdSetScissorWithCountEXT"))
- {
+ if (!strcmp(name, "vkCmdSetScissorWithCountEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetScissorWithCountEXT;
}
- if (!strcmp(name, "vkCmdBindVertexBuffers2EXT"))
- {
+ if (!strcmp(name, "vkCmdBindVertexBuffers2EXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdBindVertexBuffers2EXT;
}
- if (!strcmp(name, "vkCmdSetDepthTestEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetDepthTestEnableEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetDepthTestEnableEXT;
}
- if (!strcmp(name, "vkCmdSetDepthWriteEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetDepthWriteEnableEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetDepthWriteEnableEXT;
}
- if (!strcmp(name, "vkCmdSetDepthCompareOpEXT"))
- {
+ if (!strcmp(name, "vkCmdSetDepthCompareOpEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetDepthCompareOpEXT;
}
- if (!strcmp(name, "vkCmdSetDepthBoundsTestEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetDepthBoundsTestEnableEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetDepthBoundsTestEnableEXT;
}
- if (!strcmp(name, "vkCmdSetStencilTestEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetStencilTestEnableEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetStencilTestEnableEXT;
}
- if (!strcmp(name, "vkCmdSetStencilOpEXT"))
- {
+ if (!strcmp(name, "vkCmdSetStencilOpEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetStencilOpEXT;
}
#endif
#ifdef VK_NV_device_generated_commands
- if (!strcmp(name, "vkGetGeneratedCommandsMemoryRequirementsNV"))
- {
+ if (!strcmp(name, "vkGetGeneratedCommandsMemoryRequirementsNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetGeneratedCommandsMemoryRequirementsNV;
}
- if (!strcmp(name, "vkCmdPreprocessGeneratedCommandsNV"))
- {
+ if (!strcmp(name, "vkCmdPreprocessGeneratedCommandsNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdPreprocessGeneratedCommandsNV;
}
- if (!strcmp(name, "vkCmdExecuteGeneratedCommandsNV"))
- {
+ if (!strcmp(name, "vkCmdExecuteGeneratedCommandsNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdExecuteGeneratedCommandsNV;
}
- if (!strcmp(name, "vkCmdBindPipelineShaderGroupNV"))
- {
+ if (!strcmp(name, "vkCmdBindPipelineShaderGroupNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdBindPipelineShaderGroupNV;
}
- if (!strcmp(name, "vkCreateIndirectCommandsLayoutNV"))
- {
+ if (!strcmp(name, "vkCreateIndirectCommandsLayoutNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCreateIndirectCommandsLayoutNV;
}
- if (!strcmp(name, "vkDestroyIndirectCommandsLayoutNV"))
- {
+ if (!strcmp(name, "vkDestroyIndirectCommandsLayoutNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkDestroyIndirectCommandsLayoutNV;
}
#endif
#ifdef VK_EXT_acquire_drm_display
- if (!strcmp(name, "vkAcquireDrmDisplayEXT"))
- {
+ if (!strcmp(name, "vkAcquireDrmDisplayEXT")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_acquire_drm_display");
return hasExt ? (void*)entry_vkAcquireDrmDisplayEXT : nullptr;
}
- if (!strcmp(name, "vkGetDrmDisplayEXT"))
- {
+ if (!strcmp(name, "vkGetDrmDisplayEXT")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_acquire_drm_display");
return hasExt ? (void*)entry_vkGetDrmDisplayEXT : nullptr;
}
#endif
#ifdef VK_EXT_private_data
- if (!strcmp(name, "vkCreatePrivateDataSlotEXT"))
- {
+ if (!strcmp(name, "vkCreatePrivateDataSlotEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCreatePrivateDataSlotEXT;
}
- if (!strcmp(name, "vkDestroyPrivateDataSlotEXT"))
- {
+ if (!strcmp(name, "vkDestroyPrivateDataSlotEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkDestroyPrivateDataSlotEXT;
}
- if (!strcmp(name, "vkSetPrivateDataEXT"))
- {
+ if (!strcmp(name, "vkSetPrivateDataEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkSetPrivateDataEXT;
}
- if (!strcmp(name, "vkGetPrivateDataEXT"))
- {
+ if (!strcmp(name, "vkGetPrivateDataEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetPrivateDataEXT;
}
#endif
#ifdef VK_NV_fragment_shading_rate_enums
- if (!strcmp(name, "vkCmdSetFragmentShadingRateEnumNV"))
- {
+ if (!strcmp(name, "vkCmdSetFragmentShadingRateEnumNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetFragmentShadingRateEnumNV;
}
#endif
#ifdef VK_NV_acquire_winrt_display
- if (!strcmp(name, "vkAcquireWinrtDisplayNV"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_NV_acquire_winrt_display");
- return hasExt ? (void*)entry_vkAcquireWinrtDisplayNV : nullptr;
+ if (!strcmp(name, "vkAcquireWinrtDisplayNV")) {
+ // TODO(b/236246382): Check support for device extension;
+ return (void*)entry_vkAcquireWinrtDisplayNV;
}
- if (!strcmp(name, "vkGetWinrtDisplayNV"))
- {
- bool hasExt = resources->hasInstanceExtension(instance, "VK_NV_acquire_winrt_display");
- return hasExt ? (void*)entry_vkGetWinrtDisplayNV : nullptr;
+ if (!strcmp(name, "vkGetWinrtDisplayNV")) {
+ // TODO(b/236246382): Check support for device extension;
+ return (void*)entry_vkGetWinrtDisplayNV;
}
#endif
#ifdef VK_EXT_directfb_surface
- if (!strcmp(name, "vkCreateDirectFBSurfaceEXT"))
- {
+ if (!strcmp(name, "vkCreateDirectFBSurfaceEXT")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_directfb_surface");
return hasExt ? (void*)entry_vkCreateDirectFBSurfaceEXT : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_directfb_surface");
return hasExt ? (void*)entry_vkGetPhysicalDeviceDirectFBPresentationSupportEXT : nullptr;
}
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
- if (!strcmp(name, "vkCmdSetVertexInputEXT"))
- {
+ if (!strcmp(name, "vkCmdSetVertexInputEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetVertexInputEXT;
}
#endif
#ifdef VK_FUCHSIA_external_memory
- if (!strcmp(name, "vkGetMemoryZirconHandleFUCHSIA"))
- {
+ if (!strcmp(name, "vkGetMemoryZirconHandleFUCHSIA")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetMemoryZirconHandleFUCHSIA;
}
- if (!strcmp(name, "vkGetMemoryZirconHandlePropertiesFUCHSIA"))
- {
+ if (!strcmp(name, "vkGetMemoryZirconHandlePropertiesFUCHSIA")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetMemoryZirconHandlePropertiesFUCHSIA;
}
#endif
#ifdef VK_FUCHSIA_external_semaphore
- if (!strcmp(name, "vkImportSemaphoreZirconHandleFUCHSIA"))
- {
+ if (!strcmp(name, "vkImportSemaphoreZirconHandleFUCHSIA")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkImportSemaphoreZirconHandleFUCHSIA;
}
- if (!strcmp(name, "vkGetSemaphoreZirconHandleFUCHSIA"))
- {
+ if (!strcmp(name, "vkGetSemaphoreZirconHandleFUCHSIA")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetSemaphoreZirconHandleFUCHSIA;
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
- if (!strcmp(name, "vkCreateBufferCollectionFUCHSIA"))
- {
+ if (!strcmp(name, "vkCreateBufferCollectionFUCHSIA")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCreateBufferCollectionFUCHSIA;
}
- if (!strcmp(name, "vkSetBufferCollectionImageConstraintsFUCHSIA"))
- {
+ if (!strcmp(name, "vkSetBufferCollectionImageConstraintsFUCHSIA")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkSetBufferCollectionImageConstraintsFUCHSIA;
}
- if (!strcmp(name, "vkSetBufferCollectionBufferConstraintsFUCHSIA"))
- {
+ if (!strcmp(name, "vkSetBufferCollectionBufferConstraintsFUCHSIA")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkSetBufferCollectionBufferConstraintsFUCHSIA;
}
- if (!strcmp(name, "vkDestroyBufferCollectionFUCHSIA"))
- {
+ if (!strcmp(name, "vkDestroyBufferCollectionFUCHSIA")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkDestroyBufferCollectionFUCHSIA;
}
- if (!strcmp(name, "vkGetBufferCollectionPropertiesFUCHSIA"))
- {
+ if (!strcmp(name, "vkGetBufferCollectionPropertiesFUCHSIA")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetBufferCollectionPropertiesFUCHSIA;
}
#endif
#ifdef VK_HUAWEI_subpass_shading
- if (!strcmp(name, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI"))
- {
+ if (!strcmp(name, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI;
}
- if (!strcmp(name, "vkCmdSubpassShadingHUAWEI"))
- {
+ if (!strcmp(name, "vkCmdSubpassShadingHUAWEI")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSubpassShadingHUAWEI;
}
#endif
#ifdef VK_HUAWEI_invocation_mask
- if (!strcmp(name, "vkCmdBindInvocationMaskHUAWEI"))
- {
+ if (!strcmp(name, "vkCmdBindInvocationMaskHUAWEI")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdBindInvocationMaskHUAWEI;
}
#endif
#ifdef VK_NV_external_memory_rdma
- if (!strcmp(name, "vkGetMemoryRemoteAddressNV"))
- {
+ if (!strcmp(name, "vkGetMemoryRemoteAddressNV")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetMemoryRemoteAddressNV;
}
#endif
#ifdef VK_EXT_extended_dynamic_state2
- if (!strcmp(name, "vkCmdSetPatchControlPointsEXT"))
- {
+ if (!strcmp(name, "vkCmdSetPatchControlPointsEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetPatchControlPointsEXT;
}
- if (!strcmp(name, "vkCmdSetRasterizerDiscardEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetRasterizerDiscardEnableEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetRasterizerDiscardEnableEXT;
}
- if (!strcmp(name, "vkCmdSetDepthBiasEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetDepthBiasEnableEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetDepthBiasEnableEXT;
}
- if (!strcmp(name, "vkCmdSetLogicOpEXT"))
- {
+ if (!strcmp(name, "vkCmdSetLogicOpEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetLogicOpEXT;
}
- if (!strcmp(name, "vkCmdSetPrimitiveRestartEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetPrimitiveRestartEnableEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetPrimitiveRestartEnableEXT;
}
#endif
#ifdef VK_QNX_screen_surface
- if (!strcmp(name, "vkCreateScreenSurfaceQNX"))
- {
+ if (!strcmp(name, "vkCreateScreenSurfaceQNX")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_QNX_screen_surface");
return hasExt ? (void*)entry_vkCreateScreenSurfaceQNX : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceScreenPresentationSupportQNX"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceScreenPresentationSupportQNX")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_QNX_screen_surface");
return hasExt ? (void*)entry_vkGetPhysicalDeviceScreenPresentationSupportQNX : nullptr;
}
#endif
#ifdef VK_EXT_color_write_enable
- if (!strcmp(name, "vkCmdSetColorWriteEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetColorWriteEnableEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetColorWriteEnableEXT;
}
#endif
#ifdef VK_GOOGLE_gfxstream
- if (!strcmp(name, "vkRegisterImageColorBufferGOOGLE"))
- {
- return (void*)dynCheck_entry_vkRegisterImageColorBufferGOOGLE;
+ if (!strcmp(name, "vkRegisterImageColorBufferGOOGLE")) {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
+ return hasExt ? (void*)dynCheck_entry_vkRegisterImageColorBufferGOOGLE : nullptr;
}
- if (!strcmp(name, "vkRegisterBufferColorBufferGOOGLE"))
- {
- return (void*)dynCheck_entry_vkRegisterBufferColorBufferGOOGLE;
+ if (!strcmp(name, "vkRegisterBufferColorBufferGOOGLE")) {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
+ return hasExt ? (void*)dynCheck_entry_vkRegisterBufferColorBufferGOOGLE : nullptr;
}
- if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE"))
- {
- return (void*)dynCheck_entry_vkMapMemoryIntoAddressSpaceGOOGLE;
+ if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
+ return hasExt ? (void*)dynCheck_entry_vkMapMemoryIntoAddressSpaceGOOGLE : nullptr;
}
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE"))
- {
- return (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE;
+ if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE")) {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
+ return hasExt ? (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE
+ : nullptr;
}
- if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE"))
- {
- return (void*)dynCheck_entry_vkBeginCommandBufferAsyncGOOGLE;
+ if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE")) {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
+ return hasExt ? (void*)entry_vkBeginCommandBufferAsyncGOOGLE : nullptr;
}
- if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE"))
- {
- return (void*)dynCheck_entry_vkEndCommandBufferAsyncGOOGLE;
+ if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE")) {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
+ return hasExt ? (void*)entry_vkEndCommandBufferAsyncGOOGLE : nullptr;
}
- if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE"))
- {
- return (void*)dynCheck_entry_vkResetCommandBufferAsyncGOOGLE;
+ if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE")) {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
+ return hasExt ? (void*)entry_vkResetCommandBufferAsyncGOOGLE : nullptr;
}
- if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE"))
- {
- return (void*)dynCheck_entry_vkCommandBufferHostSyncGOOGLE;
+ if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE")) {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
+ return hasExt ? (void*)entry_vkCommandBufferHostSyncGOOGLE : nullptr;
}
- if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE"))
- {
- return (void*)dynCheck_entry_vkCreateImageWithRequirementsGOOGLE;
+ if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE")) {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
+ return hasExt ? (void*)dynCheck_entry_vkCreateImageWithRequirementsGOOGLE : nullptr;
}
- if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE"))
- {
- return (void*)dynCheck_entry_vkCreateBufferWithRequirementsGOOGLE;
+ if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE")) {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
+ return hasExt ? (void*)dynCheck_entry_vkCreateBufferWithRequirementsGOOGLE : nullptr;
}
- if (!strcmp(name, "vkGetMemoryHostAddressInfoGOOGLE"))
- {
- return (void*)dynCheck_entry_vkGetMemoryHostAddressInfoGOOGLE;
+ if (!strcmp(name, "vkGetMemoryHostAddressInfoGOOGLE")) {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
+ return hasExt ? (void*)dynCheck_entry_vkGetMemoryHostAddressInfoGOOGLE : nullptr;
}
- if (!strcmp(name, "vkFreeMemorySyncGOOGLE"))
- {
- return (void*)dynCheck_entry_vkFreeMemorySyncGOOGLE;
+ if (!strcmp(name, "vkFreeMemorySyncGOOGLE")) {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
+ return hasExt ? (void*)dynCheck_entry_vkFreeMemorySyncGOOGLE : nullptr;
}
- if (!strcmp(name, "vkQueueHostSyncGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueHostSyncGOOGLE")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkQueueHostSyncGOOGLE : nullptr;
}
- if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkQueueSubmitAsyncGOOGLE : nullptr;
}
- if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkQueueWaitIdleAsyncGOOGLE : nullptr;
}
- if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkQueueBindSparseAsyncGOOGLE : nullptr;
}
- if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE"))
- {
- return (void*)dynCheck_entry_vkGetLinearImageLayoutGOOGLE;
+ if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE")) {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
+ return hasExt ? (void*)dynCheck_entry_vkGetLinearImageLayoutGOOGLE : nullptr;
}
- if (!strcmp(name, "vkGetLinearImageLayout2GOOGLE"))
- {
- return (void*)dynCheck_entry_vkGetLinearImageLayout2GOOGLE;
+ if (!strcmp(name, "vkGetLinearImageLayout2GOOGLE")) {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
+ return hasExt ? (void*)dynCheck_entry_vkGetLinearImageLayout2GOOGLE : nullptr;
}
- if (!strcmp(name, "vkQueueFlushCommandsGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueFlushCommandsGOOGLE")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkQueueFlushCommandsGOOGLE : nullptr;
}
- if (!strcmp(name, "vkQueueCommitDescriptorSetUpdatesGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueCommitDescriptorSetUpdatesGOOGLE")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkQueueCommitDescriptorSetUpdatesGOOGLE : nullptr;
}
- if (!strcmp(name, "vkCollectDescriptorPoolIdsGOOGLE"))
- {
- return (void*)dynCheck_entry_vkCollectDescriptorPoolIdsGOOGLE;
+ if (!strcmp(name, "vkCollectDescriptorPoolIdsGOOGLE")) {
+ bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
+ return hasExt ? (void*)dynCheck_entry_vkCollectDescriptorPoolIdsGOOGLE : nullptr;
}
- if (!strcmp(name, "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE")) {
bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE : nullptr;
}
#endif
#ifdef VK_EXT_multi_draw
- if (!strcmp(name, "vkCmdDrawMultiEXT"))
- {
+ if (!strcmp(name, "vkCmdDrawMultiEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdDrawMultiEXT;
}
- if (!strcmp(name, "vkCmdDrawMultiIndexedEXT"))
- {
+ if (!strcmp(name, "vkCmdDrawMultiIndexedEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdDrawMultiIndexedEXT;
}
#endif
#ifdef VK_EXT_pageable_device_local_memory
- if (!strcmp(name, "vkSetDeviceMemoryPriorityEXT"))
- {
+ if (!strcmp(name, "vkSetDeviceMemoryPriorityEXT")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkSetDeviceMemoryPriorityEXT;
}
#endif
#ifdef VK_KHR_acceleration_structure
- if (!strcmp(name, "vkCreateAccelerationStructureKHR"))
- {
+ if (!strcmp(name, "vkCreateAccelerationStructureKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCreateAccelerationStructureKHR;
}
- if (!strcmp(name, "vkDestroyAccelerationStructureKHR"))
- {
+ if (!strcmp(name, "vkDestroyAccelerationStructureKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkDestroyAccelerationStructureKHR;
}
- if (!strcmp(name, "vkCmdBuildAccelerationStructuresKHR"))
- {
+ if (!strcmp(name, "vkCmdBuildAccelerationStructuresKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdBuildAccelerationStructuresKHR;
}
- if (!strcmp(name, "vkCmdBuildAccelerationStructuresIndirectKHR"))
- {
+ if (!strcmp(name, "vkCmdBuildAccelerationStructuresIndirectKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdBuildAccelerationStructuresIndirectKHR;
}
- if (!strcmp(name, "vkBuildAccelerationStructuresKHR"))
- {
+ if (!strcmp(name, "vkBuildAccelerationStructuresKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkBuildAccelerationStructuresKHR;
}
- if (!strcmp(name, "vkCopyAccelerationStructureKHR"))
- {
+ if (!strcmp(name, "vkCopyAccelerationStructureKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCopyAccelerationStructureKHR;
}
- if (!strcmp(name, "vkCopyAccelerationStructureToMemoryKHR"))
- {
+ if (!strcmp(name, "vkCopyAccelerationStructureToMemoryKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCopyAccelerationStructureToMemoryKHR;
}
- if (!strcmp(name, "vkCopyMemoryToAccelerationStructureKHR"))
- {
+ if (!strcmp(name, "vkCopyMemoryToAccelerationStructureKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCopyMemoryToAccelerationStructureKHR;
}
- if (!strcmp(name, "vkWriteAccelerationStructuresPropertiesKHR"))
- {
+ if (!strcmp(name, "vkWriteAccelerationStructuresPropertiesKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkWriteAccelerationStructuresPropertiesKHR;
}
- if (!strcmp(name, "vkCmdCopyAccelerationStructureKHR"))
- {
+ if (!strcmp(name, "vkCmdCopyAccelerationStructureKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdCopyAccelerationStructureKHR;
}
- if (!strcmp(name, "vkCmdCopyAccelerationStructureToMemoryKHR"))
- {
+ if (!strcmp(name, "vkCmdCopyAccelerationStructureToMemoryKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdCopyAccelerationStructureToMemoryKHR;
}
- if (!strcmp(name, "vkCmdCopyMemoryToAccelerationStructureKHR"))
- {
+ if (!strcmp(name, "vkCmdCopyMemoryToAccelerationStructureKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdCopyMemoryToAccelerationStructureKHR;
}
- if (!strcmp(name, "vkGetAccelerationStructureDeviceAddressKHR"))
- {
+ if (!strcmp(name, "vkGetAccelerationStructureDeviceAddressKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetAccelerationStructureDeviceAddressKHR;
}
- if (!strcmp(name, "vkCmdWriteAccelerationStructuresPropertiesKHR"))
- {
+ if (!strcmp(name, "vkCmdWriteAccelerationStructuresPropertiesKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdWriteAccelerationStructuresPropertiesKHR;
}
- if (!strcmp(name, "vkGetDeviceAccelerationStructureCompatibilityKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceAccelerationStructureCompatibilityKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetDeviceAccelerationStructureCompatibilityKHR;
}
- if (!strcmp(name, "vkGetAccelerationStructureBuildSizesKHR"))
- {
+ if (!strcmp(name, "vkGetAccelerationStructureBuildSizesKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetAccelerationStructureBuildSizesKHR;
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
- if (!strcmp(name, "vkCmdTraceRaysKHR"))
- {
+ if (!strcmp(name, "vkCmdTraceRaysKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdTraceRaysKHR;
}
- if (!strcmp(name, "vkCreateRayTracingPipelinesKHR"))
- {
+ if (!strcmp(name, "vkCreateRayTracingPipelinesKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCreateRayTracingPipelinesKHR;
}
- if (!strcmp(name, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR"))
- {
+ if (!strcmp(name, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR;
}
- if (!strcmp(name, "vkCmdTraceRaysIndirectKHR"))
- {
+ if (!strcmp(name, "vkCmdTraceRaysIndirectKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdTraceRaysIndirectKHR;
}
- if (!strcmp(name, "vkGetRayTracingShaderGroupStackSizeKHR"))
- {
+ if (!strcmp(name, "vkGetRayTracingShaderGroupStackSizeKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkGetRayTracingShaderGroupStackSizeKHR;
}
- if (!strcmp(name, "vkCmdSetRayTracingPipelineStackSizeKHR"))
- {
+ if (!strcmp(name, "vkCmdSetRayTracingPipelineStackSizeKHR")) {
+ // TODO(b/236246382): Check support for device extension;
return (void*)dynCheck_entry_vkCmdSetRayTracingPipelineStackSizeKHR;
}
#endif
return nullptr;
}
-void* goldfish_vulkan_get_device_proc_address(VkDevice device, const char* name){
+void* goldfish_vulkan_get_device_proc_address(VkDevice device, const char* name) {
auto resources = ResourceTracker::get();
bool has1_1OrHigher = resources->getApiVersionFromDevice(device) >= VK_API_VERSION_1_1;
#ifdef VK_VERSION_1_0
- if (!strcmp(name, "vkCreateInstance"))
- {
+ if (!strcmp(name, "vkCreateInstance")) {
return (void*)entry_vkCreateInstance;
}
- if (!strcmp(name, "vkDestroyInstance"))
- {
+ if (!strcmp(name, "vkDestroyInstance")) {
return (void*)entry_vkDestroyInstance;
}
- if (!strcmp(name, "vkEnumeratePhysicalDevices"))
- {
+ if (!strcmp(name, "vkEnumeratePhysicalDevices")) {
return (void*)entry_vkEnumeratePhysicalDevices;
}
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceFeatures")) {
return (void*)entry_vkGetPhysicalDeviceFeatures;
}
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties")) {
return (void*)entry_vkGetPhysicalDeviceFormatProperties;
}
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties")) {
return (void*)entry_vkGetPhysicalDeviceImageFormatProperties;
}
- if (!strcmp(name, "vkGetPhysicalDeviceProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceProperties")) {
return (void*)entry_vkGetPhysicalDeviceProperties;
}
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties")) {
return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties;
}
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties")) {
return (void*)entry_vkGetPhysicalDeviceMemoryProperties;
}
- if (!strcmp(name, "vkGetInstanceProcAddr"))
- {
+ if (!strcmp(name, "vkGetInstanceProcAddr")) {
return (void*)entry_vkGetInstanceProcAddr;
}
- if (!strcmp(name, "vkGetDeviceProcAddr"))
- {
+ if (!strcmp(name, "vkGetDeviceProcAddr")) {
return (void*)entry_vkGetDeviceProcAddr;
}
- if (!strcmp(name, "vkCreateDevice"))
- {
+ if (!strcmp(name, "vkCreateDevice")) {
return (void*)entry_vkCreateDevice;
}
- if (!strcmp(name, "vkDestroyDevice"))
- {
+ if (!strcmp(name, "vkDestroyDevice")) {
return (void*)entry_vkDestroyDevice;
}
- if (!strcmp(name, "vkEnumerateInstanceExtensionProperties"))
- {
+ if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) {
return (void*)entry_vkEnumerateInstanceExtensionProperties;
}
- if (!strcmp(name, "vkEnumerateDeviceExtensionProperties"))
- {
+ if (!strcmp(name, "vkEnumerateDeviceExtensionProperties")) {
return (void*)entry_vkEnumerateDeviceExtensionProperties;
}
- if (!strcmp(name, "vkEnumerateInstanceLayerProperties"))
- {
+ if (!strcmp(name, "vkEnumerateInstanceLayerProperties")) {
return (void*)entry_vkEnumerateInstanceLayerProperties;
}
- if (!strcmp(name, "vkEnumerateDeviceLayerProperties"))
- {
+ if (!strcmp(name, "vkEnumerateDeviceLayerProperties")) {
return (void*)entry_vkEnumerateDeviceLayerProperties;
}
- if (!strcmp(name, "vkGetDeviceQueue"))
- {
+ if (!strcmp(name, "vkGetDeviceQueue")) {
return (void*)entry_vkGetDeviceQueue;
}
- if (!strcmp(name, "vkQueueSubmit"))
- {
+ if (!strcmp(name, "vkQueueSubmit")) {
return (void*)entry_vkQueueSubmit;
}
- if (!strcmp(name, "vkQueueWaitIdle"))
- {
+ if (!strcmp(name, "vkQueueWaitIdle")) {
return (void*)entry_vkQueueWaitIdle;
}
- if (!strcmp(name, "vkDeviceWaitIdle"))
- {
+ if (!strcmp(name, "vkDeviceWaitIdle")) {
return (void*)entry_vkDeviceWaitIdle;
}
- if (!strcmp(name, "vkAllocateMemory"))
- {
+ if (!strcmp(name, "vkAllocateMemory")) {
return (void*)entry_vkAllocateMemory;
}
- if (!strcmp(name, "vkFreeMemory"))
- {
+ if (!strcmp(name, "vkFreeMemory")) {
return (void*)entry_vkFreeMemory;
}
- if (!strcmp(name, "vkMapMemory"))
- {
+ if (!strcmp(name, "vkMapMemory")) {
return (void*)entry_vkMapMemory;
}
- if (!strcmp(name, "vkUnmapMemory"))
- {
+ if (!strcmp(name, "vkUnmapMemory")) {
return (void*)entry_vkUnmapMemory;
}
- if (!strcmp(name, "vkFlushMappedMemoryRanges"))
- {
+ if (!strcmp(name, "vkFlushMappedMemoryRanges")) {
return (void*)entry_vkFlushMappedMemoryRanges;
}
- if (!strcmp(name, "vkInvalidateMappedMemoryRanges"))
- {
+ if (!strcmp(name, "vkInvalidateMappedMemoryRanges")) {
return (void*)entry_vkInvalidateMappedMemoryRanges;
}
- if (!strcmp(name, "vkGetDeviceMemoryCommitment"))
- {
+ if (!strcmp(name, "vkGetDeviceMemoryCommitment")) {
return (void*)entry_vkGetDeviceMemoryCommitment;
}
- if (!strcmp(name, "vkBindBufferMemory"))
- {
+ if (!strcmp(name, "vkBindBufferMemory")) {
return (void*)entry_vkBindBufferMemory;
}
- if (!strcmp(name, "vkBindImageMemory"))
- {
+ if (!strcmp(name, "vkBindImageMemory")) {
return (void*)entry_vkBindImageMemory;
}
- if (!strcmp(name, "vkGetBufferMemoryRequirements"))
- {
+ if (!strcmp(name, "vkGetBufferMemoryRequirements")) {
return (void*)entry_vkGetBufferMemoryRequirements;
}
- if (!strcmp(name, "vkGetImageMemoryRequirements"))
- {
+ if (!strcmp(name, "vkGetImageMemoryRequirements")) {
return (void*)entry_vkGetImageMemoryRequirements;
}
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements"))
- {
+ if (!strcmp(name, "vkGetImageSparseMemoryRequirements")) {
return (void*)entry_vkGetImageSparseMemoryRequirements;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties")) {
return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties;
}
- if (!strcmp(name, "vkQueueBindSparse"))
- {
+ if (!strcmp(name, "vkQueueBindSparse")) {
return (void*)entry_vkQueueBindSparse;
}
- if (!strcmp(name, "vkCreateFence"))
- {
+ if (!strcmp(name, "vkCreateFence")) {
return (void*)entry_vkCreateFence;
}
- if (!strcmp(name, "vkDestroyFence"))
- {
+ if (!strcmp(name, "vkDestroyFence")) {
return (void*)entry_vkDestroyFence;
}
- if (!strcmp(name, "vkResetFences"))
- {
+ if (!strcmp(name, "vkResetFences")) {
return (void*)entry_vkResetFences;
}
- if (!strcmp(name, "vkGetFenceStatus"))
- {
+ if (!strcmp(name, "vkGetFenceStatus")) {
return (void*)entry_vkGetFenceStatus;
}
- if (!strcmp(name, "vkWaitForFences"))
- {
+ if (!strcmp(name, "vkWaitForFences")) {
return (void*)entry_vkWaitForFences;
}
- if (!strcmp(name, "vkCreateSemaphore"))
- {
+ if (!strcmp(name, "vkCreateSemaphore")) {
return (void*)entry_vkCreateSemaphore;
}
- if (!strcmp(name, "vkDestroySemaphore"))
- {
+ if (!strcmp(name, "vkDestroySemaphore")) {
return (void*)entry_vkDestroySemaphore;
}
- if (!strcmp(name, "vkCreateEvent"))
- {
+ if (!strcmp(name, "vkCreateEvent")) {
return (void*)entry_vkCreateEvent;
}
- if (!strcmp(name, "vkDestroyEvent"))
- {
+ if (!strcmp(name, "vkDestroyEvent")) {
return (void*)entry_vkDestroyEvent;
}
- if (!strcmp(name, "vkGetEventStatus"))
- {
+ if (!strcmp(name, "vkGetEventStatus")) {
return (void*)entry_vkGetEventStatus;
}
- if (!strcmp(name, "vkSetEvent"))
- {
+ if (!strcmp(name, "vkSetEvent")) {
return (void*)entry_vkSetEvent;
}
- if (!strcmp(name, "vkResetEvent"))
- {
+ if (!strcmp(name, "vkResetEvent")) {
return (void*)entry_vkResetEvent;
}
- if (!strcmp(name, "vkCreateQueryPool"))
- {
+ if (!strcmp(name, "vkCreateQueryPool")) {
return (void*)entry_vkCreateQueryPool;
}
- if (!strcmp(name, "vkDestroyQueryPool"))
- {
+ if (!strcmp(name, "vkDestroyQueryPool")) {
return (void*)entry_vkDestroyQueryPool;
}
- if (!strcmp(name, "vkGetQueryPoolResults"))
- {
+ if (!strcmp(name, "vkGetQueryPoolResults")) {
return (void*)entry_vkGetQueryPoolResults;
}
- if (!strcmp(name, "vkCreateBuffer"))
- {
+ if (!strcmp(name, "vkCreateBuffer")) {
return (void*)entry_vkCreateBuffer;
}
- if (!strcmp(name, "vkDestroyBuffer"))
- {
+ if (!strcmp(name, "vkDestroyBuffer")) {
return (void*)entry_vkDestroyBuffer;
}
- if (!strcmp(name, "vkCreateBufferView"))
- {
+ if (!strcmp(name, "vkCreateBufferView")) {
return (void*)entry_vkCreateBufferView;
}
- if (!strcmp(name, "vkDestroyBufferView"))
- {
+ if (!strcmp(name, "vkDestroyBufferView")) {
return (void*)entry_vkDestroyBufferView;
}
- if (!strcmp(name, "vkCreateImage"))
- {
+ if (!strcmp(name, "vkCreateImage")) {
return (void*)entry_vkCreateImage;
}
- if (!strcmp(name, "vkDestroyImage"))
- {
+ if (!strcmp(name, "vkDestroyImage")) {
return (void*)entry_vkDestroyImage;
}
- if (!strcmp(name, "vkGetImageSubresourceLayout"))
- {
+ if (!strcmp(name, "vkGetImageSubresourceLayout")) {
return (void*)entry_vkGetImageSubresourceLayout;
}
- if (!strcmp(name, "vkCreateImageView"))
- {
+ if (!strcmp(name, "vkCreateImageView")) {
return (void*)entry_vkCreateImageView;
}
- if (!strcmp(name, "vkDestroyImageView"))
- {
+ if (!strcmp(name, "vkDestroyImageView")) {
return (void*)entry_vkDestroyImageView;
}
- if (!strcmp(name, "vkCreateShaderModule"))
- {
+ if (!strcmp(name, "vkCreateShaderModule")) {
return (void*)entry_vkCreateShaderModule;
}
- if (!strcmp(name, "vkDestroyShaderModule"))
- {
+ if (!strcmp(name, "vkDestroyShaderModule")) {
return (void*)entry_vkDestroyShaderModule;
}
- if (!strcmp(name, "vkCreatePipelineCache"))
- {
+ if (!strcmp(name, "vkCreatePipelineCache")) {
return (void*)entry_vkCreatePipelineCache;
}
- if (!strcmp(name, "vkDestroyPipelineCache"))
- {
+ if (!strcmp(name, "vkDestroyPipelineCache")) {
return (void*)entry_vkDestroyPipelineCache;
}
- if (!strcmp(name, "vkGetPipelineCacheData"))
- {
+ if (!strcmp(name, "vkGetPipelineCacheData")) {
return (void*)entry_vkGetPipelineCacheData;
}
- if (!strcmp(name, "vkMergePipelineCaches"))
- {
+ if (!strcmp(name, "vkMergePipelineCaches")) {
return (void*)entry_vkMergePipelineCaches;
}
- if (!strcmp(name, "vkCreateGraphicsPipelines"))
- {
+ if (!strcmp(name, "vkCreateGraphicsPipelines")) {
return (void*)entry_vkCreateGraphicsPipelines;
}
- if (!strcmp(name, "vkCreateComputePipelines"))
- {
+ if (!strcmp(name, "vkCreateComputePipelines")) {
return (void*)entry_vkCreateComputePipelines;
}
- if (!strcmp(name, "vkDestroyPipeline"))
- {
+ if (!strcmp(name, "vkDestroyPipeline")) {
return (void*)entry_vkDestroyPipeline;
}
- if (!strcmp(name, "vkCreatePipelineLayout"))
- {
+ if (!strcmp(name, "vkCreatePipelineLayout")) {
return (void*)entry_vkCreatePipelineLayout;
}
- if (!strcmp(name, "vkDestroyPipelineLayout"))
- {
+ if (!strcmp(name, "vkDestroyPipelineLayout")) {
return (void*)entry_vkDestroyPipelineLayout;
}
- if (!strcmp(name, "vkCreateSampler"))
- {
+ if (!strcmp(name, "vkCreateSampler")) {
return (void*)entry_vkCreateSampler;
}
- if (!strcmp(name, "vkDestroySampler"))
- {
+ if (!strcmp(name, "vkDestroySampler")) {
return (void*)entry_vkDestroySampler;
}
- if (!strcmp(name, "vkCreateDescriptorSetLayout"))
- {
+ if (!strcmp(name, "vkCreateDescriptorSetLayout")) {
return (void*)entry_vkCreateDescriptorSetLayout;
}
- if (!strcmp(name, "vkDestroyDescriptorSetLayout"))
- {
+ if (!strcmp(name, "vkDestroyDescriptorSetLayout")) {
return (void*)entry_vkDestroyDescriptorSetLayout;
}
- if (!strcmp(name, "vkCreateDescriptorPool"))
- {
+ if (!strcmp(name, "vkCreateDescriptorPool")) {
return (void*)entry_vkCreateDescriptorPool;
}
- if (!strcmp(name, "vkDestroyDescriptorPool"))
- {
+ if (!strcmp(name, "vkDestroyDescriptorPool")) {
return (void*)entry_vkDestroyDescriptorPool;
}
- if (!strcmp(name, "vkResetDescriptorPool"))
- {
+ if (!strcmp(name, "vkResetDescriptorPool")) {
return (void*)entry_vkResetDescriptorPool;
}
- if (!strcmp(name, "vkAllocateDescriptorSets"))
- {
+ if (!strcmp(name, "vkAllocateDescriptorSets")) {
return (void*)entry_vkAllocateDescriptorSets;
}
- if (!strcmp(name, "vkFreeDescriptorSets"))
- {
+ if (!strcmp(name, "vkFreeDescriptorSets")) {
return (void*)entry_vkFreeDescriptorSets;
}
- if (!strcmp(name, "vkUpdateDescriptorSets"))
- {
+ if (!strcmp(name, "vkUpdateDescriptorSets")) {
return (void*)entry_vkUpdateDescriptorSets;
}
- if (!strcmp(name, "vkCreateFramebuffer"))
- {
+ if (!strcmp(name, "vkCreateFramebuffer")) {
return (void*)entry_vkCreateFramebuffer;
}
- if (!strcmp(name, "vkDestroyFramebuffer"))
- {
+ if (!strcmp(name, "vkDestroyFramebuffer")) {
return (void*)entry_vkDestroyFramebuffer;
}
- if (!strcmp(name, "vkCreateRenderPass"))
- {
+ if (!strcmp(name, "vkCreateRenderPass")) {
return (void*)entry_vkCreateRenderPass;
}
- if (!strcmp(name, "vkDestroyRenderPass"))
- {
+ if (!strcmp(name, "vkDestroyRenderPass")) {
return (void*)entry_vkDestroyRenderPass;
}
- if (!strcmp(name, "vkGetRenderAreaGranularity"))
- {
+ if (!strcmp(name, "vkGetRenderAreaGranularity")) {
return (void*)entry_vkGetRenderAreaGranularity;
}
- if (!strcmp(name, "vkCreateCommandPool"))
- {
+ if (!strcmp(name, "vkCreateCommandPool")) {
return (void*)entry_vkCreateCommandPool;
}
- if (!strcmp(name, "vkDestroyCommandPool"))
- {
+ if (!strcmp(name, "vkDestroyCommandPool")) {
return (void*)entry_vkDestroyCommandPool;
}
- if (!strcmp(name, "vkResetCommandPool"))
- {
+ if (!strcmp(name, "vkResetCommandPool")) {
return (void*)entry_vkResetCommandPool;
}
- if (!strcmp(name, "vkAllocateCommandBuffers"))
- {
+ if (!strcmp(name, "vkAllocateCommandBuffers")) {
return (void*)entry_vkAllocateCommandBuffers;
}
- if (!strcmp(name, "vkFreeCommandBuffers"))
- {
+ if (!strcmp(name, "vkFreeCommandBuffers")) {
return (void*)entry_vkFreeCommandBuffers;
}
- if (!strcmp(name, "vkBeginCommandBuffer"))
- {
+ if (!strcmp(name, "vkBeginCommandBuffer")) {
return (void*)entry_vkBeginCommandBuffer;
}
- if (!strcmp(name, "vkEndCommandBuffer"))
- {
+ if (!strcmp(name, "vkEndCommandBuffer")) {
return (void*)entry_vkEndCommandBuffer;
}
- if (!strcmp(name, "vkResetCommandBuffer"))
- {
+ if (!strcmp(name, "vkResetCommandBuffer")) {
return (void*)entry_vkResetCommandBuffer;
}
- if (!strcmp(name, "vkCmdBindPipeline"))
- {
+ if (!strcmp(name, "vkCmdBindPipeline")) {
return (void*)entry_vkCmdBindPipeline;
}
- if (!strcmp(name, "vkCmdSetViewport"))
- {
+ if (!strcmp(name, "vkCmdSetViewport")) {
return (void*)entry_vkCmdSetViewport;
}
- if (!strcmp(name, "vkCmdSetScissor"))
- {
+ if (!strcmp(name, "vkCmdSetScissor")) {
return (void*)entry_vkCmdSetScissor;
}
- if (!strcmp(name, "vkCmdSetLineWidth"))
- {
+ if (!strcmp(name, "vkCmdSetLineWidth")) {
return (void*)entry_vkCmdSetLineWidth;
}
- if (!strcmp(name, "vkCmdSetDepthBias"))
- {
+ if (!strcmp(name, "vkCmdSetDepthBias")) {
return (void*)entry_vkCmdSetDepthBias;
}
- if (!strcmp(name, "vkCmdSetBlendConstants"))
- {
+ if (!strcmp(name, "vkCmdSetBlendConstants")) {
return (void*)entry_vkCmdSetBlendConstants;
}
- if (!strcmp(name, "vkCmdSetDepthBounds"))
- {
+ if (!strcmp(name, "vkCmdSetDepthBounds")) {
return (void*)entry_vkCmdSetDepthBounds;
}
- if (!strcmp(name, "vkCmdSetStencilCompareMask"))
- {
+ if (!strcmp(name, "vkCmdSetStencilCompareMask")) {
return (void*)entry_vkCmdSetStencilCompareMask;
}
- if (!strcmp(name, "vkCmdSetStencilWriteMask"))
- {
+ if (!strcmp(name, "vkCmdSetStencilWriteMask")) {
return (void*)entry_vkCmdSetStencilWriteMask;
}
- if (!strcmp(name, "vkCmdSetStencilReference"))
- {
+ if (!strcmp(name, "vkCmdSetStencilReference")) {
return (void*)entry_vkCmdSetStencilReference;
}
- if (!strcmp(name, "vkCmdBindDescriptorSets"))
- {
+ if (!strcmp(name, "vkCmdBindDescriptorSets")) {
return (void*)entry_vkCmdBindDescriptorSets;
}
- if (!strcmp(name, "vkCmdBindIndexBuffer"))
- {
+ if (!strcmp(name, "vkCmdBindIndexBuffer")) {
return (void*)entry_vkCmdBindIndexBuffer;
}
- if (!strcmp(name, "vkCmdBindVertexBuffers"))
- {
+ if (!strcmp(name, "vkCmdBindVertexBuffers")) {
return (void*)entry_vkCmdBindVertexBuffers;
}
- if (!strcmp(name, "vkCmdDraw"))
- {
+ if (!strcmp(name, "vkCmdDraw")) {
return (void*)entry_vkCmdDraw;
}
- if (!strcmp(name, "vkCmdDrawIndexed"))
- {
+ if (!strcmp(name, "vkCmdDrawIndexed")) {
return (void*)entry_vkCmdDrawIndexed;
}
- if (!strcmp(name, "vkCmdDrawIndirect"))
- {
+ if (!strcmp(name, "vkCmdDrawIndirect")) {
return (void*)entry_vkCmdDrawIndirect;
}
- if (!strcmp(name, "vkCmdDrawIndexedIndirect"))
- {
+ if (!strcmp(name, "vkCmdDrawIndexedIndirect")) {
return (void*)entry_vkCmdDrawIndexedIndirect;
}
- if (!strcmp(name, "vkCmdDispatch"))
- {
+ if (!strcmp(name, "vkCmdDispatch")) {
return (void*)entry_vkCmdDispatch;
}
- if (!strcmp(name, "vkCmdDispatchIndirect"))
- {
+ if (!strcmp(name, "vkCmdDispatchIndirect")) {
return (void*)entry_vkCmdDispatchIndirect;
}
- if (!strcmp(name, "vkCmdCopyBuffer"))
- {
+ if (!strcmp(name, "vkCmdCopyBuffer")) {
return (void*)entry_vkCmdCopyBuffer;
}
- if (!strcmp(name, "vkCmdCopyImage"))
- {
+ if (!strcmp(name, "vkCmdCopyImage")) {
return (void*)entry_vkCmdCopyImage;
}
- if (!strcmp(name, "vkCmdBlitImage"))
- {
+ if (!strcmp(name, "vkCmdBlitImage")) {
return (void*)entry_vkCmdBlitImage;
}
- if (!strcmp(name, "vkCmdCopyBufferToImage"))
- {
+ if (!strcmp(name, "vkCmdCopyBufferToImage")) {
return (void*)entry_vkCmdCopyBufferToImage;
}
- if (!strcmp(name, "vkCmdCopyImageToBuffer"))
- {
+ if (!strcmp(name, "vkCmdCopyImageToBuffer")) {
return (void*)entry_vkCmdCopyImageToBuffer;
}
- if (!strcmp(name, "vkCmdUpdateBuffer"))
- {
+ if (!strcmp(name, "vkCmdUpdateBuffer")) {
return (void*)entry_vkCmdUpdateBuffer;
}
- if (!strcmp(name, "vkCmdFillBuffer"))
- {
+ if (!strcmp(name, "vkCmdFillBuffer")) {
return (void*)entry_vkCmdFillBuffer;
}
- if (!strcmp(name, "vkCmdClearColorImage"))
- {
+ if (!strcmp(name, "vkCmdClearColorImage")) {
return (void*)entry_vkCmdClearColorImage;
}
- if (!strcmp(name, "vkCmdClearDepthStencilImage"))
- {
+ if (!strcmp(name, "vkCmdClearDepthStencilImage")) {
return (void*)entry_vkCmdClearDepthStencilImage;
}
- if (!strcmp(name, "vkCmdClearAttachments"))
- {
+ if (!strcmp(name, "vkCmdClearAttachments")) {
return (void*)entry_vkCmdClearAttachments;
}
- if (!strcmp(name, "vkCmdResolveImage"))
- {
+ if (!strcmp(name, "vkCmdResolveImage")) {
return (void*)entry_vkCmdResolveImage;
}
- if (!strcmp(name, "vkCmdSetEvent"))
- {
+ if (!strcmp(name, "vkCmdSetEvent")) {
return (void*)entry_vkCmdSetEvent;
}
- if (!strcmp(name, "vkCmdResetEvent"))
- {
+ if (!strcmp(name, "vkCmdResetEvent")) {
return (void*)entry_vkCmdResetEvent;
}
- if (!strcmp(name, "vkCmdWaitEvents"))
- {
+ if (!strcmp(name, "vkCmdWaitEvents")) {
return (void*)entry_vkCmdWaitEvents;
}
- if (!strcmp(name, "vkCmdPipelineBarrier"))
- {
+ if (!strcmp(name, "vkCmdPipelineBarrier")) {
return (void*)entry_vkCmdPipelineBarrier;
}
- if (!strcmp(name, "vkCmdBeginQuery"))
- {
+ if (!strcmp(name, "vkCmdBeginQuery")) {
return (void*)entry_vkCmdBeginQuery;
}
- if (!strcmp(name, "vkCmdEndQuery"))
- {
+ if (!strcmp(name, "vkCmdEndQuery")) {
return (void*)entry_vkCmdEndQuery;
}
- if (!strcmp(name, "vkCmdResetQueryPool"))
- {
+ if (!strcmp(name, "vkCmdResetQueryPool")) {
return (void*)entry_vkCmdResetQueryPool;
}
- if (!strcmp(name, "vkCmdWriteTimestamp"))
- {
+ if (!strcmp(name, "vkCmdWriteTimestamp")) {
return (void*)entry_vkCmdWriteTimestamp;
}
- if (!strcmp(name, "vkCmdCopyQueryPoolResults"))
- {
+ if (!strcmp(name, "vkCmdCopyQueryPoolResults")) {
return (void*)entry_vkCmdCopyQueryPoolResults;
}
- if (!strcmp(name, "vkCmdPushConstants"))
- {
+ if (!strcmp(name, "vkCmdPushConstants")) {
return (void*)entry_vkCmdPushConstants;
}
- if (!strcmp(name, "vkCmdBeginRenderPass"))
- {
+ if (!strcmp(name, "vkCmdBeginRenderPass")) {
return (void*)entry_vkCmdBeginRenderPass;
}
- if (!strcmp(name, "vkCmdNextSubpass"))
- {
+ if (!strcmp(name, "vkCmdNextSubpass")) {
return (void*)entry_vkCmdNextSubpass;
}
- if (!strcmp(name, "vkCmdEndRenderPass"))
- {
+ if (!strcmp(name, "vkCmdEndRenderPass")) {
return (void*)entry_vkCmdEndRenderPass;
}
- if (!strcmp(name, "vkCmdExecuteCommands"))
- {
+ if (!strcmp(name, "vkCmdExecuteCommands")) {
return (void*)entry_vkCmdExecuteCommands;
}
#endif
#ifdef VK_VERSION_1_1
- if (!strcmp(name, "vkEnumerateInstanceVersion"))
- {
+ if (!strcmp(name, "vkEnumerateInstanceVersion")) {
return has1_1OrHigher ? (void*)entry_vkEnumerateInstanceVersion : nullptr;
}
- if (!strcmp(name, "vkBindBufferMemory2"))
- {
+ if (!strcmp(name, "vkBindBufferMemory2")) {
return has1_1OrHigher ? (void*)entry_vkBindBufferMemory2 : nullptr;
}
- if (!strcmp(name, "vkBindImageMemory2"))
- {
+ if (!strcmp(name, "vkBindImageMemory2")) {
return has1_1OrHigher ? (void*)entry_vkBindImageMemory2 : nullptr;
}
- if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures"))
- {
+ if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures")) {
return has1_1OrHigher ? (void*)entry_vkGetDeviceGroupPeerMemoryFeatures : nullptr;
}
- if (!strcmp(name, "vkCmdSetDeviceMask"))
- {
+ if (!strcmp(name, "vkCmdSetDeviceMask")) {
return has1_1OrHigher ? (void*)entry_vkCmdSetDeviceMask : nullptr;
}
- if (!strcmp(name, "vkCmdDispatchBase"))
- {
+ if (!strcmp(name, "vkCmdDispatchBase")) {
return has1_1OrHigher ? (void*)entry_vkCmdDispatchBase : nullptr;
}
- if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups"))
- {
+ if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups")) {
return nullptr;
}
- if (!strcmp(name, "vkGetImageMemoryRequirements2"))
- {
+ if (!strcmp(name, "vkGetImageMemoryRequirements2")) {
return has1_1OrHigher ? (void*)entry_vkGetImageMemoryRequirements2 : nullptr;
}
- if (!strcmp(name, "vkGetBufferMemoryRequirements2"))
- {
+ if (!strcmp(name, "vkGetBufferMemoryRequirements2")) {
return has1_1OrHigher ? (void*)entry_vkGetBufferMemoryRequirements2 : nullptr;
}
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements2"))
- {
+ if (!strcmp(name, "vkGetImageSparseMemoryRequirements2")) {
return has1_1OrHigher ? (void*)entry_vkGetImageSparseMemoryRequirements2 : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures2"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceFeatures2")) {
return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFeatures2 : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceProperties2"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceProperties2")) {
return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceProperties2 : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2")) {
return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFormatProperties2 : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2")) {
return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2 : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2")) {
return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2 : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2")) {
return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2 : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2"))
- {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2 : nullptr;
+ if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2")) {
+ return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2
+ : nullptr;
}
- if (!strcmp(name, "vkTrimCommandPool"))
- {
+ if (!strcmp(name, "vkTrimCommandPool")) {
return has1_1OrHigher ? (void*)entry_vkTrimCommandPool : nullptr;
}
- if (!strcmp(name, "vkGetDeviceQueue2"))
- {
+ if (!strcmp(name, "vkGetDeviceQueue2")) {
return has1_1OrHigher ? (void*)entry_vkGetDeviceQueue2 : nullptr;
}
- if (!strcmp(name, "vkCreateSamplerYcbcrConversion"))
- {
+ if (!strcmp(name, "vkCreateSamplerYcbcrConversion")) {
return has1_1OrHigher ? (void*)entry_vkCreateSamplerYcbcrConversion : nullptr;
}
- if (!strcmp(name, "vkDestroySamplerYcbcrConversion"))
- {
+ if (!strcmp(name, "vkDestroySamplerYcbcrConversion")) {
return has1_1OrHigher ? (void*)entry_vkDestroySamplerYcbcrConversion : nullptr;
}
- if (!strcmp(name, "vkCreateDescriptorUpdateTemplate"))
- {
+ if (!strcmp(name, "vkCreateDescriptorUpdateTemplate")) {
return has1_1OrHigher ? (void*)entry_vkCreateDescriptorUpdateTemplate : nullptr;
}
- if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate"))
- {
+ if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate")) {
return has1_1OrHigher ? (void*)entry_vkDestroyDescriptorUpdateTemplate : nullptr;
}
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate"))
- {
+ if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate")) {
return has1_1OrHigher ? (void*)entry_vkUpdateDescriptorSetWithTemplate : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties")) {
return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalBufferProperties : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties")) {
return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalFenceProperties : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties"))
- {
- return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalSemaphoreProperties : nullptr;
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties")) {
+ return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalSemaphoreProperties
+ : nullptr;
}
- if (!strcmp(name, "vkGetDescriptorSetLayoutSupport"))
- {
+ if (!strcmp(name, "vkGetDescriptorSetLayoutSupport")) {
return has1_1OrHigher ? (void*)entry_vkGetDescriptorSetLayoutSupport : nullptr;
}
#endif
#ifdef VK_VERSION_1_2
- if (!strcmp(name, "vkCmdDrawIndirectCount"))
- {
+ if (!strcmp(name, "vkCmdDrawIndirectCount")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_VERSION_1_2");
return hasExt ? (void*)entry_vkCmdDrawIndirectCount : nullptr;
}
- if (!strcmp(name, "vkCmdDrawIndexedIndirectCount"))
- {
+ if (!strcmp(name, "vkCmdDrawIndexedIndirectCount")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_VERSION_1_2");
return hasExt ? (void*)entry_vkCmdDrawIndexedIndirectCount : nullptr;
}
- if (!strcmp(name, "vkCreateRenderPass2"))
- {
+ if (!strcmp(name, "vkCreateRenderPass2")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_VERSION_1_2");
return hasExt ? (void*)entry_vkCreateRenderPass2 : nullptr;
}
- if (!strcmp(name, "vkCmdBeginRenderPass2"))
- {
+ if (!strcmp(name, "vkCmdBeginRenderPass2")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_VERSION_1_2");
return hasExt ? (void*)entry_vkCmdBeginRenderPass2 : nullptr;
}
- if (!strcmp(name, "vkCmdNextSubpass2"))
- {
+ if (!strcmp(name, "vkCmdNextSubpass2")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_VERSION_1_2");
return hasExt ? (void*)entry_vkCmdNextSubpass2 : nullptr;
}
- if (!strcmp(name, "vkCmdEndRenderPass2"))
- {
+ if (!strcmp(name, "vkCmdEndRenderPass2")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_VERSION_1_2");
return hasExt ? (void*)entry_vkCmdEndRenderPass2 : nullptr;
}
- if (!strcmp(name, "vkResetQueryPool"))
- {
+ if (!strcmp(name, "vkResetQueryPool")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_VERSION_1_2");
return hasExt ? (void*)entry_vkResetQueryPool : nullptr;
}
- if (!strcmp(name, "vkGetSemaphoreCounterValue"))
- {
+ if (!strcmp(name, "vkGetSemaphoreCounterValue")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_VERSION_1_2");
return hasExt ? (void*)entry_vkGetSemaphoreCounterValue : nullptr;
}
- if (!strcmp(name, "vkWaitSemaphores"))
- {
+ if (!strcmp(name, "vkWaitSemaphores")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_VERSION_1_2");
return hasExt ? (void*)entry_vkWaitSemaphores : nullptr;
}
- if (!strcmp(name, "vkSignalSemaphore"))
- {
+ if (!strcmp(name, "vkSignalSemaphore")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_VERSION_1_2");
return hasExt ? (void*)entry_vkSignalSemaphore : nullptr;
}
- if (!strcmp(name, "vkGetBufferDeviceAddress"))
- {
+ if (!strcmp(name, "vkGetBufferDeviceAddress")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_VERSION_1_2");
return hasExt ? (void*)entry_vkGetBufferDeviceAddress : nullptr;
}
- if (!strcmp(name, "vkGetBufferOpaqueCaptureAddress"))
- {
+ if (!strcmp(name, "vkGetBufferOpaqueCaptureAddress")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_VERSION_1_2");
return hasExt ? (void*)entry_vkGetBufferOpaqueCaptureAddress : nullptr;
}
- if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddress"))
- {
+ if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddress")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_VERSION_1_2");
return hasExt ? (void*)entry_vkGetDeviceMemoryOpaqueCaptureAddress : nullptr;
}
#endif
#ifdef VK_KHR_surface
- if (!strcmp(name, "vkDestroySurfaceKHR"))
- {
+ if (!strcmp(name, "vkDestroySurfaceKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_surface");
return hasExt ? (void*)entry_vkDestroySurfaceKHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSurfaceSupportKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceSupportKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_surface");
return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceSupportKHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_surface");
return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceCapabilitiesKHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormatsKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormatsKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_surface");
return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceFormatsKHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSurfacePresentModesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfacePresentModesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_surface");
return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfacePresentModesKHR : nullptr;
}
#endif
#ifdef VK_KHR_swapchain
- if (!strcmp(name, "vkCreateSwapchainKHR"))
- {
+ if (!strcmp(name, "vkCreateSwapchainKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain");
return hasExt ? (void*)entry_vkCreateSwapchainKHR : nullptr;
}
- if (!strcmp(name, "vkDestroySwapchainKHR"))
- {
+ if (!strcmp(name, "vkDestroySwapchainKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain");
return hasExt ? (void*)entry_vkDestroySwapchainKHR : nullptr;
}
- if (!strcmp(name, "vkGetSwapchainImagesKHR"))
- {
+ if (!strcmp(name, "vkGetSwapchainImagesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain");
return hasExt ? (void*)entry_vkGetSwapchainImagesKHR : nullptr;
}
- if (!strcmp(name, "vkAcquireNextImageKHR"))
- {
+ if (!strcmp(name, "vkAcquireNextImageKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain");
return hasExt ? (void*)entry_vkAcquireNextImageKHR : nullptr;
}
- if (!strcmp(name, "vkQueuePresentKHR"))
- {
+ if (!strcmp(name, "vkQueuePresentKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain");
return hasExt ? (void*)entry_vkQueuePresentKHR : nullptr;
}
- if (!strcmp(name, "vkGetDeviceGroupPresentCapabilitiesKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceGroupPresentCapabilitiesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain");
return hasExt ? (void*)entry_vkGetDeviceGroupPresentCapabilitiesKHR : nullptr;
}
- if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModesKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain");
return hasExt ? (void*)entry_vkGetDeviceGroupSurfacePresentModesKHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDevicePresentRectanglesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDevicePresentRectanglesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain");
return hasExt ? (void*)entry_vkGetPhysicalDevicePresentRectanglesKHR : nullptr;
}
- if (!strcmp(name, "vkAcquireNextImage2KHR"))
- {
+ if (!strcmp(name, "vkAcquireNextImage2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain");
return hasExt ? (void*)entry_vkAcquireNextImage2KHR : nullptr;
}
#endif
#ifdef VK_KHR_display
- if (!strcmp(name, "vkGetPhysicalDeviceDisplayPropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayPropertiesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_display");
return hasExt ? (void*)entry_vkGetPhysicalDeviceDisplayPropertiesKHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_display");
return hasExt ? (void*)entry_vkGetPhysicalDeviceDisplayPlanePropertiesKHR : nullptr;
}
- if (!strcmp(name, "vkGetDisplayPlaneSupportedDisplaysKHR"))
- {
+ if (!strcmp(name, "vkGetDisplayPlaneSupportedDisplaysKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_display");
return hasExt ? (void*)entry_vkGetDisplayPlaneSupportedDisplaysKHR : nullptr;
}
- if (!strcmp(name, "vkGetDisplayModePropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetDisplayModePropertiesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_display");
return hasExt ? (void*)entry_vkGetDisplayModePropertiesKHR : nullptr;
}
- if (!strcmp(name, "vkCreateDisplayModeKHR"))
- {
+ if (!strcmp(name, "vkCreateDisplayModeKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_display");
return hasExt ? (void*)entry_vkCreateDisplayModeKHR : nullptr;
}
- if (!strcmp(name, "vkGetDisplayPlaneCapabilitiesKHR"))
- {
+ if (!strcmp(name, "vkGetDisplayPlaneCapabilitiesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_display");
return hasExt ? (void*)entry_vkGetDisplayPlaneCapabilitiesKHR : nullptr;
}
- if (!strcmp(name, "vkCreateDisplayPlaneSurfaceKHR"))
- {
+ if (!strcmp(name, "vkCreateDisplayPlaneSurfaceKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_display");
return hasExt ? (void*)entry_vkCreateDisplayPlaneSurfaceKHR : nullptr;
}
#endif
#ifdef VK_KHR_display_swapchain
- if (!strcmp(name, "vkCreateSharedSwapchainsKHR"))
- {
+ if (!strcmp(name, "vkCreateSharedSwapchainsKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_display_swapchain");
return hasExt ? (void*)entry_vkCreateSharedSwapchainsKHR : nullptr;
}
#endif
#ifdef VK_KHR_xlib_surface
- if (!strcmp(name, "vkCreateXlibSurfaceKHR"))
- {
+ if (!strcmp(name, "vkCreateXlibSurfaceKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_xlib_surface");
return hasExt ? (void*)entry_vkCreateXlibSurfaceKHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceXlibPresentationSupportKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceXlibPresentationSupportKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_xlib_surface");
return hasExt ? (void*)entry_vkGetPhysicalDeviceXlibPresentationSupportKHR : nullptr;
}
#endif
#ifdef VK_KHR_xcb_surface
- if (!strcmp(name, "vkCreateXcbSurfaceKHR"))
- {
+ if (!strcmp(name, "vkCreateXcbSurfaceKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_xcb_surface");
return hasExt ? (void*)entry_vkCreateXcbSurfaceKHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceXcbPresentationSupportKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceXcbPresentationSupportKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_xcb_surface");
return hasExt ? (void*)entry_vkGetPhysicalDeviceXcbPresentationSupportKHR : nullptr;
}
#endif
#ifdef VK_KHR_wayland_surface
- if (!strcmp(name, "vkCreateWaylandSurfaceKHR"))
- {
+ if (!strcmp(name, "vkCreateWaylandSurfaceKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_wayland_surface");
return hasExt ? (void*)entry_vkCreateWaylandSurfaceKHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceWaylandPresentationSupportKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceWaylandPresentationSupportKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_wayland_surface");
return hasExt ? (void*)entry_vkGetPhysicalDeviceWaylandPresentationSupportKHR : nullptr;
}
#endif
#ifdef VK_KHR_android_surface
- if (!strcmp(name, "vkCreateAndroidSurfaceKHR"))
- {
+ if (!strcmp(name, "vkCreateAndroidSurfaceKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_android_surface");
return hasExt ? (void*)entry_vkCreateAndroidSurfaceKHR : nullptr;
}
#endif
#ifdef VK_KHR_win32_surface
- if (!strcmp(name, "vkCreateWin32SurfaceKHR"))
- {
+ if (!strcmp(name, "vkCreateWin32SurfaceKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_win32_surface");
return hasExt ? (void*)entry_vkCreateWin32SurfaceKHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceWin32PresentationSupportKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceWin32PresentationSupportKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_win32_surface");
return hasExt ? (void*)entry_vkGetPhysicalDeviceWin32PresentationSupportKHR : nullptr;
}
#endif
#ifdef VK_KHR_video_queue
- if (!strcmp(name, "vkGetPhysicalDeviceVideoCapabilitiesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceVideoCapabilitiesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_video_queue");
return hasExt ? (void*)entry_vkGetPhysicalDeviceVideoCapabilitiesKHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceVideoFormatPropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceVideoFormatPropertiesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_video_queue");
return hasExt ? (void*)entry_vkGetPhysicalDeviceVideoFormatPropertiesKHR : nullptr;
}
- if (!strcmp(name, "vkCreateVideoSessionKHR"))
- {
+ if (!strcmp(name, "vkCreateVideoSessionKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_video_queue");
return hasExt ? (void*)entry_vkCreateVideoSessionKHR : nullptr;
}
- if (!strcmp(name, "vkDestroyVideoSessionKHR"))
- {
+ if (!strcmp(name, "vkDestroyVideoSessionKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_video_queue");
return hasExt ? (void*)entry_vkDestroyVideoSessionKHR : nullptr;
}
- if (!strcmp(name, "vkGetVideoSessionMemoryRequirementsKHR"))
- {
+ if (!strcmp(name, "vkGetVideoSessionMemoryRequirementsKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_video_queue");
return hasExt ? (void*)entry_vkGetVideoSessionMemoryRequirementsKHR : nullptr;
}
- if (!strcmp(name, "vkBindVideoSessionMemoryKHR"))
- {
+ if (!strcmp(name, "vkBindVideoSessionMemoryKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_video_queue");
return hasExt ? (void*)entry_vkBindVideoSessionMemoryKHR : nullptr;
}
- if (!strcmp(name, "vkCreateVideoSessionParametersKHR"))
- {
+ if (!strcmp(name, "vkCreateVideoSessionParametersKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_video_queue");
return hasExt ? (void*)entry_vkCreateVideoSessionParametersKHR : nullptr;
}
- if (!strcmp(name, "vkUpdateVideoSessionParametersKHR"))
- {
+ if (!strcmp(name, "vkUpdateVideoSessionParametersKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_video_queue");
return hasExt ? (void*)entry_vkUpdateVideoSessionParametersKHR : nullptr;
}
- if (!strcmp(name, "vkDestroyVideoSessionParametersKHR"))
- {
+ if (!strcmp(name, "vkDestroyVideoSessionParametersKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_video_queue");
return hasExt ? (void*)entry_vkDestroyVideoSessionParametersKHR : nullptr;
}
- if (!strcmp(name, "vkCmdBeginVideoCodingKHR"))
- {
+ if (!strcmp(name, "vkCmdBeginVideoCodingKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_video_queue");
return hasExt ? (void*)entry_vkCmdBeginVideoCodingKHR : nullptr;
}
- if (!strcmp(name, "vkCmdEndVideoCodingKHR"))
- {
+ if (!strcmp(name, "vkCmdEndVideoCodingKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_video_queue");
return hasExt ? (void*)entry_vkCmdEndVideoCodingKHR : nullptr;
}
- if (!strcmp(name, "vkCmdControlVideoCodingKHR"))
- {
+ if (!strcmp(name, "vkCmdControlVideoCodingKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_video_queue");
return hasExt ? (void*)entry_vkCmdControlVideoCodingKHR : nullptr;
}
#endif
#ifdef VK_KHR_video_decode_queue
- if (!strcmp(name, "vkCmdDecodeVideoKHR"))
- {
+ if (!strcmp(name, "vkCmdDecodeVideoKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_video_decode_queue");
return hasExt ? (void*)entry_vkCmdDecodeVideoKHR : nullptr;
}
#endif
#ifdef VK_KHR_dynamic_rendering
- if (!strcmp(name, "vkCmdBeginRenderingKHR"))
- {
+ if (!strcmp(name, "vkCmdBeginRenderingKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering");
return hasExt ? (void*)entry_vkCmdBeginRenderingKHR : nullptr;
}
- if (!strcmp(name, "vkCmdEndRenderingKHR"))
- {
+ if (!strcmp(name, "vkCmdEndRenderingKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering");
return hasExt ? (void*)entry_vkCmdEndRenderingKHR : nullptr;
}
#endif
#ifdef VK_KHR_get_physical_device_properties2
- if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR"))
- {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
+ if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR")) {
+ bool hasExt =
+ resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceFeatures2KHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR"))
- {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
+ if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR")) {
+ bool hasExt =
+ resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceProperties2KHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR"))
- {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
+ if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR")) {
+ bool hasExt =
+ resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceFormatProperties2KHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR"))
- {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
+ if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR")) {
+ bool hasExt =
+ resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2KHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR"))
- {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
+ if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")) {
+ bool hasExt =
+ resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR"))
- {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
+ if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR")) {
+ bool hasExt =
+ resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2KHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR"))
- {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
+ if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")) {
+ bool hasExt =
+ resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR : nullptr;
}
#endif
#ifdef VK_KHR_device_group
- if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeaturesKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeaturesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_device_group");
return hasExt ? (void*)entry_vkGetDeviceGroupPeerMemoryFeaturesKHR : nullptr;
}
- if (!strcmp(name, "vkCmdSetDeviceMaskKHR"))
- {
+ if (!strcmp(name, "vkCmdSetDeviceMaskKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_device_group");
return hasExt ? (void*)entry_vkCmdSetDeviceMaskKHR : nullptr;
}
- if (!strcmp(name, "vkCmdDispatchBaseKHR"))
- {
+ if (!strcmp(name, "vkCmdDispatchBaseKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_device_group");
return hasExt ? (void*)entry_vkCmdDispatchBaseKHR : nullptr;
}
#endif
#ifdef VK_KHR_maintenance1
- if (!strcmp(name, "vkTrimCommandPoolKHR"))
- {
+ if (!strcmp(name, "vkTrimCommandPoolKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance1");
return hasExt ? (void*)entry_vkTrimCommandPoolKHR : nullptr;
}
#endif
#ifdef VK_KHR_device_group_creation
- if (!strcmp(name, "vkEnumeratePhysicalDeviceGroupsKHR"))
- {
+ if (!strcmp(name, "vkEnumeratePhysicalDeviceGroupsKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_device_group_creation");
return hasExt ? (void*)entry_vkEnumeratePhysicalDeviceGroupsKHR : nullptr;
}
#endif
#ifdef VK_KHR_external_memory_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_memory_capabilities");
return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR : nullptr;
}
#endif
#ifdef VK_KHR_external_memory_win32
- if (!strcmp(name, "vkGetMemoryWin32HandleKHR"))
- {
+ if (!strcmp(name, "vkGetMemoryWin32HandleKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_memory_win32");
return hasExt ? (void*)entry_vkGetMemoryWin32HandleKHR : nullptr;
}
- if (!strcmp(name, "vkGetMemoryWin32HandlePropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetMemoryWin32HandlePropertiesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_memory_win32");
return hasExt ? (void*)entry_vkGetMemoryWin32HandlePropertiesKHR : nullptr;
}
#endif
#ifdef VK_KHR_external_memory_fd
- if (!strcmp(name, "vkGetMemoryFdKHR"))
- {
+ if (!strcmp(name, "vkGetMemoryFdKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_memory_fd");
return hasExt ? (void*)entry_vkGetMemoryFdKHR : nullptr;
}
- if (!strcmp(name, "vkGetMemoryFdPropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetMemoryFdPropertiesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_memory_fd");
return hasExt ? (void*)entry_vkGetMemoryFdPropertiesKHR : nullptr;
}
#endif
#ifdef VK_KHR_external_semaphore_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"))
- {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_capabilities");
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")) {
+ bool hasExt =
+ resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_capabilities");
return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR : nullptr;
}
#endif
#ifdef VK_KHR_external_semaphore_win32
- if (!strcmp(name, "vkImportSemaphoreWin32HandleKHR"))
- {
+ if (!strcmp(name, "vkImportSemaphoreWin32HandleKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_win32");
return hasExt ? (void*)entry_vkImportSemaphoreWin32HandleKHR : nullptr;
}
- if (!strcmp(name, "vkGetSemaphoreWin32HandleKHR"))
- {
+ if (!strcmp(name, "vkGetSemaphoreWin32HandleKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_win32");
return hasExt ? (void*)entry_vkGetSemaphoreWin32HandleKHR : nullptr;
}
#endif
#ifdef VK_KHR_external_semaphore_fd
- if (!strcmp(name, "vkImportSemaphoreFdKHR"))
- {
+ if (!strcmp(name, "vkImportSemaphoreFdKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd");
return hasExt ? (void*)entry_vkImportSemaphoreFdKHR : nullptr;
}
- if (!strcmp(name, "vkGetSemaphoreFdKHR"))
- {
+ if (!strcmp(name, "vkGetSemaphoreFdKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd");
return hasExt ? (void*)entry_vkGetSemaphoreFdKHR : nullptr;
}
#endif
#ifdef VK_KHR_push_descriptor
- if (!strcmp(name, "vkCmdPushDescriptorSetKHR"))
- {
+ if (!strcmp(name, "vkCmdPushDescriptorSetKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_push_descriptor");
return hasExt ? (void*)entry_vkCmdPushDescriptorSetKHR : nullptr;
}
- if (!strcmp(name, "vkCmdPushDescriptorSetWithTemplateKHR"))
- {
+ if (!strcmp(name, "vkCmdPushDescriptorSetWithTemplateKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_push_descriptor");
return hasExt ? (void*)entry_vkCmdPushDescriptorSetWithTemplateKHR : nullptr;
}
#endif
#ifdef VK_KHR_descriptor_update_template
- if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR"))
- {
+ if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template");
return hasExt ? (void*)entry_vkCreateDescriptorUpdateTemplateKHR : nullptr;
}
- if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR"))
- {
+ if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template");
return hasExt ? (void*)entry_vkDestroyDescriptorUpdateTemplateKHR : nullptr;
}
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR"))
- {
+ if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template");
return hasExt ? (void*)entry_vkUpdateDescriptorSetWithTemplateKHR : nullptr;
}
#endif
#ifdef VK_KHR_create_renderpass2
- if (!strcmp(name, "vkCreateRenderPass2KHR"))
- {
+ if (!strcmp(name, "vkCreateRenderPass2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2");
return hasExt ? (void*)entry_vkCreateRenderPass2KHR : nullptr;
}
- if (!strcmp(name, "vkCmdBeginRenderPass2KHR"))
- {
+ if (!strcmp(name, "vkCmdBeginRenderPass2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2");
return hasExt ? (void*)entry_vkCmdBeginRenderPass2KHR : nullptr;
}
- if (!strcmp(name, "vkCmdNextSubpass2KHR"))
- {
+ if (!strcmp(name, "vkCmdNextSubpass2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2");
return hasExt ? (void*)entry_vkCmdNextSubpass2KHR : nullptr;
}
- if (!strcmp(name, "vkCmdEndRenderPass2KHR"))
- {
+ if (!strcmp(name, "vkCmdEndRenderPass2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2");
return hasExt ? (void*)entry_vkCmdEndRenderPass2KHR : nullptr;
}
#endif
#ifdef VK_KHR_shared_presentable_image
- if (!strcmp(name, "vkGetSwapchainStatusKHR"))
- {
+ if (!strcmp(name, "vkGetSwapchainStatusKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_shared_presentable_image");
return hasExt ? (void*)entry_vkGetSwapchainStatusKHR : nullptr;
}
#endif
#ifdef VK_KHR_external_fence_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_capabilities");
return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalFencePropertiesKHR : nullptr;
}
#endif
#ifdef VK_KHR_external_fence_win32
- if (!strcmp(name, "vkImportFenceWin32HandleKHR"))
- {
+ if (!strcmp(name, "vkImportFenceWin32HandleKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_win32");
return hasExt ? (void*)entry_vkImportFenceWin32HandleKHR : nullptr;
}
- if (!strcmp(name, "vkGetFenceWin32HandleKHR"))
- {
+ if (!strcmp(name, "vkGetFenceWin32HandleKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_win32");
return hasExt ? (void*)entry_vkGetFenceWin32HandleKHR : nullptr;
}
#endif
#ifdef VK_KHR_external_fence_fd
- if (!strcmp(name, "vkImportFenceFdKHR"))
- {
+ if (!strcmp(name, "vkImportFenceFdKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd");
return hasExt ? (void*)entry_vkImportFenceFdKHR : nullptr;
}
- if (!strcmp(name, "vkGetFenceFdKHR"))
- {
+ if (!strcmp(name, "vkGetFenceFdKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd");
return hasExt ? (void*)entry_vkGetFenceFdKHR : nullptr;
}
#endif
#ifdef VK_KHR_performance_query
- if (!strcmp(name, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"))
- {
+ if (!strcmp(name, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_performance_query");
- return hasExt ? (void*)entry_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR : nullptr;
+ return hasExt ? (void*)entry_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR
+ : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_performance_query");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR : nullptr;
+ return hasExt ? (void*)entry_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR
+ : nullptr;
}
- if (!strcmp(name, "vkAcquireProfilingLockKHR"))
- {
+ if (!strcmp(name, "vkAcquireProfilingLockKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_performance_query");
return hasExt ? (void*)entry_vkAcquireProfilingLockKHR : nullptr;
}
- if (!strcmp(name, "vkReleaseProfilingLockKHR"))
- {
+ if (!strcmp(name, "vkReleaseProfilingLockKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_performance_query");
return hasExt ? (void*)entry_vkReleaseProfilingLockKHR : nullptr;
}
#endif
#ifdef VK_KHR_get_surface_capabilities2
- if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2KHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_surface_capabilities2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceCapabilities2KHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormats2KHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceFormats2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_surface_capabilities2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceFormats2KHR : nullptr;
}
#endif
#ifdef VK_KHR_get_display_properties2
- if (!strcmp(name, "vkGetPhysicalDeviceDisplayProperties2KHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayProperties2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_display_properties2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceDisplayProperties2KHR : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_display_properties2");
return hasExt ? (void*)entry_vkGetPhysicalDeviceDisplayPlaneProperties2KHR : nullptr;
}
- if (!strcmp(name, "vkGetDisplayModeProperties2KHR"))
- {
+ if (!strcmp(name, "vkGetDisplayModeProperties2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_display_properties2");
return hasExt ? (void*)entry_vkGetDisplayModeProperties2KHR : nullptr;
}
- if (!strcmp(name, "vkGetDisplayPlaneCapabilities2KHR"))
- {
+ if (!strcmp(name, "vkGetDisplayPlaneCapabilities2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_display_properties2");
return hasExt ? (void*)entry_vkGetDisplayPlaneCapabilities2KHR : nullptr;
}
#endif
#ifdef VK_KHR_get_memory_requirements2
- if (!strcmp(name, "vkGetImageMemoryRequirements2KHR"))
- {
+ if (!strcmp(name, "vkGetImageMemoryRequirements2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2");
return hasExt ? (void*)entry_vkGetImageMemoryRequirements2KHR : nullptr;
}
- if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR"))
- {
+ if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2");
return hasExt ? (void*)entry_vkGetBufferMemoryRequirements2KHR : nullptr;
}
- if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR"))
- {
+ if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2");
return hasExt ? (void*)entry_vkGetImageSparseMemoryRequirements2KHR : nullptr;
}
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
- if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR"))
- {
+ if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion");
return hasExt ? (void*)entry_vkCreateSamplerYcbcrConversionKHR : nullptr;
}
- if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR"))
- {
+ if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion");
return hasExt ? (void*)entry_vkDestroySamplerYcbcrConversionKHR : nullptr;
}
#endif
#ifdef VK_KHR_bind_memory2
- if (!strcmp(name, "vkBindBufferMemory2KHR"))
- {
+ if (!strcmp(name, "vkBindBufferMemory2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_bind_memory2");
return hasExt ? (void*)entry_vkBindBufferMemory2KHR : nullptr;
}
- if (!strcmp(name, "vkBindImageMemory2KHR"))
- {
+ if (!strcmp(name, "vkBindImageMemory2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_bind_memory2");
return hasExt ? (void*)entry_vkBindImageMemory2KHR : nullptr;
}
#endif
#ifdef VK_KHR_maintenance3
- if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR"))
- {
+ if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance3");
return hasExt ? (void*)entry_vkGetDescriptorSetLayoutSupportKHR : nullptr;
}
#endif
#ifdef VK_KHR_draw_indirect_count
- if (!strcmp(name, "vkCmdDrawIndirectCountKHR"))
- {
+ if (!strcmp(name, "vkCmdDrawIndirectCountKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_draw_indirect_count");
return hasExt ? (void*)entry_vkCmdDrawIndirectCountKHR : nullptr;
}
- if (!strcmp(name, "vkCmdDrawIndexedIndirectCountKHR"))
- {
+ if (!strcmp(name, "vkCmdDrawIndexedIndirectCountKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_draw_indirect_count");
return hasExt ? (void*)entry_vkCmdDrawIndexedIndirectCountKHR : nullptr;
}
#endif
#ifdef VK_KHR_timeline_semaphore
- if (!strcmp(name, "vkGetSemaphoreCounterValueKHR"))
- {
+ if (!strcmp(name, "vkGetSemaphoreCounterValueKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_timeline_semaphore");
return hasExt ? (void*)entry_vkGetSemaphoreCounterValueKHR : nullptr;
}
- if (!strcmp(name, "vkWaitSemaphoresKHR"))
- {
+ if (!strcmp(name, "vkWaitSemaphoresKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_timeline_semaphore");
return hasExt ? (void*)entry_vkWaitSemaphoresKHR : nullptr;
}
- if (!strcmp(name, "vkSignalSemaphoreKHR"))
- {
+ if (!strcmp(name, "vkSignalSemaphoreKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_timeline_semaphore");
return hasExt ? (void*)entry_vkSignalSemaphoreKHR : nullptr;
}
#endif
#ifdef VK_KHR_fragment_shading_rate
- if (!strcmp(name, "vkGetPhysicalDeviceFragmentShadingRatesKHR"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceFragmentShadingRatesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_fragment_shading_rate");
return hasExt ? (void*)entry_vkGetPhysicalDeviceFragmentShadingRatesKHR : nullptr;
}
- if (!strcmp(name, "vkCmdSetFragmentShadingRateKHR"))
- {
+ if (!strcmp(name, "vkCmdSetFragmentShadingRateKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_fragment_shading_rate");
return hasExt ? (void*)entry_vkCmdSetFragmentShadingRateKHR : nullptr;
}
#endif
#ifdef VK_KHR_present_wait
- if (!strcmp(name, "vkWaitForPresentKHR"))
- {
+ if (!strcmp(name, "vkWaitForPresentKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_present_wait");
return hasExt ? (void*)entry_vkWaitForPresentKHR : nullptr;
}
#endif
#ifdef VK_KHR_buffer_device_address
- if (!strcmp(name, "vkGetBufferDeviceAddressKHR"))
- {
+ if (!strcmp(name, "vkGetBufferDeviceAddressKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address");
return hasExt ? (void*)entry_vkGetBufferDeviceAddressKHR : nullptr;
}
- if (!strcmp(name, "vkGetBufferOpaqueCaptureAddressKHR"))
- {
+ if (!strcmp(name, "vkGetBufferOpaqueCaptureAddressKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address");
return hasExt ? (void*)entry_vkGetBufferOpaqueCaptureAddressKHR : nullptr;
}
- if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddressKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddressKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address");
return hasExt ? (void*)entry_vkGetDeviceMemoryOpaqueCaptureAddressKHR : nullptr;
}
#endif
#ifdef VK_KHR_deferred_host_operations
- if (!strcmp(name, "vkCreateDeferredOperationKHR"))
- {
+ if (!strcmp(name, "vkCreateDeferredOperationKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_deferred_host_operations");
return hasExt ? (void*)entry_vkCreateDeferredOperationKHR : nullptr;
}
- if (!strcmp(name, "vkDestroyDeferredOperationKHR"))
- {
+ if (!strcmp(name, "vkDestroyDeferredOperationKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_deferred_host_operations");
return hasExt ? (void*)entry_vkDestroyDeferredOperationKHR : nullptr;
}
- if (!strcmp(name, "vkGetDeferredOperationMaxConcurrencyKHR"))
- {
+ if (!strcmp(name, "vkGetDeferredOperationMaxConcurrencyKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_deferred_host_operations");
return hasExt ? (void*)entry_vkGetDeferredOperationMaxConcurrencyKHR : nullptr;
}
- if (!strcmp(name, "vkGetDeferredOperationResultKHR"))
- {
+ if (!strcmp(name, "vkGetDeferredOperationResultKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_deferred_host_operations");
return hasExt ? (void*)entry_vkGetDeferredOperationResultKHR : nullptr;
}
- if (!strcmp(name, "vkDeferredOperationJoinKHR"))
- {
+ if (!strcmp(name, "vkDeferredOperationJoinKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_deferred_host_operations");
return hasExt ? (void*)entry_vkDeferredOperationJoinKHR : nullptr;
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
- if (!strcmp(name, "vkGetPipelineExecutablePropertiesKHR"))
- {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties");
+ if (!strcmp(name, "vkGetPipelineExecutablePropertiesKHR")) {
+ bool hasExt =
+ resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties");
return hasExt ? (void*)entry_vkGetPipelineExecutablePropertiesKHR : nullptr;
}
- if (!strcmp(name, "vkGetPipelineExecutableStatisticsKHR"))
- {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties");
+ if (!strcmp(name, "vkGetPipelineExecutableStatisticsKHR")) {
+ bool hasExt =
+ resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties");
return hasExt ? (void*)entry_vkGetPipelineExecutableStatisticsKHR : nullptr;
}
- if (!strcmp(name, "vkGetPipelineExecutableInternalRepresentationsKHR"))
- {
- bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties");
+ if (!strcmp(name, "vkGetPipelineExecutableInternalRepresentationsKHR")) {
+ bool hasExt =
+ resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties");
return hasExt ? (void*)entry_vkGetPipelineExecutableInternalRepresentationsKHR : nullptr;
}
#endif
#ifdef VK_KHR_video_encode_queue
- if (!strcmp(name, "vkCmdEncodeVideoKHR"))
- {
+ if (!strcmp(name, "vkCmdEncodeVideoKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_video_encode_queue");
return hasExt ? (void*)entry_vkCmdEncodeVideoKHR : nullptr;
}
#endif
#ifdef VK_KHR_synchronization2
- if (!strcmp(name, "vkCmdSetEvent2KHR"))
- {
+ if (!strcmp(name, "vkCmdSetEvent2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
return hasExt ? (void*)entry_vkCmdSetEvent2KHR : nullptr;
}
- if (!strcmp(name, "vkCmdResetEvent2KHR"))
- {
+ if (!strcmp(name, "vkCmdResetEvent2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
return hasExt ? (void*)entry_vkCmdResetEvent2KHR : nullptr;
}
- if (!strcmp(name, "vkCmdWaitEvents2KHR"))
- {
+ if (!strcmp(name, "vkCmdWaitEvents2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
return hasExt ? (void*)entry_vkCmdWaitEvents2KHR : nullptr;
}
- if (!strcmp(name, "vkCmdPipelineBarrier2KHR"))
- {
+ if (!strcmp(name, "vkCmdPipelineBarrier2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
return hasExt ? (void*)entry_vkCmdPipelineBarrier2KHR : nullptr;
}
- if (!strcmp(name, "vkCmdWriteTimestamp2KHR"))
- {
+ if (!strcmp(name, "vkCmdWriteTimestamp2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
return hasExt ? (void*)entry_vkCmdWriteTimestamp2KHR : nullptr;
}
- if (!strcmp(name, "vkQueueSubmit2KHR"))
- {
+ if (!strcmp(name, "vkQueueSubmit2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
return hasExt ? (void*)entry_vkQueueSubmit2KHR : nullptr;
}
- if (!strcmp(name, "vkCmdWriteBufferMarker2AMD"))
- {
+ if (!strcmp(name, "vkCmdWriteBufferMarker2AMD")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
return hasExt ? (void*)entry_vkCmdWriteBufferMarker2AMD : nullptr;
}
- if (!strcmp(name, "vkGetQueueCheckpointData2NV"))
- {
+ if (!strcmp(name, "vkGetQueueCheckpointData2NV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
return hasExt ? (void*)entry_vkGetQueueCheckpointData2NV : nullptr;
}
#endif
#ifdef VK_KHR_copy_commands2
- if (!strcmp(name, "vkCmdCopyBuffer2KHR"))
- {
+ if (!strcmp(name, "vkCmdCopyBuffer2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
return hasExt ? (void*)entry_vkCmdCopyBuffer2KHR : nullptr;
}
- if (!strcmp(name, "vkCmdCopyImage2KHR"))
- {
+ if (!strcmp(name, "vkCmdCopyImage2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
return hasExt ? (void*)entry_vkCmdCopyImage2KHR : nullptr;
}
- if (!strcmp(name, "vkCmdCopyBufferToImage2KHR"))
- {
+ if (!strcmp(name, "vkCmdCopyBufferToImage2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
return hasExt ? (void*)entry_vkCmdCopyBufferToImage2KHR : nullptr;
}
- if (!strcmp(name, "vkCmdCopyImageToBuffer2KHR"))
- {
+ if (!strcmp(name, "vkCmdCopyImageToBuffer2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
return hasExt ? (void*)entry_vkCmdCopyImageToBuffer2KHR : nullptr;
}
- if (!strcmp(name, "vkCmdBlitImage2KHR"))
- {
+ if (!strcmp(name, "vkCmdBlitImage2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
return hasExt ? (void*)entry_vkCmdBlitImage2KHR : nullptr;
}
- if (!strcmp(name, "vkCmdResolveImage2KHR"))
- {
+ if (!strcmp(name, "vkCmdResolveImage2KHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
return hasExt ? (void*)entry_vkCmdResolveImage2KHR : nullptr;
}
#endif
#ifdef VK_KHR_maintenance4
- if (!strcmp(name, "vkGetDeviceBufferMemoryRequirementsKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceBufferMemoryRequirementsKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance4");
return hasExt ? (void*)entry_vkGetDeviceBufferMemoryRequirementsKHR : nullptr;
}
- if (!strcmp(name, "vkGetDeviceImageMemoryRequirementsKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceImageMemoryRequirementsKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance4");
return hasExt ? (void*)entry_vkGetDeviceImageMemoryRequirementsKHR : nullptr;
}
- if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirementsKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirementsKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance4");
return hasExt ? (void*)entry_vkGetDeviceImageSparseMemoryRequirementsKHR : nullptr;
}
#endif
#ifdef VK_ANDROID_native_buffer
- if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID"))
- {
+ if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer");
return hasExt ? (void*)entry_vkGetSwapchainGrallocUsageANDROID : nullptr;
}
- if (!strcmp(name, "vkAcquireImageANDROID"))
- {
+ if (!strcmp(name, "vkAcquireImageANDROID")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer");
return hasExt ? (void*)entry_vkAcquireImageANDROID : nullptr;
}
- if (!strcmp(name, "vkQueueSignalReleaseImageANDROID"))
- {
+ if (!strcmp(name, "vkQueueSignalReleaseImageANDROID")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer");
return hasExt ? (void*)entry_vkQueueSignalReleaseImageANDROID : nullptr;
}
#endif
#ifdef VK_EXT_debug_report
- if (!strcmp(name, "vkCreateDebugReportCallbackEXT"))
- {
+ if (!strcmp(name, "vkCreateDebugReportCallbackEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_report");
return hasExt ? (void*)entry_vkCreateDebugReportCallbackEXT : nullptr;
}
- if (!strcmp(name, "vkDestroyDebugReportCallbackEXT"))
- {
+ if (!strcmp(name, "vkDestroyDebugReportCallbackEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_report");
return hasExt ? (void*)entry_vkDestroyDebugReportCallbackEXT : nullptr;
}
- if (!strcmp(name, "vkDebugReportMessageEXT"))
- {
+ if (!strcmp(name, "vkDebugReportMessageEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_report");
return hasExt ? (void*)entry_vkDebugReportMessageEXT : nullptr;
}
#endif
#ifdef VK_EXT_debug_marker
- if (!strcmp(name, "vkDebugMarkerSetObjectTagEXT"))
- {
+ if (!strcmp(name, "vkDebugMarkerSetObjectTagEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_marker");
return hasExt ? (void*)entry_vkDebugMarkerSetObjectTagEXT : nullptr;
}
- if (!strcmp(name, "vkDebugMarkerSetObjectNameEXT"))
- {
+ if (!strcmp(name, "vkDebugMarkerSetObjectNameEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_marker");
return hasExt ? (void*)entry_vkDebugMarkerSetObjectNameEXT : nullptr;
}
- if (!strcmp(name, "vkCmdDebugMarkerBeginEXT"))
- {
+ if (!strcmp(name, "vkCmdDebugMarkerBeginEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_marker");
return hasExt ? (void*)entry_vkCmdDebugMarkerBeginEXT : nullptr;
}
- if (!strcmp(name, "vkCmdDebugMarkerEndEXT"))
- {
+ if (!strcmp(name, "vkCmdDebugMarkerEndEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_marker");
return hasExt ? (void*)entry_vkCmdDebugMarkerEndEXT : nullptr;
}
- if (!strcmp(name, "vkCmdDebugMarkerInsertEXT"))
- {
+ if (!strcmp(name, "vkCmdDebugMarkerInsertEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_marker");
return hasExt ? (void*)entry_vkCmdDebugMarkerInsertEXT : nullptr;
}
#endif
#ifdef VK_EXT_transform_feedback
- if (!strcmp(name, "vkCmdBindTransformFeedbackBuffersEXT"))
- {
+ if (!strcmp(name, "vkCmdBindTransformFeedbackBuffersEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
return hasExt ? (void*)entry_vkCmdBindTransformFeedbackBuffersEXT : nullptr;
}
- if (!strcmp(name, "vkCmdBeginTransformFeedbackEXT"))
- {
+ if (!strcmp(name, "vkCmdBeginTransformFeedbackEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
return hasExt ? (void*)entry_vkCmdBeginTransformFeedbackEXT : nullptr;
}
- if (!strcmp(name, "vkCmdEndTransformFeedbackEXT"))
- {
+ if (!strcmp(name, "vkCmdEndTransformFeedbackEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
return hasExt ? (void*)entry_vkCmdEndTransformFeedbackEXT : nullptr;
}
- if (!strcmp(name, "vkCmdBeginQueryIndexedEXT"))
- {
+ if (!strcmp(name, "vkCmdBeginQueryIndexedEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
return hasExt ? (void*)entry_vkCmdBeginQueryIndexedEXT : nullptr;
}
- if (!strcmp(name, "vkCmdEndQueryIndexedEXT"))
- {
+ if (!strcmp(name, "vkCmdEndQueryIndexedEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
return hasExt ? (void*)entry_vkCmdEndQueryIndexedEXT : nullptr;
}
- if (!strcmp(name, "vkCmdDrawIndirectByteCountEXT"))
- {
+ if (!strcmp(name, "vkCmdDrawIndirectByteCountEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
return hasExt ? (void*)entry_vkCmdDrawIndirectByteCountEXT : nullptr;
}
#endif
#ifdef VK_NVX_binary_import
- if (!strcmp(name, "vkCreateCuModuleNVX"))
- {
+ if (!strcmp(name, "vkCreateCuModuleNVX")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NVX_binary_import");
return hasExt ? (void*)entry_vkCreateCuModuleNVX : nullptr;
}
- if (!strcmp(name, "vkCreateCuFunctionNVX"))
- {
+ if (!strcmp(name, "vkCreateCuFunctionNVX")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NVX_binary_import");
return hasExt ? (void*)entry_vkCreateCuFunctionNVX : nullptr;
}
- if (!strcmp(name, "vkDestroyCuModuleNVX"))
- {
+ if (!strcmp(name, "vkDestroyCuModuleNVX")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NVX_binary_import");
return hasExt ? (void*)entry_vkDestroyCuModuleNVX : nullptr;
}
- if (!strcmp(name, "vkDestroyCuFunctionNVX"))
- {
+ if (!strcmp(name, "vkDestroyCuFunctionNVX")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NVX_binary_import");
return hasExt ? (void*)entry_vkDestroyCuFunctionNVX : nullptr;
}
- if (!strcmp(name, "vkCmdCuLaunchKernelNVX"))
- {
+ if (!strcmp(name, "vkCmdCuLaunchKernelNVX")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NVX_binary_import");
return hasExt ? (void*)entry_vkCmdCuLaunchKernelNVX : nullptr;
}
#endif
#ifdef VK_NVX_image_view_handle
- if (!strcmp(name, "vkGetImageViewHandleNVX"))
- {
+ if (!strcmp(name, "vkGetImageViewHandleNVX")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NVX_image_view_handle");
return hasExt ? (void*)entry_vkGetImageViewHandleNVX : nullptr;
}
- if (!strcmp(name, "vkGetImageViewAddressNVX"))
- {
+ if (!strcmp(name, "vkGetImageViewAddressNVX")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NVX_image_view_handle");
return hasExt ? (void*)entry_vkGetImageViewAddressNVX : nullptr;
}
#endif
#ifdef VK_AMD_draw_indirect_count
- if (!strcmp(name, "vkCmdDrawIndirectCountAMD"))
- {
+ if (!strcmp(name, "vkCmdDrawIndirectCountAMD")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_AMD_draw_indirect_count");
return hasExt ? (void*)entry_vkCmdDrawIndirectCountAMD : nullptr;
}
- if (!strcmp(name, "vkCmdDrawIndexedIndirectCountAMD"))
- {
+ if (!strcmp(name, "vkCmdDrawIndexedIndirectCountAMD")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_AMD_draw_indirect_count");
return hasExt ? (void*)entry_vkCmdDrawIndexedIndirectCountAMD : nullptr;
}
#endif
#ifdef VK_AMD_shader_info
- if (!strcmp(name, "vkGetShaderInfoAMD"))
- {
+ if (!strcmp(name, "vkGetShaderInfoAMD")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_AMD_shader_info");
return hasExt ? (void*)entry_vkGetShaderInfoAMD : nullptr;
}
#endif
#ifdef VK_GGP_stream_descriptor_surface
- if (!strcmp(name, "vkCreateStreamDescriptorSurfaceGGP"))
- {
+ if (!strcmp(name, "vkCreateStreamDescriptorSurfaceGGP")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GGP_stream_descriptor_surface");
return hasExt ? (void*)entry_vkCreateStreamDescriptorSurfaceGGP : nullptr;
}
#endif
#ifdef VK_NV_external_memory_capabilities
- if (!strcmp(name, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_external_memory_capabilities");
return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalImageFormatPropertiesNV : nullptr;
}
#endif
#ifdef VK_NV_external_memory_win32
- if (!strcmp(name, "vkGetMemoryWin32HandleNV"))
- {
+ if (!strcmp(name, "vkGetMemoryWin32HandleNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_external_memory_win32");
return hasExt ? (void*)entry_vkGetMemoryWin32HandleNV : nullptr;
}
#endif
#ifdef VK_NN_vi_surface
- if (!strcmp(name, "vkCreateViSurfaceNN"))
- {
+ if (!strcmp(name, "vkCreateViSurfaceNN")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NN_vi_surface");
return hasExt ? (void*)entry_vkCreateViSurfaceNN : nullptr;
}
#endif
#ifdef VK_EXT_conditional_rendering
- if (!strcmp(name, "vkCmdBeginConditionalRenderingEXT"))
- {
+ if (!strcmp(name, "vkCmdBeginConditionalRenderingEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_conditional_rendering");
return hasExt ? (void*)entry_vkCmdBeginConditionalRenderingEXT : nullptr;
}
- if (!strcmp(name, "vkCmdEndConditionalRenderingEXT"))
- {
+ if (!strcmp(name, "vkCmdEndConditionalRenderingEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_conditional_rendering");
return hasExt ? (void*)entry_vkCmdEndConditionalRenderingEXT : nullptr;
}
#endif
#ifdef VK_NV_clip_space_w_scaling
- if (!strcmp(name, "vkCmdSetViewportWScalingNV"))
- {
+ if (!strcmp(name, "vkCmdSetViewportWScalingNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_clip_space_w_scaling");
return hasExt ? (void*)entry_vkCmdSetViewportWScalingNV : nullptr;
}
#endif
#ifdef VK_EXT_direct_mode_display
- if (!strcmp(name, "vkReleaseDisplayEXT"))
- {
+ if (!strcmp(name, "vkReleaseDisplayEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_direct_mode_display");
return hasExt ? (void*)entry_vkReleaseDisplayEXT : nullptr;
}
#endif
#ifdef VK_EXT_acquire_xlib_display
- if (!strcmp(name, "vkAcquireXlibDisplayEXT"))
- {
+ if (!strcmp(name, "vkAcquireXlibDisplayEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_acquire_xlib_display");
return hasExt ? (void*)entry_vkAcquireXlibDisplayEXT : nullptr;
}
- if (!strcmp(name, "vkGetRandROutputDisplayEXT"))
- {
+ if (!strcmp(name, "vkGetRandROutputDisplayEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_acquire_xlib_display");
return hasExt ? (void*)entry_vkGetRandROutputDisplayEXT : nullptr;
}
#endif
#ifdef VK_EXT_display_surface_counter
- if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_display_surface_counter");
return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfaceCapabilities2EXT : nullptr;
}
#endif
#ifdef VK_EXT_display_control
- if (!strcmp(name, "vkDisplayPowerControlEXT"))
- {
+ if (!strcmp(name, "vkDisplayPowerControlEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_display_control");
return hasExt ? (void*)entry_vkDisplayPowerControlEXT : nullptr;
}
- if (!strcmp(name, "vkRegisterDeviceEventEXT"))
- {
+ if (!strcmp(name, "vkRegisterDeviceEventEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_display_control");
return hasExt ? (void*)entry_vkRegisterDeviceEventEXT : nullptr;
}
- if (!strcmp(name, "vkRegisterDisplayEventEXT"))
- {
+ if (!strcmp(name, "vkRegisterDisplayEventEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_display_control");
return hasExt ? (void*)entry_vkRegisterDisplayEventEXT : nullptr;
}
- if (!strcmp(name, "vkGetSwapchainCounterEXT"))
- {
+ if (!strcmp(name, "vkGetSwapchainCounterEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_display_control");
return hasExt ? (void*)entry_vkGetSwapchainCounterEXT : nullptr;
}
#endif
#ifdef VK_GOOGLE_display_timing
- if (!strcmp(name, "vkGetRefreshCycleDurationGOOGLE"))
- {
+ if (!strcmp(name, "vkGetRefreshCycleDurationGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_display_timing");
return hasExt ? (void*)entry_vkGetRefreshCycleDurationGOOGLE : nullptr;
}
- if (!strcmp(name, "vkGetPastPresentationTimingGOOGLE"))
- {
+ if (!strcmp(name, "vkGetPastPresentationTimingGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_display_timing");
return hasExt ? (void*)entry_vkGetPastPresentationTimingGOOGLE : nullptr;
}
#endif
#ifdef VK_EXT_discard_rectangles
- if (!strcmp(name, "vkCmdSetDiscardRectangleEXT"))
- {
+ if (!strcmp(name, "vkCmdSetDiscardRectangleEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_discard_rectangles");
return hasExt ? (void*)entry_vkCmdSetDiscardRectangleEXT : nullptr;
}
#endif
#ifdef VK_EXT_hdr_metadata
- if (!strcmp(name, "vkSetHdrMetadataEXT"))
- {
+ if (!strcmp(name, "vkSetHdrMetadataEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_hdr_metadata");
return hasExt ? (void*)entry_vkSetHdrMetadataEXT : nullptr;
}
#endif
#ifdef VK_MVK_ios_surface
- if (!strcmp(name, "vkCreateIOSSurfaceMVK"))
- {
+ if (!strcmp(name, "vkCreateIOSSurfaceMVK")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_MVK_ios_surface");
return hasExt ? (void*)entry_vkCreateIOSSurfaceMVK : nullptr;
}
#endif
#ifdef VK_MVK_macos_surface
- if (!strcmp(name, "vkCreateMacOSSurfaceMVK"))
- {
+ if (!strcmp(name, "vkCreateMacOSSurfaceMVK")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_MVK_macos_surface");
return hasExt ? (void*)entry_vkCreateMacOSSurfaceMVK : nullptr;
}
#endif
#ifdef VK_MVK_moltenvk
- if (!strcmp(name, "vkGetMTLDeviceMVK"))
- {
+ if (!strcmp(name, "vkGetMTLDeviceMVK")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_MVK_moltenvk");
return hasExt ? (void*)entry_vkGetMTLDeviceMVK : nullptr;
}
- if (!strcmp(name, "vkSetMTLTextureMVK"))
- {
+ if (!strcmp(name, "vkSetMTLTextureMVK")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_MVK_moltenvk");
return hasExt ? (void*)entry_vkSetMTLTextureMVK : nullptr;
}
- if (!strcmp(name, "vkGetMTLTextureMVK"))
- {
+ if (!strcmp(name, "vkGetMTLTextureMVK")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_MVK_moltenvk");
return hasExt ? (void*)entry_vkGetMTLTextureMVK : nullptr;
}
- if (!strcmp(name, "vkGetMTLBufferMVK"))
- {
+ if (!strcmp(name, "vkGetMTLBufferMVK")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_MVK_moltenvk");
return hasExt ? (void*)entry_vkGetMTLBufferMVK : nullptr;
}
- if (!strcmp(name, "vkUseIOSurfaceMVK"))
- {
+ if (!strcmp(name, "vkUseIOSurfaceMVK")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_MVK_moltenvk");
return hasExt ? (void*)entry_vkUseIOSurfaceMVK : nullptr;
}
- if (!strcmp(name, "vkGetIOSurfaceMVK"))
- {
+ if (!strcmp(name, "vkGetIOSurfaceMVK")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_MVK_moltenvk");
return hasExt ? (void*)entry_vkGetIOSurfaceMVK : nullptr;
}
#endif
#ifdef VK_EXT_debug_utils
- if (!strcmp(name, "vkSetDebugUtilsObjectNameEXT"))
- {
+ if (!strcmp(name, "vkSetDebugUtilsObjectNameEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils");
return hasExt ? (void*)entry_vkSetDebugUtilsObjectNameEXT : nullptr;
}
- if (!strcmp(name, "vkSetDebugUtilsObjectTagEXT"))
- {
+ if (!strcmp(name, "vkSetDebugUtilsObjectTagEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils");
return hasExt ? (void*)entry_vkSetDebugUtilsObjectTagEXT : nullptr;
}
- if (!strcmp(name, "vkQueueBeginDebugUtilsLabelEXT"))
- {
+ if (!strcmp(name, "vkQueueBeginDebugUtilsLabelEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils");
return hasExt ? (void*)entry_vkQueueBeginDebugUtilsLabelEXT : nullptr;
}
- if (!strcmp(name, "vkQueueEndDebugUtilsLabelEXT"))
- {
+ if (!strcmp(name, "vkQueueEndDebugUtilsLabelEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils");
return hasExt ? (void*)entry_vkQueueEndDebugUtilsLabelEXT : nullptr;
}
- if (!strcmp(name, "vkQueueInsertDebugUtilsLabelEXT"))
- {
+ if (!strcmp(name, "vkQueueInsertDebugUtilsLabelEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils");
return hasExt ? (void*)entry_vkQueueInsertDebugUtilsLabelEXT : nullptr;
}
- if (!strcmp(name, "vkCmdBeginDebugUtilsLabelEXT"))
- {
+ if (!strcmp(name, "vkCmdBeginDebugUtilsLabelEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils");
return hasExt ? (void*)entry_vkCmdBeginDebugUtilsLabelEXT : nullptr;
}
- if (!strcmp(name, "vkCmdEndDebugUtilsLabelEXT"))
- {
+ if (!strcmp(name, "vkCmdEndDebugUtilsLabelEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils");
return hasExt ? (void*)entry_vkCmdEndDebugUtilsLabelEXT : nullptr;
}
- if (!strcmp(name, "vkCmdInsertDebugUtilsLabelEXT"))
- {
+ if (!strcmp(name, "vkCmdInsertDebugUtilsLabelEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils");
return hasExt ? (void*)entry_vkCmdInsertDebugUtilsLabelEXT : nullptr;
}
- if (!strcmp(name, "vkCreateDebugUtilsMessengerEXT"))
- {
+ if (!strcmp(name, "vkCreateDebugUtilsMessengerEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils");
return hasExt ? (void*)entry_vkCreateDebugUtilsMessengerEXT : nullptr;
}
- if (!strcmp(name, "vkDestroyDebugUtilsMessengerEXT"))
- {
+ if (!strcmp(name, "vkDestroyDebugUtilsMessengerEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils");
return hasExt ? (void*)entry_vkDestroyDebugUtilsMessengerEXT : nullptr;
}
- if (!strcmp(name, "vkSubmitDebugUtilsMessageEXT"))
- {
+ if (!strcmp(name, "vkSubmitDebugUtilsMessageEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_debug_utils");
return hasExt ? (void*)entry_vkSubmitDebugUtilsMessageEXT : nullptr;
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
- if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID"))
- {
- bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_external_memory_android_hardware_buffer");
+ if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID")) {
+ bool hasExt = resources->hasDeviceExtension(
+ device, "VK_ANDROID_external_memory_android_hardware_buffer");
return hasExt ? (void*)entry_vkGetAndroidHardwareBufferPropertiesANDROID : nullptr;
}
- if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID"))
- {
- bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_external_memory_android_hardware_buffer");
+ if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID")) {
+ bool hasExt = resources->hasDeviceExtension(
+ device, "VK_ANDROID_external_memory_android_hardware_buffer");
return hasExt ? (void*)entry_vkGetMemoryAndroidHardwareBufferANDROID : nullptr;
}
#endif
#ifdef VK_EXT_sample_locations
- if (!strcmp(name, "vkCmdSetSampleLocationsEXT"))
- {
+ if (!strcmp(name, "vkCmdSetSampleLocationsEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_sample_locations");
return hasExt ? (void*)entry_vkCmdSetSampleLocationsEXT : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceMultisamplePropertiesEXT"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceMultisamplePropertiesEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_sample_locations");
return hasExt ? (void*)entry_vkGetPhysicalDeviceMultisamplePropertiesEXT : nullptr;
}
#endif
#ifdef VK_EXT_image_drm_format_modifier
- if (!strcmp(name, "vkGetImageDrmFormatModifierPropertiesEXT"))
- {
+ if (!strcmp(name, "vkGetImageDrmFormatModifierPropertiesEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_image_drm_format_modifier");
return hasExt ? (void*)entry_vkGetImageDrmFormatModifierPropertiesEXT : nullptr;
}
#endif
#ifdef VK_EXT_validation_cache
- if (!strcmp(name, "vkCreateValidationCacheEXT"))
- {
+ if (!strcmp(name, "vkCreateValidationCacheEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_validation_cache");
return hasExt ? (void*)entry_vkCreateValidationCacheEXT : nullptr;
}
- if (!strcmp(name, "vkDestroyValidationCacheEXT"))
- {
+ if (!strcmp(name, "vkDestroyValidationCacheEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_validation_cache");
return hasExt ? (void*)entry_vkDestroyValidationCacheEXT : nullptr;
}
- if (!strcmp(name, "vkMergeValidationCachesEXT"))
- {
+ if (!strcmp(name, "vkMergeValidationCachesEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_validation_cache");
return hasExt ? (void*)entry_vkMergeValidationCachesEXT : nullptr;
}
- if (!strcmp(name, "vkGetValidationCacheDataEXT"))
- {
+ if (!strcmp(name, "vkGetValidationCacheDataEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_validation_cache");
return hasExt ? (void*)entry_vkGetValidationCacheDataEXT : nullptr;
}
#endif
#ifdef VK_NV_shading_rate_image
- if (!strcmp(name, "vkCmdBindShadingRateImageNV"))
- {
+ if (!strcmp(name, "vkCmdBindShadingRateImageNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_shading_rate_image");
return hasExt ? (void*)entry_vkCmdBindShadingRateImageNV : nullptr;
}
- if (!strcmp(name, "vkCmdSetViewportShadingRatePaletteNV"))
- {
+ if (!strcmp(name, "vkCmdSetViewportShadingRatePaletteNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_shading_rate_image");
return hasExt ? (void*)entry_vkCmdSetViewportShadingRatePaletteNV : nullptr;
}
- if (!strcmp(name, "vkCmdSetCoarseSampleOrderNV"))
- {
+ if (!strcmp(name, "vkCmdSetCoarseSampleOrderNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_shading_rate_image");
return hasExt ? (void*)entry_vkCmdSetCoarseSampleOrderNV : nullptr;
}
#endif
#ifdef VK_NV_ray_tracing
- if (!strcmp(name, "vkCreateAccelerationStructureNV"))
- {
+ if (!strcmp(name, "vkCreateAccelerationStructureNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_ray_tracing");
return hasExt ? (void*)entry_vkCreateAccelerationStructureNV : nullptr;
}
- if (!strcmp(name, "vkDestroyAccelerationStructureNV"))
- {
+ if (!strcmp(name, "vkDestroyAccelerationStructureNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_ray_tracing");
return hasExt ? (void*)entry_vkDestroyAccelerationStructureNV : nullptr;
}
- if (!strcmp(name, "vkGetAccelerationStructureMemoryRequirementsNV"))
- {
+ if (!strcmp(name, "vkGetAccelerationStructureMemoryRequirementsNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_ray_tracing");
return hasExt ? (void*)entry_vkGetAccelerationStructureMemoryRequirementsNV : nullptr;
}
- if (!strcmp(name, "vkBindAccelerationStructureMemoryNV"))
- {
+ if (!strcmp(name, "vkBindAccelerationStructureMemoryNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_ray_tracing");
return hasExt ? (void*)entry_vkBindAccelerationStructureMemoryNV : nullptr;
}
- if (!strcmp(name, "vkCmdBuildAccelerationStructureNV"))
- {
+ if (!strcmp(name, "vkCmdBuildAccelerationStructureNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_ray_tracing");
return hasExt ? (void*)entry_vkCmdBuildAccelerationStructureNV : nullptr;
}
- if (!strcmp(name, "vkCmdCopyAccelerationStructureNV"))
- {
+ if (!strcmp(name, "vkCmdCopyAccelerationStructureNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_ray_tracing");
return hasExt ? (void*)entry_vkCmdCopyAccelerationStructureNV : nullptr;
}
- if (!strcmp(name, "vkCmdTraceRaysNV"))
- {
+ if (!strcmp(name, "vkCmdTraceRaysNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_ray_tracing");
return hasExt ? (void*)entry_vkCmdTraceRaysNV : nullptr;
}
- if (!strcmp(name, "vkCreateRayTracingPipelinesNV"))
- {
+ if (!strcmp(name, "vkCreateRayTracingPipelinesNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_ray_tracing");
return hasExt ? (void*)entry_vkCreateRayTracingPipelinesNV : nullptr;
}
- if (!strcmp(name, "vkGetRayTracingShaderGroupHandlesKHR"))
- {
+ if (!strcmp(name, "vkGetRayTracingShaderGroupHandlesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_ray_tracing");
return hasExt ? (void*)entry_vkGetRayTracingShaderGroupHandlesKHR : nullptr;
}
- if (!strcmp(name, "vkGetRayTracingShaderGroupHandlesNV"))
- {
+ if (!strcmp(name, "vkGetRayTracingShaderGroupHandlesNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_ray_tracing");
return hasExt ? (void*)entry_vkGetRayTracingShaderGroupHandlesNV : nullptr;
}
- if (!strcmp(name, "vkGetAccelerationStructureHandleNV"))
- {
+ if (!strcmp(name, "vkGetAccelerationStructureHandleNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_ray_tracing");
return hasExt ? (void*)entry_vkGetAccelerationStructureHandleNV : nullptr;
}
- if (!strcmp(name, "vkCmdWriteAccelerationStructuresPropertiesNV"))
- {
+ if (!strcmp(name, "vkCmdWriteAccelerationStructuresPropertiesNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_ray_tracing");
return hasExt ? (void*)entry_vkCmdWriteAccelerationStructuresPropertiesNV : nullptr;
}
- if (!strcmp(name, "vkCompileDeferredNV"))
- {
+ if (!strcmp(name, "vkCompileDeferredNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_ray_tracing");
return hasExt ? (void*)entry_vkCompileDeferredNV : nullptr;
}
#endif
#ifdef VK_EXT_external_memory_host
- if (!strcmp(name, "vkGetMemoryHostPointerPropertiesEXT"))
- {
+ if (!strcmp(name, "vkGetMemoryHostPointerPropertiesEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_external_memory_host");
return hasExt ? (void*)entry_vkGetMemoryHostPointerPropertiesEXT : nullptr;
}
#endif
#ifdef VK_AMD_buffer_marker
- if (!strcmp(name, "vkCmdWriteBufferMarkerAMD"))
- {
+ if (!strcmp(name, "vkCmdWriteBufferMarkerAMD")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_AMD_buffer_marker");
return hasExt ? (void*)entry_vkCmdWriteBufferMarkerAMD : nullptr;
}
#endif
#ifdef VK_EXT_calibrated_timestamps
- if (!strcmp(name, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_calibrated_timestamps");
return hasExt ? (void*)entry_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT : nullptr;
}
- if (!strcmp(name, "vkGetCalibratedTimestampsEXT"))
- {
+ if (!strcmp(name, "vkGetCalibratedTimestampsEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_calibrated_timestamps");
return hasExt ? (void*)entry_vkGetCalibratedTimestampsEXT : nullptr;
}
#endif
#ifdef VK_NV_mesh_shader
- if (!strcmp(name, "vkCmdDrawMeshTasksNV"))
- {
+ if (!strcmp(name, "vkCmdDrawMeshTasksNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_mesh_shader");
return hasExt ? (void*)entry_vkCmdDrawMeshTasksNV : nullptr;
}
- if (!strcmp(name, "vkCmdDrawMeshTasksIndirectNV"))
- {
+ if (!strcmp(name, "vkCmdDrawMeshTasksIndirectNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_mesh_shader");
return hasExt ? (void*)entry_vkCmdDrawMeshTasksIndirectNV : nullptr;
}
- if (!strcmp(name, "vkCmdDrawMeshTasksIndirectCountNV"))
- {
+ if (!strcmp(name, "vkCmdDrawMeshTasksIndirectCountNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_mesh_shader");
return hasExt ? (void*)entry_vkCmdDrawMeshTasksIndirectCountNV : nullptr;
}
#endif
#ifdef VK_NV_scissor_exclusive
- if (!strcmp(name, "vkCmdSetExclusiveScissorNV"))
- {
+ if (!strcmp(name, "vkCmdSetExclusiveScissorNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_scissor_exclusive");
return hasExt ? (void*)entry_vkCmdSetExclusiveScissorNV : nullptr;
}
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
- if (!strcmp(name, "vkCmdSetCheckpointNV"))
- {
+ if (!strcmp(name, "vkCmdSetCheckpointNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_device_diagnostic_checkpoints");
return hasExt ? (void*)entry_vkCmdSetCheckpointNV : nullptr;
}
- if (!strcmp(name, "vkGetQueueCheckpointDataNV"))
- {
+ if (!strcmp(name, "vkGetQueueCheckpointDataNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_device_diagnostic_checkpoints");
return hasExt ? (void*)entry_vkGetQueueCheckpointDataNV : nullptr;
}
#endif
#ifdef VK_INTEL_performance_query
- if (!strcmp(name, "vkInitializePerformanceApiINTEL"))
- {
+ if (!strcmp(name, "vkInitializePerformanceApiINTEL")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_INTEL_performance_query");
return hasExt ? (void*)entry_vkInitializePerformanceApiINTEL : nullptr;
}
- if (!strcmp(name, "vkUninitializePerformanceApiINTEL"))
- {
+ if (!strcmp(name, "vkUninitializePerformanceApiINTEL")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_INTEL_performance_query");
return hasExt ? (void*)entry_vkUninitializePerformanceApiINTEL : nullptr;
}
- if (!strcmp(name, "vkCmdSetPerformanceMarkerINTEL"))
- {
+ if (!strcmp(name, "vkCmdSetPerformanceMarkerINTEL")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_INTEL_performance_query");
return hasExt ? (void*)entry_vkCmdSetPerformanceMarkerINTEL : nullptr;
}
- if (!strcmp(name, "vkCmdSetPerformanceStreamMarkerINTEL"))
- {
+ if (!strcmp(name, "vkCmdSetPerformanceStreamMarkerINTEL")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_INTEL_performance_query");
return hasExt ? (void*)entry_vkCmdSetPerformanceStreamMarkerINTEL : nullptr;
}
- if (!strcmp(name, "vkCmdSetPerformanceOverrideINTEL"))
- {
+ if (!strcmp(name, "vkCmdSetPerformanceOverrideINTEL")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_INTEL_performance_query");
return hasExt ? (void*)entry_vkCmdSetPerformanceOverrideINTEL : nullptr;
}
- if (!strcmp(name, "vkAcquirePerformanceConfigurationINTEL"))
- {
+ if (!strcmp(name, "vkAcquirePerformanceConfigurationINTEL")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_INTEL_performance_query");
return hasExt ? (void*)entry_vkAcquirePerformanceConfigurationINTEL : nullptr;
}
- if (!strcmp(name, "vkReleasePerformanceConfigurationINTEL"))
- {
+ if (!strcmp(name, "vkReleasePerformanceConfigurationINTEL")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_INTEL_performance_query");
return hasExt ? (void*)entry_vkReleasePerformanceConfigurationINTEL : nullptr;
}
- if (!strcmp(name, "vkQueueSetPerformanceConfigurationINTEL"))
- {
+ if (!strcmp(name, "vkQueueSetPerformanceConfigurationINTEL")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_INTEL_performance_query");
return hasExt ? (void*)entry_vkQueueSetPerformanceConfigurationINTEL : nullptr;
}
- if (!strcmp(name, "vkGetPerformanceParameterINTEL"))
- {
+ if (!strcmp(name, "vkGetPerformanceParameterINTEL")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_INTEL_performance_query");
return hasExt ? (void*)entry_vkGetPerformanceParameterINTEL : nullptr;
}
#endif
#ifdef VK_AMD_display_native_hdr
- if (!strcmp(name, "vkSetLocalDimmingAMD"))
- {
+ if (!strcmp(name, "vkSetLocalDimmingAMD")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_AMD_display_native_hdr");
return hasExt ? (void*)entry_vkSetLocalDimmingAMD : nullptr;
}
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
- if (!strcmp(name, "vkCreateImagePipeSurfaceFUCHSIA"))
- {
+ if (!strcmp(name, "vkCreateImagePipeSurfaceFUCHSIA")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_FUCHSIA_imagepipe_surface");
return hasExt ? (void*)entry_vkCreateImagePipeSurfaceFUCHSIA : nullptr;
}
#endif
#ifdef VK_EXT_metal_surface
- if (!strcmp(name, "vkCreateMetalSurfaceEXT"))
- {
+ if (!strcmp(name, "vkCreateMetalSurfaceEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_metal_surface");
return hasExt ? (void*)entry_vkCreateMetalSurfaceEXT : nullptr;
}
#endif
#ifdef VK_EXT_buffer_device_address
- if (!strcmp(name, "vkGetBufferDeviceAddressEXT"))
- {
+ if (!strcmp(name, "vkGetBufferDeviceAddressEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_buffer_device_address");
return hasExt ? (void*)entry_vkGetBufferDeviceAddressEXT : nullptr;
}
#endif
#ifdef VK_EXT_tooling_info
- if (!strcmp(name, "vkGetPhysicalDeviceToolPropertiesEXT"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceToolPropertiesEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_tooling_info");
return hasExt ? (void*)entry_vkGetPhysicalDeviceToolPropertiesEXT : nullptr;
}
#endif
#ifdef VK_NV_cooperative_matrix
- if (!strcmp(name, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_cooperative_matrix");
return hasExt ? (void*)entry_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV : nullptr;
}
#endif
#ifdef VK_NV_coverage_reduction_mode
- if (!strcmp(name, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_coverage_reduction_mode");
- return hasExt ? (void*)entry_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV : nullptr;
+ return hasExt
+ ? (void*)entry_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV
+ : nullptr;
}
#endif
#ifdef VK_EXT_full_screen_exclusive
- if (!strcmp(name, "vkGetPhysicalDeviceSurfacePresentModes2EXT"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceSurfacePresentModes2EXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_full_screen_exclusive");
return hasExt ? (void*)entry_vkGetPhysicalDeviceSurfacePresentModes2EXT : nullptr;
}
- if (!strcmp(name, "vkAcquireFullScreenExclusiveModeEXT"))
- {
+ if (!strcmp(name, "vkAcquireFullScreenExclusiveModeEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_full_screen_exclusive");
return hasExt ? (void*)entry_vkAcquireFullScreenExclusiveModeEXT : nullptr;
}
- if (!strcmp(name, "vkReleaseFullScreenExclusiveModeEXT"))
- {
+ if (!strcmp(name, "vkReleaseFullScreenExclusiveModeEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_full_screen_exclusive");
return hasExt ? (void*)entry_vkReleaseFullScreenExclusiveModeEXT : nullptr;
}
- if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModes2EXT"))
- {
+ if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModes2EXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_full_screen_exclusive");
return hasExt ? (void*)entry_vkGetDeviceGroupSurfacePresentModes2EXT : nullptr;
}
#endif
#ifdef VK_EXT_headless_surface
- if (!strcmp(name, "vkCreateHeadlessSurfaceEXT"))
- {
+ if (!strcmp(name, "vkCreateHeadlessSurfaceEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_headless_surface");
return hasExt ? (void*)entry_vkCreateHeadlessSurfaceEXT : nullptr;
}
#endif
#ifdef VK_EXT_line_rasterization
- if (!strcmp(name, "vkCmdSetLineStippleEXT"))
- {
+ if (!strcmp(name, "vkCmdSetLineStippleEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_line_rasterization");
return hasExt ? (void*)entry_vkCmdSetLineStippleEXT : nullptr;
}
#endif
#ifdef VK_EXT_host_query_reset
- if (!strcmp(name, "vkResetQueryPoolEXT"))
- {
+ if (!strcmp(name, "vkResetQueryPoolEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_query_reset");
return hasExt ? (void*)entry_vkResetQueryPoolEXT : nullptr;
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- if (!strcmp(name, "vkCmdSetCullModeEXT"))
- {
+ if (!strcmp(name, "vkCmdSetCullModeEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
return hasExt ? (void*)entry_vkCmdSetCullModeEXT : nullptr;
}
- if (!strcmp(name, "vkCmdSetFrontFaceEXT"))
- {
+ if (!strcmp(name, "vkCmdSetFrontFaceEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
return hasExt ? (void*)entry_vkCmdSetFrontFaceEXT : nullptr;
}
- if (!strcmp(name, "vkCmdSetPrimitiveTopologyEXT"))
- {
+ if (!strcmp(name, "vkCmdSetPrimitiveTopologyEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
return hasExt ? (void*)entry_vkCmdSetPrimitiveTopologyEXT : nullptr;
}
- if (!strcmp(name, "vkCmdSetViewportWithCountEXT"))
- {
+ if (!strcmp(name, "vkCmdSetViewportWithCountEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
return hasExt ? (void*)entry_vkCmdSetViewportWithCountEXT : nullptr;
}
- if (!strcmp(name, "vkCmdSetScissorWithCountEXT"))
- {
+ if (!strcmp(name, "vkCmdSetScissorWithCountEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
return hasExt ? (void*)entry_vkCmdSetScissorWithCountEXT : nullptr;
}
- if (!strcmp(name, "vkCmdBindVertexBuffers2EXT"))
- {
+ if (!strcmp(name, "vkCmdBindVertexBuffers2EXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
return hasExt ? (void*)entry_vkCmdBindVertexBuffers2EXT : nullptr;
}
- if (!strcmp(name, "vkCmdSetDepthTestEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetDepthTestEnableEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
return hasExt ? (void*)entry_vkCmdSetDepthTestEnableEXT : nullptr;
}
- if (!strcmp(name, "vkCmdSetDepthWriteEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetDepthWriteEnableEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
return hasExt ? (void*)entry_vkCmdSetDepthWriteEnableEXT : nullptr;
}
- if (!strcmp(name, "vkCmdSetDepthCompareOpEXT"))
- {
+ if (!strcmp(name, "vkCmdSetDepthCompareOpEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
return hasExt ? (void*)entry_vkCmdSetDepthCompareOpEXT : nullptr;
}
- if (!strcmp(name, "vkCmdSetDepthBoundsTestEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetDepthBoundsTestEnableEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
return hasExt ? (void*)entry_vkCmdSetDepthBoundsTestEnableEXT : nullptr;
}
- if (!strcmp(name, "vkCmdSetStencilTestEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetStencilTestEnableEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
return hasExt ? (void*)entry_vkCmdSetStencilTestEnableEXT : nullptr;
}
- if (!strcmp(name, "vkCmdSetStencilOpEXT"))
- {
+ if (!strcmp(name, "vkCmdSetStencilOpEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
return hasExt ? (void*)entry_vkCmdSetStencilOpEXT : nullptr;
}
#endif
#ifdef VK_NV_device_generated_commands
- if (!strcmp(name, "vkGetGeneratedCommandsMemoryRequirementsNV"))
- {
+ if (!strcmp(name, "vkGetGeneratedCommandsMemoryRequirementsNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_device_generated_commands");
return hasExt ? (void*)entry_vkGetGeneratedCommandsMemoryRequirementsNV : nullptr;
}
- if (!strcmp(name, "vkCmdPreprocessGeneratedCommandsNV"))
- {
+ if (!strcmp(name, "vkCmdPreprocessGeneratedCommandsNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_device_generated_commands");
return hasExt ? (void*)entry_vkCmdPreprocessGeneratedCommandsNV : nullptr;
}
- if (!strcmp(name, "vkCmdExecuteGeneratedCommandsNV"))
- {
+ if (!strcmp(name, "vkCmdExecuteGeneratedCommandsNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_device_generated_commands");
return hasExt ? (void*)entry_vkCmdExecuteGeneratedCommandsNV : nullptr;
}
- if (!strcmp(name, "vkCmdBindPipelineShaderGroupNV"))
- {
+ if (!strcmp(name, "vkCmdBindPipelineShaderGroupNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_device_generated_commands");
return hasExt ? (void*)entry_vkCmdBindPipelineShaderGroupNV : nullptr;
}
- if (!strcmp(name, "vkCreateIndirectCommandsLayoutNV"))
- {
+ if (!strcmp(name, "vkCreateIndirectCommandsLayoutNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_device_generated_commands");
return hasExt ? (void*)entry_vkCreateIndirectCommandsLayoutNV : nullptr;
}
- if (!strcmp(name, "vkDestroyIndirectCommandsLayoutNV"))
- {
+ if (!strcmp(name, "vkDestroyIndirectCommandsLayoutNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_device_generated_commands");
return hasExt ? (void*)entry_vkDestroyIndirectCommandsLayoutNV : nullptr;
}
#endif
#ifdef VK_EXT_acquire_drm_display
- if (!strcmp(name, "vkAcquireDrmDisplayEXT"))
- {
+ if (!strcmp(name, "vkAcquireDrmDisplayEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_acquire_drm_display");
return hasExt ? (void*)entry_vkAcquireDrmDisplayEXT : nullptr;
}
- if (!strcmp(name, "vkGetDrmDisplayEXT"))
- {
+ if (!strcmp(name, "vkGetDrmDisplayEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_acquire_drm_display");
return hasExt ? (void*)entry_vkGetDrmDisplayEXT : nullptr;
}
#endif
#ifdef VK_EXT_private_data
- if (!strcmp(name, "vkCreatePrivateDataSlotEXT"))
- {
+ if (!strcmp(name, "vkCreatePrivateDataSlotEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_private_data");
return hasExt ? (void*)entry_vkCreatePrivateDataSlotEXT : nullptr;
}
- if (!strcmp(name, "vkDestroyPrivateDataSlotEXT"))
- {
+ if (!strcmp(name, "vkDestroyPrivateDataSlotEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_private_data");
return hasExt ? (void*)entry_vkDestroyPrivateDataSlotEXT : nullptr;
}
- if (!strcmp(name, "vkSetPrivateDataEXT"))
- {
+ if (!strcmp(name, "vkSetPrivateDataEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_private_data");
return hasExt ? (void*)entry_vkSetPrivateDataEXT : nullptr;
}
- if (!strcmp(name, "vkGetPrivateDataEXT"))
- {
+ if (!strcmp(name, "vkGetPrivateDataEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_private_data");
return hasExt ? (void*)entry_vkGetPrivateDataEXT : nullptr;
}
#endif
#ifdef VK_NV_fragment_shading_rate_enums
- if (!strcmp(name, "vkCmdSetFragmentShadingRateEnumNV"))
- {
+ if (!strcmp(name, "vkCmdSetFragmentShadingRateEnumNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_fragment_shading_rate_enums");
return hasExt ? (void*)entry_vkCmdSetFragmentShadingRateEnumNV : nullptr;
}
#endif
#ifdef VK_NV_acquire_winrt_display
- if (!strcmp(name, "vkAcquireWinrtDisplayNV"))
- {
+ if (!strcmp(name, "vkAcquireWinrtDisplayNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_acquire_winrt_display");
return hasExt ? (void*)entry_vkAcquireWinrtDisplayNV : nullptr;
}
- if (!strcmp(name, "vkGetWinrtDisplayNV"))
- {
+ if (!strcmp(name, "vkGetWinrtDisplayNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_acquire_winrt_display");
return hasExt ? (void*)entry_vkGetWinrtDisplayNV : nullptr;
}
#endif
#ifdef VK_EXT_directfb_surface
- if (!strcmp(name, "vkCreateDirectFBSurfaceEXT"))
- {
+ if (!strcmp(name, "vkCreateDirectFBSurfaceEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_directfb_surface");
return hasExt ? (void*)entry_vkCreateDirectFBSurfaceEXT : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_directfb_surface");
return hasExt ? (void*)entry_vkGetPhysicalDeviceDirectFBPresentationSupportEXT : nullptr;
}
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
- if (!strcmp(name, "vkCmdSetVertexInputEXT"))
- {
+ if (!strcmp(name, "vkCmdSetVertexInputEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_vertex_input_dynamic_state");
return hasExt ? (void*)entry_vkCmdSetVertexInputEXT : nullptr;
}
#endif
#ifdef VK_FUCHSIA_external_memory
- if (!strcmp(name, "vkGetMemoryZirconHandleFUCHSIA"))
- {
+ if (!strcmp(name, "vkGetMemoryZirconHandleFUCHSIA")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_FUCHSIA_external_memory");
return hasExt ? (void*)entry_vkGetMemoryZirconHandleFUCHSIA : nullptr;
}
- if (!strcmp(name, "vkGetMemoryZirconHandlePropertiesFUCHSIA"))
- {
+ if (!strcmp(name, "vkGetMemoryZirconHandlePropertiesFUCHSIA")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_FUCHSIA_external_memory");
return hasExt ? (void*)entry_vkGetMemoryZirconHandlePropertiesFUCHSIA : nullptr;
}
#endif
#ifdef VK_FUCHSIA_external_semaphore
- if (!strcmp(name, "vkImportSemaphoreZirconHandleFUCHSIA"))
- {
+ if (!strcmp(name, "vkImportSemaphoreZirconHandleFUCHSIA")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_FUCHSIA_external_semaphore");
return hasExt ? (void*)entry_vkImportSemaphoreZirconHandleFUCHSIA : nullptr;
}
- if (!strcmp(name, "vkGetSemaphoreZirconHandleFUCHSIA"))
- {
+ if (!strcmp(name, "vkGetSemaphoreZirconHandleFUCHSIA")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_FUCHSIA_external_semaphore");
return hasExt ? (void*)entry_vkGetSemaphoreZirconHandleFUCHSIA : nullptr;
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
- if (!strcmp(name, "vkCreateBufferCollectionFUCHSIA"))
- {
+ if (!strcmp(name, "vkCreateBufferCollectionFUCHSIA")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_FUCHSIA_buffer_collection");
return hasExt ? (void*)entry_vkCreateBufferCollectionFUCHSIA : nullptr;
}
- if (!strcmp(name, "vkSetBufferCollectionImageConstraintsFUCHSIA"))
- {
+ if (!strcmp(name, "vkSetBufferCollectionImageConstraintsFUCHSIA")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_FUCHSIA_buffer_collection");
return hasExt ? (void*)entry_vkSetBufferCollectionImageConstraintsFUCHSIA : nullptr;
}
- if (!strcmp(name, "vkSetBufferCollectionBufferConstraintsFUCHSIA"))
- {
+ if (!strcmp(name, "vkSetBufferCollectionBufferConstraintsFUCHSIA")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_FUCHSIA_buffer_collection");
return hasExt ? (void*)entry_vkSetBufferCollectionBufferConstraintsFUCHSIA : nullptr;
}
- if (!strcmp(name, "vkDestroyBufferCollectionFUCHSIA"))
- {
+ if (!strcmp(name, "vkDestroyBufferCollectionFUCHSIA")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_FUCHSIA_buffer_collection");
return hasExt ? (void*)entry_vkDestroyBufferCollectionFUCHSIA : nullptr;
}
- if (!strcmp(name, "vkGetBufferCollectionPropertiesFUCHSIA"))
- {
+ if (!strcmp(name, "vkGetBufferCollectionPropertiesFUCHSIA")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_FUCHSIA_buffer_collection");
return hasExt ? (void*)entry_vkGetBufferCollectionPropertiesFUCHSIA : nullptr;
}
#endif
#ifdef VK_HUAWEI_subpass_shading
- if (!strcmp(name, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI"))
- {
+ if (!strcmp(name, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_HUAWEI_subpass_shading");
return hasExt ? (void*)entry_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI : nullptr;
}
- if (!strcmp(name, "vkCmdSubpassShadingHUAWEI"))
- {
+ if (!strcmp(name, "vkCmdSubpassShadingHUAWEI")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_HUAWEI_subpass_shading");
return hasExt ? (void*)entry_vkCmdSubpassShadingHUAWEI : nullptr;
}
#endif
#ifdef VK_HUAWEI_invocation_mask
- if (!strcmp(name, "vkCmdBindInvocationMaskHUAWEI"))
- {
+ if (!strcmp(name, "vkCmdBindInvocationMaskHUAWEI")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_HUAWEI_invocation_mask");
return hasExt ? (void*)entry_vkCmdBindInvocationMaskHUAWEI : nullptr;
}
#endif
#ifdef VK_NV_external_memory_rdma
- if (!strcmp(name, "vkGetMemoryRemoteAddressNV"))
- {
+ if (!strcmp(name, "vkGetMemoryRemoteAddressNV")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_NV_external_memory_rdma");
return hasExt ? (void*)entry_vkGetMemoryRemoteAddressNV : nullptr;
}
#endif
#ifdef VK_EXT_extended_dynamic_state2
- if (!strcmp(name, "vkCmdSetPatchControlPointsEXT"))
- {
+ if (!strcmp(name, "vkCmdSetPatchControlPointsEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
return hasExt ? (void*)entry_vkCmdSetPatchControlPointsEXT : nullptr;
}
- if (!strcmp(name, "vkCmdSetRasterizerDiscardEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetRasterizerDiscardEnableEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
return hasExt ? (void*)entry_vkCmdSetRasterizerDiscardEnableEXT : nullptr;
}
- if (!strcmp(name, "vkCmdSetDepthBiasEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetDepthBiasEnableEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
return hasExt ? (void*)entry_vkCmdSetDepthBiasEnableEXT : nullptr;
}
- if (!strcmp(name, "vkCmdSetLogicOpEXT"))
- {
+ if (!strcmp(name, "vkCmdSetLogicOpEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
return hasExt ? (void*)entry_vkCmdSetLogicOpEXT : nullptr;
}
- if (!strcmp(name, "vkCmdSetPrimitiveRestartEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetPrimitiveRestartEnableEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
return hasExt ? (void*)entry_vkCmdSetPrimitiveRestartEnableEXT : nullptr;
}
#endif
#ifdef VK_QNX_screen_surface
- if (!strcmp(name, "vkCreateScreenSurfaceQNX"))
- {
+ if (!strcmp(name, "vkCreateScreenSurfaceQNX")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_QNX_screen_surface");
return hasExt ? (void*)entry_vkCreateScreenSurfaceQNX : nullptr;
}
- if (!strcmp(name, "vkGetPhysicalDeviceScreenPresentationSupportQNX"))
- {
+ if (!strcmp(name, "vkGetPhysicalDeviceScreenPresentationSupportQNX")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_QNX_screen_surface");
return hasExt ? (void*)entry_vkGetPhysicalDeviceScreenPresentationSupportQNX : nullptr;
}
#endif
#ifdef VK_EXT_color_write_enable
- if (!strcmp(name, "vkCmdSetColorWriteEnableEXT"))
- {
+ if (!strcmp(name, "vkCmdSetColorWriteEnableEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_color_write_enable");
return hasExt ? (void*)entry_vkCmdSetColorWriteEnableEXT : nullptr;
}
#endif
#ifdef VK_GOOGLE_gfxstream
- if (!strcmp(name, "vkRegisterImageColorBufferGOOGLE"))
- {
+ if (!strcmp(name, "vkRegisterImageColorBufferGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkRegisterImageColorBufferGOOGLE : nullptr;
}
- if (!strcmp(name, "vkRegisterBufferColorBufferGOOGLE"))
- {
+ if (!strcmp(name, "vkRegisterBufferColorBufferGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkRegisterBufferColorBufferGOOGLE : nullptr;
}
- if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE"))
- {
+ if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkMapMemoryIntoAddressSpaceGOOGLE : nullptr;
}
- if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE"))
- {
+ if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE : nullptr;
}
- if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE"))
- {
+ if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkBeginCommandBufferAsyncGOOGLE : nullptr;
}
- if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE"))
- {
+ if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkEndCommandBufferAsyncGOOGLE : nullptr;
}
- if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE"))
- {
+ if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkResetCommandBufferAsyncGOOGLE : nullptr;
}
- if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE"))
- {
+ if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkCommandBufferHostSyncGOOGLE : nullptr;
}
- if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE"))
- {
+ if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkCreateImageWithRequirementsGOOGLE : nullptr;
}
- if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE"))
- {
+ if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkCreateBufferWithRequirementsGOOGLE : nullptr;
}
- if (!strcmp(name, "vkGetMemoryHostAddressInfoGOOGLE"))
- {
+ if (!strcmp(name, "vkGetMemoryHostAddressInfoGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkGetMemoryHostAddressInfoGOOGLE : nullptr;
}
- if (!strcmp(name, "vkFreeMemorySyncGOOGLE"))
- {
+ if (!strcmp(name, "vkFreeMemorySyncGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkFreeMemorySyncGOOGLE : nullptr;
}
- if (!strcmp(name, "vkQueueHostSyncGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueHostSyncGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkQueueHostSyncGOOGLE : nullptr;
}
- if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkQueueSubmitAsyncGOOGLE : nullptr;
}
- if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkQueueWaitIdleAsyncGOOGLE : nullptr;
}
- if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkQueueBindSparseAsyncGOOGLE : nullptr;
}
- if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE"))
- {
+ if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkGetLinearImageLayoutGOOGLE : nullptr;
}
- if (!strcmp(name, "vkGetLinearImageLayout2GOOGLE"))
- {
+ if (!strcmp(name, "vkGetLinearImageLayout2GOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkGetLinearImageLayout2GOOGLE : nullptr;
}
- if (!strcmp(name, "vkQueueFlushCommandsGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueFlushCommandsGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkQueueFlushCommandsGOOGLE : nullptr;
}
- if (!strcmp(name, "vkQueueCommitDescriptorSetUpdatesGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueCommitDescriptorSetUpdatesGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkQueueCommitDescriptorSetUpdatesGOOGLE : nullptr;
}
- if (!strcmp(name, "vkCollectDescriptorPoolIdsGOOGLE"))
- {
+ if (!strcmp(name, "vkCollectDescriptorPoolIdsGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkCollectDescriptorPoolIdsGOOGLE : nullptr;
}
- if (!strcmp(name, "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE"))
- {
+ if (!strcmp(name, "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
return hasExt ? (void*)entry_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE : nullptr;
}
#endif
#ifdef VK_EXT_multi_draw
- if (!strcmp(name, "vkCmdDrawMultiEXT"))
- {
+ if (!strcmp(name, "vkCmdDrawMultiEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_multi_draw");
return hasExt ? (void*)entry_vkCmdDrawMultiEXT : nullptr;
}
- if (!strcmp(name, "vkCmdDrawMultiIndexedEXT"))
- {
+ if (!strcmp(name, "vkCmdDrawMultiIndexedEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_multi_draw");
return hasExt ? (void*)entry_vkCmdDrawMultiIndexedEXT : nullptr;
}
#endif
#ifdef VK_EXT_pageable_device_local_memory
- if (!strcmp(name, "vkSetDeviceMemoryPriorityEXT"))
- {
+ if (!strcmp(name, "vkSetDeviceMemoryPriorityEXT")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_pageable_device_local_memory");
return hasExt ? (void*)entry_vkSetDeviceMemoryPriorityEXT : nullptr;
}
#endif
#ifdef VK_KHR_acceleration_structure
- if (!strcmp(name, "vkCreateAccelerationStructureKHR"))
- {
+ if (!strcmp(name, "vkCreateAccelerationStructureKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure");
return hasExt ? (void*)entry_vkCreateAccelerationStructureKHR : nullptr;
}
- if (!strcmp(name, "vkDestroyAccelerationStructureKHR"))
- {
+ if (!strcmp(name, "vkDestroyAccelerationStructureKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure");
return hasExt ? (void*)entry_vkDestroyAccelerationStructureKHR : nullptr;
}
- if (!strcmp(name, "vkCmdBuildAccelerationStructuresKHR"))
- {
+ if (!strcmp(name, "vkCmdBuildAccelerationStructuresKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure");
return hasExt ? (void*)entry_vkCmdBuildAccelerationStructuresKHR : nullptr;
}
- if (!strcmp(name, "vkCmdBuildAccelerationStructuresIndirectKHR"))
- {
+ if (!strcmp(name, "vkCmdBuildAccelerationStructuresIndirectKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure");
return hasExt ? (void*)entry_vkCmdBuildAccelerationStructuresIndirectKHR : nullptr;
}
- if (!strcmp(name, "vkBuildAccelerationStructuresKHR"))
- {
+ if (!strcmp(name, "vkBuildAccelerationStructuresKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure");
return hasExt ? (void*)entry_vkBuildAccelerationStructuresKHR : nullptr;
}
- if (!strcmp(name, "vkCopyAccelerationStructureKHR"))
- {
+ if (!strcmp(name, "vkCopyAccelerationStructureKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure");
return hasExt ? (void*)entry_vkCopyAccelerationStructureKHR : nullptr;
}
- if (!strcmp(name, "vkCopyAccelerationStructureToMemoryKHR"))
- {
+ if (!strcmp(name, "vkCopyAccelerationStructureToMemoryKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure");
return hasExt ? (void*)entry_vkCopyAccelerationStructureToMemoryKHR : nullptr;
}
- if (!strcmp(name, "vkCopyMemoryToAccelerationStructureKHR"))
- {
+ if (!strcmp(name, "vkCopyMemoryToAccelerationStructureKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure");
return hasExt ? (void*)entry_vkCopyMemoryToAccelerationStructureKHR : nullptr;
}
- if (!strcmp(name, "vkWriteAccelerationStructuresPropertiesKHR"))
- {
+ if (!strcmp(name, "vkWriteAccelerationStructuresPropertiesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure");
return hasExt ? (void*)entry_vkWriteAccelerationStructuresPropertiesKHR : nullptr;
}
- if (!strcmp(name, "vkCmdCopyAccelerationStructureKHR"))
- {
+ if (!strcmp(name, "vkCmdCopyAccelerationStructureKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure");
return hasExt ? (void*)entry_vkCmdCopyAccelerationStructureKHR : nullptr;
}
- if (!strcmp(name, "vkCmdCopyAccelerationStructureToMemoryKHR"))
- {
+ if (!strcmp(name, "vkCmdCopyAccelerationStructureToMemoryKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure");
return hasExt ? (void*)entry_vkCmdCopyAccelerationStructureToMemoryKHR : nullptr;
}
- if (!strcmp(name, "vkCmdCopyMemoryToAccelerationStructureKHR"))
- {
+ if (!strcmp(name, "vkCmdCopyMemoryToAccelerationStructureKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure");
return hasExt ? (void*)entry_vkCmdCopyMemoryToAccelerationStructureKHR : nullptr;
}
- if (!strcmp(name, "vkGetAccelerationStructureDeviceAddressKHR"))
- {
+ if (!strcmp(name, "vkGetAccelerationStructureDeviceAddressKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure");
return hasExt ? (void*)entry_vkGetAccelerationStructureDeviceAddressKHR : nullptr;
}
- if (!strcmp(name, "vkCmdWriteAccelerationStructuresPropertiesKHR"))
- {
+ if (!strcmp(name, "vkCmdWriteAccelerationStructuresPropertiesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure");
return hasExt ? (void*)entry_vkCmdWriteAccelerationStructuresPropertiesKHR : nullptr;
}
- if (!strcmp(name, "vkGetDeviceAccelerationStructureCompatibilityKHR"))
- {
+ if (!strcmp(name, "vkGetDeviceAccelerationStructureCompatibilityKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure");
return hasExt ? (void*)entry_vkGetDeviceAccelerationStructureCompatibilityKHR : nullptr;
}
- if (!strcmp(name, "vkGetAccelerationStructureBuildSizesKHR"))
- {
+ if (!strcmp(name, "vkGetAccelerationStructureBuildSizesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_acceleration_structure");
return hasExt ? (void*)entry_vkGetAccelerationStructureBuildSizesKHR : nullptr;
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
- if (!strcmp(name, "vkCmdTraceRaysKHR"))
- {
+ if (!strcmp(name, "vkCmdTraceRaysKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_ray_tracing_pipeline");
return hasExt ? (void*)entry_vkCmdTraceRaysKHR : nullptr;
}
- if (!strcmp(name, "vkCreateRayTracingPipelinesKHR"))
- {
+ if (!strcmp(name, "vkCreateRayTracingPipelinesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_ray_tracing_pipeline");
return hasExt ? (void*)entry_vkCreateRayTracingPipelinesKHR : nullptr;
}
- if (!strcmp(name, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR"))
- {
+ if (!strcmp(name, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_ray_tracing_pipeline");
return hasExt ? (void*)entry_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR : nullptr;
}
- if (!strcmp(name, "vkCmdTraceRaysIndirectKHR"))
- {
+ if (!strcmp(name, "vkCmdTraceRaysIndirectKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_ray_tracing_pipeline");
return hasExt ? (void*)entry_vkCmdTraceRaysIndirectKHR : nullptr;
}
- if (!strcmp(name, "vkGetRayTracingShaderGroupStackSizeKHR"))
- {
+ if (!strcmp(name, "vkGetRayTracingShaderGroupStackSizeKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_ray_tracing_pipeline");
return hasExt ? (void*)entry_vkGetRayTracingShaderGroupStackSizeKHR : nullptr;
}
- if (!strcmp(name, "vkCmdSetRayTracingPipelineStackSizeKHR"))
- {
+ if (!strcmp(name, "vkCmdSetRayTracingPipelineStackSizeKHR")) {
bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_ray_tracing_pipeline");
return hasExt ? (void*)entry_vkCmdSetRayTracingPipelineStackSizeKHR : nullptr;
}
@@ -18513,4 +15443,4 @@
return nullptr;
}
-} // namespace goldfish_vk
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/func_table.h b/system/vulkan_enc/func_table.h
index 17c6286..bda48a8 100644
--- a/system/vulkan_enc/func_table.h
+++ b/system/vulkan_enc/func_table.h
@@ -14,23 +14,26 @@
// limitations under the License.
// Autogenerated module func_table
-// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal -o ../qemu/android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+//
+// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
+// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
-// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
-
+//
+// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
+// $CEREAL_OUTPUT_DIR
+//
#pragma once
-
#include <vulkan/vulkan.h>
-
+#include "vulkan_gfxstream.h"
namespace goldfish_vk {
-
#ifdef VK_VERSION_1_0
#endif
#ifdef VK_VERSION_1_1
@@ -577,4 +580,4 @@
void* goldfish_vulkan_get_instance_proc_address(VkInstance instance, const char* name);
void* goldfish_vulkan_get_device_proc_address(VkDevice device, const char* name);
-} // namespace goldfish_vk
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_counting_guest.cpp b/system/vulkan_enc/goldfish_vk_counting_guest.cpp
index bf4f9b6..f359126 100644
--- a/system/vulkan_enc/goldfish_vk_counting_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_counting_guest.cpp
@@ -14,39 +14,36 @@
// limitations under the License.
// Autogenerated module goldfish_vk_counting_guest
-// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal -o ../qemu/android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+//
+// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
+// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
-// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+//
+// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
+// $CEREAL_OUTPUT_DIR
+//
#include "goldfish_vk_counting_guest.h"
+#include <cstring>
#include "goldfish_vk_extension_structs_guest.h"
#include "goldfish_vk_private_defs.h"
-#include <cstring>
-
-
namespace goldfish_vk {
-void count_extension_struct(
- uint32_t featureBits,
- VkStructureType rootType,
- const void* structExtension,
- size_t* count);
+void count_extension_struct(uint32_t featureBits, VkStructureType rootType,
+ const void* structExtension, size_t* count);
#ifdef VK_VERSION_1_0
-void count_VkExtent2D(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExtent2D* toCount,
- size_t* count)
-{
+void count_VkExtent2D(uint32_t featureBits, VkStructureType rootType, const VkExtent2D* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -55,12 +52,8 @@
*count += sizeof(uint32_t);
}
-void count_VkExtent3D(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExtent3D* toCount,
- size_t* count)
-{
+void count_VkExtent3D(uint32_t featureBits, VkStructureType rootType, const VkExtent3D* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -70,12 +63,8 @@
*count += sizeof(uint32_t);
}
-void count_VkOffset2D(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkOffset2D* toCount,
- size_t* count)
-{
+void count_VkOffset2D(uint32_t featureBits, VkStructureType rootType, const VkOffset2D* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -84,12 +73,8 @@
*count += sizeof(int32_t);
}
-void count_VkOffset3D(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkOffset3D* toCount,
- size_t* count)
-{
+void count_VkOffset3D(uint32_t featureBits, VkStructureType rootType, const VkOffset3D* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -99,12 +84,8 @@
*count += sizeof(int32_t);
}
-void count_VkRect2D(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRect2D* toCount,
- size_t* count)
-{
+void count_VkRect2D(uint32_t featureBits, VkStructureType rootType, const VkRect2D* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -113,55 +94,40 @@
count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->extent), count);
}
-void count_VkBaseInStructure(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBaseInStructure* toCount,
- size_t* count)
-{
+void count_VkBaseInStructure(uint32_t featureBits, VkStructureType rootType,
+ const VkBaseInStructure* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
}
-void count_VkBaseOutStructure(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBaseOutStructure* toCount,
- size_t* count)
-{
+void count_VkBaseOutStructure(uint32_t featureBits, VkStructureType rootType,
+ const VkBaseOutStructure* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
}
-void count_VkBufferMemoryBarrier(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferMemoryBarrier* toCount,
- size_t* count)
-{
+void count_VkBufferMemoryBarrier(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferMemoryBarrier* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -175,12 +141,8 @@
*count += sizeof(VkDeviceSize);
}
-void count_VkDispatchIndirectCommand(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDispatchIndirectCommand* toCount,
- size_t* count)
-{
+void count_VkDispatchIndirectCommand(uint32_t featureBits, VkStructureType rootType,
+ const VkDispatchIndirectCommand* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -190,12 +152,9 @@
*count += sizeof(uint32_t);
}
-void count_VkDrawIndexedIndirectCommand(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDrawIndexedIndirectCommand* toCount,
- size_t* count)
-{
+void count_VkDrawIndexedIndirectCommand(uint32_t featureBits, VkStructureType rootType,
+ const VkDrawIndexedIndirectCommand* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -207,12 +166,8 @@
*count += sizeof(uint32_t);
}
-void count_VkDrawIndirectCommand(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDrawIndirectCommand* toCount,
- size_t* count)
-{
+void count_VkDrawIndirectCommand(uint32_t featureBits, VkStructureType rootType,
+ const VkDrawIndirectCommand* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -223,12 +178,8 @@
*count += sizeof(uint32_t);
}
-void count_VkImageSubresourceRange(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageSubresourceRange* toCount,
- size_t* count)
-{
+void count_VkImageSubresourceRange(uint32_t featureBits, VkStructureType rootType,
+ const VkImageSubresourceRange* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -240,19 +191,14 @@
*count += sizeof(uint32_t);
}
-void count_VkImageMemoryBarrier(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageMemoryBarrier* toCount,
- size_t* count)
-{
+void count_VkImageMemoryBarrier(uint32_t featureBits, VkStructureType rootType,
+ const VkImageMemoryBarrier* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -264,22 +210,18 @@
*count += sizeof(uint32_t);
uint64_t cgen_var_0;
*count += 1 * 8;
- count_VkImageSubresourceRange(featureBits, rootType, (VkImageSubresourceRange*)(&toCount->subresourceRange), count);
+ count_VkImageSubresourceRange(featureBits, rootType,
+ (VkImageSubresourceRange*)(&toCount->subresourceRange), count);
}
-void count_VkMemoryBarrier(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryBarrier* toCount,
- size_t* count)
-{
+void count_VkMemoryBarrier(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryBarrier* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -287,12 +229,9 @@
*count += sizeof(VkAccessFlags);
}
-void count_VkPipelineCacheHeaderVersionOne(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineCacheHeaderVersionOne* toCount,
- size_t* count)
-{
+void count_VkPipelineCacheHeaderVersionOne(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineCacheHeaderVersionOne* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -304,20 +243,15 @@
*count += VK_UUID_SIZE * sizeof(uint8_t);
}
-void count_VkAllocationCallbacks(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAllocationCallbacks* toCount,
- size_t* count)
-{
+void count_VkAllocationCallbacks(uint32_t featureBits, VkStructureType rootType,
+ const VkAllocationCallbacks* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
// WARNING PTR CHECK
*count += 8;
- if (toCount->pUserData)
- {
+ if (toCount->pUserData) {
*count += sizeof(uint8_t);
}
*count += 8;
@@ -327,59 +261,44 @@
*count += 8;
}
-void count_VkApplicationInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkApplicationInfo* toCount,
- size_t* count)
-{
+void count_VkApplicationInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkApplicationInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- if (featureBits & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
- {
+ if (featureBits & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
// WARNING PTR CHECK
*count += 8;
- if (toCount->pApplicationName)
- {
- *count += sizeof(uint32_t) + (toCount->pApplicationName ? strlen(toCount->pApplicationName) : 0);
+ if (toCount->pApplicationName) {
+ *count += sizeof(uint32_t) +
+ (toCount->pApplicationName ? strlen(toCount->pApplicationName) : 0);
}
- }
- else
- {
- *count += sizeof(uint32_t) + (toCount->pApplicationName ? strlen(toCount->pApplicationName) : 0);
+ } else {
+ *count +=
+ sizeof(uint32_t) + (toCount->pApplicationName ? strlen(toCount->pApplicationName) : 0);
}
*count += sizeof(uint32_t);
- if (featureBits & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
- {
+ if (featureBits & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
// WARNING PTR CHECK
*count += 8;
- if (toCount->pEngineName)
- {
+ if (toCount->pEngineName) {
*count += sizeof(uint32_t) + (toCount->pEngineName ? strlen(toCount->pEngineName) : 0);
}
- }
- else
- {
+ } else {
*count += sizeof(uint32_t) + (toCount->pEngineName ? strlen(toCount->pEngineName) : 0);
}
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
}
-void count_VkFormatProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFormatProperties* toCount,
- size_t* count)
-{
+void count_VkFormatProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkFormatProperties* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -389,12 +308,8 @@
*count += sizeof(VkFormatFeatureFlags);
}
-void count_VkImageFormatProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageFormatProperties* toCount,
- size_t* count)
-{
+void count_VkImageFormatProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkImageFormatProperties* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -406,57 +321,51 @@
*count += sizeof(VkDeviceSize);
}
-void count_VkInstanceCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkInstanceCreateInfo* toCount,
- size_t* count)
-{
+void count_VkInstanceCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkInstanceCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkInstanceCreateFlags);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pApplicationInfo)
- {
- count_VkApplicationInfo(featureBits, rootType, (const VkApplicationInfo*)(toCount->pApplicationInfo), count);
+ if (toCount->pApplicationInfo) {
+ count_VkApplicationInfo(featureBits, rootType,
+ (const VkApplicationInfo*)(toCount->pApplicationInfo), count);
}
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < toCount->enabledLayerCount; ++i)
- {
- size_t l = toCount->ppEnabledLayerNames[i] ? strlen(toCount->ppEnabledLayerNames[i]) : 0;
- *count += sizeof(uint32_t) + (toCount->ppEnabledLayerNames[i] ? strlen(toCount->ppEnabledLayerNames[i]) : 0);
+ if (toCount) {
+ for (uint32_t i = 0; i < toCount->enabledLayerCount; ++i) {
+ size_t l =
+ toCount->ppEnabledLayerNames[i] ? strlen(toCount->ppEnabledLayerNames[i]) : 0;
+ *count +=
+ sizeof(uint32_t) +
+ (toCount->ppEnabledLayerNames[i] ? strlen(toCount->ppEnabledLayerNames[i]) : 0);
}
}
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < toCount->enabledExtensionCount; ++i)
- {
- size_t l = toCount->ppEnabledExtensionNames[i] ? strlen(toCount->ppEnabledExtensionNames[i]) : 0;
- *count += sizeof(uint32_t) + (toCount->ppEnabledExtensionNames[i] ? strlen(toCount->ppEnabledExtensionNames[i]) : 0);
+ if (toCount) {
+ for (uint32_t i = 0; i < toCount->enabledExtensionCount; ++i) {
+ size_t l = toCount->ppEnabledExtensionNames[i]
+ ? strlen(toCount->ppEnabledExtensionNames[i])
+ : 0;
+ *count += sizeof(uint32_t) + (toCount->ppEnabledExtensionNames[i]
+ ? strlen(toCount->ppEnabledExtensionNames[i])
+ : 0);
}
}
}
-void count_VkMemoryHeap(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryHeap* toCount,
- size_t* count)
-{
+void count_VkMemoryHeap(uint32_t featureBits, VkStructureType rootType, const VkMemoryHeap* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -465,12 +374,8 @@
*count += sizeof(VkMemoryHeapFlags);
}
-void count_VkMemoryType(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryType* toCount,
- size_t* count)
-{
+void count_VkMemoryType(uint32_t featureBits, VkStructureType rootType, const VkMemoryType* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -479,12 +384,8 @@
*count += sizeof(uint32_t);
}
-void count_VkPhysicalDeviceFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFeatures* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceFeatures(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFeatures* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -546,12 +447,8 @@
*count += sizeof(VkBool32);
}
-void count_VkPhysicalDeviceLimits(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceLimits* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceLimits(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceLimits* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -664,34 +561,26 @@
*count += sizeof(VkDeviceSize);
}
-void count_VkPhysicalDeviceMemoryProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryProperties* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceMemoryProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryProperties* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i)
- {
+ for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i) {
count_VkMemoryType(featureBits, rootType, (VkMemoryType*)(toCount->memoryTypes + i), count);
}
*count += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i)
- {
+ for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i) {
count_VkMemoryHeap(featureBits, rootType, (VkMemoryHeap*)(toCount->memoryHeaps + i), count);
}
}
-void count_VkPhysicalDeviceSparseProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSparseProperties* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceSparseProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSparseProperties* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -703,12 +592,8 @@
*count += sizeof(VkBool32);
}
-void count_VkPhysicalDeviceProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceProperties* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceProperties* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -720,16 +605,15 @@
*count += sizeof(VkPhysicalDeviceType);
*count += VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char);
*count += VK_UUID_SIZE * sizeof(uint8_t);
- count_VkPhysicalDeviceLimits(featureBits, rootType, (VkPhysicalDeviceLimits*)(&toCount->limits), count);
- count_VkPhysicalDeviceSparseProperties(featureBits, rootType, (VkPhysicalDeviceSparseProperties*)(&toCount->sparseProperties), count);
+ count_VkPhysicalDeviceLimits(featureBits, rootType, (VkPhysicalDeviceLimits*)(&toCount->limits),
+ count);
+ count_VkPhysicalDeviceSparseProperties(
+ featureBits, rootType, (VkPhysicalDeviceSparseProperties*)(&toCount->sparseProperties),
+ count);
}
-void count_VkQueueFamilyProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkQueueFamilyProperties* toCount,
- size_t* count)
-{
+void count_VkQueueFamilyProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkQueueFamilyProperties* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -737,93 +621,83 @@
*count += sizeof(VkQueueFlags);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->minImageTransferGranularity), count);
+ count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->minImageTransferGranularity),
+ count);
}
-void count_VkDeviceQueueCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceQueueCreateInfo* toCount,
- size_t* count)
-{
+void count_VkDeviceQueueCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceQueueCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDeviceQueueCreateFlags);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->queueCount * sizeof(const float);
}
}
-void count_VkDeviceCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceCreateInfo* toCount,
- size_t* count)
-{
+void count_VkDeviceCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDeviceCreateFlags);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->queueCreateInfoCount; ++i)
- {
- count_VkDeviceQueueCreateInfo(featureBits, rootType, (const VkDeviceQueueCreateInfo*)(toCount->pQueueCreateInfos + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->queueCreateInfoCount; ++i) {
+ count_VkDeviceQueueCreateInfo(
+ featureBits, rootType,
+ (const VkDeviceQueueCreateInfo*)(toCount->pQueueCreateInfos + i), count);
}
}
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < toCount->enabledLayerCount; ++i)
- {
- size_t l = toCount->ppEnabledLayerNames[i] ? strlen(toCount->ppEnabledLayerNames[i]) : 0;
- *count += sizeof(uint32_t) + (toCount->ppEnabledLayerNames[i] ? strlen(toCount->ppEnabledLayerNames[i]) : 0);
+ if (toCount) {
+ for (uint32_t i = 0; i < toCount->enabledLayerCount; ++i) {
+ size_t l =
+ toCount->ppEnabledLayerNames[i] ? strlen(toCount->ppEnabledLayerNames[i]) : 0;
+ *count +=
+ sizeof(uint32_t) +
+ (toCount->ppEnabledLayerNames[i] ? strlen(toCount->ppEnabledLayerNames[i]) : 0);
}
}
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < toCount->enabledExtensionCount; ++i)
- {
- size_t l = toCount->ppEnabledExtensionNames[i] ? strlen(toCount->ppEnabledExtensionNames[i]) : 0;
- *count += sizeof(uint32_t) + (toCount->ppEnabledExtensionNames[i] ? strlen(toCount->ppEnabledExtensionNames[i]) : 0);
+ if (toCount) {
+ for (uint32_t i = 0; i < toCount->enabledExtensionCount; ++i) {
+ size_t l = toCount->ppEnabledExtensionNames[i]
+ ? strlen(toCount->ppEnabledExtensionNames[i])
+ : 0;
+ *count += sizeof(uint32_t) + (toCount->ppEnabledExtensionNames[i]
+ ? strlen(toCount->ppEnabledExtensionNames[i])
+ : 0);
}
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->pEnabledFeatures)
- {
- count_VkPhysicalDeviceFeatures(featureBits, rootType, (const VkPhysicalDeviceFeatures*)(toCount->pEnabledFeatures), count);
+ if (toCount->pEnabledFeatures) {
+ count_VkPhysicalDeviceFeatures(featureBits, rootType,
+ (const VkPhysicalDeviceFeatures*)(toCount->pEnabledFeatures),
+ count);
}
}
-void count_VkExtensionProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExtensionProperties* toCount,
- size_t* count)
-{
+void count_VkExtensionProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkExtensionProperties* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -832,12 +706,8 @@
*count += sizeof(uint32_t);
}
-void count_VkLayerProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkLayerProperties* toCount,
- size_t* count)
-{
+void count_VkLayerProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkLayerProperties* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -848,56 +718,42 @@
*count += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
}
-void count_VkSubmitInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubmitInfo* toCount,
- size_t* count)
-{
+void count_VkSubmitInfo(uint32_t featureBits, VkStructureType rootType, const VkSubmitInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount->waitSemaphoreCount)
- {
+ if (toCount->waitSemaphoreCount) {
*count += toCount->waitSemaphoreCount * 8;
}
- if (toCount)
- {
+ if (toCount) {
*count += toCount->waitSemaphoreCount * sizeof(const VkPipelineStageFlags);
}
*count += sizeof(uint32_t);
- if (toCount->commandBufferCount)
- {
+ if (toCount->commandBufferCount) {
*count += toCount->commandBufferCount * 8;
}
*count += sizeof(uint32_t);
- if (toCount->signalSemaphoreCount)
- {
+ if (toCount->signalSemaphoreCount) {
*count += toCount->signalSemaphoreCount * 8;
}
}
-void count_VkMappedMemoryRange(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMappedMemoryRange* toCount,
- size_t* count)
-{
+void count_VkMappedMemoryRange(uint32_t featureBits, VkStructureType rootType,
+ const VkMappedMemoryRange* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -907,19 +763,14 @@
*count += sizeof(VkDeviceSize);
}
-void count_VkMemoryAllocateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryAllocateInfo* toCount,
- size_t* count)
-{
+void count_VkMemoryAllocateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryAllocateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -927,12 +778,8 @@
*count += sizeof(uint32_t);
}
-void count_VkMemoryRequirements(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryRequirements* toCount,
- size_t* count)
-{
+void count_VkMemoryRequirements(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryRequirements* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -942,12 +789,8 @@
*count += sizeof(uint32_t);
}
-void count_VkSparseMemoryBind(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSparseMemoryBind* toCount,
- size_t* count)
-{
+void count_VkSparseMemoryBind(uint32_t featureBits, VkStructureType rootType,
+ const VkSparseMemoryBind* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -960,12 +803,9 @@
*count += sizeof(VkSparseMemoryBindFlags);
}
-void count_VkSparseBufferMemoryBindInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSparseBufferMemoryBindInfo* toCount,
- size_t* count)
-{
+void count_VkSparseBufferMemoryBindInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSparseBufferMemoryBindInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -973,21 +813,17 @@
uint64_t cgen_var_0;
*count += 1 * 8;
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->bindCount; ++i)
- {
- count_VkSparseMemoryBind(featureBits, rootType, (const VkSparseMemoryBind*)(toCount->pBinds + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->bindCount; ++i) {
+ count_VkSparseMemoryBind(featureBits, rootType,
+ (const VkSparseMemoryBind*)(toCount->pBinds + i), count);
}
}
}
-void count_VkSparseImageOpaqueMemoryBindInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSparseImageOpaqueMemoryBindInfo* toCount,
- size_t* count)
-{
+void count_VkSparseImageOpaqueMemoryBindInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSparseImageOpaqueMemoryBindInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -995,21 +831,16 @@
uint64_t cgen_var_0;
*count += 1 * 8;
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->bindCount; ++i)
- {
- count_VkSparseMemoryBind(featureBits, rootType, (const VkSparseMemoryBind*)(toCount->pBinds + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->bindCount; ++i) {
+ count_VkSparseMemoryBind(featureBits, rootType,
+ (const VkSparseMemoryBind*)(toCount->pBinds + i), count);
}
}
}
-void count_VkImageSubresource(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageSubresource* toCount,
- size_t* count)
-{
+void count_VkImageSubresource(uint32_t featureBits, VkStructureType rootType,
+ const VkImageSubresource* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -1019,17 +850,14 @@
*count += sizeof(uint32_t);
}
-void count_VkSparseImageMemoryBind(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSparseImageMemoryBind* toCount,
- size_t* count)
-{
+void count_VkSparseImageMemoryBind(uint32_t featureBits, VkStructureType rootType,
+ const VkSparseImageMemoryBind* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
- count_VkImageSubresource(featureBits, rootType, (VkImageSubresource*)(&toCount->subresource), count);
+ count_VkImageSubresource(featureBits, rootType, (VkImageSubresource*)(&toCount->subresource),
+ count);
count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->offset), count);
count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->extent), count);
uint64_t cgen_var_0;
@@ -1038,12 +866,8 @@
*count += sizeof(VkSparseMemoryBindFlags);
}
-void count_VkSparseImageMemoryBindInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSparseImageMemoryBindInfo* toCount,
- size_t* count)
-{
+void count_VkSparseImageMemoryBindInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSparseImageMemoryBindInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -1051,73 +875,63 @@
uint64_t cgen_var_0;
*count += 1 * 8;
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->bindCount; ++i)
- {
- count_VkSparseImageMemoryBind(featureBits, rootType, (const VkSparseImageMemoryBind*)(toCount->pBinds + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->bindCount; ++i) {
+ count_VkSparseImageMemoryBind(featureBits, rootType,
+ (const VkSparseImageMemoryBind*)(toCount->pBinds + i),
+ count);
}
}
}
-void count_VkBindSparseInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindSparseInfo* toCount,
- size_t* count)
-{
+void count_VkBindSparseInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBindSparseInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount->waitSemaphoreCount)
- {
+ if (toCount->waitSemaphoreCount) {
*count += toCount->waitSemaphoreCount * 8;
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->bufferBindCount; ++i)
- {
- count_VkSparseBufferMemoryBindInfo(featureBits, rootType, (const VkSparseBufferMemoryBindInfo*)(toCount->pBufferBinds + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->bufferBindCount; ++i) {
+ count_VkSparseBufferMemoryBindInfo(
+ featureBits, rootType,
+ (const VkSparseBufferMemoryBindInfo*)(toCount->pBufferBinds + i), count);
}
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->imageOpaqueBindCount; ++i)
- {
- count_VkSparseImageOpaqueMemoryBindInfo(featureBits, rootType, (const VkSparseImageOpaqueMemoryBindInfo*)(toCount->pImageOpaqueBinds + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->imageOpaqueBindCount; ++i) {
+ count_VkSparseImageOpaqueMemoryBindInfo(
+ featureBits, rootType,
+ (const VkSparseImageOpaqueMemoryBindInfo*)(toCount->pImageOpaqueBinds + i), count);
}
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->imageBindCount; ++i)
- {
- count_VkSparseImageMemoryBindInfo(featureBits, rootType, (const VkSparseImageMemoryBindInfo*)(toCount->pImageBinds + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->imageBindCount; ++i) {
+ count_VkSparseImageMemoryBindInfo(
+ featureBits, rootType,
+ (const VkSparseImageMemoryBindInfo*)(toCount->pImageBinds + i), count);
}
}
*count += sizeof(uint32_t);
- if (toCount->signalSemaphoreCount)
- {
+ if (toCount->signalSemaphoreCount) {
*count += toCount->signalSemaphoreCount * 8;
}
}
-void count_VkSparseImageFormatProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSparseImageFormatProperties* toCount,
- size_t* count)
-{
+void count_VkSparseImageFormatProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkSparseImageFormatProperties* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -1127,93 +941,71 @@
*count += sizeof(VkSparseImageFormatFlags);
}
-void count_VkSparseImageMemoryRequirements(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSparseImageMemoryRequirements* toCount,
- size_t* count)
-{
+void count_VkSparseImageMemoryRequirements(uint32_t featureBits, VkStructureType rootType,
+ const VkSparseImageMemoryRequirements* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
- count_VkSparseImageFormatProperties(featureBits, rootType, (VkSparseImageFormatProperties*)(&toCount->formatProperties), count);
+ count_VkSparseImageFormatProperties(
+ featureBits, rootType, (VkSparseImageFormatProperties*)(&toCount->formatProperties), count);
*count += sizeof(uint32_t);
*count += sizeof(VkDeviceSize);
*count += sizeof(VkDeviceSize);
*count += sizeof(VkDeviceSize);
}
-void count_VkFenceCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFenceCreateInfo* toCount,
- size_t* count)
-{
+void count_VkFenceCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkFenceCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkFenceCreateFlags);
}
-void count_VkSemaphoreCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSemaphoreCreateInfo* toCount,
- size_t* count)
-{
+void count_VkSemaphoreCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSemaphoreCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkSemaphoreCreateFlags);
}
-void count_VkEventCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkEventCreateInfo* toCount,
- size_t* count)
-{
+void count_VkEventCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkEventCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkEventCreateFlags);
}
-void count_VkQueryPoolCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkQueryPoolCreateInfo* toCount,
- size_t* count)
-{
+void count_VkQueryPoolCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkQueryPoolCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -1223,19 +1015,14 @@
*count += sizeof(VkQueryPipelineStatisticFlags);
}
-void count_VkBufferCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferCreateInfo* toCount,
- size_t* count)
-{
+void count_VkBufferCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -1246,28 +1033,21 @@
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pQueueFamilyIndices)
- {
- if (toCount)
- {
+ if (toCount->pQueueFamilyIndices) {
+ if (toCount) {
*count += toCount->queueFamilyIndexCount * sizeof(const uint32_t);
}
}
}
-void count_VkBufferViewCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferViewCreateInfo* toCount,
- size_t* count)
-{
+void count_VkBufferViewCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferViewCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -1279,19 +1059,14 @@
*count += sizeof(VkDeviceSize);
}
-void count_VkImageCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageCreateInfo* toCount,
- size_t* count)
-{
+void count_VkImageCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkImageCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -1308,22 +1083,16 @@
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pQueueFamilyIndices)
- {
- if (toCount)
- {
+ if (toCount->pQueueFamilyIndices) {
+ if (toCount) {
*count += toCount->queueFamilyIndexCount * sizeof(const uint32_t);
}
}
*count += sizeof(VkImageLayout);
}
-void count_VkSubresourceLayout(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubresourceLayout* toCount,
- size_t* count)
-{
+void count_VkSubresourceLayout(uint32_t featureBits, VkStructureType rootType,
+ const VkSubresourceLayout* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -1335,12 +1104,8 @@
*count += sizeof(VkDeviceSize);
}
-void count_VkComponentMapping(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkComponentMapping* toCount,
- size_t* count)
-{
+void count_VkComponentMapping(uint32_t featureBits, VkStructureType rootType,
+ const VkComponentMapping* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -1351,19 +1116,14 @@
*count += sizeof(VkComponentSwizzle);
}
-void count_VkImageViewCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageViewCreateInfo* toCount,
- size_t* count)
-{
+void count_VkImageViewCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkImageViewCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -1372,64 +1132,50 @@
*count += 1 * 8;
*count += sizeof(VkImageViewType);
*count += sizeof(VkFormat);
- count_VkComponentMapping(featureBits, rootType, (VkComponentMapping*)(&toCount->components), count);
- count_VkImageSubresourceRange(featureBits, rootType, (VkImageSubresourceRange*)(&toCount->subresourceRange), count);
+ count_VkComponentMapping(featureBits, rootType, (VkComponentMapping*)(&toCount->components),
+ count);
+ count_VkImageSubresourceRange(featureBits, rootType,
+ (VkImageSubresourceRange*)(&toCount->subresourceRange), count);
}
-void count_VkShaderModuleCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkShaderModuleCreateInfo* toCount,
- size_t* count)
-{
+void count_VkShaderModuleCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkShaderModuleCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkShaderModuleCreateFlags);
*count += 8;
- if (toCount)
- {
+ if (toCount) {
*count += (toCount->codeSize / 4) * sizeof(const uint32_t);
}
}
-void count_VkPipelineCacheCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineCacheCreateInfo* toCount,
- size_t* count)
-{
+void count_VkPipelineCacheCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineCacheCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineCacheCreateFlags);
*count += 8;
- if (toCount)
- {
+ if (toCount) {
*count += toCount->initialDataSize * sizeof(const uint8_t);
}
}
-void count_VkSpecializationMapEntry(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSpecializationMapEntry* toCount,
- size_t* count)
-{
+void count_VkSpecializationMapEntry(uint32_t featureBits, VkStructureType rootType,
+ const VkSpecializationMapEntry* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -1439,44 +1185,35 @@
*count += 8;
}
-void count_VkSpecializationInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSpecializationInfo* toCount,
- size_t* count)
-{
+void count_VkSpecializationInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSpecializationInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->mapEntryCount; ++i)
- {
- count_VkSpecializationMapEntry(featureBits, rootType, (const VkSpecializationMapEntry*)(toCount->pMapEntries + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->mapEntryCount; ++i) {
+ count_VkSpecializationMapEntry(
+ featureBits, rootType, (const VkSpecializationMapEntry*)(toCount->pMapEntries + i),
+ count);
}
}
*count += 8;
- if (toCount)
- {
+ if (toCount) {
*count += toCount->dataSize * sizeof(const uint8_t);
}
}
-void count_VkPipelineShaderStageCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineShaderStageCreateInfo* toCount,
- size_t* count)
-{
+void count_VkPipelineShaderStageCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineShaderStageCreateInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -1487,30 +1224,27 @@
*count += sizeof(uint32_t) + (toCount->pName ? strlen(toCount->pName) : 0);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pSpecializationInfo)
- {
- count_VkSpecializationInfo(featureBits, rootType, (const VkSpecializationInfo*)(toCount->pSpecializationInfo), count);
+ if (toCount->pSpecializationInfo) {
+ count_VkSpecializationInfo(featureBits, rootType,
+ (const VkSpecializationInfo*)(toCount->pSpecializationInfo),
+ count);
}
}
-void count_VkComputePipelineCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkComputePipelineCreateInfo* toCount,
- size_t* count)
-{
+void count_VkComputePipelineCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkComputePipelineCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineCreateFlags);
- count_VkPipelineShaderStageCreateInfo(featureBits, rootType, (VkPipelineShaderStageCreateInfo*)(&toCount->stage), count);
+ count_VkPipelineShaderStageCreateInfo(
+ featureBits, rootType, (VkPipelineShaderStageCreateInfo*)(&toCount->stage), count);
uint64_t cgen_var_0;
*count += 1 * 8;
uint64_t cgen_var_1;
@@ -1518,12 +1252,9 @@
*count += sizeof(int32_t);
}
-void count_VkVertexInputBindingDescription(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVertexInputBindingDescription* toCount,
- size_t* count)
-{
+void count_VkVertexInputBindingDescription(uint32_t featureBits, VkStructureType rootType,
+ const VkVertexInputBindingDescription* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -1533,12 +1264,9 @@
*count += sizeof(VkVertexInputRate);
}
-void count_VkVertexInputAttributeDescription(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVertexInputAttributeDescription* toCount,
- size_t* count)
-{
+void count_VkVertexInputAttributeDescription(uint32_t featureBits, VkStructureType rootType,
+ const VkVertexInputAttributeDescription* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -1549,54 +1277,49 @@
*count += sizeof(uint32_t);
}
-void count_VkPipelineVertexInputStateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineVertexInputStateCreateInfo* toCount,
- size_t* count)
-{
+void count_VkPipelineVertexInputStateCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineVertexInputStateCreateInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineVertexInputStateCreateFlags);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->vertexBindingDescriptionCount; ++i)
- {
- count_VkVertexInputBindingDescription(featureBits, rootType, (const VkVertexInputBindingDescription*)(toCount->pVertexBindingDescriptions + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->vertexBindingDescriptionCount; ++i) {
+ count_VkVertexInputBindingDescription(
+ featureBits, rootType,
+ (const VkVertexInputBindingDescription*)(toCount->pVertexBindingDescriptions + i),
+ count);
}
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->vertexAttributeDescriptionCount; ++i)
- {
- count_VkVertexInputAttributeDescription(featureBits, rootType, (const VkVertexInputAttributeDescription*)(toCount->pVertexAttributeDescriptions + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->vertexAttributeDescriptionCount; ++i) {
+ count_VkVertexInputAttributeDescription(
+ featureBits, rootType,
+ (const VkVertexInputAttributeDescription*)(toCount->pVertexAttributeDescriptions +
+ i),
+ count);
}
}
}
void count_VkPipelineInputAssemblyStateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineInputAssemblyStateCreateInfo* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineInputAssemblyStateCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -1606,18 +1329,14 @@
}
void count_VkPipelineTessellationStateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineTessellationStateCreateInfo* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineTessellationStateCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -1625,12 +1344,8 @@
*count += sizeof(uint32_t);
}
-void count_VkViewport(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkViewport* toCount,
- size_t* count)
-{
+void count_VkViewport(uint32_t featureBits, VkStructureType rootType, const VkViewport* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -1643,19 +1358,15 @@
*count += sizeof(float);
}
-void count_VkPipelineViewportStateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineViewportStateCreateInfo* toCount,
- size_t* count)
-{
+void count_VkPipelineViewportStateCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineViewportStateCreateInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -1663,44 +1374,36 @@
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pViewports)
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->viewportCount; ++i)
- {
- count_VkViewport(featureBits, rootType, (const VkViewport*)(toCount->pViewports + i), count);
+ if (toCount->pViewports) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->viewportCount; ++i) {
+ count_VkViewport(featureBits, rootType,
+ (const VkViewport*)(toCount->pViewports + i), count);
}
}
}
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pScissors)
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->scissorCount; ++i)
- {
- count_VkRect2D(featureBits, rootType, (const VkRect2D*)(toCount->pScissors + i), count);
+ if (toCount->pScissors) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->scissorCount; ++i) {
+ count_VkRect2D(featureBits, rootType, (const VkRect2D*)(toCount->pScissors + i),
+ count);
}
}
}
}
void count_VkPipelineRasterizationStateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineRasterizationStateCreateInfo* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRasterizationStateCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -1717,19 +1420,15 @@
*count += sizeof(float);
}
-void count_VkPipelineMultisampleStateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineMultisampleStateCreateInfo* toCount,
- size_t* count)
-{
+void count_VkPipelineMultisampleStateCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineMultisampleStateCreateInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -1739,10 +1438,8 @@
*count += sizeof(float);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pSampleMask)
- {
- if (toCount)
- {
+ if (toCount->pSampleMask) {
+ if (toCount) {
*count += (((toCount->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask);
}
}
@@ -1750,12 +1447,8 @@
*count += sizeof(VkBool32);
}
-void count_VkStencilOpState(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkStencilOpState* toCount,
- size_t* count)
-{
+void count_VkStencilOpState(uint32_t featureBits, VkStructureType rootType,
+ const VkStencilOpState* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -1770,18 +1463,14 @@
}
void count_VkPipelineDepthStencilStateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineDepthStencilStateCreateInfo* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineDepthStencilStateCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -1797,12 +1486,9 @@
*count += sizeof(float);
}
-void count_VkPipelineColorBlendAttachmentState(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineColorBlendAttachmentState* toCount,
- size_t* count)
-{
+void count_VkPipelineColorBlendAttachmentState(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineColorBlendAttachmentState* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -1817,19 +1503,15 @@
*count += sizeof(VkColorComponentFlags);
}
-void count_VkPipelineColorBlendStateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineColorBlendStateCreateInfo* toCount,
- size_t* count)
-{
+void count_VkPipelineColorBlendStateCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineColorBlendStateCreateInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -1837,154 +1519,153 @@
*count += sizeof(VkBool32);
*count += sizeof(VkLogicOp);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->attachmentCount; ++i)
- {
- count_VkPipelineColorBlendAttachmentState(featureBits, rootType, (const VkPipelineColorBlendAttachmentState*)(toCount->pAttachments + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->attachmentCount; ++i) {
+ count_VkPipelineColorBlendAttachmentState(
+ featureBits, rootType,
+ (const VkPipelineColorBlendAttachmentState*)(toCount->pAttachments + i), count);
}
}
*count += 4 * sizeof(float);
}
-void count_VkPipelineDynamicStateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineDynamicStateCreateInfo* toCount,
- size_t* count)
-{
+void count_VkPipelineDynamicStateCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineDynamicStateCreateInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineDynamicStateCreateFlags);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->dynamicStateCount * sizeof(const VkDynamicState);
}
}
-void count_VkGraphicsPipelineCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkGraphicsPipelineCreateInfo* toCount,
- size_t* count)
-{
+void count_VkGraphicsPipelineCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkGraphicsPipelineCreateInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
uint32_t hasRasterization = 1;
- if (featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
- {
- hasRasterization = (((0 == toCount->pRasterizationState)) ? (0) : (!((*(toCount->pRasterizationState)).rasterizerDiscardEnable)));
+ if (featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
+ hasRasterization = (((0 == toCount->pRasterizationState))
+ ? (0)
+ : (!((*(toCount->pRasterizationState)).rasterizerDiscardEnable)));
*count += 4;
}
uint32_t hasTessellation = 1;
- if (featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
- {
- hasTessellation = arrayany(toCount->pStages, 0, toCount->stageCount, [](VkPipelineShaderStageCreateInfo s) { return ((s.stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) || (s.stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)); });
+ if (featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
+ hasTessellation = arrayany(
+ toCount->pStages, 0, toCount->stageCount, [](VkPipelineShaderStageCreateInfo s) {
+ return ((s.stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) ||
+ (s.stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT));
+ });
*count += 4;
}
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineCreateFlags);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->stageCount; ++i)
- {
- count_VkPipelineShaderStageCreateInfo(featureBits, rootType, (const VkPipelineShaderStageCreateInfo*)(toCount->pStages + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->stageCount; ++i) {
+ count_VkPipelineShaderStageCreateInfo(
+ featureBits, rootType,
+ (const VkPipelineShaderStageCreateInfo*)(toCount->pStages + i), count);
}
}
// WARNING PTR CHECK
- if (featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
- {
+ if (featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
*count += 8;
}
- if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || toCount->pVertexInputState))
- {
- count_VkPipelineVertexInputStateCreateInfo(featureBits, rootType, (const VkPipelineVertexInputStateCreateInfo*)(toCount->pVertexInputState), count);
+ if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ toCount->pVertexInputState)) {
+ count_VkPipelineVertexInputStateCreateInfo(
+ featureBits, rootType,
+ (const VkPipelineVertexInputStateCreateInfo*)(toCount->pVertexInputState), count);
}
// WARNING PTR CHECK
- if (featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
- {
+ if (featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
*count += 8;
}
- if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || toCount->pInputAssemblyState))
- {
- count_VkPipelineInputAssemblyStateCreateInfo(featureBits, rootType, (const VkPipelineInputAssemblyStateCreateInfo*)(toCount->pInputAssemblyState), count);
+ if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ toCount->pInputAssemblyState)) {
+ count_VkPipelineInputAssemblyStateCreateInfo(
+ featureBits, rootType,
+ (const VkPipelineInputAssemblyStateCreateInfo*)(toCount->pInputAssemblyState), count);
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->pTessellationState)
- {
- if (hasTessellation)
- {
- count_VkPipelineTessellationStateCreateInfo(featureBits, rootType, (const VkPipelineTessellationStateCreateInfo*)(toCount->pTessellationState), count);
+ if (toCount->pTessellationState) {
+ if (hasTessellation) {
+ count_VkPipelineTessellationStateCreateInfo(
+ featureBits, rootType,
+ (const VkPipelineTessellationStateCreateInfo*)(toCount->pTessellationState), count);
}
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->pViewportState)
- {
- if (hasRasterization)
- {
- count_VkPipelineViewportStateCreateInfo(featureBits, rootType, (const VkPipelineViewportStateCreateInfo*)(toCount->pViewportState), count);
+ if (toCount->pViewportState) {
+ if (hasRasterization) {
+ count_VkPipelineViewportStateCreateInfo(
+ featureBits, rootType,
+ (const VkPipelineViewportStateCreateInfo*)(toCount->pViewportState), count);
}
}
// WARNING PTR CHECK
- if (featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
- {
+ if (featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
*count += 8;
}
- if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || toCount->pRasterizationState))
- {
- count_VkPipelineRasterizationStateCreateInfo(featureBits, rootType, (const VkPipelineRasterizationStateCreateInfo*)(toCount->pRasterizationState), count);
+ if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ toCount->pRasterizationState)) {
+ count_VkPipelineRasterizationStateCreateInfo(
+ featureBits, rootType,
+ (const VkPipelineRasterizationStateCreateInfo*)(toCount->pRasterizationState), count);
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->pMultisampleState)
- {
- if (hasRasterization)
- {
- count_VkPipelineMultisampleStateCreateInfo(featureBits, rootType, (const VkPipelineMultisampleStateCreateInfo*)(toCount->pMultisampleState), count);
+ if (toCount->pMultisampleState) {
+ if (hasRasterization) {
+ count_VkPipelineMultisampleStateCreateInfo(
+ featureBits, rootType,
+ (const VkPipelineMultisampleStateCreateInfo*)(toCount->pMultisampleState), count);
}
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->pDepthStencilState)
- {
- if (hasRasterization)
- {
- count_VkPipelineDepthStencilStateCreateInfo(featureBits, rootType, (const VkPipelineDepthStencilStateCreateInfo*)(toCount->pDepthStencilState), count);
+ if (toCount->pDepthStencilState) {
+ if (hasRasterization) {
+ count_VkPipelineDepthStencilStateCreateInfo(
+ featureBits, rootType,
+ (const VkPipelineDepthStencilStateCreateInfo*)(toCount->pDepthStencilState), count);
}
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->pColorBlendState)
- {
- if (hasRasterization)
- {
- count_VkPipelineColorBlendStateCreateInfo(featureBits, rootType, (const VkPipelineColorBlendStateCreateInfo*)(toCount->pColorBlendState), count);
+ if (toCount->pColorBlendState) {
+ if (hasRasterization) {
+ count_VkPipelineColorBlendStateCreateInfo(
+ featureBits, rootType,
+ (const VkPipelineColorBlendStateCreateInfo*)(toCount->pColorBlendState), count);
}
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->pDynamicState)
- {
- count_VkPipelineDynamicStateCreateInfo(featureBits, rootType, (const VkPipelineDynamicStateCreateInfo*)(toCount->pDynamicState), count);
+ if (toCount->pDynamicState) {
+ count_VkPipelineDynamicStateCreateInfo(
+ featureBits, rootType,
+ (const VkPipelineDynamicStateCreateInfo*)(toCount->pDynamicState), count);
}
uint64_t cgen_var_0;
*count += 1 * 8;
@@ -1996,12 +1677,8 @@
*count += sizeof(int32_t);
}
-void count_VkPushConstantRange(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPushConstantRange* toCount,
- size_t* count)
-{
+void count_VkPushConstantRange(uint32_t featureBits, VkStructureType rootType,
+ const VkPushConstantRange* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -2011,51 +1688,40 @@
*count += sizeof(uint32_t);
}
-void count_VkPipelineLayoutCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineLayoutCreateInfo* toCount,
- size_t* count)
-{
+void count_VkPipelineLayoutCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineLayoutCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineLayoutCreateFlags);
*count += sizeof(uint32_t);
- if (toCount->setLayoutCount)
- {
+ if (toCount->setLayoutCount) {
*count += toCount->setLayoutCount * 8;
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->pushConstantRangeCount; ++i)
- {
- count_VkPushConstantRange(featureBits, rootType, (const VkPushConstantRange*)(toCount->pPushConstantRanges + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->pushConstantRangeCount; ++i) {
+ count_VkPushConstantRange(
+ featureBits, rootType,
+ (const VkPushConstantRange*)(toCount->pPushConstantRanges + i), count);
}
}
}
-void count_VkSamplerCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSamplerCreateInfo* toCount,
- size_t* count)
-{
+void count_VkSamplerCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSamplerCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -2077,19 +1743,14 @@
*count += sizeof(VkBool32);
}
-void count_VkCopyDescriptorSet(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCopyDescriptorSet* toCount,
- size_t* count)
-{
+void count_VkCopyDescriptorSet(uint32_t featureBits, VkStructureType rootType,
+ const VkCopyDescriptorSet* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -2104,12 +1765,8 @@
*count += sizeof(uint32_t);
}
-void count_VkDescriptorBufferInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorBufferInfo* toCount,
- size_t* count)
-{
+void count_VkDescriptorBufferInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorBufferInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -2120,12 +1777,8 @@
*count += sizeof(VkDeviceSize);
}
-void count_VkDescriptorImageInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorImageInfo* toCount,
- size_t* count)
-{
+void count_VkDescriptorImageInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorImageInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -2137,12 +1790,8 @@
*count += sizeof(VkImageLayout);
}
-void count_VkDescriptorPoolSize(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorPoolSize* toCount,
- size_t* count)
-{
+void count_VkDescriptorPoolSize(uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorPoolSize* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -2151,65 +1800,51 @@
*count += sizeof(uint32_t);
}
-void count_VkDescriptorPoolCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorPoolCreateInfo* toCount,
- size_t* count)
-{
+void count_VkDescriptorPoolCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorPoolCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDescriptorPoolCreateFlags);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->poolSizeCount; ++i)
- {
- count_VkDescriptorPoolSize(featureBits, rootType, (const VkDescriptorPoolSize*)(toCount->pPoolSizes + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->poolSizeCount; ++i) {
+ count_VkDescriptorPoolSize(featureBits, rootType,
+ (const VkDescriptorPoolSize*)(toCount->pPoolSizes + i),
+ count);
}
}
}
-void count_VkDescriptorSetAllocateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorSetAllocateInfo* toCount,
- size_t* count)
-{
+void count_VkDescriptorSetAllocateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorSetAllocateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
uint64_t cgen_var_0;
*count += 1 * 8;
*count += sizeof(uint32_t);
- if (toCount->descriptorSetCount)
- {
+ if (toCount->descriptorSetCount) {
*count += toCount->descriptorSetCount * 8;
}
}
-void count_VkDescriptorSetLayoutBinding(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorSetLayoutBinding* toCount,
- size_t* count)
-{
+void count_VkDescriptorSetLayoutBinding(uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorSetLayoutBinding* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -2220,55 +1855,44 @@
*count += sizeof(VkShaderStageFlags);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pImmutableSamplers)
- {
- if (toCount->descriptorCount)
- {
+ if (toCount->pImmutableSamplers) {
+ if (toCount->descriptorCount) {
*count += toCount->descriptorCount * 8;
}
}
}
-void count_VkDescriptorSetLayoutCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorSetLayoutCreateInfo* toCount,
- size_t* count)
-{
+void count_VkDescriptorSetLayoutCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorSetLayoutCreateInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDescriptorSetLayoutCreateFlags);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->bindingCount; ++i)
- {
- count_VkDescriptorSetLayoutBinding(featureBits, rootType, (const VkDescriptorSetLayoutBinding*)(toCount->pBindings + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->bindingCount; ++i) {
+ count_VkDescriptorSetLayoutBinding(
+ featureBits, rootType,
+ (const VkDescriptorSetLayoutBinding*)(toCount->pBindings + i), count);
}
}
}
-void count_VkWriteDescriptorSet(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkWriteDescriptorSet* toCount,
- size_t* count)
-{
+void count_VkWriteDescriptorSet(uint32_t featureBits, VkStructureType rootType,
+ const VkWriteDescriptorSet* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -2280,54 +1904,54 @@
*count += sizeof(VkDescriptorType);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pImageInfo)
- {
- if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_SAMPLER == toCount->descriptorType) || (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER == toCount->descriptorType) || (VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE == toCount->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE == toCount->descriptorType) || (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT == toCount->descriptorType))))
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->descriptorCount; ++i)
- {
- count_VkDescriptorImageInfo(featureBits, rootType, (const VkDescriptorImageInfo*)(toCount->pImageInfo + i), count);
+ if (toCount->pImageInfo) {
+ if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ ((VK_DESCRIPTOR_TYPE_SAMPLER == toCount->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER == toCount->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE == toCount->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE == toCount->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT == toCount->descriptorType)))) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->descriptorCount; ++i) {
+ count_VkDescriptorImageInfo(
+ featureBits, rootType,
+ (const VkDescriptorImageInfo*)(toCount->pImageInfo + i), count);
}
}
}
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->pBufferInfo)
- {
- if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER == toCount->descriptorType) || (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == toCount->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == toCount->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == toCount->descriptorType))))
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->descriptorCount; ++i)
- {
- count_VkDescriptorBufferInfo(featureBits, rootType, (const VkDescriptorBufferInfo*)(toCount->pBufferInfo + i), count);
+ if (toCount->pBufferInfo) {
+ if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ ((VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER == toCount->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == toCount->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == toCount->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == toCount->descriptorType)))) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->descriptorCount; ++i) {
+ count_VkDescriptorBufferInfo(
+ featureBits, rootType,
+ (const VkDescriptorBufferInfo*)(toCount->pBufferInfo + i), count);
}
}
}
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->pTexelBufferView)
- {
- if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER == toCount->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER == toCount->descriptorType))))
- {
- if (toCount->descriptorCount)
- {
+ if (toCount->pTexelBufferView) {
+ if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ ((VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER == toCount->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER == toCount->descriptorType)))) {
+ if (toCount->descriptorCount) {
*count += toCount->descriptorCount * 8;
}
}
}
}
-void count_VkAttachmentDescription(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAttachmentDescription* toCount,
- size_t* count)
-{
+void count_VkAttachmentDescription(uint32_t featureBits, VkStructureType rootType,
+ const VkAttachmentDescription* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -2343,12 +1967,8 @@
*count += sizeof(VkImageLayout);
}
-void count_VkAttachmentReference(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAttachmentReference* toCount,
- size_t* count)
-{
+void count_VkAttachmentReference(uint32_t featureBits, VkStructureType rootType,
+ const VkAttachmentReference* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -2357,19 +1977,14 @@
*count += sizeof(VkImageLayout);
}
-void count_VkFramebufferCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFramebufferCreateInfo* toCount,
- size_t* count)
-{
+void count_VkFramebufferCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkFramebufferCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -2377,21 +1992,19 @@
uint64_t cgen_var_0;
*count += 1 * 8;
*count += sizeof(uint32_t);
- if (toCount->attachmentCount)
- {
- *count += toCount->attachmentCount * 8;
+ if ((!(featureBits & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ (((toCount->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT) == 0)))) {
+ if (toCount->attachmentCount) {
+ *count += toCount->attachmentCount * 8;
+ }
}
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
}
-void count_VkSubpassDescription(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubpassDescription* toCount,
- size_t* count)
-{
+void count_VkSubpassDescription(uint32_t featureBits, VkStructureType rootType,
+ const VkSubpassDescription* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -2399,52 +2012,47 @@
*count += sizeof(VkSubpassDescriptionFlags);
*count += sizeof(VkPipelineBindPoint);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->inputAttachmentCount; ++i)
- {
- count_VkAttachmentReference(featureBits, rootType, (const VkAttachmentReference*)(toCount->pInputAttachments + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->inputAttachmentCount; ++i) {
+ count_VkAttachmentReference(
+ featureBits, rootType,
+ (const VkAttachmentReference*)(toCount->pInputAttachments + i), count);
}
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->colorAttachmentCount; ++i)
- {
- count_VkAttachmentReference(featureBits, rootType, (const VkAttachmentReference*)(toCount->pColorAttachments + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->colorAttachmentCount; ++i) {
+ count_VkAttachmentReference(
+ featureBits, rootType,
+ (const VkAttachmentReference*)(toCount->pColorAttachments + i), count);
}
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->pResolveAttachments)
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->colorAttachmentCount; ++i)
- {
- count_VkAttachmentReference(featureBits, rootType, (const VkAttachmentReference*)(toCount->pResolveAttachments + i), count);
+ if (toCount->pResolveAttachments) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->colorAttachmentCount; ++i) {
+ count_VkAttachmentReference(
+ featureBits, rootType,
+ (const VkAttachmentReference*)(toCount->pResolveAttachments + i), count);
}
}
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->pDepthStencilAttachment)
- {
- count_VkAttachmentReference(featureBits, rootType, (const VkAttachmentReference*)(toCount->pDepthStencilAttachment), count);
+ if (toCount->pDepthStencilAttachment) {
+ count_VkAttachmentReference(
+ featureBits, rootType, (const VkAttachmentReference*)(toCount->pDepthStencilAttachment),
+ count);
}
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->preserveAttachmentCount * sizeof(const uint32_t);
}
}
-void count_VkSubpassDependency(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubpassDependency* toCount,
- size_t* count)
-{
+void count_VkSubpassDependency(uint32_t featureBits, VkStructureType rootType,
+ const VkSubpassDependency* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -2458,62 +2066,52 @@
*count += sizeof(VkDependencyFlags);
}
-void count_VkRenderPassCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderPassCreateInfo* toCount,
- size_t* count)
-{
+void count_VkRenderPassCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderPassCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkRenderPassCreateFlags);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->attachmentCount; ++i)
- {
- count_VkAttachmentDescription(featureBits, rootType, (const VkAttachmentDescription*)(toCount->pAttachments + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->attachmentCount; ++i) {
+ count_VkAttachmentDescription(
+ featureBits, rootType, (const VkAttachmentDescription*)(toCount->pAttachments + i),
+ count);
}
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->subpassCount; ++i)
- {
- count_VkSubpassDescription(featureBits, rootType, (const VkSubpassDescription*)(toCount->pSubpasses + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->subpassCount; ++i) {
+ count_VkSubpassDescription(featureBits, rootType,
+ (const VkSubpassDescription*)(toCount->pSubpasses + i),
+ count);
}
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->dependencyCount; ++i)
- {
- count_VkSubpassDependency(featureBits, rootType, (const VkSubpassDependency*)(toCount->pDependencies + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->dependencyCount; ++i) {
+ count_VkSubpassDependency(featureBits, rootType,
+ (const VkSubpassDependency*)(toCount->pDependencies + i),
+ count);
}
}
}
-void count_VkCommandPoolCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCommandPoolCreateInfo* toCount,
- size_t* count)
-{
+void count_VkCommandPoolCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkCommandPoolCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -2521,19 +2119,14 @@
*count += sizeof(uint32_t);
}
-void count_VkCommandBufferAllocateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCommandBufferAllocateInfo* toCount,
- size_t* count)
-{
+void count_VkCommandBufferAllocateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkCommandBufferAllocateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -2543,19 +2136,15 @@
*count += sizeof(uint32_t);
}
-void count_VkCommandBufferInheritanceInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCommandBufferInheritanceInfo* toCount,
- size_t* count)
-{
+void count_VkCommandBufferInheritanceInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkCommandBufferInheritanceInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -2569,37 +2158,29 @@
*count += sizeof(VkQueryPipelineStatisticFlags);
}
-void count_VkCommandBufferBeginInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCommandBufferBeginInfo* toCount,
- size_t* count)
-{
+void count_VkCommandBufferBeginInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkCommandBufferBeginInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkCommandBufferUsageFlags);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pInheritanceInfo)
- {
- count_VkCommandBufferInheritanceInfo(featureBits, rootType, (const VkCommandBufferInheritanceInfo*)(toCount->pInheritanceInfo), count);
+ if (toCount->pInheritanceInfo) {
+ count_VkCommandBufferInheritanceInfo(
+ featureBits, rootType,
+ (const VkCommandBufferInheritanceInfo*)(toCount->pInheritanceInfo), count);
}
}
-void count_VkBufferCopy(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferCopy* toCount,
- size_t* count)
-{
+void count_VkBufferCopy(uint32_t featureBits, VkStructureType rootType, const VkBufferCopy* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -2609,12 +2190,8 @@
*count += sizeof(VkDeviceSize);
}
-void count_VkImageSubresourceLayers(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageSubresourceLayers* toCount,
- size_t* count)
-{
+void count_VkImageSubresourceLayers(uint32_t featureBits, VkStructureType rootType,
+ const VkImageSubresourceLayers* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -2625,12 +2202,8 @@
*count += sizeof(uint32_t);
}
-void count_VkBufferImageCopy(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferImageCopy* toCount,
- size_t* count)
-{
+void count_VkBufferImageCopy(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferImageCopy* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -2638,17 +2211,14 @@
*count += sizeof(VkDeviceSize);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- count_VkImageSubresourceLayers(featureBits, rootType, (VkImageSubresourceLayers*)(&toCount->imageSubresource), count);
+ count_VkImageSubresourceLayers(featureBits, rootType,
+ (VkImageSubresourceLayers*)(&toCount->imageSubresource), count);
count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->imageOffset), count);
count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->imageExtent), count);
}
-void count_VkClearColorValue(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkClearColorValue* toCount,
- size_t* count)
-{
+void count_VkClearColorValue(uint32_t featureBits, VkStructureType rootType,
+ const VkClearColorValue* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -2656,12 +2226,8 @@
*count += 4 * sizeof(float);
}
-void count_VkClearDepthStencilValue(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkClearDepthStencilValue* toCount,
- size_t* count)
-{
+void count_VkClearDepthStencilValue(uint32_t featureBits, VkStructureType rootType,
+ const VkClearDepthStencilValue* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -2670,12 +2236,8 @@
*count += sizeof(uint32_t);
}
-void count_VkClearValue(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkClearValue* toCount,
- size_t* count)
-{
+void count_VkClearValue(uint32_t featureBits, VkStructureType rootType, const VkClearValue* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -2683,12 +2245,8 @@
count_VkClearColorValue(featureBits, rootType, (VkClearColorValue*)(&toCount->color), count);
}
-void count_VkClearAttachment(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkClearAttachment* toCount,
- size_t* count)
-{
+void count_VkClearAttachment(uint32_t featureBits, VkStructureType rootType,
+ const VkClearAttachment* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -2698,12 +2256,8 @@
count_VkClearValue(featureBits, rootType, (VkClearValue*)(&toCount->clearValue), count);
}
-void count_VkClearRect(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkClearRect* toCount,
- size_t* count)
-{
+void count_VkClearRect(uint32_t featureBits, VkStructureType rootType, const VkClearRect* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -2713,75 +2267,62 @@
*count += sizeof(uint32_t);
}
-void count_VkImageBlit(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageBlit* toCount,
- size_t* count)
-{
+void count_VkImageBlit(uint32_t featureBits, VkStructureType rootType, const VkImageBlit* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
- count_VkImageSubresourceLayers(featureBits, rootType, (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ count_VkImageSubresourceLayers(featureBits, rootType,
+ (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(toCount->srcOffsets + i), count);
}
- count_VkImageSubresourceLayers(featureBits, rootType, (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ count_VkImageSubresourceLayers(featureBits, rootType,
+ (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(toCount->dstOffsets + i), count);
}
}
-void count_VkImageCopy(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageCopy* toCount,
- size_t* count)
-{
+void count_VkImageCopy(uint32_t featureBits, VkStructureType rootType, const VkImageCopy* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
- count_VkImageSubresourceLayers(featureBits, rootType, (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
+ count_VkImageSubresourceLayers(featureBits, rootType,
+ (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->srcOffset), count);
- count_VkImageSubresourceLayers(featureBits, rootType, (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
+ count_VkImageSubresourceLayers(featureBits, rootType,
+ (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->dstOffset), count);
count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->extent), count);
}
-void count_VkImageResolve(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageResolve* toCount,
- size_t* count)
-{
+void count_VkImageResolve(uint32_t featureBits, VkStructureType rootType,
+ const VkImageResolve* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
- count_VkImageSubresourceLayers(featureBits, rootType, (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
+ count_VkImageSubresourceLayers(featureBits, rootType,
+ (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->srcOffset), count);
- count_VkImageSubresourceLayers(featureBits, rootType, (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
+ count_VkImageSubresourceLayers(featureBits, rootType,
+ (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->dstOffset), count);
count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->extent), count);
}
-void count_VkRenderPassBeginInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderPassBeginInfo* toCount,
- size_t* count)
-{
+void count_VkRenderPassBeginInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderPassBeginInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -2793,13 +2334,11 @@
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pClearValues)
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->clearValueCount; ++i)
- {
- count_VkClearValue(featureBits, rootType, (const VkClearValue*)(toCount->pClearValues + i), count);
+ if (toCount->pClearValues) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->clearValueCount; ++i) {
+ count_VkClearValue(featureBits, rootType,
+ (const VkClearValue*)(toCount->pClearValues + i), count);
}
}
}
@@ -2807,19 +2346,15 @@
#endif
#ifdef VK_VERSION_1_1
-void count_VkPhysicalDeviceSubgroupProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSubgroupProperties* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceSubgroupProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSubgroupProperties* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -2829,19 +2364,14 @@
*count += sizeof(VkBool32);
}
-void count_VkBindBufferMemoryInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindBufferMemoryInfo* toCount,
- size_t* count)
-{
+void count_VkBindBufferMemoryInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBindBufferMemoryInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -2852,19 +2382,14 @@
*count += sizeof(VkDeviceSize);
}
-void count_VkBindImageMemoryInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindImageMemoryInfo* toCount,
- size_t* count)
-{
+void count_VkBindImageMemoryInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBindImageMemoryInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -2875,19 +2400,15 @@
*count += sizeof(VkDeviceSize);
}
-void count_VkPhysicalDevice16BitStorageFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevice16BitStorageFeatures* toCount,
- size_t* count)
-{
+void count_VkPhysicalDevice16BitStorageFeatures(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevice16BitStorageFeatures* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -2897,19 +2418,15 @@
*count += sizeof(VkBool32);
}
-void count_VkMemoryDedicatedRequirements(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryDedicatedRequirements* toCount,
- size_t* count)
-{
+void count_VkMemoryDedicatedRequirements(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryDedicatedRequirements* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -2917,19 +2434,15 @@
*count += sizeof(VkBool32);
}
-void count_VkMemoryDedicatedAllocateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryDedicatedAllocateInfo* toCount,
- size_t* count)
-{
+void count_VkMemoryDedicatedAllocateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryDedicatedAllocateInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -2939,19 +2452,14 @@
*count += 1 * 8;
}
-void count_VkMemoryAllocateFlagsInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryAllocateFlagsInfo* toCount,
- size_t* count)
-{
+void count_VkMemoryAllocateFlagsInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryAllocateFlagsInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -2959,98 +2467,76 @@
*count += sizeof(uint32_t);
}
-void count_VkDeviceGroupRenderPassBeginInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceGroupRenderPassBeginInfo* toCount,
- size_t* count)
-{
+void count_VkDeviceGroupRenderPassBeginInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceGroupRenderPassBeginInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->deviceRenderAreaCount; ++i)
- {
- count_VkRect2D(featureBits, rootType, (const VkRect2D*)(toCount->pDeviceRenderAreas + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->deviceRenderAreaCount; ++i) {
+ count_VkRect2D(featureBits, rootType,
+ (const VkRect2D*)(toCount->pDeviceRenderAreas + i), count);
}
}
}
-void count_VkDeviceGroupCommandBufferBeginInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceGroupCommandBufferBeginInfo* toCount,
- size_t* count)
-{
+void count_VkDeviceGroupCommandBufferBeginInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceGroupCommandBufferBeginInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
-void count_VkDeviceGroupSubmitInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceGroupSubmitInfo* toCount,
- size_t* count)
-{
+void count_VkDeviceGroupSubmitInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceGroupSubmitInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->waitSemaphoreCount * sizeof(const uint32_t);
}
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->commandBufferCount * sizeof(const uint32_t);
}
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->signalSemaphoreCount * sizeof(const uint32_t);
}
}
-void count_VkDeviceGroupBindSparseInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceGroupBindSparseInfo* toCount,
- size_t* count)
-{
+void count_VkDeviceGroupBindSparseInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceGroupBindSparseInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -3058,73 +2544,58 @@
*count += sizeof(uint32_t);
}
-void count_VkBindBufferMemoryDeviceGroupInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindBufferMemoryDeviceGroupInfo* toCount,
- size_t* count)
-{
+void count_VkBindBufferMemoryDeviceGroupInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBindBufferMemoryDeviceGroupInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->deviceIndexCount * sizeof(const uint32_t);
}
}
-void count_VkBindImageMemoryDeviceGroupInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindImageMemoryDeviceGroupInfo* toCount,
- size_t* count)
-{
+void count_VkBindImageMemoryDeviceGroupInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBindImageMemoryDeviceGroupInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->deviceIndexCount * sizeof(const uint32_t);
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->splitInstanceBindRegionCount; ++i)
- {
- count_VkRect2D(featureBits, rootType, (const VkRect2D*)(toCount->pSplitInstanceBindRegions + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->splitInstanceBindRegionCount; ++i) {
+ count_VkRect2D(featureBits, rootType,
+ (const VkRect2D*)(toCount->pSplitInstanceBindRegions + i), count);
}
}
}
-void count_VkPhysicalDeviceGroupProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceGroupProperties* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceGroupProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceGroupProperties* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -3133,42 +2604,33 @@
*count += sizeof(VkBool32);
}
-void count_VkDeviceGroupDeviceCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceGroupDeviceCreateInfo* toCount,
- size_t* count)
-{
+void count_VkDeviceGroupDeviceCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceGroupDeviceCreateInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount->physicalDeviceCount)
- {
+ if (toCount->physicalDeviceCount) {
*count += toCount->physicalDeviceCount * 8;
}
}
-void count_VkBufferMemoryRequirementsInfo2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferMemoryRequirementsInfo2* toCount,
- size_t* count)
-{
+void count_VkBufferMemoryRequirementsInfo2(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferMemoryRequirementsInfo2* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -3176,19 +2638,15 @@
*count += 1 * 8;
}
-void count_VkImageMemoryRequirementsInfo2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageMemoryRequirementsInfo2* toCount,
- size_t* count)
-{
+void count_VkImageMemoryRequirementsInfo2(uint32_t featureBits, VkStructureType rootType,
+ const VkImageMemoryRequirementsInfo2* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -3196,19 +2654,15 @@
*count += 1 * 8;
}
-void count_VkImageSparseMemoryRequirementsInfo2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageSparseMemoryRequirementsInfo2* toCount,
- size_t* count)
-{
+void count_VkImageSparseMemoryRequirementsInfo2(uint32_t featureBits, VkStructureType rootType,
+ const VkImageSparseMemoryRequirementsInfo2* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -3216,133 +2670,107 @@
*count += 1 * 8;
}
-void count_VkMemoryRequirements2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryRequirements2* toCount,
- size_t* count)
-{
+void count_VkMemoryRequirements2(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryRequirements2* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkMemoryRequirements(featureBits, rootType, (VkMemoryRequirements*)(&toCount->memoryRequirements), count);
+ count_VkMemoryRequirements(featureBits, rootType,
+ (VkMemoryRequirements*)(&toCount->memoryRequirements), count);
}
-void count_VkSparseImageMemoryRequirements2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSparseImageMemoryRequirements2* toCount,
- size_t* count)
-{
+void count_VkSparseImageMemoryRequirements2(uint32_t featureBits, VkStructureType rootType,
+ const VkSparseImageMemoryRequirements2* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkSparseImageMemoryRequirements(featureBits, rootType, (VkSparseImageMemoryRequirements*)(&toCount->memoryRequirements), count);
+ count_VkSparseImageMemoryRequirements(
+ featureBits, rootType, (VkSparseImageMemoryRequirements*)(&toCount->memoryRequirements),
+ count);
}
-void count_VkPhysicalDeviceFeatures2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFeatures2* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceFeatures2(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFeatures2* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkPhysicalDeviceFeatures(featureBits, rootType, (VkPhysicalDeviceFeatures*)(&toCount->features), count);
+ count_VkPhysicalDeviceFeatures(featureBits, rootType,
+ (VkPhysicalDeviceFeatures*)(&toCount->features), count);
}
-void count_VkPhysicalDeviceProperties2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceProperties2* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceProperties2(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceProperties2* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkPhysicalDeviceProperties(featureBits, rootType, (VkPhysicalDeviceProperties*)(&toCount->properties), count);
+ count_VkPhysicalDeviceProperties(featureBits, rootType,
+ (VkPhysicalDeviceProperties*)(&toCount->properties), count);
}
-void count_VkFormatProperties2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFormatProperties2* toCount,
- size_t* count)
-{
+void count_VkFormatProperties2(uint32_t featureBits, VkStructureType rootType,
+ const VkFormatProperties2* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkFormatProperties(featureBits, rootType, (VkFormatProperties*)(&toCount->formatProperties), count);
+ count_VkFormatProperties(featureBits, rootType,
+ (VkFormatProperties*)(&toCount->formatProperties), count);
}
-void count_VkImageFormatProperties2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageFormatProperties2* toCount,
- size_t* count)
-{
+void count_VkImageFormatProperties2(uint32_t featureBits, VkStructureType rootType,
+ const VkImageFormatProperties2* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkImageFormatProperties(featureBits, rootType, (VkImageFormatProperties*)(&toCount->imageFormatProperties), count);
+ count_VkImageFormatProperties(
+ featureBits, rootType, (VkImageFormatProperties*)(&toCount->imageFormatProperties), count);
}
-void count_VkPhysicalDeviceImageFormatInfo2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceImageFormatInfo2* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceImageFormatInfo2(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceImageFormatInfo2* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -3353,76 +2781,63 @@
*count += sizeof(VkImageCreateFlags);
}
-void count_VkQueueFamilyProperties2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkQueueFamilyProperties2* toCount,
- size_t* count)
-{
+void count_VkQueueFamilyProperties2(uint32_t featureBits, VkStructureType rootType,
+ const VkQueueFamilyProperties2* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkQueueFamilyProperties(featureBits, rootType, (VkQueueFamilyProperties*)(&toCount->queueFamilyProperties), count);
+ count_VkQueueFamilyProperties(
+ featureBits, rootType, (VkQueueFamilyProperties*)(&toCount->queueFamilyProperties), count);
}
-void count_VkPhysicalDeviceMemoryProperties2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryProperties2* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceMemoryProperties2(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryProperties2* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkPhysicalDeviceMemoryProperties(featureBits, rootType, (VkPhysicalDeviceMemoryProperties*)(&toCount->memoryProperties), count);
+ count_VkPhysicalDeviceMemoryProperties(
+ featureBits, rootType, (VkPhysicalDeviceMemoryProperties*)(&toCount->memoryProperties),
+ count);
}
-void count_VkSparseImageFormatProperties2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSparseImageFormatProperties2* toCount,
- size_t* count)
-{
+void count_VkSparseImageFormatProperties2(uint32_t featureBits, VkStructureType rootType,
+ const VkSparseImageFormatProperties2* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkSparseImageFormatProperties(featureBits, rootType, (VkSparseImageFormatProperties*)(&toCount->properties), count);
+ count_VkSparseImageFormatProperties(
+ featureBits, rootType, (VkSparseImageFormatProperties*)(&toCount->properties), count);
}
void count_VkPhysicalDeviceSparseImageFormatInfo2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSparseImageFormatInfo2* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSparseImageFormatInfo2* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -3434,30 +2849,23 @@
}
void count_VkPhysicalDevicePointClippingProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePointClippingProperties* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePointClippingProperties* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPointClippingBehavior);
}
-void count_VkInputAttachmentAspectReference(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkInputAttachmentAspectReference* toCount,
- size_t* count)
-{
+void count_VkInputAttachmentAspectReference(uint32_t featureBits, VkStructureType rootType,
+ const VkInputAttachmentAspectReference* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -3468,44 +2876,35 @@
}
void count_VkRenderPassInputAttachmentAspectCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderPassInputAttachmentAspectCreateInfo* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkRenderPassInputAttachmentAspectCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->aspectReferenceCount; ++i)
- {
- count_VkInputAttachmentAspectReference(featureBits, rootType, (const VkInputAttachmentAspectReference*)(toCount->pAspectReferences + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->aspectReferenceCount; ++i) {
+ count_VkInputAttachmentAspectReference(
+ featureBits, rootType,
+ (const VkInputAttachmentAspectReference*)(toCount->pAspectReferences + i), count);
}
}
}
-void count_VkImageViewUsageCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageViewUsageCreateInfo* toCount,
- size_t* count)
-{
+void count_VkImageViewUsageCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkImageViewUsageCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -3513,70 +2912,55 @@
}
void count_VkPipelineTessellationDomainOriginStateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineTessellationDomainOriginStateCreateInfo* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineTessellationDomainOriginStateCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkTessellationDomainOrigin);
}
-void count_VkRenderPassMultiviewCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderPassMultiviewCreateInfo* toCount,
- size_t* count)
-{
+void count_VkRenderPassMultiviewCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderPassMultiviewCreateInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->subpassCount * sizeof(const uint32_t);
}
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->dependencyCount * sizeof(const int32_t);
}
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->correlationMaskCount * sizeof(const uint32_t);
}
}
-void count_VkPhysicalDeviceMultiviewFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiviewFeatures* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceMultiviewFeatures(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMultiviewFeatures* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -3585,19 +2969,15 @@
*count += sizeof(VkBool32);
}
-void count_VkPhysicalDeviceMultiviewProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiviewProperties* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceMultiviewProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMultiviewProperties* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -3606,18 +2986,14 @@
}
void count_VkPhysicalDeviceVariablePointersFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceVariablePointersFeatures* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVariablePointersFeatures* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -3626,18 +3002,14 @@
}
void count_VkPhysicalDeviceProtectedMemoryFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceProtectedMemoryFeatures* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceProtectedMemoryFeatures* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -3645,37 +3017,28 @@
}
void count_VkPhysicalDeviceProtectedMemoryProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceProtectedMemoryProperties* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceProtectedMemoryProperties* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
-void count_VkDeviceQueueInfo2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceQueueInfo2* toCount,
- size_t* count)
-{
+void count_VkDeviceQueueInfo2(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceQueueInfo2* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -3684,64 +3047,52 @@
*count += sizeof(uint32_t);
}
-void count_VkProtectedSubmitInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkProtectedSubmitInfo* toCount,
- size_t* count)
-{
+void count_VkProtectedSubmitInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkProtectedSubmitInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
-void count_VkSamplerYcbcrConversionCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSamplerYcbcrConversionCreateInfo* toCount,
- size_t* count)
-{
+void count_VkSamplerYcbcrConversionCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSamplerYcbcrConversionCreateInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkFormat);
*count += sizeof(VkSamplerYcbcrModelConversion);
*count += sizeof(VkSamplerYcbcrRange);
- count_VkComponentMapping(featureBits, rootType, (VkComponentMapping*)(&toCount->components), count);
+ count_VkComponentMapping(featureBits, rootType, (VkComponentMapping*)(&toCount->components),
+ count);
*count += sizeof(VkChromaLocation);
*count += sizeof(VkChromaLocation);
*count += sizeof(VkFilter);
*count += sizeof(VkBool32);
}
-void count_VkSamplerYcbcrConversionInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSamplerYcbcrConversionInfo* toCount,
- size_t* count)
-{
+void count_VkSamplerYcbcrConversionInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSamplerYcbcrConversionInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -3749,38 +3100,29 @@
*count += 1 * 8;
}
-void count_VkBindImagePlaneMemoryInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindImagePlaneMemoryInfo* toCount,
- size_t* count)
-{
+void count_VkBindImagePlaneMemoryInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBindImagePlaneMemoryInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkImageAspectFlagBits);
}
-void count_VkImagePlaneMemoryRequirementsInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImagePlaneMemoryRequirementsInfo* toCount,
- size_t* count)
-{
+void count_VkImagePlaneMemoryRequirementsInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkImagePlaneMemoryRequirementsInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -3788,18 +3130,14 @@
}
void count_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSamplerYcbcrConversionFeatures* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSamplerYcbcrConversionFeatures* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -3807,30 +3145,23 @@
}
void count_VkSamplerYcbcrConversionImageFormatProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSamplerYcbcrConversionImageFormatProperties* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkSamplerYcbcrConversionImageFormatProperties* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
-void count_VkDescriptorUpdateTemplateEntry(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorUpdateTemplateEntry* toCount,
- size_t* count)
-{
+void count_VkDescriptorUpdateTemplateEntry(uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorUpdateTemplateEntry* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -3843,29 +3174,26 @@
*count += 8;
}
-void count_VkDescriptorUpdateTemplateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorUpdateTemplateCreateInfo* toCount,
- size_t* count)
-{
+void count_VkDescriptorUpdateTemplateCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorUpdateTemplateCreateInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDescriptorUpdateTemplateCreateFlags);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->descriptorUpdateEntryCount; ++i)
- {
- count_VkDescriptorUpdateTemplateEntry(featureBits, rootType, (const VkDescriptorUpdateTemplateEntry*)(toCount->pDescriptorUpdateEntries + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->descriptorUpdateEntryCount; ++i) {
+ count_VkDescriptorUpdateTemplateEntry(
+ featureBits, rootType,
+ (const VkDescriptorUpdateTemplateEntry*)(toCount->pDescriptorUpdateEntries + i),
+ count);
}
}
*count += sizeof(VkDescriptorUpdateTemplateType);
@@ -3877,12 +3205,8 @@
*count += sizeof(uint32_t);
}
-void count_VkExternalMemoryProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExternalMemoryProperties* toCount,
- size_t* count)
-{
+void count_VkExternalMemoryProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkExternalMemoryProperties* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -3893,56 +3217,46 @@
}
void count_VkPhysicalDeviceExternalImageFormatInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalImageFormatInfo* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceExternalImageFormatInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkExternalMemoryHandleTypeFlagBits);
}
-void count_VkExternalImageFormatProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExternalImageFormatProperties* toCount,
- size_t* count)
-{
+void count_VkExternalImageFormatProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkExternalImageFormatProperties* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkExternalMemoryProperties(featureBits, rootType, (VkExternalMemoryProperties*)(&toCount->externalMemoryProperties), count);
+ count_VkExternalMemoryProperties(
+ featureBits, rootType, (VkExternalMemoryProperties*)(&toCount->externalMemoryProperties),
+ count);
}
-void count_VkPhysicalDeviceExternalBufferInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalBufferInfo* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceExternalBufferInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceExternalBufferInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -3951,38 +3265,31 @@
*count += sizeof(VkExternalMemoryHandleTypeFlagBits);
}
-void count_VkExternalBufferProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExternalBufferProperties* toCount,
- size_t* count)
-{
+void count_VkExternalBufferProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkExternalBufferProperties* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkExternalMemoryProperties(featureBits, rootType, (VkExternalMemoryProperties*)(&toCount->externalMemoryProperties), count);
+ count_VkExternalMemoryProperties(
+ featureBits, rootType, (VkExternalMemoryProperties*)(&toCount->externalMemoryProperties),
+ count);
}
-void count_VkPhysicalDeviceIDProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceIDProperties* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceIDProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceIDProperties* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -3993,95 +3300,73 @@
*count += sizeof(VkBool32);
}
-void count_VkExternalMemoryImageCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExternalMemoryImageCreateInfo* toCount,
- size_t* count)
-{
+void count_VkExternalMemoryImageCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkExternalMemoryImageCreateInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkExternalMemoryHandleTypeFlags);
}
-void count_VkExternalMemoryBufferCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExternalMemoryBufferCreateInfo* toCount,
- size_t* count)
-{
+void count_VkExternalMemoryBufferCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkExternalMemoryBufferCreateInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkExternalMemoryHandleTypeFlags);
}
-void count_VkExportMemoryAllocateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExportMemoryAllocateInfo* toCount,
- size_t* count)
-{
+void count_VkExportMemoryAllocateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkExportMemoryAllocateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkExternalMemoryHandleTypeFlags);
}
-void count_VkPhysicalDeviceExternalFenceInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalFenceInfo* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceExternalFenceInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceExternalFenceInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkExternalFenceHandleTypeFlagBits);
}
-void count_VkExternalFenceProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExternalFenceProperties* toCount,
- size_t* count)
-{
+void count_VkExternalFenceProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkExternalFenceProperties* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4090,38 +3375,28 @@
*count += sizeof(VkExternalFenceFeatureFlags);
}
-void count_VkExportFenceCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExportFenceCreateInfo* toCount,
- size_t* count)
-{
+void count_VkExportFenceCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkExportFenceCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkExternalFenceHandleTypeFlags);
}
-void count_VkExportSemaphoreCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExportSemaphoreCreateInfo* toCount,
- size_t* count)
-{
+void count_VkExportSemaphoreCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkExportSemaphoreCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4129,37 +3404,29 @@
}
void count_VkPhysicalDeviceExternalSemaphoreInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalSemaphoreInfo* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceExternalSemaphoreInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkExternalSemaphoreHandleTypeFlagBits);
}
-void count_VkExternalSemaphoreProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExternalSemaphoreProperties* toCount,
- size_t* count)
-{
+void count_VkExternalSemaphoreProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkExternalSemaphoreProperties* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4169,18 +3436,14 @@
}
void count_VkPhysicalDeviceMaintenance3Properties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMaintenance3Properties* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance3Properties* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4188,19 +3451,15 @@
*count += sizeof(VkDeviceSize);
}
-void count_VkDescriptorSetLayoutSupport(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorSetLayoutSupport* toCount,
- size_t* count)
-{
+void count_VkDescriptorSetLayoutSupport(uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorSetLayoutSupport* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4208,18 +3467,14 @@
}
void count_VkPhysicalDeviceShaderDrawParametersFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderDrawParametersFeatures* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderDrawParametersFeatures* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4228,19 +3483,15 @@
#endif
#ifdef VK_VERSION_1_2
-void count_VkPhysicalDeviceVulkan11Features(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan11Features* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceVulkan11Features(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan11Features* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4258,19 +3509,15 @@
*count += sizeof(VkBool32);
}
-void count_VkPhysicalDeviceVulkan11Properties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan11Properties* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceVulkan11Properties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan11Properties* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4291,19 +3538,15 @@
*count += sizeof(VkDeviceSize);
}
-void count_VkPhysicalDeviceVulkan12Features(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan12Features* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceVulkan12Features(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan12Features* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4356,12 +3599,8 @@
*count += sizeof(VkBool32);
}
-void count_VkConformanceVersion(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkConformanceVersion* toCount,
- size_t* count)
-{
+void count_VkConformanceVersion(uint32_t featureBits, VkStructureType rootType,
+ const VkConformanceVersion* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -4372,26 +3611,23 @@
*count += sizeof(uint8_t);
}
-void count_VkPhysicalDeviceVulkan12Properties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan12Properties* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceVulkan12Properties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan12Properties* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDriverId);
*count += VK_MAX_DRIVER_NAME_SIZE * sizeof(char);
*count += VK_MAX_DRIVER_INFO_SIZE * sizeof(char);
- count_VkConformanceVersion(featureBits, rootType, (VkConformanceVersion*)(&toCount->conformanceVersion), count);
+ count_VkConformanceVersion(featureBits, rootType,
+ (VkConformanceVersion*)(&toCount->conformanceVersion), count);
*count += sizeof(VkShaderFloatControlsIndependence);
*count += sizeof(VkShaderFloatControlsIndependence);
*count += sizeof(VkBool32);
@@ -4442,42 +3678,31 @@
*count += sizeof(VkSampleCountFlags);
}
-void count_VkImageFormatListCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageFormatListCreateInfo* toCount,
- size_t* count)
-{
+void count_VkImageFormatListCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkImageFormatListCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->viewFormatCount * sizeof(const VkFormat);
}
}
-void count_VkAttachmentDescription2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAttachmentDescription2* toCount,
- size_t* count)
-{
+void count_VkAttachmentDescription2(uint32_t featureBits, VkStructureType rootType,
+ const VkAttachmentDescription2* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4492,19 +3717,14 @@
*count += sizeof(VkImageLayout);
}
-void count_VkAttachmentReference2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAttachmentReference2* toCount,
- size_t* count)
-{
+void count_VkAttachmentReference2(uint32_t featureBits, VkStructureType rootType,
+ const VkAttachmentReference2* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4513,19 +3733,14 @@
*count += sizeof(VkImageAspectFlags);
}
-void count_VkSubpassDescription2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubpassDescription2* toCount,
- size_t* count)
-{
+void count_VkSubpassDescription2(uint32_t featureBits, VkStructureType rootType,
+ const VkSubpassDescription2* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4533,59 +3748,53 @@
*count += sizeof(VkPipelineBindPoint);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->inputAttachmentCount; ++i)
- {
- count_VkAttachmentReference2(featureBits, rootType, (const VkAttachmentReference2*)(toCount->pInputAttachments + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->inputAttachmentCount; ++i) {
+ count_VkAttachmentReference2(
+ featureBits, rootType,
+ (const VkAttachmentReference2*)(toCount->pInputAttachments + i), count);
}
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->colorAttachmentCount; ++i)
- {
- count_VkAttachmentReference2(featureBits, rootType, (const VkAttachmentReference2*)(toCount->pColorAttachments + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->colorAttachmentCount; ++i) {
+ count_VkAttachmentReference2(
+ featureBits, rootType,
+ (const VkAttachmentReference2*)(toCount->pColorAttachments + i), count);
}
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->pResolveAttachments)
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->colorAttachmentCount; ++i)
- {
- count_VkAttachmentReference2(featureBits, rootType, (const VkAttachmentReference2*)(toCount->pResolveAttachments + i), count);
+ if (toCount->pResolveAttachments) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->colorAttachmentCount; ++i) {
+ count_VkAttachmentReference2(
+ featureBits, rootType,
+ (const VkAttachmentReference2*)(toCount->pResolveAttachments + i), count);
}
}
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->pDepthStencilAttachment)
- {
- count_VkAttachmentReference2(featureBits, rootType, (const VkAttachmentReference2*)(toCount->pDepthStencilAttachment), count);
+ if (toCount->pDepthStencilAttachment) {
+ count_VkAttachmentReference2(
+ featureBits, rootType,
+ (const VkAttachmentReference2*)(toCount->pDepthStencilAttachment), count);
}
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->preserveAttachmentCount * sizeof(const uint32_t);
}
}
-void count_VkSubpassDependency2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubpassDependency2* toCount,
- size_t* count)
-{
+void count_VkSubpassDependency2(uint32_t featureBits, VkStructureType rootType,
+ const VkSubpassDependency2* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4599,104 +3808,84 @@
*count += sizeof(int32_t);
}
-void count_VkRenderPassCreateInfo2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderPassCreateInfo2* toCount,
- size_t* count)
-{
+void count_VkRenderPassCreateInfo2(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderPassCreateInfo2* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkRenderPassCreateFlags);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->attachmentCount; ++i)
- {
- count_VkAttachmentDescription2(featureBits, rootType, (const VkAttachmentDescription2*)(toCount->pAttachments + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->attachmentCount; ++i) {
+ count_VkAttachmentDescription2(
+ featureBits, rootType, (const VkAttachmentDescription2*)(toCount->pAttachments + i),
+ count);
}
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->subpassCount; ++i)
- {
- count_VkSubpassDescription2(featureBits, rootType, (const VkSubpassDescription2*)(toCount->pSubpasses + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->subpassCount; ++i) {
+ count_VkSubpassDescription2(featureBits, rootType,
+ (const VkSubpassDescription2*)(toCount->pSubpasses + i),
+ count);
}
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->dependencyCount; ++i)
- {
- count_VkSubpassDependency2(featureBits, rootType, (const VkSubpassDependency2*)(toCount->pDependencies + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->dependencyCount; ++i) {
+ count_VkSubpassDependency2(featureBits, rootType,
+ (const VkSubpassDependency2*)(toCount->pDependencies + i),
+ count);
}
}
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->correlatedViewMaskCount * sizeof(const uint32_t);
}
}
-void count_VkSubpassBeginInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubpassBeginInfo* toCount,
- size_t* count)
-{
+void count_VkSubpassBeginInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSubpassBeginInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkSubpassContents);
}
-void count_VkSubpassEndInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubpassEndInfo* toCount,
- size_t* count)
-{
+void count_VkSubpassEndInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSubpassEndInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
}
-void count_VkPhysicalDevice8BitStorageFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevice8BitStorageFeatures* toCount,
- size_t* count)
-{
+void count_VkPhysicalDevice8BitStorageFeatures(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevice8BitStorageFeatures* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4705,41 +3894,34 @@
*count += sizeof(VkBool32);
}
-void count_VkPhysicalDeviceDriverProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDriverProperties* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceDriverProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDriverProperties* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDriverId);
*count += VK_MAX_DRIVER_NAME_SIZE * sizeof(char);
*count += VK_MAX_DRIVER_INFO_SIZE * sizeof(char);
- count_VkConformanceVersion(featureBits, rootType, (VkConformanceVersion*)(&toCount->conformanceVersion), count);
+ count_VkConformanceVersion(featureBits, rootType,
+ (VkConformanceVersion*)(&toCount->conformanceVersion), count);
}
void count_VkPhysicalDeviceShaderAtomicInt64Features(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderAtomicInt64Features* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderAtomicInt64Features* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4748,18 +3930,14 @@
}
void count_VkPhysicalDeviceShaderFloat16Int8Features(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderFloat16Int8Features* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderFloat16Int8Features* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4768,18 +3946,14 @@
}
void count_VkPhysicalDeviceFloatControlsProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFloatControlsProperties* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFloatControlsProperties* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4803,46 +3977,36 @@
}
void count_VkDescriptorSetLayoutBindingFlagsCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorSetLayoutBindingFlagsCreateInfo* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorSetLayoutBindingFlagsCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pBindingFlags)
- {
- if (toCount)
- {
+ if (toCount->pBindingFlags) {
+ if (toCount) {
*count += toCount->bindingCount * sizeof(const VkDescriptorBindingFlags);
}
}
}
void count_VkPhysicalDeviceDescriptorIndexingFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDescriptorIndexingFeatures* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDescriptorIndexingFeatures* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4869,18 +4033,14 @@
}
void count_VkPhysicalDeviceDescriptorIndexingProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDescriptorIndexingProperties* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDescriptorIndexingProperties* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4910,41 +4070,32 @@
}
void count_VkDescriptorSetVariableDescriptorCountAllocateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorSetVariableDescriptorCountAllocateInfo* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorSetVariableDescriptorCountAllocateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->descriptorSetCount * sizeof(const uint32_t);
}
}
void count_VkDescriptorSetVariableDescriptorCountLayoutSupport(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorSetVariableDescriptorCountLayoutSupport* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorSetVariableDescriptorCountLayoutSupport* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4952,18 +4103,14 @@
}
void count_VkSubpassDescriptionDepthStencilResolve(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubpassDescriptionDepthStencilResolve* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkSubpassDescriptionDepthStencilResolve* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -4971,25 +4118,22 @@
*count += sizeof(VkResolveModeFlagBits);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pDepthStencilResolveAttachment)
- {
- count_VkAttachmentReference2(featureBits, rootType, (const VkAttachmentReference2*)(toCount->pDepthStencilResolveAttachment), count);
+ if (toCount->pDepthStencilResolveAttachment) {
+ count_VkAttachmentReference2(
+ featureBits, rootType,
+ (const VkAttachmentReference2*)(toCount->pDepthStencilResolveAttachment), count);
}
}
void count_VkPhysicalDeviceDepthStencilResolveProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDepthStencilResolveProperties* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDepthStencilResolveProperties* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5000,56 +4144,44 @@
}
void count_VkPhysicalDeviceScalarBlockLayoutFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceScalarBlockLayoutFeatures* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceScalarBlockLayoutFeatures* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
-void count_VkImageStencilUsageCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageStencilUsageCreateInfo* toCount,
- size_t* count)
-{
+void count_VkImageStencilUsageCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkImageStencilUsageCreateInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkImageUsageFlags);
}
-void count_VkSamplerReductionModeCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSamplerReductionModeCreateInfo* toCount,
- size_t* count)
-{
+void count_VkSamplerReductionModeCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSamplerReductionModeCreateInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5057,18 +4189,14 @@
}
void count_VkPhysicalDeviceSamplerFilterMinmaxProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSamplerFilterMinmaxProperties* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSamplerFilterMinmaxProperties* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5077,18 +4205,14 @@
}
void count_VkPhysicalDeviceVulkanMemoryModelFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkanMemoryModelFeatures* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVulkanMemoryModelFeatures* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5098,37 +4222,29 @@
}
void count_VkPhysicalDeviceImagelessFramebufferFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceImagelessFramebufferFeatures* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceImagelessFramebufferFeatures* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
-void count_VkFramebufferAttachmentImageInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFramebufferAttachmentImageInfo* toCount,
- size_t* count)
-{
+void count_VkFramebufferAttachmentImageInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkFramebufferAttachmentImageInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5138,74 +4254,61 @@
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->viewFormatCount * sizeof(const VkFormat);
}
}
-void count_VkFramebufferAttachmentsCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFramebufferAttachmentsCreateInfo* toCount,
- size_t* count)
-{
+void count_VkFramebufferAttachmentsCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkFramebufferAttachmentsCreateInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->attachmentImageInfoCount; ++i)
- {
- count_VkFramebufferAttachmentImageInfo(featureBits, rootType, (const VkFramebufferAttachmentImageInfo*)(toCount->pAttachmentImageInfos + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->attachmentImageInfoCount; ++i) {
+ count_VkFramebufferAttachmentImageInfo(
+ featureBits, rootType,
+ (const VkFramebufferAttachmentImageInfo*)(toCount->pAttachmentImageInfos + i),
+ count);
}
}
}
-void count_VkRenderPassAttachmentBeginInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderPassAttachmentBeginInfo* toCount,
- size_t* count)
-{
+void count_VkRenderPassAttachmentBeginInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderPassAttachmentBeginInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount->attachmentCount)
- {
+ if (toCount->attachmentCount) {
*count += toCount->attachmentCount * 8;
}
}
void count_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5213,18 +4316,14 @@
}
void count_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5232,56 +4331,44 @@
}
void count_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
-void count_VkAttachmentReferenceStencilLayout(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAttachmentReferenceStencilLayout* toCount,
- size_t* count)
-{
+void count_VkAttachmentReferenceStencilLayout(uint32_t featureBits, VkStructureType rootType,
+ const VkAttachmentReferenceStencilLayout* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkImageLayout);
}
-void count_VkAttachmentDescriptionStencilLayout(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAttachmentDescriptionStencilLayout* toCount,
- size_t* count)
-{
+void count_VkAttachmentDescriptionStencilLayout(uint32_t featureBits, VkStructureType rootType,
+ const VkAttachmentDescriptionStencilLayout* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5290,18 +4377,14 @@
}
void count_VkPhysicalDeviceHostQueryResetFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceHostQueryResetFeatures* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceHostQueryResetFeatures* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5309,18 +4392,14 @@
}
void count_VkPhysicalDeviceTimelineSemaphoreFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceTimelineSemaphoreFeatures* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceTimelineSemaphoreFeatures* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5328,37 +4407,28 @@
}
void count_VkPhysicalDeviceTimelineSemaphoreProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceTimelineSemaphoreProperties* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceTimelineSemaphoreProperties* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint64_t);
}
-void count_VkSemaphoreTypeCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSemaphoreTypeCreateInfo* toCount,
- size_t* count)
-{
+void count_VkSemaphoreTypeCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSemaphoreTypeCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5366,85 +4436,65 @@
*count += sizeof(uint64_t);
}
-void count_VkTimelineSemaphoreSubmitInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkTimelineSemaphoreSubmitInfo* toCount,
- size_t* count)
-{
+void count_VkTimelineSemaphoreSubmitInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkTimelineSemaphoreSubmitInfo* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pWaitSemaphoreValues)
- {
- if (toCount)
- {
+ if (toCount->pWaitSemaphoreValues) {
+ if (toCount) {
*count += toCount->waitSemaphoreValueCount * sizeof(const uint64_t);
}
}
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pSignalSemaphoreValues)
- {
- if (toCount)
- {
+ if (toCount->pSignalSemaphoreValues) {
+ if (toCount) {
*count += toCount->signalSemaphoreValueCount * sizeof(const uint64_t);
}
}
}
-void count_VkSemaphoreWaitInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSemaphoreWaitInfo* toCount,
- size_t* count)
-{
+void count_VkSemaphoreWaitInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSemaphoreWaitInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkSemaphoreWaitFlags);
*count += sizeof(uint32_t);
- if (toCount->semaphoreCount)
- {
+ if (toCount->semaphoreCount) {
*count += toCount->semaphoreCount * 8;
}
- if (toCount)
- {
+ if (toCount) {
*count += toCount->semaphoreCount * sizeof(const uint64_t);
}
}
-void count_VkSemaphoreSignalInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSemaphoreSignalInfo* toCount,
- size_t* count)
-{
+void count_VkSemaphoreSignalInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSemaphoreSignalInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5454,18 +4504,14 @@
}
void count_VkPhysicalDeviceBufferDeviceAddressFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceBufferDeviceAddressFeatures* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceBufferDeviceAddressFeatures* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5474,19 +4520,14 @@
*count += sizeof(VkBool32);
}
-void count_VkBufferDeviceAddressInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferDeviceAddressInfo* toCount,
- size_t* count)
-{
+void count_VkBufferDeviceAddressInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferDeviceAddressInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5495,18 +4536,14 @@
}
void count_VkBufferOpaqueCaptureAddressCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferOpaqueCaptureAddressCreateInfo* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkBufferOpaqueCaptureAddressCreateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5514,18 +4551,14 @@
}
void count_VkMemoryOpaqueCaptureAddressAllocateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryOpaqueCaptureAddressAllocateInfo* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryOpaqueCaptureAddressAllocateInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5533,18 +4566,14 @@
}
void count_VkDeviceMemoryOpaqueCaptureAddressInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceMemoryOpaqueCaptureAddressInfo* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceMemoryOpaqueCaptureAddressInfo* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5554,12 +4583,8 @@
#endif
#ifdef VK_KHR_surface
-void count_VkSurfaceCapabilitiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSurfaceCapabilitiesKHR* toCount,
- size_t* count)
-{
+void count_VkSurfaceCapabilitiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkSurfaceCapabilitiesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -5576,12 +4601,8 @@
*count += sizeof(VkImageUsageFlags);
}
-void count_VkSurfaceFormatKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSurfaceFormatKHR* toCount,
- size_t* count)
-{
+void count_VkSurfaceFormatKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkSurfaceFormatKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -5592,19 +4613,14 @@
#endif
#ifdef VK_KHR_swapchain
-void count_VkSwapchainCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSwapchainCreateInfoKHR* toCount,
- size_t* count)
-{
+void count_VkSwapchainCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkSwapchainCreateInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5621,10 +4637,8 @@
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pQueueFamilyIndices)
- {
- if (toCount)
- {
+ if (toCount->pQueueFamilyIndices) {
+ if (toCount) {
*count += toCount->queueFamilyIndexCount * sizeof(const uint32_t);
}
}
@@ -5636,60 +4650,46 @@
*count += 1 * 8;
}
-void count_VkPresentInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPresentInfoKHR* toCount,
- size_t* count)
-{
+void count_VkPresentInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPresentInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount->waitSemaphoreCount)
- {
+ if (toCount->waitSemaphoreCount) {
*count += toCount->waitSemaphoreCount * 8;
}
*count += sizeof(uint32_t);
- if (toCount->swapchainCount)
- {
+ if (toCount->swapchainCount) {
*count += toCount->swapchainCount * 8;
}
- if (toCount)
- {
+ if (toCount) {
*count += toCount->swapchainCount * sizeof(const uint32_t);
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->pResults)
- {
- if (toCount)
- {
+ if (toCount->pResults) {
+ if (toCount) {
*count += toCount->swapchainCount * sizeof(VkResult);
}
}
}
-void count_VkImageSwapchainCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageSwapchainCreateInfoKHR* toCount,
- size_t* count)
-{
+void count_VkImageSwapchainCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImageSwapchainCreateInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5697,19 +4697,15 @@
*count += 1 * 8;
}
-void count_VkBindImageMemorySwapchainInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindImageMemorySwapchainInfoKHR* toCount,
- size_t* count)
-{
+void count_VkBindImageMemorySwapchainInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkBindImageMemorySwapchainInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5718,19 +4714,14 @@
*count += sizeof(uint32_t);
}
-void count_VkAcquireNextImageInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAcquireNextImageInfoKHR* toCount,
- size_t* count)
-{
+void count_VkAcquireNextImageInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkAcquireNextImageInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5744,19 +4735,15 @@
*count += sizeof(uint32_t);
}
-void count_VkDeviceGroupPresentCapabilitiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceGroupPresentCapabilitiesKHR* toCount,
- size_t* count)
-{
+void count_VkDeviceGroupPresentCapabilitiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceGroupPresentCapabilitiesKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5764,43 +4751,33 @@
*count += sizeof(VkDeviceGroupPresentModeFlagsKHR);
}
-void count_VkDeviceGroupPresentInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceGroupPresentInfoKHR* toCount,
- size_t* count)
-{
+void count_VkDeviceGroupPresentInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceGroupPresentInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->swapchainCount * sizeof(const uint32_t);
}
*count += sizeof(VkDeviceGroupPresentModeFlagBitsKHR);
}
-void count_VkDeviceGroupSwapchainCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceGroupSwapchainCreateInfoKHR* toCount,
- size_t* count)
-{
+void count_VkDeviceGroupSwapchainCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceGroupSwapchainCreateInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5809,12 +4786,8 @@
#endif
#ifdef VK_KHR_display
-void count_VkDisplayModeParametersKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayModeParametersKHR* toCount,
- size_t* count)
-{
+void count_VkDisplayModeParametersKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayModeParametersKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -5823,47 +4796,37 @@
*count += sizeof(uint32_t);
}
-void count_VkDisplayModeCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayModeCreateInfoKHR* toCount,
- size_t* count)
-{
+void count_VkDisplayModeCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayModeCreateInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDisplayModeCreateFlagsKHR);
- count_VkDisplayModeParametersKHR(featureBits, rootType, (VkDisplayModeParametersKHR*)(&toCount->parameters), count);
+ count_VkDisplayModeParametersKHR(featureBits, rootType,
+ (VkDisplayModeParametersKHR*)(&toCount->parameters), count);
}
-void count_VkDisplayModePropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayModePropertiesKHR* toCount,
- size_t* count)
-{
+void count_VkDisplayModePropertiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayModePropertiesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
uint64_t cgen_var_0;
*count += 1 * 8;
- count_VkDisplayModeParametersKHR(featureBits, rootType, (VkDisplayModeParametersKHR*)(&toCount->parameters), count);
+ count_VkDisplayModeParametersKHR(featureBits, rootType,
+ (VkDisplayModeParametersKHR*)(&toCount->parameters), count);
}
-void count_VkDisplayPlaneCapabilitiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayPlaneCapabilitiesKHR* toCount,
- size_t* count)
-{
+void count_VkDisplayPlaneCapabilitiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayPlaneCapabilitiesKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -5879,12 +4842,8 @@
count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->maxDstExtent), count);
}
-void count_VkDisplayPlanePropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayPlanePropertiesKHR* toCount,
- size_t* count)
-{
+void count_VkDisplayPlanePropertiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayPlanePropertiesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -5894,12 +4853,8 @@
*count += sizeof(uint32_t);
}
-void count_VkDisplayPropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayPropertiesKHR* toCount,
- size_t* count)
-{
+void count_VkDisplayPropertiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayPropertiesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -5914,19 +4869,15 @@
*count += sizeof(VkBool32);
}
-void count_VkDisplaySurfaceCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplaySurfaceCreateInfoKHR* toCount,
- size_t* count)
-{
+void count_VkDisplaySurfaceCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplaySurfaceCreateInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5943,19 +4894,14 @@
#endif
#ifdef VK_KHR_display_swapchain
-void count_VkDisplayPresentInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayPresentInfoKHR* toCount,
- size_t* count)
-{
+void count_VkDisplayPresentInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayPresentInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -5966,27 +4912,21 @@
#endif
#ifdef VK_KHR_xlib_surface
-void count_VkXlibSurfaceCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkXlibSurfaceCreateInfoKHR* toCount,
- size_t* count)
-{
+void count_VkXlibSurfaceCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkXlibSurfaceCreateInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkXlibSurfaceCreateFlagsKHR);
// WARNING PTR CHECK
*count += 8;
- if (toCount->dpy)
- {
+ if (toCount->dpy) {
*count += sizeof(Display);
}
*count += sizeof(Window);
@@ -5994,27 +4934,21 @@
#endif
#ifdef VK_KHR_xcb_surface
-void count_VkXcbSurfaceCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkXcbSurfaceCreateInfoKHR* toCount,
- size_t* count)
-{
+void count_VkXcbSurfaceCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkXcbSurfaceCreateInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkXcbSurfaceCreateFlagsKHR);
// WARNING PTR CHECK
*count += 8;
- if (toCount->connection)
- {
+ if (toCount->connection) {
*count += sizeof(xcb_connection_t);
}
*count += sizeof(xcb_window_t);
@@ -6022,79 +4956,63 @@
#endif
#ifdef VK_KHR_wayland_surface
-void count_VkWaylandSurfaceCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkWaylandSurfaceCreateInfoKHR* toCount,
- size_t* count)
-{
+void count_VkWaylandSurfaceCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkWaylandSurfaceCreateInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkWaylandSurfaceCreateFlagsKHR);
// WARNING PTR CHECK
*count += 8;
- if (toCount->display)
- {
+ if (toCount->display) {
*count += sizeof(wl_display);
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->surface)
- {
+ if (toCount->surface) {
*count += sizeof(wl_surface);
}
}
#endif
#ifdef VK_KHR_android_surface
-void count_VkAndroidSurfaceCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAndroidSurfaceCreateInfoKHR* toCount,
- size_t* count)
-{
+void count_VkAndroidSurfaceCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkAndroidSurfaceCreateInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkAndroidSurfaceCreateFlagsKHR);
// WARNING PTR CHECK
*count += 8;
- if (toCount->window)
- {
+ if (toCount->window) {
*count += sizeof(ANativeWindow);
}
}
#endif
#ifdef VK_KHR_win32_surface
-void count_VkWin32SurfaceCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkWin32SurfaceCreateInfoKHR* toCount,
- size_t* count)
-{
+void count_VkWin32SurfaceCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkWin32SurfaceCreateInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -6107,38 +5025,29 @@
#ifdef VK_KHR_sampler_mirror_clamp_to_edge
#endif
#ifdef VK_KHR_video_queue
-void count_VkVideoQueueFamilyProperties2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoQueueFamilyProperties2KHR* toCount,
- size_t* count)
-{
+void count_VkVideoQueueFamilyProperties2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoQueueFamilyProperties2KHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkVideoCodecOperationFlagsKHR);
}
-void count_VkVideoProfileKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoProfileKHR* toCount,
- size_t* count)
-{
+void count_VkVideoProfileKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoProfileKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -6148,104 +5057,83 @@
*count += sizeof(VkVideoComponentBitDepthFlagsKHR);
}
-void count_VkVideoProfilesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoProfilesKHR* toCount,
- size_t* count)
-{
+void count_VkVideoProfilesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoProfilesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- count_VkVideoProfileKHR(featureBits, rootType, (const VkVideoProfileKHR*)(toCount->pProfiles), count);
+ count_VkVideoProfileKHR(featureBits, rootType, (const VkVideoProfileKHR*)(toCount->pProfiles),
+ count);
}
-void count_VkVideoCapabilitiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoCapabilitiesKHR* toCount,
- size_t* count)
-{
+void count_VkVideoCapabilitiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoCapabilitiesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkVideoCapabilityFlagsKHR);
*count += sizeof(VkDeviceSize);
*count += sizeof(VkDeviceSize);
- count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->videoPictureExtentGranularity), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->videoPictureExtentGranularity),
+ count);
count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->minExtent), count);
count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->maxExtent), count);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
}
-void count_VkPhysicalDeviceVideoFormatInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceVideoFormatInfoKHR* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceVideoFormatInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVideoFormatInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkImageUsageFlags);
- count_VkVideoProfilesKHR(featureBits, rootType, (const VkVideoProfilesKHR*)(toCount->pVideoProfiles), count);
+ count_VkVideoProfilesKHR(featureBits, rootType,
+ (const VkVideoProfilesKHR*)(toCount->pVideoProfiles), count);
}
-void count_VkVideoFormatPropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoFormatPropertiesKHR* toCount,
- size_t* count)
-{
+void count_VkVideoFormatPropertiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoFormatPropertiesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkFormat);
}
-void count_VkVideoPictureResourceKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoPictureResourceKHR* toCount,
- size_t* count)
-{
+void count_VkVideoPictureResourceKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoPictureResourceKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -6256,59 +5144,48 @@
*count += 1 * 8;
}
-void count_VkVideoReferenceSlotKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoReferenceSlotKHR* toCount,
- size_t* count)
-{
+void count_VkVideoReferenceSlotKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoReferenceSlotKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(int8_t);
- count_VkVideoPictureResourceKHR(featureBits, rootType, (const VkVideoPictureResourceKHR*)(toCount->pPictureResource), count);
+ count_VkVideoPictureResourceKHR(featureBits, rootType,
+ (const VkVideoPictureResourceKHR*)(toCount->pPictureResource),
+ count);
}
-void count_VkVideoGetMemoryPropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoGetMemoryPropertiesKHR* toCount,
- size_t* count)
-{
+void count_VkVideoGetMemoryPropertiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoGetMemoryPropertiesKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- count_VkMemoryRequirements2(featureBits, rootType, (VkMemoryRequirements2*)(toCount->pMemoryRequirements), count);
+ count_VkMemoryRequirements2(featureBits, rootType,
+ (VkMemoryRequirements2*)(toCount->pMemoryRequirements), count);
}
-void count_VkVideoBindMemoryKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoBindMemoryKHR* toCount,
- size_t* count)
-{
+void count_VkVideoBindMemoryKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoBindMemoryKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -6319,25 +5196,21 @@
*count += sizeof(VkDeviceSize);
}
-void count_VkVideoSessionCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoSessionCreateInfoKHR* toCount,
- size_t* count)
-{
+void count_VkVideoSessionCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoSessionCreateInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
*count += sizeof(VkVideoSessionCreateFlagsKHR);
- count_VkVideoProfileKHR(featureBits, rootType, (const VkVideoProfileKHR*)(toCount->pVideoProfile), count);
+ count_VkVideoProfileKHR(featureBits, rootType,
+ (const VkVideoProfileKHR*)(toCount->pVideoProfile), count);
*count += sizeof(VkFormat);
count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->maxCodedExtent), count);
*count += sizeof(VkFormat);
@@ -6346,18 +5219,14 @@
}
void count_VkVideoSessionParametersCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoSessionParametersCreateInfoKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoSessionParametersCreateInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -6366,37 +5235,28 @@
}
void count_VkVideoSessionParametersUpdateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoSessionParametersUpdateInfoKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoSessionParametersUpdateInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
-void count_VkVideoBeginCodingInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoBeginCodingInfoKHR* toCount,
- size_t* count)
-{
+void count_VkVideoBeginCodingInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoBeginCodingInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -6405,47 +5265,37 @@
*count += 8;
*count += 8;
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->referenceSlotCount; ++i)
- {
- count_VkVideoReferenceSlotKHR(featureBits, rootType, (const VkVideoReferenceSlotKHR*)(toCount->pReferenceSlots + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->referenceSlotCount; ++i) {
+ count_VkVideoReferenceSlotKHR(
+ featureBits, rootType,
+ (const VkVideoReferenceSlotKHR*)(toCount->pReferenceSlots + i), count);
}
}
}
-void count_VkVideoEndCodingInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEndCodingInfoKHR* toCount,
- size_t* count)
-{
+void count_VkVideoEndCodingInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEndCodingInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkVideoEndCodingFlagsKHR);
}
-void count_VkVideoCodingControlInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoCodingControlInfoKHR* toCount,
- size_t* count)
-{
+void count_VkVideoCodingControlInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoCodingControlInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -6454,19 +5304,14 @@
#endif
#ifdef VK_KHR_video_decode_queue
-void count_VkVideoDecodeInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeInfoKHR* toCount,
- size_t* count)
-{
+void count_VkVideoDecodeInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -6477,33 +5322,32 @@
*count += 1 * 8;
*count += sizeof(VkDeviceSize);
*count += sizeof(VkDeviceSize);
- count_VkVideoPictureResourceKHR(featureBits, rootType, (VkVideoPictureResourceKHR*)(&toCount->dstPictureResource), count);
- count_VkVideoReferenceSlotKHR(featureBits, rootType, (const VkVideoReferenceSlotKHR*)(toCount->pSetupReferenceSlot), count);
+ count_VkVideoPictureResourceKHR(
+ featureBits, rootType, (VkVideoPictureResourceKHR*)(&toCount->dstPictureResource), count);
+ count_VkVideoReferenceSlotKHR(featureBits, rootType,
+ (const VkVideoReferenceSlotKHR*)(toCount->pSetupReferenceSlot),
+ count);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->referenceSlotCount; ++i)
- {
- count_VkVideoReferenceSlotKHR(featureBits, rootType, (const VkVideoReferenceSlotKHR*)(toCount->pReferenceSlots + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->referenceSlotCount; ++i) {
+ count_VkVideoReferenceSlotKHR(
+ featureBits, rootType,
+ (const VkVideoReferenceSlotKHR*)(toCount->pReferenceSlots + i), count);
}
}
}
#endif
#ifdef VK_KHR_dynamic_rendering
-void count_VkRenderingAttachmentInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderingAttachmentInfoKHR* toCount,
- size_t* count)
-{
+void count_VkRenderingAttachmentInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderingAttachmentInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -6519,19 +5363,14 @@
count_VkClearValue(featureBits, rootType, (VkClearValue*)(&toCount->clearValue), count);
}
-void count_VkRenderingInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderingInfoKHR* toCount,
- size_t* count)
-{
+void count_VkRenderingInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderingInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -6540,47 +5379,44 @@
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->colorAttachmentCount; ++i)
- {
- count_VkRenderingAttachmentInfoKHR(featureBits, rootType, (const VkRenderingAttachmentInfoKHR*)(toCount->pColorAttachments + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->colorAttachmentCount; ++i) {
+ count_VkRenderingAttachmentInfoKHR(
+ featureBits, rootType,
+ (const VkRenderingAttachmentInfoKHR*)(toCount->pColorAttachments + i), count);
}
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->pDepthAttachment)
- {
- count_VkRenderingAttachmentInfoKHR(featureBits, rootType, (const VkRenderingAttachmentInfoKHR*)(toCount->pDepthAttachment), count);
+ if (toCount->pDepthAttachment) {
+ count_VkRenderingAttachmentInfoKHR(
+ featureBits, rootType, (const VkRenderingAttachmentInfoKHR*)(toCount->pDepthAttachment),
+ count);
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->pStencilAttachment)
- {
- count_VkRenderingAttachmentInfoKHR(featureBits, rootType, (const VkRenderingAttachmentInfoKHR*)(toCount->pStencilAttachment), count);
+ if (toCount->pStencilAttachment) {
+ count_VkRenderingAttachmentInfoKHR(
+ featureBits, rootType,
+ (const VkRenderingAttachmentInfoKHR*)(toCount->pStencilAttachment), count);
}
}
-void count_VkPipelineRenderingCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineRenderingCreateInfoKHR* toCount,
- size_t* count)
-{
+void count_VkPipelineRenderingCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRenderingCreateInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->colorAttachmentCount * sizeof(const VkFormat);
}
*count += sizeof(VkFormat);
@@ -6588,18 +5424,14 @@
}
void count_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDynamicRenderingFeaturesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDynamicRenderingFeaturesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -6607,26 +5439,21 @@
}
void count_VkCommandBufferInheritanceRenderingInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCommandBufferInheritanceRenderingInfoKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkCommandBufferInheritanceRenderingInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkRenderingFlagsKHR);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->colorAttachmentCount * sizeof(const VkFormat);
}
*count += sizeof(VkFormat);
@@ -6635,40 +5462,33 @@
}
void count_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderingFragmentShadingRateAttachmentInfoKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkRenderingFragmentShadingRateAttachmentInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
uint64_t cgen_var_0;
*count += 1 * 8;
*count += sizeof(VkImageLayout);
- count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->shadingRateAttachmentTexelSize), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->shadingRateAttachmentTexelSize),
+ count);
}
void count_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderingFragmentDensityMapAttachmentInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkRenderingFragmentDensityMapAttachmentInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -6677,48 +5497,38 @@
*count += sizeof(VkImageLayout);
}
-void count_VkAttachmentSampleCountInfoAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAttachmentSampleCountInfoAMD* toCount,
- size_t* count)
-{
+void count_VkAttachmentSampleCountInfoAMD(uint32_t featureBits, VkStructureType rootType,
+ const VkAttachmentSampleCountInfoAMD* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pColorAttachmentSamples)
- {
- if (toCount)
- {
+ if (toCount->pColorAttachmentSamples) {
+ if (toCount) {
*count += toCount->colorAttachmentCount * sizeof(const VkSampleCountFlagBits);
}
}
*count += sizeof(VkSampleCountFlagBits);
}
-void count_VkMultiviewPerViewAttributesInfoNVX(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMultiviewPerViewAttributesInfoNVX* toCount,
- size_t* count)
-{
+void count_VkMultiviewPerViewAttributesInfoNVX(uint32_t featureBits, VkStructureType rootType,
+ const VkMultiviewPerViewAttributesInfoNVX* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -6744,19 +5554,15 @@
#ifdef VK_KHR_external_memory
#endif
#ifdef VK_KHR_external_memory_win32
-void count_VkImportMemoryWin32HandleInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportMemoryWin32HandleInfoKHR* toCount,
- size_t* count)
-{
+void count_VkImportMemoryWin32HandleInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImportMemoryWin32HandleInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -6765,64 +5571,51 @@
*count += sizeof(LPCWSTR);
}
-void count_VkExportMemoryWin32HandleInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExportMemoryWin32HandleInfoKHR* toCount,
- size_t* count)
-{
+void count_VkExportMemoryWin32HandleInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkExportMemoryWin32HandleInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pAttributes)
- {
+ if (toCount->pAttributes) {
*count += sizeof(const SECURITY_ATTRIBUTES);
}
*count += sizeof(DWORD);
*count += sizeof(LPCWSTR);
}
-void count_VkMemoryWin32HandlePropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryWin32HandlePropertiesKHR* toCount,
- size_t* count)
-{
+void count_VkMemoryWin32HandlePropertiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryWin32HandlePropertiesKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
-void count_VkMemoryGetWin32HandleInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryGetWin32HandleInfoKHR* toCount,
- size_t* count)
-{
+void count_VkMemoryGetWin32HandleInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryGetWin32HandleInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -6833,19 +5626,14 @@
#endif
#ifdef VK_KHR_external_memory_fd
-void count_VkImportMemoryFdInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportMemoryFdInfoKHR* toCount,
- size_t* count)
-{
+void count_VkImportMemoryFdInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImportMemoryFdInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -6853,38 +5641,28 @@
*count += sizeof(int);
}
-void count_VkMemoryFdPropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryFdPropertiesKHR* toCount,
- size_t* count)
-{
+void count_VkMemoryFdPropertiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryFdPropertiesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
-void count_VkMemoryGetFdInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryGetFdInfoKHR* toCount,
- size_t* count)
-{
+void count_VkMemoryGetFdInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryGetFdInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -6896,41 +5674,32 @@
#endif
#ifdef VK_KHR_win32_keyed_mutex
void count_VkWin32KeyedMutexAcquireReleaseInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkWin32KeyedMutexAcquireReleaseInfoKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkWin32KeyedMutexAcquireReleaseInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount->acquireCount)
- {
+ if (toCount->acquireCount) {
*count += toCount->acquireCount * 8;
}
- if (toCount)
- {
+ if (toCount) {
*count += toCount->acquireCount * sizeof(const uint64_t);
}
- if (toCount)
- {
+ if (toCount) {
*count += toCount->acquireCount * sizeof(const uint32_t);
}
*count += sizeof(uint32_t);
- if (toCount->releaseCount)
- {
+ if (toCount->releaseCount) {
*count += toCount->releaseCount * 8;
}
- if (toCount)
- {
+ if (toCount) {
*count += toCount->releaseCount * sizeof(const uint64_t);
}
}
@@ -6941,19 +5710,15 @@
#ifdef VK_KHR_external_semaphore
#endif
#ifdef VK_KHR_external_semaphore_win32
-void count_VkImportSemaphoreWin32HandleInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportSemaphoreWin32HandleInfoKHR* toCount,
- size_t* count)
-{
+void count_VkImportSemaphoreWin32HandleInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImportSemaphoreWin32HandleInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -6965,83 +5730,65 @@
*count += sizeof(LPCWSTR);
}
-void count_VkExportSemaphoreWin32HandleInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExportSemaphoreWin32HandleInfoKHR* toCount,
- size_t* count)
-{
+void count_VkExportSemaphoreWin32HandleInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkExportSemaphoreWin32HandleInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pAttributes)
- {
+ if (toCount->pAttributes) {
*count += sizeof(const SECURITY_ATTRIBUTES);
}
*count += sizeof(DWORD);
*count += sizeof(LPCWSTR);
}
-void count_VkD3D12FenceSubmitInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkD3D12FenceSubmitInfoKHR* toCount,
- size_t* count)
-{
+void count_VkD3D12FenceSubmitInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkD3D12FenceSubmitInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pWaitSemaphoreValues)
- {
- if (toCount)
- {
+ if (toCount->pWaitSemaphoreValues) {
+ if (toCount) {
*count += toCount->waitSemaphoreValuesCount * sizeof(const uint64_t);
}
}
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pSignalSemaphoreValues)
- {
- if (toCount)
- {
+ if (toCount->pSignalSemaphoreValues) {
+ if (toCount) {
*count += toCount->signalSemaphoreValuesCount * sizeof(const uint64_t);
}
}
}
-void count_VkSemaphoreGetWin32HandleInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSemaphoreGetWin32HandleInfoKHR* toCount,
- size_t* count)
-{
+void count_VkSemaphoreGetWin32HandleInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkSemaphoreGetWin32HandleInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7052,19 +5799,14 @@
#endif
#ifdef VK_KHR_external_semaphore_fd
-void count_VkImportSemaphoreFdInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportSemaphoreFdInfoKHR* toCount,
- size_t* count)
-{
+void count_VkImportSemaphoreFdInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImportSemaphoreFdInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7075,19 +5817,14 @@
*count += sizeof(int);
}
-void count_VkSemaphoreGetFdInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSemaphoreGetFdInfoKHR* toCount,
- size_t* count)
-{
+void count_VkSemaphoreGetFdInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkSemaphoreGetFdInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7099,18 +5836,14 @@
#endif
#ifdef VK_KHR_push_descriptor
void count_VkPhysicalDevicePushDescriptorPropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePushDescriptorPropertiesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePushDescriptorPropertiesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7123,12 +5856,8 @@
#ifdef VK_KHR_16bit_storage
#endif
#ifdef VK_KHR_incremental_present
-void count_VkRectLayerKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRectLayerKHR* toCount,
- size_t* count)
-{
+void count_VkRectLayerKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkRectLayerKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -7138,12 +5867,8 @@
*count += sizeof(uint32_t);
}
-void count_VkPresentRegionKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPresentRegionKHR* toCount,
- size_t* count)
-{
+void count_VkPresentRegionKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPresentRegionKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -7151,44 +5876,35 @@
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pRectangles)
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->rectangleCount; ++i)
- {
- count_VkRectLayerKHR(featureBits, rootType, (const VkRectLayerKHR*)(toCount->pRectangles + i), count);
+ if (toCount->pRectangles) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->rectangleCount; ++i) {
+ count_VkRectLayerKHR(featureBits, rootType,
+ (const VkRectLayerKHR*)(toCount->pRectangles + i), count);
}
}
}
}
-void count_VkPresentRegionsKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPresentRegionsKHR* toCount,
- size_t* count)
-{
+void count_VkPresentRegionsKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPresentRegionsKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pRegions)
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->swapchainCount; ++i)
- {
- count_VkPresentRegionKHR(featureBits, rootType, (const VkPresentRegionKHR*)(toCount->pRegions + i), count);
+ if (toCount->pRegions) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->swapchainCount; ++i) {
+ count_VkPresentRegionKHR(featureBits, rootType,
+ (const VkPresentRegionKHR*)(toCount->pRegions + i), count);
}
}
}
@@ -7203,18 +5919,14 @@
#endif
#ifdef VK_KHR_shared_presentable_image
void count_VkSharedPresentSurfaceCapabilitiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSharedPresentSurfaceCapabilitiesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkSharedPresentSurfaceCapabilitiesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7227,19 +5939,15 @@
#ifdef VK_KHR_external_fence
#endif
#ifdef VK_KHR_external_fence_win32
-void count_VkImportFenceWin32HandleInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportFenceWin32HandleInfoKHR* toCount,
- size_t* count)
-{
+void count_VkImportFenceWin32HandleInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImportFenceWin32HandleInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7251,45 +5959,36 @@
*count += sizeof(LPCWSTR);
}
-void count_VkExportFenceWin32HandleInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExportFenceWin32HandleInfoKHR* toCount,
- size_t* count)
-{
+void count_VkExportFenceWin32HandleInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkExportFenceWin32HandleInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pAttributes)
- {
+ if (toCount->pAttributes) {
*count += sizeof(const SECURITY_ATTRIBUTES);
}
*count += sizeof(DWORD);
*count += sizeof(LPCWSTR);
}
-void count_VkFenceGetWin32HandleInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFenceGetWin32HandleInfoKHR* toCount,
- size_t* count)
-{
+void count_VkFenceGetWin32HandleInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkFenceGetWin32HandleInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7300,19 +5999,14 @@
#endif
#ifdef VK_KHR_external_fence_fd
-void count_VkImportFenceFdInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportFenceFdInfoKHR* toCount,
- size_t* count)
-{
+void count_VkImportFenceFdInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImportFenceFdInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7323,19 +6017,14 @@
*count += sizeof(int);
}
-void count_VkFenceGetFdInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFenceGetFdInfoKHR* toCount,
- size_t* count)
-{
+void count_VkFenceGetFdInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkFenceGetFdInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7347,18 +6036,14 @@
#endif
#ifdef VK_KHR_performance_query
void count_VkPhysicalDevicePerformanceQueryFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePerformanceQueryFeaturesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePerformanceQueryFeaturesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7367,37 +6052,28 @@
}
void count_VkPhysicalDevicePerformanceQueryPropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePerformanceQueryPropertiesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePerformanceQueryPropertiesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
-void count_VkPerformanceCounterKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPerformanceCounterKHR* toCount,
- size_t* count)
-{
+void count_VkPerformanceCounterKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPerformanceCounterKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7407,19 +6083,15 @@
*count += VK_UUID_SIZE * sizeof(uint8_t);
}
-void count_VkPerformanceCounterDescriptionKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPerformanceCounterDescriptionKHR* toCount,
- size_t* count)
-{
+void count_VkPerformanceCounterDescriptionKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPerformanceCounterDescriptionKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7429,36 +6101,28 @@
*count += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
}
-void count_VkQueryPoolPerformanceCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkQueryPoolPerformanceCreateInfoKHR* toCount,
- size_t* count)
-{
+void count_VkQueryPoolPerformanceCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkQueryPoolPerformanceCreateInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->counterIndexCount * sizeof(const uint32_t);
}
}
-void count_VkPerformanceCounterResultKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPerformanceCounterResultKHR* toCount,
- size_t* count)
-{
+void count_VkPerformanceCounterResultKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPerformanceCounterResultKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -7466,19 +6130,15 @@
*count += sizeof(int32_t);
}
-void count_VkAcquireProfilingLockInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAcquireProfilingLockInfoKHR* toCount,
- size_t* count)
-{
+void count_VkAcquireProfilingLockInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkAcquireProfilingLockInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7486,19 +6146,15 @@
*count += sizeof(uint64_t);
}
-void count_VkPerformanceQuerySubmitInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPerformanceQuerySubmitInfoKHR* toCount,
- size_t* count)
-{
+void count_VkPerformanceQuerySubmitInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPerformanceQuerySubmitInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7509,19 +6165,15 @@
#ifdef VK_KHR_maintenance2
#endif
#ifdef VK_KHR_get_surface_capabilities2
-void count_VkPhysicalDeviceSurfaceInfo2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSurfaceInfo2KHR* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceSurfaceInfo2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSurfaceInfo2KHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7529,118 +6181,96 @@
*count += 1 * 8;
}
-void count_VkSurfaceCapabilities2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSurfaceCapabilities2KHR* toCount,
- size_t* count)
-{
+void count_VkSurfaceCapabilities2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkSurfaceCapabilities2KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkSurfaceCapabilitiesKHR(featureBits, rootType, (VkSurfaceCapabilitiesKHR*)(&toCount->surfaceCapabilities), count);
+ count_VkSurfaceCapabilitiesKHR(
+ featureBits, rootType, (VkSurfaceCapabilitiesKHR*)(&toCount->surfaceCapabilities), count);
}
-void count_VkSurfaceFormat2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSurfaceFormat2KHR* toCount,
- size_t* count)
-{
+void count_VkSurfaceFormat2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkSurfaceFormat2KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkSurfaceFormatKHR(featureBits, rootType, (VkSurfaceFormatKHR*)(&toCount->surfaceFormat), count);
+ count_VkSurfaceFormatKHR(featureBits, rootType, (VkSurfaceFormatKHR*)(&toCount->surfaceFormat),
+ count);
}
#endif
#ifdef VK_KHR_variable_pointers
#endif
#ifdef VK_KHR_get_display_properties2
-void count_VkDisplayProperties2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayProperties2KHR* toCount,
- size_t* count)
-{
+void count_VkDisplayProperties2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayProperties2KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkDisplayPropertiesKHR(featureBits, rootType, (VkDisplayPropertiesKHR*)(&toCount->displayProperties), count);
+ count_VkDisplayPropertiesKHR(featureBits, rootType,
+ (VkDisplayPropertiesKHR*)(&toCount->displayProperties), count);
}
-void count_VkDisplayPlaneProperties2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayPlaneProperties2KHR* toCount,
- size_t* count)
-{
+void count_VkDisplayPlaneProperties2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayPlaneProperties2KHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkDisplayPlanePropertiesKHR(featureBits, rootType, (VkDisplayPlanePropertiesKHR*)(&toCount->displayPlaneProperties), count);
+ count_VkDisplayPlanePropertiesKHR(
+ featureBits, rootType, (VkDisplayPlanePropertiesKHR*)(&toCount->displayPlaneProperties),
+ count);
}
-void count_VkDisplayModeProperties2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayModeProperties2KHR* toCount,
- size_t* count)
-{
+void count_VkDisplayModeProperties2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayModeProperties2KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkDisplayModePropertiesKHR(featureBits, rootType, (VkDisplayModePropertiesKHR*)(&toCount->displayModeProperties), count);
+ count_VkDisplayModePropertiesKHR(featureBits, rootType,
+ (VkDisplayModePropertiesKHR*)(&toCount->displayModeProperties),
+ count);
}
-void count_VkDisplayPlaneInfo2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayPlaneInfo2KHR* toCount,
- size_t* count)
-{
+void count_VkDisplayPlaneInfo2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayPlaneInfo2KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7649,23 +6279,20 @@
*count += sizeof(uint32_t);
}
-void count_VkDisplayPlaneCapabilities2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayPlaneCapabilities2KHR* toCount,
- size_t* count)
-{
+void count_VkDisplayPlaneCapabilities2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayPlaneCapabilities2KHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkDisplayPlaneCapabilitiesKHR(featureBits, rootType, (VkDisplayPlaneCapabilitiesKHR*)(&toCount->capabilities), count);
+ count_VkDisplayPlaneCapabilitiesKHR(
+ featureBits, rootType, (VkDisplayPlaneCapabilitiesKHR*)(&toCount->capabilities), count);
}
#endif
@@ -7685,18 +6312,14 @@
#endif
#ifdef VK_KHR_portability_subset
void count_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePortabilitySubsetFeaturesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePortabilitySubsetFeaturesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7718,18 +6341,14 @@
}
void count_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePortabilitySubsetPropertiesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePortabilitySubsetPropertiesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7749,18 +6368,14 @@
#endif
#ifdef VK_KHR_shader_clock
void count_VkPhysicalDeviceShaderClockFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderClockFeaturesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderClockFeaturesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7783,18 +6398,14 @@
#endif
#ifdef VK_KHR_shader_terminate_invocation
void count_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7804,43 +6415,37 @@
#endif
#ifdef VK_KHR_fragment_shading_rate
void count_VkFragmentShadingRateAttachmentInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFragmentShadingRateAttachmentInfoKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkFragmentShadingRateAttachmentInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pFragmentShadingRateAttachment)
- {
- count_VkAttachmentReference2(featureBits, rootType, (const VkAttachmentReference2*)(toCount->pFragmentShadingRateAttachment), count);
+ if (toCount->pFragmentShadingRateAttachment) {
+ count_VkAttachmentReference2(
+ featureBits, rootType,
+ (const VkAttachmentReference2*)(toCount->pFragmentShadingRateAttachment), count);
}
- count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->shadingRateAttachmentTexelSize), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->shadingRateAttachmentTexelSize),
+ count);
}
void count_VkPipelineFragmentShadingRateStateCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineFragmentShadingRateStateCreateInfoKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineFragmentShadingRateStateCreateInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7849,18 +6454,14 @@
}
void count_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7870,23 +6471,21 @@
}
void count_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->minFragmentShadingRateAttachmentTexelSize), count);
- count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->maxFragmentShadingRateAttachmentTexelSize), count);
+ count_VkExtent2D(featureBits, rootType,
+ (VkExtent2D*)(&toCount->minFragmentShadingRateAttachmentTexelSize), count);
+ count_VkExtent2D(featureBits, rootType,
+ (VkExtent2D*)(&toCount->maxFragmentShadingRateAttachmentTexelSize), count);
*count += sizeof(uint32_t);
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
@@ -7905,18 +6504,14 @@
}
void count_VkPhysicalDeviceFragmentShadingRateKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRateKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7928,19 +6523,15 @@
#ifdef VK_KHR_spirv_1_4
#endif
#ifdef VK_KHR_surface_protected_capabilities
-void count_VkSurfaceProtectedCapabilitiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSurfaceProtectedCapabilitiesKHR* toCount,
- size_t* count)
-{
+void count_VkSurfaceProtectedCapabilitiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkSurfaceProtectedCapabilitiesKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7952,18 +6543,14 @@
#endif
#ifdef VK_KHR_present_wait
void count_VkPhysicalDevicePresentWaitFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePresentWaitFeaturesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePresentWaitFeaturesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -7979,37 +6566,28 @@
#endif
#ifdef VK_KHR_pipeline_executable_properties
void count_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
-void count_VkPipelineInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineInfoKHR* toCount,
- size_t* count)
-{
+void count_VkPipelineInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8017,19 +6595,15 @@
*count += 1 * 8;
}
-void count_VkPipelineExecutablePropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineExecutablePropertiesKHR* toCount,
- size_t* count)
-{
+void count_VkPipelineExecutablePropertiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineExecutablePropertiesKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8039,19 +6613,14 @@
*count += sizeof(uint32_t);
}
-void count_VkPipelineExecutableInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineExecutableInfoKHR* toCount,
- size_t* count)
-{
+void count_VkPipelineExecutableInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineExecutableInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8061,11 +6630,8 @@
}
void count_VkPipelineExecutableStatisticValueKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineExecutableStatisticValueKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineExecutableStatisticValueKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -8073,41 +6639,34 @@
*count += sizeof(VkBool32);
}
-void count_VkPipelineExecutableStatisticKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineExecutableStatisticKHR* toCount,
- size_t* count)
-{
+void count_VkPipelineExecutableStatisticKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineExecutableStatisticKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
*count += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
*count += sizeof(VkPipelineExecutableStatisticFormatKHR);
- count_VkPipelineExecutableStatisticValueKHR(featureBits, rootType, (VkPipelineExecutableStatisticValueKHR*)(&toCount->value), count);
+ count_VkPipelineExecutableStatisticValueKHR(
+ featureBits, rootType, (VkPipelineExecutableStatisticValueKHR*)(&toCount->value), count);
}
void count_VkPipelineExecutableInternalRepresentationKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineExecutableInternalRepresentationKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineExecutableInternalRepresentationKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8117,10 +6676,8 @@
*count += 8;
// WARNING PTR CHECK
*count += 8;
- if (toCount->pData)
- {
- if (toCount)
- {
+ if (toCount->pData) {
+ if (toCount) {
*count += toCount->dataSize * sizeof(uint8_t);
}
}
@@ -8129,18 +6686,14 @@
#endif
#ifdef VK_KHR_shader_integer_dot_product
void count_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8148,18 +6701,14 @@
}
void count_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8197,25 +6746,20 @@
#endif
#ifdef VK_KHR_pipeline_library
-void count_VkPipelineLibraryCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineLibraryCreateInfoKHR* toCount,
- size_t* count)
-{
+void count_VkPipelineLibraryCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineLibraryCreateInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount->libraryCount)
- {
+ if (toCount->libraryCount) {
*count += toCount->libraryCount * 8;
}
}
@@ -8224,47 +6768,36 @@
#ifdef VK_KHR_shader_non_semantic_info
#endif
#ifdef VK_KHR_present_id
-void count_VkPresentIdKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPresentIdKHR* toCount,
- size_t* count)
-{
+void count_VkPresentIdKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPresentIdKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pPresentIds)
- {
- if (toCount)
- {
+ if (toCount->pPresentIds) {
+ if (toCount) {
*count += toCount->swapchainCount * sizeof(const uint64_t);
}
}
}
-void count_VkPhysicalDevicePresentIdFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePresentIdFeaturesKHR* toCount,
- size_t* count)
-{
+void count_VkPhysicalDevicePresentIdFeaturesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePresentIdFeaturesKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8273,19 +6806,14 @@
#endif
#ifdef VK_KHR_video_encode_queue
-void count_VkVideoEncodeInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeInfoKHR* toCount,
- size_t* count)
-{
+void count_VkVideoEncodeInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8296,31 +6824,30 @@
*count += 1 * 8;
*count += sizeof(VkDeviceSize);
*count += sizeof(VkDeviceSize);
- count_VkVideoPictureResourceKHR(featureBits, rootType, (VkVideoPictureResourceKHR*)(&toCount->srcPictureResource), count);
- count_VkVideoReferenceSlotKHR(featureBits, rootType, (const VkVideoReferenceSlotKHR*)(toCount->pSetupReferenceSlot), count);
+ count_VkVideoPictureResourceKHR(
+ featureBits, rootType, (VkVideoPictureResourceKHR*)(&toCount->srcPictureResource), count);
+ count_VkVideoReferenceSlotKHR(featureBits, rootType,
+ (const VkVideoReferenceSlotKHR*)(toCount->pSetupReferenceSlot),
+ count);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->referenceSlotCount; ++i)
- {
- count_VkVideoReferenceSlotKHR(featureBits, rootType, (const VkVideoReferenceSlotKHR*)(toCount->pReferenceSlots + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->referenceSlotCount; ++i) {
+ count_VkVideoReferenceSlotKHR(
+ featureBits, rootType,
+ (const VkVideoReferenceSlotKHR*)(toCount->pReferenceSlots + i), count);
}
}
}
-void count_VkVideoEncodeRateControlInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeRateControlInfoKHR* toCount,
- size_t* count)
-{
+void count_VkVideoEncodeRateControlInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeRateControlInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8335,19 +6862,14 @@
#endif
#ifdef VK_KHR_synchronization2
-void count_VkMemoryBarrier2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryBarrier2KHR* toCount,
- size_t* count)
-{
+void count_VkMemoryBarrier2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryBarrier2KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8357,19 +6879,14 @@
*count += sizeof(VkAccessFlags2KHR);
}
-void count_VkBufferMemoryBarrier2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferMemoryBarrier2KHR* toCount,
- size_t* count)
-{
+void count_VkBufferMemoryBarrier2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferMemoryBarrier2KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8385,19 +6902,14 @@
*count += sizeof(VkDeviceSize);
}
-void count_VkImageMemoryBarrier2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageMemoryBarrier2KHR* toCount,
- size_t* count)
-{
+void count_VkImageMemoryBarrier2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImageMemoryBarrier2KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8411,65 +6923,56 @@
*count += sizeof(uint32_t);
uint64_t cgen_var_0;
*count += 1 * 8;
- count_VkImageSubresourceRange(featureBits, rootType, (VkImageSubresourceRange*)(&toCount->subresourceRange), count);
+ count_VkImageSubresourceRange(featureBits, rootType,
+ (VkImageSubresourceRange*)(&toCount->subresourceRange), count);
}
-void count_VkDependencyInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDependencyInfoKHR* toCount,
- size_t* count)
-{
+void count_VkDependencyInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDependencyInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDependencyFlags);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->memoryBarrierCount; ++i)
- {
- count_VkMemoryBarrier2KHR(featureBits, rootType, (const VkMemoryBarrier2KHR*)(toCount->pMemoryBarriers + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->memoryBarrierCount; ++i) {
+ count_VkMemoryBarrier2KHR(featureBits, rootType,
+ (const VkMemoryBarrier2KHR*)(toCount->pMemoryBarriers + i),
+ count);
}
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->bufferMemoryBarrierCount; ++i)
- {
- count_VkBufferMemoryBarrier2KHR(featureBits, rootType, (const VkBufferMemoryBarrier2KHR*)(toCount->pBufferMemoryBarriers + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->bufferMemoryBarrierCount; ++i) {
+ count_VkBufferMemoryBarrier2KHR(
+ featureBits, rootType,
+ (const VkBufferMemoryBarrier2KHR*)(toCount->pBufferMemoryBarriers + i), count);
}
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->imageMemoryBarrierCount; ++i)
- {
- count_VkImageMemoryBarrier2KHR(featureBits, rootType, (const VkImageMemoryBarrier2KHR*)(toCount->pImageMemoryBarriers + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->imageMemoryBarrierCount; ++i) {
+ count_VkImageMemoryBarrier2KHR(
+ featureBits, rootType,
+ (const VkImageMemoryBarrier2KHR*)(toCount->pImageMemoryBarriers + i), count);
}
}
}
-void count_VkSemaphoreSubmitInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSemaphoreSubmitInfoKHR* toCount,
- size_t* count)
-{
+void count_VkSemaphoreSubmitInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkSemaphoreSubmitInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8480,19 +6983,15 @@
*count += sizeof(uint32_t);
}
-void count_VkCommandBufferSubmitInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCommandBufferSubmitInfoKHR* toCount,
- size_t* count)
-{
+void count_VkCommandBufferSubmitInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkCommandBufferSubmitInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8501,108 +7000,89 @@
*count += sizeof(uint32_t);
}
-void count_VkSubmitInfo2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubmitInfo2KHR* toCount,
- size_t* count)
-{
+void count_VkSubmitInfo2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkSubmitInfo2KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkSubmitFlagsKHR);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->waitSemaphoreInfoCount; ++i)
- {
- count_VkSemaphoreSubmitInfoKHR(featureBits, rootType, (const VkSemaphoreSubmitInfoKHR*)(toCount->pWaitSemaphoreInfos + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->waitSemaphoreInfoCount; ++i) {
+ count_VkSemaphoreSubmitInfoKHR(
+ featureBits, rootType,
+ (const VkSemaphoreSubmitInfoKHR*)(toCount->pWaitSemaphoreInfos + i), count);
}
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->commandBufferInfoCount; ++i)
- {
- count_VkCommandBufferSubmitInfoKHR(featureBits, rootType, (const VkCommandBufferSubmitInfoKHR*)(toCount->pCommandBufferInfos + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->commandBufferInfoCount; ++i) {
+ count_VkCommandBufferSubmitInfoKHR(
+ featureBits, rootType,
+ (const VkCommandBufferSubmitInfoKHR*)(toCount->pCommandBufferInfos + i), count);
}
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->signalSemaphoreInfoCount; ++i)
- {
- count_VkSemaphoreSubmitInfoKHR(featureBits, rootType, (const VkSemaphoreSubmitInfoKHR*)(toCount->pSignalSemaphoreInfos + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->signalSemaphoreInfoCount; ++i) {
+ count_VkSemaphoreSubmitInfoKHR(
+ featureBits, rootType,
+ (const VkSemaphoreSubmitInfoKHR*)(toCount->pSignalSemaphoreInfos + i), count);
}
}
}
void count_VkPhysicalDeviceSynchronization2FeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSynchronization2FeaturesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSynchronization2FeaturesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
-void count_VkQueueFamilyCheckpointProperties2NV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkQueueFamilyCheckpointProperties2NV* toCount,
- size_t* count)
-{
+void count_VkQueueFamilyCheckpointProperties2NV(uint32_t featureBits, VkStructureType rootType,
+ const VkQueueFamilyCheckpointProperties2NV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineStageFlags2KHR);
}
-void count_VkCheckpointData2NV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCheckpointData2NV* toCount,
- size_t* count)
-{
+void count_VkCheckpointData2NV(uint32_t featureBits, VkStructureType rootType,
+ const VkCheckpointData2NV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineStageFlags2KHR);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pCheckpointMarker)
- {
+ if (toCount->pCheckpointMarker) {
*count += sizeof(uint8_t);
}
}
@@ -8610,18 +7090,14 @@
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
void count_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8631,18 +7107,14 @@
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
void count_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8652,18 +7124,14 @@
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
void count_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8675,19 +7143,14 @@
#endif
#ifdef VK_KHR_copy_commands2
-void count_VkBufferCopy2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferCopy2KHR* toCount,
- size_t* count)
-{
+void count_VkBufferCopy2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferCopy2KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8696,19 +7159,14 @@
*count += sizeof(VkDeviceSize);
}
-void count_VkCopyBufferInfo2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCopyBufferInfo2KHR* toCount,
- size_t* count)
-{
+void count_VkCopyBufferInfo2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkCopyBufferInfo2KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8717,51 +7175,42 @@
uint64_t cgen_var_1;
*count += 1 * 8;
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i)
- {
- count_VkBufferCopy2KHR(featureBits, rootType, (const VkBufferCopy2KHR*)(toCount->pRegions + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
+ count_VkBufferCopy2KHR(featureBits, rootType,
+ (const VkBufferCopy2KHR*)(toCount->pRegions + i), count);
}
}
}
-void count_VkImageCopy2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageCopy2KHR* toCount,
- size_t* count)
-{
+void count_VkImageCopy2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImageCopy2KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkImageSubresourceLayers(featureBits, rootType, (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
+ count_VkImageSubresourceLayers(featureBits, rootType,
+ (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->srcOffset), count);
- count_VkImageSubresourceLayers(featureBits, rootType, (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
+ count_VkImageSubresourceLayers(featureBits, rootType,
+ (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->dstOffset), count);
count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->extent), count);
}
-void count_VkCopyImageInfo2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCopyImageInfo2KHR* toCount,
- size_t* count)
-{
+void count_VkCopyImageInfo2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkCopyImageInfo2KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8772,52 +7221,42 @@
*count += 1 * 8;
*count += sizeof(VkImageLayout);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i)
- {
- count_VkImageCopy2KHR(featureBits, rootType, (const VkImageCopy2KHR*)(toCount->pRegions + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
+ count_VkImageCopy2KHR(featureBits, rootType,
+ (const VkImageCopy2KHR*)(toCount->pRegions + i), count);
}
}
}
-void count_VkBufferImageCopy2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferImageCopy2KHR* toCount,
- size_t* count)
-{
+void count_VkBufferImageCopy2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferImageCopy2KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDeviceSize);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- count_VkImageSubresourceLayers(featureBits, rootType, (VkImageSubresourceLayers*)(&toCount->imageSubresource), count);
+ count_VkImageSubresourceLayers(featureBits, rootType,
+ (VkImageSubresourceLayers*)(&toCount->imageSubresource), count);
count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->imageOffset), count);
count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->imageExtent), count);
}
-void count_VkCopyBufferToImageInfo2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCopyBufferToImageInfo2KHR* toCount,
- size_t* count)
-{
+void count_VkCopyBufferToImageInfo2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkCopyBufferToImageInfo2KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8827,28 +7266,23 @@
*count += 1 * 8;
*count += sizeof(VkImageLayout);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i)
- {
- count_VkBufferImageCopy2KHR(featureBits, rootType, (const VkBufferImageCopy2KHR*)(toCount->pRegions + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
+ count_VkBufferImageCopy2KHR(featureBits, rootType,
+ (const VkBufferImageCopy2KHR*)(toCount->pRegions + i),
+ count);
}
}
}
-void count_VkCopyImageToBufferInfo2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCopyImageToBufferInfo2KHR* toCount,
- size_t* count)
-{
+void count_VkCopyImageToBufferInfo2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkCopyImageToBufferInfo2KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8858,56 +7292,46 @@
uint64_t cgen_var_1;
*count += 1 * 8;
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i)
- {
- count_VkBufferImageCopy2KHR(featureBits, rootType, (const VkBufferImageCopy2KHR*)(toCount->pRegions + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
+ count_VkBufferImageCopy2KHR(featureBits, rootType,
+ (const VkBufferImageCopy2KHR*)(toCount->pRegions + i),
+ count);
}
}
}
-void count_VkImageBlit2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageBlit2KHR* toCount,
- size_t* count)
-{
+void count_VkImageBlit2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImageBlit2KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkImageSubresourceLayers(featureBits, rootType, (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ count_VkImageSubresourceLayers(featureBits, rootType,
+ (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(toCount->srcOffsets + i), count);
}
- count_VkImageSubresourceLayers(featureBits, rootType, (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ count_VkImageSubresourceLayers(featureBits, rootType,
+ (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(toCount->dstOffsets + i), count);
}
}
-void count_VkBlitImageInfo2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBlitImageInfo2KHR* toCount,
- size_t* count)
-{
+void count_VkBlitImageInfo2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkBlitImageInfo2KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8918,52 +7342,43 @@
*count += 1 * 8;
*count += sizeof(VkImageLayout);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i)
- {
- count_VkImageBlit2KHR(featureBits, rootType, (const VkImageBlit2KHR*)(toCount->pRegions + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
+ count_VkImageBlit2KHR(featureBits, rootType,
+ (const VkImageBlit2KHR*)(toCount->pRegions + i), count);
}
}
*count += sizeof(VkFilter);
}
-void count_VkImageResolve2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageResolve2KHR* toCount,
- size_t* count)
-{
+void count_VkImageResolve2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImageResolve2KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkImageSubresourceLayers(featureBits, rootType, (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
+ count_VkImageSubresourceLayers(featureBits, rootType,
+ (VkImageSubresourceLayers*)(&toCount->srcSubresource), count);
count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->srcOffset), count);
- count_VkImageSubresourceLayers(featureBits, rootType, (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
+ count_VkImageSubresourceLayers(featureBits, rootType,
+ (VkImageSubresourceLayers*)(&toCount->dstSubresource), count);
count_VkOffset3D(featureBits, rootType, (VkOffset3D*)(&toCount->dstOffset), count);
count_VkExtent3D(featureBits, rootType, (VkExtent3D*)(&toCount->extent), count);
}
-void count_VkResolveImageInfo2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkResolveImageInfo2KHR* toCount,
- size_t* count)
-{
+void count_VkResolveImageInfo2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkResolveImageInfo2KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -8974,30 +7389,24 @@
*count += 1 * 8;
*count += sizeof(VkImageLayout);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i)
- {
- count_VkImageResolve2KHR(featureBits, rootType, (const VkImageResolve2KHR*)(toCount->pRegions + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->regionCount; ++i) {
+ count_VkImageResolve2KHR(featureBits, rootType,
+ (const VkImageResolve2KHR*)(toCount->pRegions + i), count);
}
}
}
#endif
#ifdef VK_KHR_format_feature_flags2
-void count_VkFormatProperties3KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFormatProperties3KHR* toCount,
- size_t* count)
-{
+void count_VkFormatProperties3KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkFormatProperties3KHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9009,18 +7418,14 @@
#endif
#ifdef VK_KHR_maintenance4
void count_VkPhysicalDeviceMaintenance4FeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMaintenance4FeaturesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance4FeaturesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9028,85 +7433,69 @@
}
void count_VkPhysicalDeviceMaintenance4PropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMaintenance4PropertiesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance4PropertiesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDeviceSize);
}
-void count_VkDeviceBufferMemoryRequirementsKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceBufferMemoryRequirementsKHR* toCount,
- size_t* count)
-{
+void count_VkDeviceBufferMemoryRequirementsKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceBufferMemoryRequirementsKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkBufferCreateInfo(featureBits, rootType, (const VkBufferCreateInfo*)(toCount->pCreateInfo), count);
+ count_VkBufferCreateInfo(featureBits, rootType,
+ (const VkBufferCreateInfo*)(toCount->pCreateInfo), count);
}
-void count_VkDeviceImageMemoryRequirementsKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceImageMemoryRequirementsKHR* toCount,
- size_t* count)
-{
+void count_VkDeviceImageMemoryRequirementsKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceImageMemoryRequirementsKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkImageCreateInfo(featureBits, rootType, (const VkImageCreateInfo*)(toCount->pCreateInfo), count);
+ count_VkImageCreateInfo(featureBits, rootType, (const VkImageCreateInfo*)(toCount->pCreateInfo),
+ count);
*count += sizeof(VkImageAspectFlagBits);
}
#endif
#ifdef VK_ANDROID_native_buffer
-void count_VkNativeBufferANDROID(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkNativeBufferANDROID* toCount,
- size_t* count)
-{
+void count_VkNativeBufferANDROID(uint32_t featureBits, VkStructureType rootType,
+ const VkNativeBufferANDROID* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
// WARNING PTR CHECK
*count += 8;
- if (toCount->handle)
- {
+ if (toCount->handle) {
*count += sizeof(const uint32_t);
}
*count += sizeof(int);
@@ -9118,19 +7507,15 @@
#endif
#ifdef VK_EXT_debug_report
-void count_VkDebugReportCallbackCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDebugReportCallbackCreateInfoEXT* toCount,
- size_t* count)
-{
+void count_VkDebugReportCallbackCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDebugReportCallbackCreateInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9138,8 +7523,7 @@
*count += 8;
// WARNING PTR CHECK
*count += 8;
- if (toCount->pUserData)
- {
+ if (toCount->pUserData) {
*count += sizeof(uint8_t);
}
}
@@ -9153,18 +7537,14 @@
#endif
#ifdef VK_AMD_rasterization_order
void count_VkPipelineRasterizationStateRasterizationOrderAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineRasterizationStateRasterizationOrderAMD* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRasterizationStateRasterizationOrderAMD* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9177,19 +7557,15 @@
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
-void count_VkDebugMarkerObjectNameInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDebugMarkerObjectNameInfoEXT* toCount,
- size_t* count)
-{
+void count_VkDebugMarkerObjectNameInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDebugMarkerObjectNameInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9198,19 +7574,15 @@
*count += sizeof(uint32_t) + (toCount->pObjectName ? strlen(toCount->pObjectName) : 0);
}
-void count_VkDebugMarkerObjectTagInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDebugMarkerObjectTagInfoEXT* toCount,
- size_t* count)
-{
+void count_VkDebugMarkerObjectTagInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDebugMarkerObjectTagInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9218,25 +7590,19 @@
*count += sizeof(uint64_t);
*count += sizeof(uint64_t);
*count += 8;
- if (toCount)
- {
+ if (toCount) {
*count += toCount->tagSize * sizeof(const uint8_t);
}
}
-void count_VkDebugMarkerMarkerInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDebugMarkerMarkerInfoEXT* toCount,
- size_t* count)
-{
+void count_VkDebugMarkerMarkerInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDebugMarkerMarkerInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9249,18 +7615,14 @@
#endif
#ifdef VK_NV_dedicated_allocation
void count_VkDedicatedAllocationImageCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDedicatedAllocationImageCreateInfoNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDedicatedAllocationImageCreateInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9268,18 +7630,14 @@
}
void count_VkDedicatedAllocationBufferCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDedicatedAllocationBufferCreateInfoNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDedicatedAllocationBufferCreateInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9287,18 +7645,14 @@
}
void count_VkDedicatedAllocationMemoryAllocateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDedicatedAllocationMemoryAllocateInfoNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDedicatedAllocationMemoryAllocateInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9311,18 +7665,14 @@
#endif
#ifdef VK_EXT_transform_feedback
void count_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceTransformFeedbackFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceTransformFeedbackFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9331,18 +7681,14 @@
}
void count_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceTransformFeedbackPropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceTransformFeedbackPropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9359,18 +7705,14 @@
}
void count_VkPipelineRasterizationStateStreamCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineRasterizationStateStreamCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRasterizationStateStreamCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9380,42 +7722,31 @@
#endif
#ifdef VK_NVX_binary_import
-void count_VkCuModuleCreateInfoNVX(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCuModuleCreateInfoNVX* toCount,
- size_t* count)
-{
+void count_VkCuModuleCreateInfoNVX(uint32_t featureBits, VkStructureType rootType,
+ const VkCuModuleCreateInfoNVX* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += 8;
- if (toCount)
- {
+ if (toCount) {
*count += toCount->dataSize * sizeof(const uint8_t);
}
}
-void count_VkCuFunctionCreateInfoNVX(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCuFunctionCreateInfoNVX* toCount,
- size_t* count)
-{
+void count_VkCuFunctionCreateInfoNVX(uint32_t featureBits, VkStructureType rootType,
+ const VkCuFunctionCreateInfoNVX* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9423,19 +7754,14 @@
*count += sizeof(uint32_t) + (toCount->pName ? strlen(toCount->pName) : 0);
}
-void count_VkCuLaunchInfoNVX(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCuLaunchInfoNVX* toCount,
- size_t* count)
-{
+void count_VkCuLaunchInfoNVX(uint32_t featureBits, VkStructureType rootType,
+ const VkCuLaunchInfoNVX* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9453,19 +7779,14 @@
#endif
#ifdef VK_NVX_image_view_handle
-void count_VkImageViewHandleInfoNVX(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageViewHandleInfoNVX* toCount,
- size_t* count)
-{
+void count_VkImageViewHandleInfoNVX(uint32_t featureBits, VkStructureType rootType,
+ const VkImageViewHandleInfoNVX* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9476,19 +7797,15 @@
*count += 1 * 8;
}
-void count_VkImageViewAddressPropertiesNVX(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageViewAddressPropertiesNVX* toCount,
- size_t* count)
-{
+void count_VkImageViewAddressPropertiesNVX(uint32_t featureBits, VkStructureType rootType,
+ const VkImageViewAddressPropertiesNVX* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9506,19 +7823,15 @@
#ifdef VK_AMD_shader_ballot
#endif
#ifdef VK_EXT_video_encode_h264
-void count_VkVideoEncodeH264CapabilitiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH264CapabilitiesEXT* toCount,
- size_t* count)
-{
+void count_VkVideoEncodeH264CapabilitiesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH264CapabilitiesEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9527,86 +7840,74 @@
*count += sizeof(VkVideoEncodeH264OutputModeFlagsEXT);
count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->minPictureSizeInMbs), count);
count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->maxPictureSizeInMbs), count);
- count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->inputImageDataAlignment), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->inputImageDataAlignment),
+ count);
*count += sizeof(uint8_t);
*count += sizeof(uint8_t);
*count += sizeof(uint8_t);
*count += sizeof(uint8_t);
- count_VkExtensionProperties(featureBits, rootType, (VkExtensionProperties*)(&toCount->stdExtensionVersion), count);
+ count_VkExtensionProperties(featureBits, rootType,
+ (VkExtensionProperties*)(&toCount->stdExtensionVersion), count);
}
void count_VkVideoEncodeH264SessionCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH264SessionCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH264SessionCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkVideoEncodeH264CreateFlagsEXT);
count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->maxPictureSizeInMbs), count);
- count_VkExtensionProperties(featureBits, rootType, (const VkExtensionProperties*)(toCount->pStdExtensionVersion), count);
+ count_VkExtensionProperties(featureBits, rootType,
+ (const VkExtensionProperties*)(toCount->pStdExtensionVersion),
+ count);
}
void count_VkVideoEncodeH264SessionParametersAddInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH264SessionParametersAddInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH264SessionParametersAddInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pSpsStd)
- {
- if (toCount)
- {
+ if (toCount->pSpsStd) {
+ if (toCount) {
*count += toCount->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet);
}
}
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pPpsStd)
- {
- if (toCount)
- {
+ if (toCount->pPpsStd) {
+ if (toCount) {
*count += toCount->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet);
}
}
}
void count_VkVideoEncodeH264SessionParametersCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH264SessionParametersCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH264SessionParametersCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9614,25 +7915,23 @@
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pParametersAddInfo)
- {
- count_VkVideoEncodeH264SessionParametersAddInfoEXT(featureBits, rootType, (const VkVideoEncodeH264SessionParametersAddInfoEXT*)(toCount->pParametersAddInfo), count);
+ if (toCount->pParametersAddInfo) {
+ count_VkVideoEncodeH264SessionParametersAddInfoEXT(
+ featureBits, rootType,
+ (const VkVideoEncodeH264SessionParametersAddInfoEXT*)(toCount->pParametersAddInfo),
+ count);
}
}
-void count_VkVideoEncodeH264DpbSlotInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH264DpbSlotInfoEXT* toCount,
- size_t* count)
-{
+void count_VkVideoEncodeH264DpbSlotInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH264DpbSlotInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9640,38 +7939,36 @@
*count += sizeof(const StdVideoEncodeH264PictureInfo);
}
-void count_VkVideoEncodeH264NaluSliceEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH264NaluSliceEXT* toCount,
- size_t* count)
-{
+void count_VkVideoEncodeH264NaluSliceEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH264NaluSliceEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(const StdVideoEncodeH264SliceHeader);
*count += sizeof(uint32_t);
*count += sizeof(uint8_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->refFinalList0EntryCount; ++i)
- {
- count_VkVideoEncodeH264DpbSlotInfoEXT(featureBits, rootType, (const VkVideoEncodeH264DpbSlotInfoEXT*)(toCount->pRefFinalList0Entries + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->refFinalList0EntryCount; ++i) {
+ count_VkVideoEncodeH264DpbSlotInfoEXT(
+ featureBits, rootType,
+ (const VkVideoEncodeH264DpbSlotInfoEXT*)(toCount->pRefFinalList0Entries + i),
+ count);
}
}
*count += sizeof(uint8_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->refFinalList1EntryCount; ++i)
- {
- count_VkVideoEncodeH264DpbSlotInfoEXT(featureBits, rootType, (const VkVideoEncodeH264DpbSlotInfoEXT*)(toCount->pRefFinalList1Entries + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->refFinalList1EntryCount; ++i) {
+ count_VkVideoEncodeH264DpbSlotInfoEXT(
+ featureBits, rootType,
+ (const VkVideoEncodeH264DpbSlotInfoEXT*)(toCount->pRefFinalList1Entries + i),
+ count);
}
}
*count += sizeof(uint32_t);
@@ -9679,87 +7976,77 @@
*count += sizeof(uint8_t);
}
-void count_VkVideoEncodeH264VclFrameInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH264VclFrameInfoEXT* toCount,
- size_t* count)
-{
+void count_VkVideoEncodeH264VclFrameInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH264VclFrameInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint8_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->refDefaultFinalList0EntryCount; ++i)
- {
- count_VkVideoEncodeH264DpbSlotInfoEXT(featureBits, rootType, (const VkVideoEncodeH264DpbSlotInfoEXT*)(toCount->pRefDefaultFinalList0Entries + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->refDefaultFinalList0EntryCount; ++i) {
+ count_VkVideoEncodeH264DpbSlotInfoEXT(
+ featureBits, rootType,
+ (const VkVideoEncodeH264DpbSlotInfoEXT*)(toCount->pRefDefaultFinalList0Entries + i),
+ count);
}
}
*count += sizeof(uint8_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->refDefaultFinalList1EntryCount; ++i)
- {
- count_VkVideoEncodeH264DpbSlotInfoEXT(featureBits, rootType, (const VkVideoEncodeH264DpbSlotInfoEXT*)(toCount->pRefDefaultFinalList1Entries + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->refDefaultFinalList1EntryCount; ++i) {
+ count_VkVideoEncodeH264DpbSlotInfoEXT(
+ featureBits, rootType,
+ (const VkVideoEncodeH264DpbSlotInfoEXT*)(toCount->pRefDefaultFinalList1Entries + i),
+ count);
}
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->naluSliceEntryCount; ++i)
- {
- count_VkVideoEncodeH264NaluSliceEXT(featureBits, rootType, (const VkVideoEncodeH264NaluSliceEXT*)(toCount->pNaluSliceEntries + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->naluSliceEntryCount; ++i) {
+ count_VkVideoEncodeH264NaluSliceEXT(
+ featureBits, rootType,
+ (const VkVideoEncodeH264NaluSliceEXT*)(toCount->pNaluSliceEntries + i), count);
}
}
- count_VkVideoEncodeH264DpbSlotInfoEXT(featureBits, rootType, (const VkVideoEncodeH264DpbSlotInfoEXT*)(toCount->pCurrentPictureInfo), count);
+ count_VkVideoEncodeH264DpbSlotInfoEXT(
+ featureBits, rootType,
+ (const VkVideoEncodeH264DpbSlotInfoEXT*)(toCount->pCurrentPictureInfo), count);
}
void count_VkVideoEncodeH264EmitPictureParametersEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH264EmitPictureParametersEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH264EmitPictureParametersEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint8_t);
*count += sizeof(VkBool32);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->ppsIdEntryCount * sizeof(const uint8_t);
}
}
-void count_VkVideoEncodeH264ProfileEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH264ProfileEXT* toCount,
- size_t* count)
-{
+void count_VkVideoEncodeH264ProfileEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH264ProfileEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9768,19 +8055,15 @@
#endif
#ifdef VK_EXT_video_encode_h265
-void count_VkVideoEncodeH265CapabilitiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH265CapabilitiesEXT* toCount,
- size_t* count)
-{
+void count_VkVideoEncodeH265CapabilitiesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH265CapabilitiesEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9788,96 +8071,82 @@
*count += sizeof(VkVideoEncodeH265InputModeFlagsEXT);
*count += sizeof(VkVideoEncodeH265OutputModeFlagsEXT);
*count += sizeof(VkVideoEncodeH265CtbSizeFlagsEXT);
- count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->inputImageDataAlignment), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->inputImageDataAlignment),
+ count);
*count += sizeof(uint8_t);
*count += sizeof(uint8_t);
*count += sizeof(uint8_t);
*count += sizeof(uint8_t);
*count += sizeof(uint8_t);
- count_VkExtensionProperties(featureBits, rootType, (VkExtensionProperties*)(&toCount->stdExtensionVersion), count);
+ count_VkExtensionProperties(featureBits, rootType,
+ (VkExtensionProperties*)(&toCount->stdExtensionVersion), count);
}
void count_VkVideoEncodeH265SessionCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH265SessionCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH265SessionCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkVideoEncodeH265CreateFlagsEXT);
- count_VkExtensionProperties(featureBits, rootType, (const VkExtensionProperties*)(toCount->pStdExtensionVersion), count);
+ count_VkExtensionProperties(featureBits, rootType,
+ (const VkExtensionProperties*)(toCount->pStdExtensionVersion),
+ count);
}
void count_VkVideoEncodeH265SessionParametersAddInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH265SessionParametersAddInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH265SessionParametersAddInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pVpsStd)
- {
- if (toCount)
- {
+ if (toCount->pVpsStd) {
+ if (toCount) {
*count += toCount->vpsStdCount * sizeof(const StdVideoH265VideoParameterSet);
}
}
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pSpsStd)
- {
- if (toCount)
- {
+ if (toCount->pSpsStd) {
+ if (toCount) {
*count += toCount->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet);
}
}
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pPpsStd)
- {
- if (toCount)
- {
+ if (toCount->pPpsStd) {
+ if (toCount) {
*count += toCount->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet);
}
}
}
void count_VkVideoEncodeH265SessionParametersCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH265SessionParametersCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH265SessionParametersCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9886,25 +8155,23 @@
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pParametersAddInfo)
- {
- count_VkVideoEncodeH265SessionParametersAddInfoEXT(featureBits, rootType, (const VkVideoEncodeH265SessionParametersAddInfoEXT*)(toCount->pParametersAddInfo), count);
+ if (toCount->pParametersAddInfo) {
+ count_VkVideoEncodeH265SessionParametersAddInfoEXT(
+ featureBits, rootType,
+ (const VkVideoEncodeH265SessionParametersAddInfoEXT*)(toCount->pParametersAddInfo),
+ count);
}
}
-void count_VkVideoEncodeH265DpbSlotInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH265DpbSlotInfoEXT* toCount,
- size_t* count)
-{
+void count_VkVideoEncodeH265DpbSlotInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH265DpbSlotInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -9912,113 +8179,101 @@
*count += sizeof(const StdVideoEncodeH265ReferenceInfo);
}
-void count_VkVideoEncodeH265ReferenceListsEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH265ReferenceListsEXT* toCount,
- size_t* count)
-{
+void count_VkVideoEncodeH265ReferenceListsEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH265ReferenceListsEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint8_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->referenceList0EntryCount; ++i)
- {
- count_VkVideoEncodeH265DpbSlotInfoEXT(featureBits, rootType, (const VkVideoEncodeH265DpbSlotInfoEXT*)(toCount->pReferenceList0Entries + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->referenceList0EntryCount; ++i) {
+ count_VkVideoEncodeH265DpbSlotInfoEXT(
+ featureBits, rootType,
+ (const VkVideoEncodeH265DpbSlotInfoEXT*)(toCount->pReferenceList0Entries + i),
+ count);
}
}
*count += sizeof(uint8_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->referenceList1EntryCount; ++i)
- {
- count_VkVideoEncodeH265DpbSlotInfoEXT(featureBits, rootType, (const VkVideoEncodeH265DpbSlotInfoEXT*)(toCount->pReferenceList1Entries + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->referenceList1EntryCount; ++i) {
+ count_VkVideoEncodeH265DpbSlotInfoEXT(
+ featureBits, rootType,
+ (const VkVideoEncodeH265DpbSlotInfoEXT*)(toCount->pReferenceList1Entries + i),
+ count);
}
}
*count += sizeof(const StdVideoEncodeH265ReferenceModifications);
}
-void count_VkVideoEncodeH265NaluSliceEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH265NaluSliceEXT* toCount,
- size_t* count)
-{
+void count_VkVideoEncodeH265NaluSliceEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH265NaluSliceEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pReferenceFinalLists)
- {
- count_VkVideoEncodeH265ReferenceListsEXT(featureBits, rootType, (const VkVideoEncodeH265ReferenceListsEXT*)(toCount->pReferenceFinalLists), count);
+ if (toCount->pReferenceFinalLists) {
+ count_VkVideoEncodeH265ReferenceListsEXT(
+ featureBits, rootType,
+ (const VkVideoEncodeH265ReferenceListsEXT*)(toCount->pReferenceFinalLists), count);
}
*count += sizeof(const StdVideoEncodeH265SliceHeader);
}
-void count_VkVideoEncodeH265VclFrameInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH265VclFrameInfoEXT* toCount,
- size_t* count)
-{
+void count_VkVideoEncodeH265VclFrameInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH265VclFrameInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pReferenceFinalLists)
- {
- count_VkVideoEncodeH265ReferenceListsEXT(featureBits, rootType, (const VkVideoEncodeH265ReferenceListsEXT*)(toCount->pReferenceFinalLists), count);
+ if (toCount->pReferenceFinalLists) {
+ count_VkVideoEncodeH265ReferenceListsEXT(
+ featureBits, rootType,
+ (const VkVideoEncodeH265ReferenceListsEXT*)(toCount->pReferenceFinalLists), count);
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->naluSliceEntryCount; ++i)
- {
- count_VkVideoEncodeH265NaluSliceEXT(featureBits, rootType, (const VkVideoEncodeH265NaluSliceEXT*)(toCount->pNaluSliceEntries + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->naluSliceEntryCount; ++i) {
+ count_VkVideoEncodeH265NaluSliceEXT(
+ featureBits, rootType,
+ (const VkVideoEncodeH265NaluSliceEXT*)(toCount->pNaluSliceEntries + i), count);
}
}
*count += sizeof(const StdVideoEncodeH265PictureInfo);
}
void count_VkVideoEncodeH265EmitPictureParametersEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH265EmitPictureParametersEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH265EmitPictureParametersEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10027,25 +8282,19 @@
*count += sizeof(VkBool32);
*count += sizeof(VkBool32);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->ppsIdEntryCount * sizeof(const uint8_t);
}
}
-void count_VkVideoEncodeH265ProfileEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH265ProfileEXT* toCount,
- size_t* count)
-{
+void count_VkVideoEncodeH265ProfileEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH265ProfileEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10054,19 +8303,14 @@
#endif
#ifdef VK_EXT_video_decode_h264
-void count_VkVideoDecodeH264ProfileEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH264ProfileEXT* toCount,
- size_t* count)
-{
+void count_VkVideoDecodeH264ProfileEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH264ProfileEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10074,98 +8318,81 @@
*count += sizeof(VkVideoDecodeH264PictureLayoutFlagsEXT);
}
-void count_VkVideoDecodeH264CapabilitiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH264CapabilitiesEXT* toCount,
- size_t* count)
-{
+void count_VkVideoDecodeH264CapabilitiesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH264CapabilitiesEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
count_VkOffset2D(featureBits, rootType, (VkOffset2D*)(&toCount->fieldOffsetGranularity), count);
- count_VkExtensionProperties(featureBits, rootType, (VkExtensionProperties*)(&toCount->stdExtensionVersion), count);
+ count_VkExtensionProperties(featureBits, rootType,
+ (VkExtensionProperties*)(&toCount->stdExtensionVersion), count);
}
void count_VkVideoDecodeH264SessionCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH264SessionCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH264SessionCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkVideoDecodeH264CreateFlagsEXT);
- count_VkExtensionProperties(featureBits, rootType, (const VkExtensionProperties*)(toCount->pStdExtensionVersion), count);
+ count_VkExtensionProperties(featureBits, rootType,
+ (const VkExtensionProperties*)(toCount->pStdExtensionVersion),
+ count);
}
void count_VkVideoDecodeH264SessionParametersAddInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH264SessionParametersAddInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH264SessionParametersAddInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pSpsStd)
- {
- if (toCount)
- {
+ if (toCount->pSpsStd) {
+ if (toCount) {
*count += toCount->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet);
}
}
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pPpsStd)
- {
- if (toCount)
- {
+ if (toCount->pPpsStd) {
+ if (toCount) {
*count += toCount->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet);
}
}
}
void count_VkVideoDecodeH264SessionParametersCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH264SessionParametersCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH264SessionParametersCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10173,68 +8400,56 @@
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pParametersAddInfo)
- {
- count_VkVideoDecodeH264SessionParametersAddInfoEXT(featureBits, rootType, (const VkVideoDecodeH264SessionParametersAddInfoEXT*)(toCount->pParametersAddInfo), count);
+ if (toCount->pParametersAddInfo) {
+ count_VkVideoDecodeH264SessionParametersAddInfoEXT(
+ featureBits, rootType,
+ (const VkVideoDecodeH264SessionParametersAddInfoEXT*)(toCount->pParametersAddInfo),
+ count);
}
}
-void count_VkVideoDecodeH264PictureInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH264PictureInfoEXT* toCount,
- size_t* count)
-{
+void count_VkVideoDecodeH264PictureInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH264PictureInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(const StdVideoDecodeH264PictureInfo);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->slicesCount * sizeof(const uint32_t);
}
}
-void count_VkVideoDecodeH264MvcEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH264MvcEXT* toCount,
- size_t* count)
-{
+void count_VkVideoDecodeH264MvcEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH264MvcEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(const StdVideoDecodeH264Mvc);
}
-void count_VkVideoDecodeH264DpbSlotInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH264DpbSlotInfoEXT* toCount,
- size_t* count)
-{
+void count_VkVideoDecodeH264DpbSlotInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH264DpbSlotInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10244,18 +8459,14 @@
#endif
#ifdef VK_AMD_texture_gather_bias_lod
void count_VkTextureLODGatherFormatPropertiesAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkTextureLODGatherFormatPropertiesAMD* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkTextureLODGatherFormatPropertiesAMD* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10264,12 +8475,8 @@
#endif
#ifdef VK_AMD_shader_info
-void count_VkShaderResourceUsageAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkShaderResourceUsageAMD* toCount,
- size_t* count)
-{
+void count_VkShaderResourceUsageAMD(uint32_t featureBits, VkStructureType rootType,
+ const VkShaderResourceUsageAMD* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -10281,18 +8488,15 @@
*count += 8;
}
-void count_VkShaderStatisticsInfoAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkShaderStatisticsInfoAMD* toCount,
- size_t* count)
-{
+void count_VkShaderStatisticsInfoAMD(uint32_t featureBits, VkStructureType rootType,
+ const VkShaderStatisticsInfoAMD* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkShaderStageFlags);
- count_VkShaderResourceUsageAMD(featureBits, rootType, (VkShaderResourceUsageAMD*)(&toCount->resourceUsage), count);
+ count_VkShaderResourceUsageAMD(featureBits, rootType,
+ (VkShaderResourceUsageAMD*)(&toCount->resourceUsage), count);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
@@ -10305,18 +8509,14 @@
#endif
#ifdef VK_GGP_stream_descriptor_surface
void count_VkStreamDescriptorSurfaceCreateInfoGGP(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkStreamDescriptorSurfaceCreateInfoGGP* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkStreamDescriptorSurfaceCreateInfoGGP* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10327,18 +8527,14 @@
#endif
#ifdef VK_NV_corner_sampled_image
void count_VkPhysicalDeviceCornerSampledImageFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceCornerSampledImageFeaturesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceCornerSampledImageFeaturesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10349,17 +8545,15 @@
#ifdef VK_IMG_format_pvrtc
#endif
#ifdef VK_NV_external_memory_capabilities
-void count_VkExternalImageFormatPropertiesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExternalImageFormatPropertiesNV* toCount,
- size_t* count)
-{
+void count_VkExternalImageFormatPropertiesNV(uint32_t featureBits, VkStructureType rootType,
+ const VkExternalImageFormatPropertiesNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
- count_VkImageFormatProperties(featureBits, rootType, (VkImageFormatProperties*)(&toCount->imageFormatProperties), count);
+ count_VkImageFormatProperties(
+ featureBits, rootType, (VkImageFormatProperties*)(&toCount->imageFormatProperties), count);
*count += sizeof(VkExternalMemoryFeatureFlagsNV);
*count += sizeof(VkExternalMemoryHandleTypeFlagsNV);
*count += sizeof(VkExternalMemoryHandleTypeFlagsNV);
@@ -10367,38 +8561,30 @@
#endif
#ifdef VK_NV_external_memory
-void count_VkExternalMemoryImageCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExternalMemoryImageCreateInfoNV* toCount,
- size_t* count)
-{
+void count_VkExternalMemoryImageCreateInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkExternalMemoryImageCreateInfoNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkExternalMemoryHandleTypeFlagsNV);
}
-void count_VkExportMemoryAllocateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExportMemoryAllocateInfoNV* toCount,
- size_t* count)
-{
+void count_VkExportMemoryAllocateInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkExportMemoryAllocateInfoNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10407,19 +8593,15 @@
#endif
#ifdef VK_NV_external_memory_win32
-void count_VkImportMemoryWin32HandleInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportMemoryWin32HandleInfoNV* toCount,
- size_t* count)
-{
+void count_VkImportMemoryWin32HandleInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkImportMemoryWin32HandleInfoNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10427,26 +8609,21 @@
*count += sizeof(HANDLE);
}
-void count_VkExportMemoryWin32HandleInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExportMemoryWin32HandleInfoNV* toCount,
- size_t* count)
-{
+void count_VkExportMemoryWin32HandleInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkExportMemoryWin32HandleInfoNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pAttributes)
- {
+ if (toCount->pAttributes) {
*count += sizeof(const SECURITY_ATTRIBUTES);
}
*count += sizeof(DWORD);
@@ -10455,93 +8632,72 @@
#endif
#ifdef VK_NV_win32_keyed_mutex
void count_VkWin32KeyedMutexAcquireReleaseInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkWin32KeyedMutexAcquireReleaseInfoNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkWin32KeyedMutexAcquireReleaseInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount->acquireCount)
- {
+ if (toCount->acquireCount) {
*count += toCount->acquireCount * 8;
}
- if (toCount)
- {
+ if (toCount) {
*count += toCount->acquireCount * sizeof(const uint64_t);
}
- if (toCount)
- {
+ if (toCount) {
*count += toCount->acquireCount * sizeof(const uint32_t);
}
*count += sizeof(uint32_t);
- if (toCount->releaseCount)
- {
+ if (toCount->releaseCount) {
*count += toCount->releaseCount * 8;
}
- if (toCount)
- {
+ if (toCount) {
*count += toCount->releaseCount * sizeof(const uint64_t);
}
}
#endif
#ifdef VK_EXT_validation_flags
-void count_VkValidationFlagsEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkValidationFlagsEXT* toCount,
- size_t* count)
-{
+void count_VkValidationFlagsEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkValidationFlagsEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT);
}
}
#endif
#ifdef VK_NN_vi_surface
-void count_VkViSurfaceCreateInfoNN(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkViSurfaceCreateInfoNN* toCount,
- size_t* count)
-{
+void count_VkViSurfaceCreateInfoNN(uint32_t featureBits, VkStructureType rootType,
+ const VkViSurfaceCreateInfoNN* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkViSurfaceCreateFlagsNN);
// WARNING PTR CHECK
*count += 8;
- if (toCount->window)
- {
+ if (toCount->window) {
*count += sizeof(uint8_t);
}
}
@@ -10553,18 +8709,14 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
void count_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10573,19 +8725,15 @@
#endif
#ifdef VK_EXT_astc_decode_mode
-void count_VkImageViewASTCDecodeModeEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageViewASTCDecodeModeEXT* toCount,
- size_t* count)
-{
+void count_VkImageViewASTCDecodeModeEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkImageViewASTCDecodeModeEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10593,18 +8741,14 @@
}
void count_VkPhysicalDeviceASTCDecodeFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceASTCDecodeFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceASTCDecodeFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10613,19 +8757,15 @@
#endif
#ifdef VK_EXT_conditional_rendering
-void count_VkConditionalRenderingBeginInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkConditionalRenderingBeginInfoEXT* toCount,
- size_t* count)
-{
+void count_VkConditionalRenderingBeginInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkConditionalRenderingBeginInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10636,18 +8776,14 @@
}
void count_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceConditionalRenderingFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceConditionalRenderingFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10656,18 +8792,14 @@
}
void count_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCommandBufferInheritanceConditionalRenderingInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkCommandBufferInheritanceConditionalRenderingInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10676,12 +8808,8 @@
#endif
#ifdef VK_NV_clip_space_w_scaling
-void count_VkViewportWScalingNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkViewportWScalingNV* toCount,
- size_t* count)
-{
+void count_VkViewportWScalingNV(uint32_t featureBits, VkStructureType rootType,
+ const VkViewportWScalingNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -10691,18 +8819,14 @@
}
void count_VkPipelineViewportWScalingStateCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineViewportWScalingStateCreateInfoNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineViewportWScalingStateCreateInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10710,13 +8834,12 @@
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pViewportWScalings)
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->viewportCount; ++i)
- {
- count_VkViewportWScalingNV(featureBits, rootType, (const VkViewportWScalingNV*)(toCount->pViewportWScalings + i), count);
+ if (toCount->pViewportWScalings) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->viewportCount; ++i) {
+ count_VkViewportWScalingNV(
+ featureBits, rootType,
+ (const VkViewportWScalingNV*)(toCount->pViewportWScalings + i), count);
}
}
}
@@ -10728,19 +8851,14 @@
#ifdef VK_EXT_acquire_xlib_display
#endif
#ifdef VK_EXT_display_surface_counter
-void count_VkSurfaceCapabilities2EXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSurfaceCapabilities2EXT* toCount,
- size_t* count)
-{
+void count_VkSurfaceCapabilities2EXT(uint32_t featureBits, VkStructureType rootType,
+ const VkSurfaceCapabilities2EXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10759,76 +8877,57 @@
#endif
#ifdef VK_EXT_display_control
-void count_VkDisplayPowerInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayPowerInfoEXT* toCount,
- size_t* count)
-{
+void count_VkDisplayPowerInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayPowerInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDisplayPowerStateEXT);
}
-void count_VkDeviceEventInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceEventInfoEXT* toCount,
- size_t* count)
-{
+void count_VkDeviceEventInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceEventInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDeviceEventTypeEXT);
}
-void count_VkDisplayEventInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayEventInfoEXT* toCount,
- size_t* count)
-{
+void count_VkDisplayEventInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayEventInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDisplayEventTypeEXT);
}
-void count_VkSwapchainCounterCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSwapchainCounterCreateInfoEXT* toCount,
- size_t* count)
-{
+void count_VkSwapchainCounterCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkSwapchainCounterCreateInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10837,12 +8936,9 @@
#endif
#ifdef VK_GOOGLE_display_timing
-void count_VkRefreshCycleDurationGOOGLE(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRefreshCycleDurationGOOGLE* toCount,
- size_t* count)
-{
+void count_VkRefreshCycleDurationGOOGLE(uint32_t featureBits, VkStructureType rootType,
+ const VkRefreshCycleDurationGOOGLE* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -10850,12 +8946,9 @@
*count += sizeof(uint64_t);
}
-void count_VkPastPresentationTimingGOOGLE(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPastPresentationTimingGOOGLE* toCount,
- size_t* count)
-{
+void count_VkPastPresentationTimingGOOGLE(uint32_t featureBits, VkStructureType rootType,
+ const VkPastPresentationTimingGOOGLE* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -10867,12 +8960,8 @@
*count += sizeof(uint64_t);
}
-void count_VkPresentTimeGOOGLE(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPresentTimeGOOGLE* toCount,
- size_t* count)
-{
+void count_VkPresentTimeGOOGLE(uint32_t featureBits, VkStructureType rootType,
+ const VkPresentTimeGOOGLE* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -10881,32 +8970,25 @@
*count += sizeof(uint64_t);
}
-void count_VkPresentTimesInfoGOOGLE(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPresentTimesInfoGOOGLE* toCount,
- size_t* count)
-{
+void count_VkPresentTimesInfoGOOGLE(uint32_t featureBits, VkStructureType rootType,
+ const VkPresentTimesInfoGOOGLE* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pTimes)
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->swapchainCount; ++i)
- {
- count_VkPresentTimeGOOGLE(featureBits, rootType, (const VkPresentTimeGOOGLE*)(toCount->pTimes + i), count);
+ if (toCount->pTimes) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->swapchainCount; ++i) {
+ count_VkPresentTimeGOOGLE(featureBits, rootType,
+ (const VkPresentTimeGOOGLE*)(toCount->pTimes + i), count);
}
}
}
@@ -10921,18 +9003,14 @@
#endif
#ifdef VK_NVX_multiview_per_view_attributes
void count_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10941,12 +9019,8 @@
#endif
#ifdef VK_NV_viewport_swizzle
-void count_VkViewportSwizzleNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkViewportSwizzleNV* toCount,
- size_t* count)
-{
+void count_VkViewportSwizzleNV(uint32_t featureBits, VkStructureType rootType,
+ const VkViewportSwizzleNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -10958,18 +9032,14 @@
}
void count_VkPipelineViewportSwizzleStateCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineViewportSwizzleStateCreateInfoNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineViewportSwizzleStateCreateInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -10977,13 +9047,12 @@
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pViewportSwizzles)
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->viewportCount; ++i)
- {
- count_VkViewportSwizzleNV(featureBits, rootType, (const VkViewportSwizzleNV*)(toCount->pViewportSwizzles + i), count);
+ if (toCount->pViewportSwizzles) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->viewportCount; ++i) {
+ count_VkViewportSwizzleNV(
+ featureBits, rootType,
+ (const VkViewportSwizzleNV*)(toCount->pViewportSwizzles + i), count);
}
}
}
@@ -10992,18 +9061,14 @@
#endif
#ifdef VK_EXT_discard_rectangles
void count_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDiscardRectanglePropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDiscardRectanglePropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11011,18 +9076,14 @@
}
void count_VkPipelineDiscardRectangleStateCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineDiscardRectangleStateCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineDiscardRectangleStateCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11031,13 +9092,11 @@
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pDiscardRectangles)
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->discardRectangleCount; ++i)
- {
- count_VkRect2D(featureBits, rootType, (const VkRect2D*)(toCount->pDiscardRectangles + i), count);
+ if (toCount->pDiscardRectangles) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->discardRectangleCount; ++i) {
+ count_VkRect2D(featureBits, rootType,
+ (const VkRect2D*)(toCount->pDiscardRectangles + i), count);
}
}
}
@@ -11046,18 +9105,14 @@
#endif
#ifdef VK_EXT_conservative_rasterization
void count_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11073,18 +9128,14 @@
}
void count_VkPipelineRasterizationConservativeStateCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineRasterizationConservativeStateCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRasterizationConservativeStateCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11096,18 +9147,14 @@
#endif
#ifdef VK_EXT_depth_clip_enable
void count_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDepthClipEnableFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDepthClipEnableFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11115,18 +9162,14 @@
}
void count_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineRasterizationDepthClipStateCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRasterizationDepthClipStateCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11138,12 +9181,8 @@
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
-void count_VkXYColorEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkXYColorEXT* toCount,
- size_t* count)
-{
+void count_VkXYColorEXT(uint32_t featureBits, VkStructureType rootType, const VkXYColorEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -11152,24 +9191,20 @@
*count += sizeof(float);
}
-void count_VkHdrMetadataEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkHdrMetadataEXT* toCount,
- size_t* count)
-{
+void count_VkHdrMetadataEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkHdrMetadataEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
count_VkXYColorEXT(featureBits, rootType, (VkXYColorEXT*)(&toCount->displayPrimaryRed), count);
- count_VkXYColorEXT(featureBits, rootType, (VkXYColorEXT*)(&toCount->displayPrimaryGreen), count);
+ count_VkXYColorEXT(featureBits, rootType, (VkXYColorEXT*)(&toCount->displayPrimaryGreen),
+ count);
count_VkXYColorEXT(featureBits, rootType, (VkXYColorEXT*)(&toCount->displayPrimaryBlue), count);
count_VkXYColorEXT(featureBits, rootType, (VkXYColorEXT*)(&toCount->whitePoint), count);
*count += sizeof(float);
@@ -11180,54 +9215,42 @@
#endif
#ifdef VK_MVK_ios_surface
-void count_VkIOSSurfaceCreateInfoMVK(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkIOSSurfaceCreateInfoMVK* toCount,
- size_t* count)
-{
+void count_VkIOSSurfaceCreateInfoMVK(uint32_t featureBits, VkStructureType rootType,
+ const VkIOSSurfaceCreateInfoMVK* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkIOSSurfaceCreateFlagsMVK);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pView)
- {
+ if (toCount->pView) {
*count += sizeof(const uint8_t);
}
}
#endif
#ifdef VK_MVK_macos_surface
-void count_VkMacOSSurfaceCreateInfoMVK(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMacOSSurfaceCreateInfoMVK* toCount,
- size_t* count)
-{
+void count_VkMacOSSurfaceCreateInfoMVK(uint32_t featureBits, VkStructureType rootType,
+ const VkMacOSSurfaceCreateInfoMVK* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkMacOSSurfaceCreateFlagsMVK);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pView)
- {
+ if (toCount->pView) {
*count += sizeof(const uint8_t);
}
}
@@ -11240,19 +9263,14 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
-void count_VkDebugUtilsLabelEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDebugUtilsLabelEXT* toCount,
- size_t* count)
-{
+void count_VkDebugUtilsLabelEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDebugUtilsLabelEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11260,125 +9278,104 @@
*count += 4 * sizeof(float);
}
-void count_VkDebugUtilsObjectNameInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDebugUtilsObjectNameInfoEXT* toCount,
- size_t* count)
-{
+void count_VkDebugUtilsObjectNameInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDebugUtilsObjectNameInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkObjectType);
*count += sizeof(uint64_t);
- if (featureBits & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
- {
+ if (featureBits & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
// WARNING PTR CHECK
*count += 8;
- if (toCount->pObjectName)
- {
+ if (toCount->pObjectName) {
*count += sizeof(uint32_t) + (toCount->pObjectName ? strlen(toCount->pObjectName) : 0);
}
- }
- else
- {
+ } else {
*count += sizeof(uint32_t) + (toCount->pObjectName ? strlen(toCount->pObjectName) : 0);
}
}
-void count_VkDebugUtilsMessengerCallbackDataEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDebugUtilsMessengerCallbackDataEXT* toCount,
- size_t* count)
-{
+void count_VkDebugUtilsMessengerCallbackDataEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDebugUtilsMessengerCallbackDataEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT);
- if (featureBits & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
- {
+ if (featureBits & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
// WARNING PTR CHECK
*count += 8;
- if (toCount->pMessageIdName)
- {
- *count += sizeof(uint32_t) + (toCount->pMessageIdName ? strlen(toCount->pMessageIdName) : 0);
+ if (toCount->pMessageIdName) {
+ *count +=
+ sizeof(uint32_t) + (toCount->pMessageIdName ? strlen(toCount->pMessageIdName) : 0);
}
- }
- else
- {
- *count += sizeof(uint32_t) + (toCount->pMessageIdName ? strlen(toCount->pMessageIdName) : 0);
+ } else {
+ *count +=
+ sizeof(uint32_t) + (toCount->pMessageIdName ? strlen(toCount->pMessageIdName) : 0);
}
*count += sizeof(int32_t);
*count += sizeof(uint32_t) + (toCount->pMessage ? strlen(toCount->pMessage) : 0);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pQueueLabels)
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->queueLabelCount; ++i)
- {
- count_VkDebugUtilsLabelEXT(featureBits, rootType, (VkDebugUtilsLabelEXT*)(toCount->pQueueLabels + i), count);
+ if (toCount->pQueueLabels) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->queueLabelCount; ++i) {
+ count_VkDebugUtilsLabelEXT(featureBits, rootType,
+ (VkDebugUtilsLabelEXT*)(toCount->pQueueLabels + i),
+ count);
}
}
}
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pCmdBufLabels)
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->cmdBufLabelCount; ++i)
- {
- count_VkDebugUtilsLabelEXT(featureBits, rootType, (VkDebugUtilsLabelEXT*)(toCount->pCmdBufLabels + i), count);
+ if (toCount->pCmdBufLabels) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->cmdBufLabelCount; ++i) {
+ count_VkDebugUtilsLabelEXT(featureBits, rootType,
+ (VkDebugUtilsLabelEXT*)(toCount->pCmdBufLabels + i),
+ count);
}
}
}
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pObjects)
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->objectCount; ++i)
- {
- count_VkDebugUtilsObjectNameInfoEXT(featureBits, rootType, (VkDebugUtilsObjectNameInfoEXT*)(toCount->pObjects + i), count);
+ if (toCount->pObjects) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->objectCount; ++i) {
+ count_VkDebugUtilsObjectNameInfoEXT(
+ featureBits, rootType, (VkDebugUtilsObjectNameInfoEXT*)(toCount->pObjects + i),
+ count);
}
}
}
}
-void count_VkDebugUtilsMessengerCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDebugUtilsMessengerCreateInfoEXT* toCount,
- size_t* count)
-{
+void count_VkDebugUtilsMessengerCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDebugUtilsMessengerCreateInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11388,25 +9385,20 @@
*count += 8;
// WARNING PTR CHECK
*count += 8;
- if (toCount->pUserData)
- {
+ if (toCount->pUserData) {
*count += sizeof(uint8_t);
}
}
-void count_VkDebugUtilsObjectTagInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDebugUtilsObjectTagInfoEXT* toCount,
- size_t* count)
-{
+void count_VkDebugUtilsObjectTagInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDebugUtilsObjectTagInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11414,27 +9406,22 @@
*count += sizeof(uint64_t);
*count += sizeof(uint64_t);
*count += 8;
- if (toCount)
- {
+ if (toCount) {
*count += toCount->tagSize * sizeof(const uint8_t);
}
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
-void count_VkAndroidHardwareBufferUsageANDROID(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAndroidHardwareBufferUsageANDROID* toCount,
- size_t* count)
-{
+void count_VkAndroidHardwareBufferUsageANDROID(uint32_t featureBits, VkStructureType rootType,
+ const VkAndroidHardwareBufferUsageANDROID* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11442,18 +9429,14 @@
}
void count_VkAndroidHardwareBufferPropertiesANDROID(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAndroidHardwareBufferPropertiesANDROID* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAndroidHardwareBufferPropertiesANDROID* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11462,25 +9445,23 @@
}
void count_VkAndroidHardwareBufferFormatPropertiesANDROID(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAndroidHardwareBufferFormatPropertiesANDROID* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAndroidHardwareBufferFormatPropertiesANDROID* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkFormat);
*count += sizeof(uint64_t);
*count += sizeof(VkFormatFeatureFlags);
- count_VkComponentMapping(featureBits, rootType, (VkComponentMapping*)(&toCount->samplerYcbcrConversionComponents), count);
+ count_VkComponentMapping(featureBits, rootType,
+ (VkComponentMapping*)(&toCount->samplerYcbcrConversionComponents),
+ count);
*count += sizeof(VkSamplerYcbcrModelConversion);
*count += sizeof(VkSamplerYcbcrRange);
*count += sizeof(VkChromaLocation);
@@ -11488,18 +9469,14 @@
}
void count_VkImportAndroidHardwareBufferInfoANDROID(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportAndroidHardwareBufferInfoANDROID* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkImportAndroidHardwareBufferInfoANDROID* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11507,18 +9484,14 @@
}
void count_VkMemoryGetAndroidHardwareBufferInfoANDROID(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryGetAndroidHardwareBufferInfoANDROID* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryGetAndroidHardwareBufferInfoANDROID* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11526,19 +9499,14 @@
*count += 1 * 8;
}
-void count_VkExternalFormatANDROID(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExternalFormatANDROID* toCount,
- size_t* count)
-{
+void count_VkExternalFormatANDROID(uint32_t featureBits, VkStructureType rootType,
+ const VkExternalFormatANDROID* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11546,25 +9514,23 @@
}
void count_VkAndroidHardwareBufferFormatProperties2ANDROID(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAndroidHardwareBufferFormatProperties2ANDROID* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAndroidHardwareBufferFormatProperties2ANDROID* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkFormat);
*count += sizeof(uint64_t);
*count += sizeof(VkFormatFeatureFlags2KHR);
- count_VkComponentMapping(featureBits, rootType, (VkComponentMapping*)(&toCount->samplerYcbcrConversionComponents), count);
+ count_VkComponentMapping(featureBits, rootType,
+ (VkComponentMapping*)(&toCount->samplerYcbcrConversionComponents),
+ count);
*count += sizeof(VkSamplerYcbcrModelConversion);
*count += sizeof(VkSamplerYcbcrRange);
*count += sizeof(VkChromaLocation);
@@ -11582,18 +9548,14 @@
#endif
#ifdef VK_EXT_inline_uniform_block
void count_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11602,18 +9564,14 @@
}
void count_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11625,41 +9583,32 @@
}
void count_VkWriteDescriptorSetInlineUniformBlockEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkWriteDescriptorSetInlineUniformBlockEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkWriteDescriptorSetInlineUniformBlockEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->dataSize * sizeof(const uint8_t);
}
}
void count_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11670,12 +9619,8 @@
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
-void count_VkSampleLocationEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSampleLocationEXT* toCount,
- size_t* count)
-{
+void count_VkSampleLocationEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkSampleLocationEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -11684,173 +9629,148 @@
*count += sizeof(float);
}
-void count_VkSampleLocationsInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSampleLocationsInfoEXT* toCount,
- size_t* count)
-{
+void count_VkSampleLocationsInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkSampleLocationsInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkSampleCountFlagBits);
count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->sampleLocationGridSize), count);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->sampleLocationsCount; ++i)
- {
- count_VkSampleLocationEXT(featureBits, rootType, (const VkSampleLocationEXT*)(toCount->pSampleLocations + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->sampleLocationsCount; ++i) {
+ count_VkSampleLocationEXT(featureBits, rootType,
+ (const VkSampleLocationEXT*)(toCount->pSampleLocations + i),
+ count);
}
}
}
-void count_VkAttachmentSampleLocationsEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAttachmentSampleLocationsEXT* toCount,
- size_t* count)
-{
+void count_VkAttachmentSampleLocationsEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkAttachmentSampleLocationsEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
- count_VkSampleLocationsInfoEXT(featureBits, rootType, (VkSampleLocationsInfoEXT*)(&toCount->sampleLocationsInfo), count);
+ count_VkSampleLocationsInfoEXT(
+ featureBits, rootType, (VkSampleLocationsInfoEXT*)(&toCount->sampleLocationsInfo), count);
}
-void count_VkSubpassSampleLocationsEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubpassSampleLocationsEXT* toCount,
- size_t* count)
-{
+void count_VkSubpassSampleLocationsEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkSubpassSampleLocationsEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
- count_VkSampleLocationsInfoEXT(featureBits, rootType, (VkSampleLocationsInfoEXT*)(&toCount->sampleLocationsInfo), count);
+ count_VkSampleLocationsInfoEXT(
+ featureBits, rootType, (VkSampleLocationsInfoEXT*)(&toCount->sampleLocationsInfo), count);
}
void count_VkRenderPassSampleLocationsBeginInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderPassSampleLocationsBeginInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkRenderPassSampleLocationsBeginInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->attachmentInitialSampleLocationsCount; ++i)
- {
- count_VkAttachmentSampleLocationsEXT(featureBits, rootType, (const VkAttachmentSampleLocationsEXT*)(toCount->pAttachmentInitialSampleLocations + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->attachmentInitialSampleLocationsCount; ++i) {
+ count_VkAttachmentSampleLocationsEXT(
+ featureBits, rootType,
+ (const VkAttachmentSampleLocationsEXT*)(toCount->pAttachmentInitialSampleLocations +
+ i),
+ count);
}
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->postSubpassSampleLocationsCount; ++i)
- {
- count_VkSubpassSampleLocationsEXT(featureBits, rootType, (const VkSubpassSampleLocationsEXT*)(toCount->pPostSubpassSampleLocations + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->postSubpassSampleLocationsCount; ++i) {
+ count_VkSubpassSampleLocationsEXT(
+ featureBits, rootType,
+ (const VkSubpassSampleLocationsEXT*)(toCount->pPostSubpassSampleLocations + i),
+ count);
}
}
}
void count_VkPipelineSampleLocationsStateCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineSampleLocationsStateCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineSampleLocationsStateCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
- count_VkSampleLocationsInfoEXT(featureBits, rootType, (VkSampleLocationsInfoEXT*)(&toCount->sampleLocationsInfo), count);
+ count_VkSampleLocationsInfoEXT(
+ featureBits, rootType, (VkSampleLocationsInfoEXT*)(&toCount->sampleLocationsInfo), count);
}
void count_VkPhysicalDeviceSampleLocationsPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSampleLocationsPropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSampleLocationsPropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkSampleCountFlags);
- count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->maxSampleLocationGridSize), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->maxSampleLocationGridSize),
+ count);
*count += 2 * sizeof(float);
*count += sizeof(uint32_t);
*count += sizeof(VkBool32);
}
-void count_VkMultisamplePropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMultisamplePropertiesEXT* toCount,
- size_t* count)
-{
+void count_VkMultisamplePropertiesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkMultisamplePropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->maxSampleLocationGridSize), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->maxSampleLocationGridSize),
+ count);
}
#endif
#ifdef VK_EXT_blend_operation_advanced
void count_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11858,18 +9778,14 @@
}
void count_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11882,18 +9798,14 @@
}
void count_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineColorBlendAdvancedStateCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineColorBlendAdvancedStateCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11905,18 +9817,14 @@
#endif
#ifdef VK_NV_fragment_coverage_to_color
void count_VkPipelineCoverageToColorStateCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineCoverageToColorStateCreateInfoNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineCoverageToColorStateCreateInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11928,18 +9836,14 @@
#endif
#ifdef VK_NV_framebuffer_mixed_samples
void count_VkPipelineCoverageModulationStateCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineCoverageModulationStateCreateInfoNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineCoverageModulationStateCreateInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11949,10 +9853,8 @@
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pCoverageModulationTable)
- {
- if (toCount)
- {
+ if (toCount->pCoverageModulationTable) {
+ if (toCount) {
*count += toCount->coverageModulationTableCount * sizeof(const float);
}
}
@@ -11963,18 +9865,14 @@
#endif
#ifdef VK_NV_shader_sm_builtins
void count_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -11983,18 +9881,14 @@
}
void count_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12005,12 +9899,9 @@
#ifdef VK_EXT_post_depth_coverage
#endif
#ifdef VK_EXT_image_drm_format_modifier
-void count_VkDrmFormatModifierPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesEXT* toCount,
- size_t* count)
-{
+void count_VkDrmFormatModifierPropertiesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDrmFormatModifierPropertiesEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -12020,50 +9911,42 @@
*count += sizeof(VkFormatFeatureFlags);
}
-void count_VkDrmFormatModifierPropertiesListEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesListEXT* toCount,
- size_t* count)
-{
+void count_VkDrmFormatModifierPropertiesListEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDrmFormatModifierPropertiesListEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pDrmFormatModifierProperties)
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->drmFormatModifierCount; ++i)
- {
- count_VkDrmFormatModifierPropertiesEXT(featureBits, rootType, (VkDrmFormatModifierPropertiesEXT*)(toCount->pDrmFormatModifierProperties + i), count);
+ if (toCount->pDrmFormatModifierProperties) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->drmFormatModifierCount; ++i) {
+ count_VkDrmFormatModifierPropertiesEXT(
+ featureBits, rootType,
+ (VkDrmFormatModifierPropertiesEXT*)(toCount->pDrmFormatModifierProperties + i),
+ count);
}
}
}
}
void count_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12072,90 +9955,72 @@
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pQueueFamilyIndices)
- {
- if (toCount)
- {
+ if (toCount->pQueueFamilyIndices) {
+ if (toCount) {
*count += toCount->queueFamilyIndexCount * sizeof(const uint32_t);
}
}
}
void count_VkImageDrmFormatModifierListCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageDrmFormatModifierListCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkImageDrmFormatModifierListCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->drmFormatModifierCount * sizeof(const uint64_t);
}
}
void count_VkImageDrmFormatModifierExplicitCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageDrmFormatModifierExplicitCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkImageDrmFormatModifierExplicitCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint64_t);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->drmFormatModifierPlaneCount; ++i)
- {
- count_VkSubresourceLayout(featureBits, rootType, (const VkSubresourceLayout*)(toCount->pPlaneLayouts + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->drmFormatModifierPlaneCount; ++i) {
+ count_VkSubresourceLayout(featureBits, rootType,
+ (const VkSubresourceLayout*)(toCount->pPlaneLayouts + i),
+ count);
}
}
}
void count_VkImageDrmFormatModifierPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageDrmFormatModifierPropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkImageDrmFormatModifierPropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint64_t);
}
-void count_VkDrmFormatModifierProperties2EXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDrmFormatModifierProperties2EXT* toCount,
- size_t* count)
-{
+void count_VkDrmFormatModifierProperties2EXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDrmFormatModifierProperties2EXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -12166,31 +10031,27 @@
}
void count_VkDrmFormatModifierPropertiesList2EXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesList2EXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDrmFormatModifierPropertiesList2EXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pDrmFormatModifierProperties)
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->drmFormatModifierCount; ++i)
- {
- count_VkDrmFormatModifierProperties2EXT(featureBits, rootType, (VkDrmFormatModifierProperties2EXT*)(toCount->pDrmFormatModifierProperties + i), count);
+ if (toCount->pDrmFormatModifierProperties) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->drmFormatModifierCount; ++i) {
+ count_VkDrmFormatModifierProperties2EXT(
+ featureBits, rootType,
+ (VkDrmFormatModifierProperties2EXT*)(toCount->pDrmFormatModifierProperties + i),
+ count);
}
}
}
@@ -12198,43 +10059,34 @@
#endif
#ifdef VK_EXT_validation_cache
-void count_VkValidationCacheCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkValidationCacheCreateInfoEXT* toCount,
- size_t* count)
-{
+void count_VkValidationCacheCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkValidationCacheCreateInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkValidationCacheCreateFlagsEXT);
*count += 8;
- if (toCount)
- {
+ if (toCount) {
*count += toCount->initialDataSize * sizeof(const uint8_t);
}
}
void count_VkShaderModuleValidationCacheCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkShaderModuleValidationCacheCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkShaderModuleValidationCacheCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12248,36 +10100,27 @@
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_NV_shading_rate_image
-void count_VkShadingRatePaletteNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkShadingRatePaletteNV* toCount,
- size_t* count)
-{
+void count_VkShadingRatePaletteNV(uint32_t featureBits, VkStructureType rootType,
+ const VkShadingRatePaletteNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->shadingRatePaletteEntryCount * sizeof(const VkShadingRatePaletteEntryNV);
}
}
void count_VkPipelineViewportShadingRateImageStateCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineViewportShadingRateImageStateCreateInfoNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineViewportShadingRateImageStateCreateInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12285,31 +10128,26 @@
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pShadingRatePalettes)
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->viewportCount; ++i)
- {
- count_VkShadingRatePaletteNV(featureBits, rootType, (const VkShadingRatePaletteNV*)(toCount->pShadingRatePalettes + i), count);
+ if (toCount->pShadingRatePalettes) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->viewportCount; ++i) {
+ count_VkShadingRatePaletteNV(
+ featureBits, rootType,
+ (const VkShadingRatePaletteNV*)(toCount->pShadingRatePalettes + i), count);
}
}
}
}
void count_VkPhysicalDeviceShadingRateImageFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShadingRateImageFeaturesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShadingRateImageFeaturesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12318,18 +10156,14 @@
}
void count_VkPhysicalDeviceShadingRateImagePropertiesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShadingRateImagePropertiesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShadingRateImagePropertiesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12338,12 +10172,8 @@
*count += sizeof(uint32_t);
}
-void count_VkCoarseSampleLocationNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCoarseSampleLocationNV* toCount,
- size_t* count)
-{
+void count_VkCoarseSampleLocationNV(uint32_t featureBits, VkStructureType rootType,
+ const VkCoarseSampleLocationNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -12353,12 +10183,8 @@
*count += sizeof(uint32_t);
}
-void count_VkCoarseSampleOrderCustomNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCoarseSampleOrderCustomNV* toCount,
- size_t* count)
-{
+void count_VkCoarseSampleOrderCustomNV(uint32_t featureBits, VkStructureType rootType,
+ const VkCoarseSampleOrderCustomNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -12366,57 +10192,49 @@
*count += sizeof(VkShadingRatePaletteEntryNV);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->sampleLocationCount; ++i)
- {
- count_VkCoarseSampleLocationNV(featureBits, rootType, (const VkCoarseSampleLocationNV*)(toCount->pSampleLocations + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->sampleLocationCount; ++i) {
+ count_VkCoarseSampleLocationNV(
+ featureBits, rootType,
+ (const VkCoarseSampleLocationNV*)(toCount->pSampleLocations + i), count);
}
}
}
void count_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkCoarseSampleOrderTypeNV);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->customSampleOrderCount; ++i)
- {
- count_VkCoarseSampleOrderCustomNV(featureBits, rootType, (const VkCoarseSampleOrderCustomNV*)(toCount->pCustomSampleOrders + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->customSampleOrderCount; ++i) {
+ count_VkCoarseSampleOrderCustomNV(
+ featureBits, rootType,
+ (const VkCoarseSampleOrderCustomNV*)(toCount->pCustomSampleOrders + i), count);
}
}
}
#endif
#ifdef VK_NV_ray_tracing
-void count_VkRayTracingShaderGroupCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRayTracingShaderGroupCreateInfoNV* toCount,
- size_t* count)
-{
+void count_VkRayTracingShaderGroupCreateInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkRayTracingShaderGroupCreateInfoNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12427,37 +10245,33 @@
*count += sizeof(uint32_t);
}
-void count_VkRayTracingPipelineCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRayTracingPipelineCreateInfoNV* toCount,
- size_t* count)
-{
+void count_VkRayTracingPipelineCreateInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkRayTracingPipelineCreateInfoNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineCreateFlags);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->stageCount; ++i)
- {
- count_VkPipelineShaderStageCreateInfo(featureBits, rootType, (const VkPipelineShaderStageCreateInfo*)(toCount->pStages + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->stageCount; ++i) {
+ count_VkPipelineShaderStageCreateInfo(
+ featureBits, rootType,
+ (const VkPipelineShaderStageCreateInfo*)(toCount->pStages + i), count);
}
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->groupCount; ++i)
- {
- count_VkRayTracingShaderGroupCreateInfoNV(featureBits, rootType, (const VkRayTracingShaderGroupCreateInfoNV*)(toCount->pGroups + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->groupCount; ++i) {
+ count_VkRayTracingShaderGroupCreateInfoNV(
+ featureBits, rootType,
+ (const VkRayTracingShaderGroupCreateInfoNV*)(toCount->pGroups + i), count);
}
}
*count += sizeof(uint32_t);
@@ -12468,19 +10282,14 @@
*count += sizeof(int32_t);
}
-void count_VkGeometryTrianglesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkGeometryTrianglesNV* toCount,
- size_t* count)
-{
+void count_VkGeometryTrianglesNV(uint32_t featureBits, VkStructureType rootType,
+ const VkGeometryTrianglesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12500,19 +10309,14 @@
*count += sizeof(VkDeviceSize);
}
-void count_VkGeometryAABBNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkGeometryAABBNV* toCount,
- size_t* count)
-{
+void count_VkGeometryAABBNV(uint32_t featureBits, VkStructureType rootType,
+ const VkGeometryAABBNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12523,33 +10327,25 @@
*count += sizeof(VkDeviceSize);
}
-void count_VkGeometryDataNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkGeometryDataNV* toCount,
- size_t* count)
-{
+void count_VkGeometryDataNV(uint32_t featureBits, VkStructureType rootType,
+ const VkGeometryDataNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
- count_VkGeometryTrianglesNV(featureBits, rootType, (VkGeometryTrianglesNV*)(&toCount->triangles), count);
+ count_VkGeometryTrianglesNV(featureBits, rootType,
+ (VkGeometryTrianglesNV*)(&toCount->triangles), count);
count_VkGeometryAABBNV(featureBits, rootType, (VkGeometryAABBNV*)(&toCount->aabbs), count);
}
-void count_VkGeometryNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkGeometryNV* toCount,
- size_t* count)
-{
+void count_VkGeometryNV(uint32_t featureBits, VkStructureType rootType, const VkGeometryNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12558,19 +10354,15 @@
*count += sizeof(VkGeometryFlagsKHR);
}
-void count_VkAccelerationStructureInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureInfoNV* toCount,
- size_t* count)
-{
+void count_VkAccelerationStructureInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureInfoNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12578,48 +10370,40 @@
*count += sizeof(VkBuildAccelerationStructureFlagsNV);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->geometryCount; ++i)
- {
- count_VkGeometryNV(featureBits, rootType, (const VkGeometryNV*)(toCount->pGeometries + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->geometryCount; ++i) {
+ count_VkGeometryNV(featureBits, rootType,
+ (const VkGeometryNV*)(toCount->pGeometries + i), count);
}
}
}
-void count_VkAccelerationStructureCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureCreateInfoNV* toCount,
- size_t* count)
-{
+void count_VkAccelerationStructureCreateInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureCreateInfoNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDeviceSize);
- count_VkAccelerationStructureInfoNV(featureBits, rootType, (VkAccelerationStructureInfoNV*)(&toCount->info), count);
+ count_VkAccelerationStructureInfoNV(featureBits, rootType,
+ (VkAccelerationStructureInfoNV*)(&toCount->info), count);
}
void count_VkBindAccelerationStructureMemoryInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindAccelerationStructureMemoryInfoNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkBindAccelerationStructureMemoryInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12629,53 +10413,42 @@
*count += 1 * 8;
*count += sizeof(VkDeviceSize);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->deviceIndexCount * sizeof(const uint32_t);
}
}
void count_VkWriteDescriptorSetAccelerationStructureNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkWriteDescriptorSetAccelerationStructureNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkWriteDescriptorSetAccelerationStructureNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pAccelerationStructures)
- {
- if (toCount->accelerationStructureCount)
- {
+ if (toCount->pAccelerationStructures) {
+ if (toCount->accelerationStructureCount) {
*count += toCount->accelerationStructureCount * 8;
}
}
}
void count_VkAccelerationStructureMemoryRequirementsInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureMemoryRequirementsInfoNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureMemoryRequirementsInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12685,18 +10458,14 @@
}
void count_VkPhysicalDeviceRayTracingPropertiesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingPropertiesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPropertiesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12710,25 +10479,17 @@
*count += sizeof(uint32_t);
}
-void count_VkTransformMatrixKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkTransformMatrixKHR* toCount,
- size_t* count)
-{
+void count_VkTransformMatrixKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkTransformMatrixKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
- *count += ((3)*(4)) * sizeof(float);
+ *count += ((3) * (4)) * sizeof(float);
}
-void count_VkAabbPositionsKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAabbPositionsKHR* toCount,
- size_t* count)
-{
+void count_VkAabbPositionsKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkAabbPositionsKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -12741,17 +10502,15 @@
*count += sizeof(float);
}
-void count_VkAccelerationStructureInstanceKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureInstanceKHR* toCount,
- size_t* count)
-{
+void count_VkAccelerationStructureInstanceKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureInstanceKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
- count_VkTransformMatrixKHR(featureBits, rootType, (VkTransformMatrixKHR*)(&toCount->transform), count);
+ count_VkTransformMatrixKHR(featureBits, rootType, (VkTransformMatrixKHR*)(&toCount->transform),
+ count);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
@@ -12762,18 +10521,14 @@
#endif
#ifdef VK_NV_representative_fragment_test
void count_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12781,18 +10536,14 @@
}
void count_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12802,18 +10553,14 @@
#endif
#ifdef VK_EXT_filter_cubic
void count_VkPhysicalDeviceImageViewImageFormatInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceImageViewImageFormatInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceImageViewImageFormatInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12821,18 +10568,14 @@
}
void count_VkFilterCubicImageViewImageFormatPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFilterCubicImageViewImageFormatPropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkFilterCubicImageViewImageFormatPropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12845,18 +10588,14 @@
#endif
#ifdef VK_EXT_global_priority
void count_VkDeviceQueueGlobalPriorityCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceQueueGlobalPriorityCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceQueueGlobalPriorityCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12865,44 +10604,35 @@
#endif
#ifdef VK_EXT_external_memory_host
-void count_VkImportMemoryHostPointerInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportMemoryHostPointerInfoEXT* toCount,
- size_t* count)
-{
+void count_VkImportMemoryHostPointerInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkImportMemoryHostPointerInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkExternalMemoryHandleTypeFlagBits);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pHostPointer)
- {
+ if (toCount->pHostPointer) {
*count += sizeof(uint8_t);
}
}
-void count_VkMemoryHostPointerPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryHostPointerPropertiesEXT* toCount,
- size_t* count)
-{
+void count_VkMemoryHostPointerPropertiesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryHostPointerPropertiesEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12910,18 +10640,14 @@
}
void count_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12933,18 +10659,14 @@
#endif
#ifdef VK_AMD_pipeline_compiler_control
void count_VkPipelineCompilerControlCreateInfoAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineCompilerControlCreateInfoAMD* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineCompilerControlCreateInfoAMD* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12953,19 +10675,15 @@
#endif
#ifdef VK_EXT_calibrated_timestamps
-void count_VkCalibratedTimestampInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCalibratedTimestampInfoEXT* toCount,
- size_t* count)
-{
+void count_VkCalibratedTimestampInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkCalibratedTimestampInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -12975,18 +10693,14 @@
#endif
#ifdef VK_AMD_shader_core_properties
void count_VkPhysicalDeviceShaderCorePropertiesAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderCorePropertiesAMD* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderCorePropertiesAMD* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13008,116 +10722,94 @@
#endif
#ifdef VK_EXT_video_decode_h265
-void count_VkVideoDecodeH265ProfileEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH265ProfileEXT* toCount,
- size_t* count)
-{
+void count_VkVideoDecodeH265ProfileEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH265ProfileEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(StdVideoH265ProfileIdc);
}
-void count_VkVideoDecodeH265CapabilitiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH265CapabilitiesEXT* toCount,
- size_t* count)
-{
+void count_VkVideoDecodeH265CapabilitiesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH265CapabilitiesEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- count_VkExtensionProperties(featureBits, rootType, (VkExtensionProperties*)(&toCount->stdExtensionVersion), count);
+ count_VkExtensionProperties(featureBits, rootType,
+ (VkExtensionProperties*)(&toCount->stdExtensionVersion), count);
}
void count_VkVideoDecodeH265SessionCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH265SessionCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH265SessionCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkVideoDecodeH265CreateFlagsEXT);
- count_VkExtensionProperties(featureBits, rootType, (const VkExtensionProperties*)(toCount->pStdExtensionVersion), count);
+ count_VkExtensionProperties(featureBits, rootType,
+ (const VkExtensionProperties*)(toCount->pStdExtensionVersion),
+ count);
}
void count_VkVideoDecodeH265SessionParametersAddInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH265SessionParametersAddInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH265SessionParametersAddInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pSpsStd)
- {
- if (toCount)
- {
+ if (toCount->pSpsStd) {
+ if (toCount) {
*count += toCount->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet);
}
}
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pPpsStd)
- {
- if (toCount)
- {
+ if (toCount->pPpsStd) {
+ if (toCount) {
*count += toCount->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet);
}
}
}
void count_VkVideoDecodeH265SessionParametersCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH265SessionParametersCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH265SessionParametersCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13125,49 +10817,42 @@
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pParametersAddInfo)
- {
- count_VkVideoDecodeH265SessionParametersAddInfoEXT(featureBits, rootType, (const VkVideoDecodeH265SessionParametersAddInfoEXT*)(toCount->pParametersAddInfo), count);
+ if (toCount->pParametersAddInfo) {
+ count_VkVideoDecodeH265SessionParametersAddInfoEXT(
+ featureBits, rootType,
+ (const VkVideoDecodeH265SessionParametersAddInfoEXT*)(toCount->pParametersAddInfo),
+ count);
}
}
-void count_VkVideoDecodeH265PictureInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH265PictureInfoEXT* toCount,
- size_t* count)
-{
+void count_VkVideoDecodeH265PictureInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH265PictureInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(StdVideoDecodeH265PictureInfo);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->slicesCount * sizeof(const uint32_t);
}
}
-void count_VkVideoDecodeH265DpbSlotInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH265DpbSlotInfoEXT* toCount,
- size_t* count)
-{
+void count_VkVideoDecodeH265DpbSlotInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH265DpbSlotInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13177,18 +10862,14 @@
#endif
#ifdef VK_AMD_memory_overallocation_behavior
void count_VkDeviceMemoryOverallocationCreateInfoAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceMemoryOverallocationCreateInfoAMD* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceMemoryOverallocationCreateInfoAMD* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13198,18 +10879,14 @@
#endif
#ifdef VK_EXT_vertex_attribute_divisor
void count_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13217,11 +10894,8 @@
}
void count_VkVertexInputBindingDivisorDescriptionEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVertexInputBindingDivisorDescriptionEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVertexInputBindingDivisorDescriptionEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -13231,44 +10905,38 @@
}
void count_VkPipelineVertexInputDivisorStateCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineVertexInputDivisorStateCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineVertexInputDivisorStateCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->vertexBindingDivisorCount; ++i)
- {
- count_VkVertexInputBindingDivisorDescriptionEXT(featureBits, rootType, (const VkVertexInputBindingDivisorDescriptionEXT*)(toCount->pVertexBindingDivisors + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->vertexBindingDivisorCount; ++i) {
+ count_VkVertexInputBindingDivisorDescriptionEXT(
+ featureBits, rootType,
+ (const VkVertexInputBindingDivisorDescriptionEXT*)(toCount->pVertexBindingDivisors +
+ i),
+ count);
}
}
}
void count_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13278,19 +10946,14 @@
#endif
#ifdef VK_GGP_frame_token
-void count_VkPresentFrameTokenGGP(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPresentFrameTokenGGP* toCount,
- size_t* count)
-{
+void count_VkPresentFrameTokenGGP(uint32_t featureBits, VkStructureType rootType,
+ const VkPresentFrameTokenGGP* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13299,12 +10962,9 @@
#endif
#ifdef VK_EXT_pipeline_creation_feedback
-void count_VkPipelineCreationFeedbackEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineCreationFeedbackEXT* toCount,
- size_t* count)
-{
+void count_VkPipelineCreationFeedbackEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineCreationFeedbackEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -13314,28 +10974,27 @@
}
void count_VkPipelineCreationFeedbackCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineCreationFeedbackCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineCreationFeedbackCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkPipelineCreationFeedbackEXT(featureBits, rootType, (VkPipelineCreationFeedbackEXT*)(toCount->pPipelineCreationFeedback), count);
+ count_VkPipelineCreationFeedbackEXT(
+ featureBits, rootType, (VkPipelineCreationFeedbackEXT*)(toCount->pPipelineCreationFeedback),
+ count);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->pipelineStageCreationFeedbackCount; ++i)
- {
- count_VkPipelineCreationFeedbackEXT(featureBits, rootType, (VkPipelineCreationFeedbackEXT*)(toCount->pPipelineStageCreationFeedbacks + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->pipelineStageCreationFeedbackCount; ++i) {
+ count_VkPipelineCreationFeedbackEXT(
+ featureBits, rootType,
+ (VkPipelineCreationFeedbackEXT*)(toCount->pPipelineStageCreationFeedbacks + i),
+ count);
}
}
}
@@ -13345,18 +11004,14 @@
#endif
#ifdef VK_NV_compute_shader_derivatives
void count_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13366,19 +11021,15 @@
#endif
#ifdef VK_NV_mesh_shader
-void count_VkPhysicalDeviceMeshShaderFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMeshShaderFeaturesNV* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceMeshShaderFeaturesNV(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMeshShaderFeaturesNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13387,18 +11038,14 @@
}
void count_VkPhysicalDeviceMeshShaderPropertiesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMeshShaderPropertiesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMeshShaderPropertiesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13417,12 +11064,9 @@
*count += sizeof(uint32_t);
}
-void count_VkDrawMeshTasksIndirectCommandNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDrawMeshTasksIndirectCommandNV* toCount,
- size_t* count)
-{
+void count_VkDrawMeshTasksIndirectCommandNV(uint32_t featureBits, VkStructureType rootType,
+ const VkDrawMeshTasksIndirectCommandNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -13434,18 +11078,14 @@
#endif
#ifdef VK_NV_fragment_shader_barycentric
void count_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13455,18 +11095,14 @@
#endif
#ifdef VK_NV_shader_image_footprint
void count_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderImageFootprintFeaturesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderImageFootprintFeaturesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13476,49 +11112,39 @@
#endif
#ifdef VK_NV_scissor_exclusive
void count_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineViewportExclusiveScissorStateCreateInfoNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineViewportExclusiveScissorStateCreateInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pExclusiveScissors)
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->exclusiveScissorCount; ++i)
- {
- count_VkRect2D(featureBits, rootType, (const VkRect2D*)(toCount->pExclusiveScissors + i), count);
+ if (toCount->pExclusiveScissors) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->exclusiveScissorCount; ++i) {
+ count_VkRect2D(featureBits, rootType,
+ (const VkRect2D*)(toCount->pExclusiveScissors + i), count);
}
}
}
}
void count_VkPhysicalDeviceExclusiveScissorFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceExclusiveScissorFeaturesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceExclusiveScissorFeaturesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13527,46 +11153,36 @@
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
-void count_VkQueueFamilyCheckpointPropertiesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkQueueFamilyCheckpointPropertiesNV* toCount,
- size_t* count)
-{
+void count_VkQueueFamilyCheckpointPropertiesNV(uint32_t featureBits, VkStructureType rootType,
+ const VkQueueFamilyCheckpointPropertiesNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineStageFlags);
}
-void count_VkCheckpointDataNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCheckpointDataNV* toCount,
- size_t* count)
-{
+void count_VkCheckpointDataNV(uint32_t featureBits, VkStructureType rootType,
+ const VkCheckpointDataNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineStageFlagBits);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pCheckpointMarker)
- {
+ if (toCount->pCheckpointMarker) {
*count += sizeof(uint8_t);
}
}
@@ -13574,18 +11190,14 @@
#endif
#ifdef VK_INTEL_shader_integer_functions2
void count_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13594,12 +11206,8 @@
#endif
#ifdef VK_INTEL_performance_query
-void count_VkPerformanceValueDataINTEL(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPerformanceValueDataINTEL* toCount,
- size_t* count)
-{
+void count_VkPerformanceValueDataINTEL(uint32_t featureBits, VkStructureType rootType,
+ const VkPerformanceValueDataINTEL* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -13607,114 +11215,90 @@
*count += sizeof(uint32_t);
}
-void count_VkPerformanceValueINTEL(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPerformanceValueINTEL* toCount,
- size_t* count)
-{
+void count_VkPerformanceValueINTEL(uint32_t featureBits, VkStructureType rootType,
+ const VkPerformanceValueINTEL* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkPerformanceValueTypeINTEL);
- count_VkPerformanceValueDataINTEL(featureBits, rootType, (VkPerformanceValueDataINTEL*)(&toCount->data), count);
+ count_VkPerformanceValueDataINTEL(featureBits, rootType,
+ (VkPerformanceValueDataINTEL*)(&toCount->data), count);
}
-void count_VkInitializePerformanceApiInfoINTEL(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkInitializePerformanceApiInfoINTEL* toCount,
- size_t* count)
-{
+void count_VkInitializePerformanceApiInfoINTEL(uint32_t featureBits, VkStructureType rootType,
+ const VkInitializePerformanceApiInfoINTEL* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pUserData)
- {
+ if (toCount->pUserData) {
*count += sizeof(uint8_t);
}
}
void count_VkQueryPoolPerformanceQueryCreateInfoINTEL(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkQueryPoolPerformanceQueryCreateInfoINTEL* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkQueryPoolPerformanceQueryCreateInfoINTEL* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkQueryPoolSamplingModeINTEL);
}
-void count_VkPerformanceMarkerInfoINTEL(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPerformanceMarkerInfoINTEL* toCount,
- size_t* count)
-{
+void count_VkPerformanceMarkerInfoINTEL(uint32_t featureBits, VkStructureType rootType,
+ const VkPerformanceMarkerInfoINTEL* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint64_t);
}
-void count_VkPerformanceStreamMarkerInfoINTEL(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPerformanceStreamMarkerInfoINTEL* toCount,
- size_t* count)
-{
+void count_VkPerformanceStreamMarkerInfoINTEL(uint32_t featureBits, VkStructureType rootType,
+ const VkPerformanceStreamMarkerInfoINTEL* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
-void count_VkPerformanceOverrideInfoINTEL(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPerformanceOverrideInfoINTEL* toCount,
- size_t* count)
-{
+void count_VkPerformanceOverrideInfoINTEL(uint32_t featureBits, VkStructureType rootType,
+ const VkPerformanceOverrideInfoINTEL* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13724,18 +11308,14 @@
}
void count_VkPerformanceConfigurationAcquireInfoINTEL(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPerformanceConfigurationAcquireInfoINTEL* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPerformanceConfigurationAcquireInfoINTEL* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13745,18 +11325,14 @@
#endif
#ifdef VK_EXT_pci_bus_info
void count_VkPhysicalDevicePCIBusInfoPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePCIBusInfoPropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePCIBusInfoPropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13769,18 +11345,14 @@
#endif
#ifdef VK_AMD_display_native_hdr
void count_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayNativeHdrSurfaceCapabilitiesAMD* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayNativeHdrSurfaceCapabilitiesAMD* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13788,18 +11360,14 @@
}
void count_VkSwapchainDisplayNativeHdrCreateInfoAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSwapchainDisplayNativeHdrCreateInfoAMD* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkSwapchainDisplayNativeHdrCreateInfoAMD* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13808,19 +11376,15 @@
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
-void count_VkImagePipeSurfaceCreateInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImagePipeSurfaceCreateInfoFUCHSIA* toCount,
- size_t* count)
-{
+void count_VkImagePipeSurfaceCreateInfoFUCHSIA(uint32_t featureBits, VkStructureType rootType,
+ const VkImagePipeSurfaceCreateInfoFUCHSIA* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13830,27 +11394,21 @@
#endif
#ifdef VK_EXT_metal_surface
-void count_VkMetalSurfaceCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMetalSurfaceCreateInfoEXT* toCount,
- size_t* count)
-{
+void count_VkMetalSurfaceCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkMetalSurfaceCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkMetalSurfaceCreateFlagsEXT);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pLayer)
- {
+ if (toCount->pLayer) {
*count += sizeof(const CAMetalLayer);
}
}
@@ -13858,18 +11416,14 @@
#endif
#ifdef VK_EXT_fragment_density_map
void count_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13879,43 +11433,39 @@
}
void count_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->minFragmentDensityTexelSize), count);
- count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->maxFragmentDensityTexelSize), count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->minFragmentDensityTexelSize),
+ count);
+ count_VkExtent2D(featureBits, rootType, (VkExtent2D*)(&toCount->maxFragmentDensityTexelSize),
+ count);
*count += sizeof(VkBool32);
}
void count_VkRenderPassFragmentDensityMapCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderPassFragmentDensityMapCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkRenderPassFragmentDensityMapCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkAttachmentReference(featureBits, rootType, (VkAttachmentReference*)(&toCount->fragmentDensityMapAttachment), count);
+ count_VkAttachmentReference(featureBits, rootType,
+ (VkAttachmentReference*)(&toCount->fragmentDensityMapAttachment),
+ count);
}
#endif
@@ -13927,18 +11477,14 @@
#endif
#ifdef VK_EXT_subgroup_size_control
void count_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13947,18 +11493,14 @@
}
void count_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13969,18 +11511,14 @@
}
void count_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -13990,18 +11528,14 @@
#endif
#ifdef VK_AMD_shader_core_properties2
void count_VkPhysicalDeviceShaderCoreProperties2AMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderCoreProperties2AMD* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderCoreProperties2AMD* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14012,18 +11546,14 @@
#endif
#ifdef VK_AMD_device_coherent_memory
void count_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceCoherentMemoryFeaturesAMD* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceCoherentMemoryFeaturesAMD* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14033,18 +11563,14 @@
#endif
#ifdef VK_EXT_shader_image_atomic_int64
void count_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14055,18 +11581,14 @@
#endif
#ifdef VK_EXT_memory_budget
void count_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryBudgetPropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryBudgetPropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14077,37 +11599,29 @@
#endif
#ifdef VK_EXT_memory_priority
void count_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryPriorityFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryPriorityFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
-void count_VkMemoryPriorityAllocateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryPriorityAllocateInfoEXT* toCount,
- size_t* count)
-{
+void count_VkMemoryPriorityAllocateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryPriorityAllocateInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14117,18 +11631,14 @@
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
void count_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14138,18 +11648,14 @@
#endif
#ifdef VK_EXT_buffer_device_address
void count_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14158,19 +11664,15 @@
*count += sizeof(VkBool32);
}
-void count_VkBufferDeviceAddressCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferDeviceAddressCreateInfoEXT* toCount,
- size_t* count)
-{
+void count_VkBufferDeviceAddressCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferDeviceAddressCreateInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14179,19 +11681,15 @@
#endif
#ifdef VK_EXT_tooling_info
-void count_VkPhysicalDeviceToolPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceToolPropertiesEXT* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceToolPropertiesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceToolPropertiesEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14206,49 +11704,40 @@
#ifdef VK_EXT_separate_stencil_usage
#endif
#ifdef VK_EXT_validation_features
-void count_VkValidationFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkValidationFeaturesEXT* toCount,
- size_t* count)
-{
+void count_VkValidationFeaturesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkValidationFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount)
- {
- *count += toCount->enabledValidationFeatureCount * sizeof(const VkValidationFeatureEnableEXT);
+ if (toCount) {
+ *count +=
+ toCount->enabledValidationFeatureCount * sizeof(const VkValidationFeatureEnableEXT);
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- *count += toCount->disabledValidationFeatureCount * sizeof(const VkValidationFeatureDisableEXT);
+ if (toCount) {
+ *count +=
+ toCount->disabledValidationFeatureCount * sizeof(const VkValidationFeatureDisableEXT);
}
}
#endif
#ifdef VK_NV_cooperative_matrix
-void count_VkCooperativeMatrixPropertiesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCooperativeMatrixPropertiesNV* toCount,
- size_t* count)
-{
+void count_VkCooperativeMatrixPropertiesNV(uint32_t featureBits, VkStructureType rootType,
+ const VkCooperativeMatrixPropertiesNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14263,18 +11752,14 @@
}
void count_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceCooperativeMatrixFeaturesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceCooperativeMatrixFeaturesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14283,18 +11768,14 @@
}
void count_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceCooperativeMatrixPropertiesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceCooperativeMatrixPropertiesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14304,18 +11785,14 @@
#endif
#ifdef VK_NV_coverage_reduction_mode
void count_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceCoverageReductionModeFeaturesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceCoverageReductionModeFeaturesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14323,18 +11800,14 @@
}
void count_VkPipelineCoverageReductionStateCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineCoverageReductionStateCreateInfoNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineCoverageReductionStateCreateInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14343,18 +11816,14 @@
}
void count_VkFramebufferMixedSamplesCombinationNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFramebufferMixedSamplesCombinationNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkFramebufferMixedSamplesCombinationNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14367,18 +11836,14 @@
#endif
#ifdef VK_EXT_fragment_shader_interlock
void count_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14390,18 +11855,14 @@
#endif
#ifdef VK_EXT_ycbcr_image_arrays
void count_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14411,18 +11872,14 @@
#endif
#ifdef VK_EXT_provoking_vertex
void count_VkPhysicalDeviceProvokingVertexFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceProvokingVertexFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceProvokingVertexFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14431,18 +11888,14 @@
}
void count_VkPhysicalDeviceProvokingVertexPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceProvokingVertexPropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceProvokingVertexPropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14451,18 +11904,14 @@
}
void count_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14471,19 +11920,15 @@
#endif
#ifdef VK_EXT_full_screen_exclusive
-void count_VkSurfaceFullScreenExclusiveInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSurfaceFullScreenExclusiveInfoEXT* toCount,
- size_t* count)
-{
+void count_VkSurfaceFullScreenExclusiveInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkSurfaceFullScreenExclusiveInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14491,18 +11936,14 @@
}
void count_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSurfaceCapabilitiesFullScreenExclusiveEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkSurfaceCapabilitiesFullScreenExclusiveEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14510,18 +11951,14 @@
}
void count_VkSurfaceFullScreenExclusiveWin32InfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSurfaceFullScreenExclusiveWin32InfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkSurfaceFullScreenExclusiveWin32InfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14530,19 +11967,15 @@
#endif
#ifdef VK_EXT_headless_surface
-void count_VkHeadlessSurfaceCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkHeadlessSurfaceCreateInfoEXT* toCount,
- size_t* count)
-{
+void count_VkHeadlessSurfaceCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkHeadlessSurfaceCreateInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14552,18 +11985,14 @@
#endif
#ifdef VK_EXT_line_rasterization
void count_VkPhysicalDeviceLineRasterizationFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14576,18 +12005,14 @@
}
void count_VkPhysicalDeviceLineRasterizationPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationPropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationPropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14595,18 +12020,14 @@
}
void count_VkPipelineRasterizationLineStateCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineRasterizationLineStateCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRasterizationLineStateCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14619,18 +12040,14 @@
#endif
#ifdef VK_EXT_shader_atomic_float
void count_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14653,18 +12070,14 @@
#endif
#ifdef VK_EXT_index_type_uint8
void count_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14674,18 +12087,14 @@
#endif
#ifdef VK_EXT_extended_dynamic_state
void count_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14695,18 +12104,14 @@
#endif
#ifdef VK_EXT_shader_atomic_float2
void count_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14727,18 +12132,14 @@
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
void count_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14748,18 +12149,14 @@
#endif
#ifdef VK_NV_device_generated_commands
void count_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14775,99 +12172,85 @@
}
void count_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
-void count_VkGraphicsShaderGroupCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkGraphicsShaderGroupCreateInfoNV* toCount,
- size_t* count)
-{
+void count_VkGraphicsShaderGroupCreateInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkGraphicsShaderGroupCreateInfoNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->stageCount; ++i)
- {
- count_VkPipelineShaderStageCreateInfo(featureBits, rootType, (const VkPipelineShaderStageCreateInfo*)(toCount->pStages + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->stageCount; ++i) {
+ count_VkPipelineShaderStageCreateInfo(
+ featureBits, rootType,
+ (const VkPipelineShaderStageCreateInfo*)(toCount->pStages + i), count);
}
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->pVertexInputState)
- {
- count_VkPipelineVertexInputStateCreateInfo(featureBits, rootType, (const VkPipelineVertexInputStateCreateInfo*)(toCount->pVertexInputState), count);
+ if (toCount->pVertexInputState) {
+ count_VkPipelineVertexInputStateCreateInfo(
+ featureBits, rootType,
+ (const VkPipelineVertexInputStateCreateInfo*)(toCount->pVertexInputState), count);
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->pTessellationState)
- {
- count_VkPipelineTessellationStateCreateInfo(featureBits, rootType, (const VkPipelineTessellationStateCreateInfo*)(toCount->pTessellationState), count);
+ if (toCount->pTessellationState) {
+ count_VkPipelineTessellationStateCreateInfo(
+ featureBits, rootType,
+ (const VkPipelineTessellationStateCreateInfo*)(toCount->pTessellationState), count);
}
}
void count_VkGraphicsPipelineShaderGroupsCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkGraphicsPipelineShaderGroupsCreateInfoNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkGraphicsPipelineShaderGroupsCreateInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->groupCount; ++i)
- {
- count_VkGraphicsShaderGroupCreateInfoNV(featureBits, rootType, (const VkGraphicsShaderGroupCreateInfoNV*)(toCount->pGroups + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->groupCount; ++i) {
+ count_VkGraphicsShaderGroupCreateInfoNV(
+ featureBits, rootType,
+ (const VkGraphicsShaderGroupCreateInfoNV*)(toCount->pGroups + i), count);
}
}
*count += sizeof(uint32_t);
- if (toCount->pipelineCount)
- {
+ if (toCount->pipelineCount) {
*count += toCount->pipelineCount * 8;
}
}
-void count_VkBindShaderGroupIndirectCommandNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindShaderGroupIndirectCommandNV* toCount,
- size_t* count)
-{
+void count_VkBindShaderGroupIndirectCommandNV(uint32_t featureBits, VkStructureType rootType,
+ const VkBindShaderGroupIndirectCommandNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -14875,12 +12258,9 @@
*count += sizeof(uint32_t);
}
-void count_VkBindIndexBufferIndirectCommandNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindIndexBufferIndirectCommandNV* toCount,
- size_t* count)
-{
+void count_VkBindIndexBufferIndirectCommandNV(uint32_t featureBits, VkStructureType rootType,
+ const VkBindIndexBufferIndirectCommandNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -14890,12 +12270,9 @@
*count += sizeof(VkIndexType);
}
-void count_VkBindVertexBufferIndirectCommandNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindVertexBufferIndirectCommandNV* toCount,
- size_t* count)
-{
+void count_VkBindVertexBufferIndirectCommandNV(uint32_t featureBits, VkStructureType rootType,
+ const VkBindVertexBufferIndirectCommandNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -14905,12 +12282,9 @@
*count += sizeof(uint32_t);
}
-void count_VkSetStateFlagsIndirectCommandNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSetStateFlagsIndirectCommandNV* toCount,
- size_t* count)
-{
+void count_VkSetStateFlagsIndirectCommandNV(uint32_t featureBits, VkStructureType rootType,
+ const VkSetStateFlagsIndirectCommandNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -14918,12 +12292,8 @@
*count += sizeof(uint32_t);
}
-void count_VkIndirectCommandsStreamNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkIndirectCommandsStreamNV* toCount,
- size_t* count)
-{
+void count_VkIndirectCommandsStreamNV(uint32_t featureBits, VkStructureType rootType,
+ const VkIndirectCommandsStreamNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -14933,19 +12303,15 @@
*count += sizeof(VkDeviceSize);
}
-void count_VkIndirectCommandsLayoutTokenNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkIndirectCommandsLayoutTokenNV* toCount,
- size_t* count)
-{
+void count_VkIndirectCommandsLayoutTokenNV(uint32_t featureBits, VkStructureType rootType,
+ const VkIndirectCommandsLayoutTokenNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -14961,62 +12327,50 @@
*count += sizeof(uint32_t);
*count += sizeof(VkIndirectStateFlagsNV);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->indexTypeCount * sizeof(const VkIndexType);
}
- if (toCount)
- {
+ if (toCount) {
*count += toCount->indexTypeCount * sizeof(const uint32_t);
}
}
-void count_VkIndirectCommandsLayoutCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkIndirectCommandsLayoutCreateInfoNV* toCount,
- size_t* count)
-{
+void count_VkIndirectCommandsLayoutCreateInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkIndirectCommandsLayoutCreateInfoNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkIndirectCommandsLayoutUsageFlagsNV);
*count += sizeof(VkPipelineBindPoint);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->tokenCount; ++i)
- {
- count_VkIndirectCommandsLayoutTokenNV(featureBits, rootType, (const VkIndirectCommandsLayoutTokenNV*)(toCount->pTokens + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->tokenCount; ++i) {
+ count_VkIndirectCommandsLayoutTokenNV(
+ featureBits, rootType,
+ (const VkIndirectCommandsLayoutTokenNV*)(toCount->pTokens + i), count);
}
}
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->streamCount * sizeof(const uint32_t);
}
}
-void count_VkGeneratedCommandsInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkGeneratedCommandsInfoNV* toCount,
- size_t* count)
-{
+void count_VkGeneratedCommandsInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkGeneratedCommandsInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15026,11 +12380,11 @@
uint64_t cgen_var_1;
*count += 1 * 8;
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->streamCount; ++i)
- {
- count_VkIndirectCommandsStreamNV(featureBits, rootType, (const VkIndirectCommandsStreamNV*)(toCount->pStreams + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->streamCount; ++i) {
+ count_VkIndirectCommandsStreamNV(
+ featureBits, rootType, (const VkIndirectCommandsStreamNV*)(toCount->pStreams + i),
+ count);
}
}
*count += sizeof(uint32_t);
@@ -15047,18 +12401,14 @@
}
void count_VkGeneratedCommandsMemoryRequirementsInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkGeneratedCommandsMemoryRequirementsInfoNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkGeneratedCommandsMemoryRequirementsInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15073,18 +12423,14 @@
#endif
#ifdef VK_NV_inherited_viewport_scissor
void count_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15092,18 +12438,14 @@
}
void count_VkCommandBufferInheritanceViewportScissorInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCommandBufferInheritanceViewportScissorInfoNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkCommandBufferInheritanceViewportScissorInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15111,27 +12453,23 @@
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pViewportDepths)
- {
- count_VkViewport(featureBits, rootType, (const VkViewport*)(toCount->pViewportDepths), count);
+ if (toCount->pViewportDepths) {
+ count_VkViewport(featureBits, rootType, (const VkViewport*)(toCount->pViewportDepths),
+ count);
}
}
#endif
#ifdef VK_EXT_texel_buffer_alignment
void count_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15139,18 +12477,14 @@
}
void count_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15162,19 +12496,15 @@
#endif
#ifdef VK_QCOM_render_pass_transform
-void count_VkRenderPassTransformBeginInfoQCOM(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderPassTransformBeginInfoQCOM* toCount,
- size_t* count)
-{
+void count_VkRenderPassTransformBeginInfoQCOM(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderPassTransformBeginInfoQCOM* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15182,18 +12512,14 @@
}
void count_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15204,37 +12530,29 @@
#endif
#ifdef VK_EXT_device_memory_report
void count_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
-void count_VkDeviceMemoryReportCallbackDataEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceMemoryReportCallbackDataEXT* toCount,
- size_t* count)
-{
+void count_VkDeviceMemoryReportCallbackDataEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceMemoryReportCallbackDataEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15248,18 +12566,14 @@
}
void count_VkDeviceDeviceMemoryReportCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceDeviceMemoryReportCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceDeviceMemoryReportCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15273,18 +12587,14 @@
#endif
#ifdef VK_EXT_robustness2
void count_VkPhysicalDeviceRobustness2FeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceRobustness2FeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceRobustness2FeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15294,18 +12604,14 @@
}
void count_VkPhysicalDeviceRobustness2PropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceRobustness2PropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceRobustness2PropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15316,38 +12622,31 @@
#endif
#ifdef VK_EXT_custom_border_color
void count_VkSamplerCustomBorderColorCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSamplerCustomBorderColorCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkSamplerCustomBorderColorCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkClearColorValue(featureBits, rootType, (VkClearColorValue*)(&toCount->customBorderColor), count);
+ count_VkClearColorValue(featureBits, rootType,
+ (VkClearColorValue*)(&toCount->customBorderColor), count);
*count += sizeof(VkFormat);
}
void count_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceCustomBorderColorPropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceCustomBorderColorPropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15355,18 +12654,14 @@
}
void count_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceCustomBorderColorFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceCustomBorderColorFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15379,56 +12674,44 @@
#endif
#ifdef VK_EXT_private_data
void count_VkPhysicalDevicePrivateDataFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePrivateDataFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePrivateDataFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
-void count_VkDevicePrivateDataCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDevicePrivateDataCreateInfoEXT* toCount,
- size_t* count)
-{
+void count_VkDevicePrivateDataCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDevicePrivateDataCreateInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
-void count_VkPrivateDataSlotCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPrivateDataSlotCreateInfoEXT* toCount,
- size_t* count)
-{
+void count_VkPrivateDataSlotCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkPrivateDataSlotCreateInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15438,18 +12721,14 @@
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
void count_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15459,18 +12738,14 @@
#endif
#ifdef VK_NV_device_diagnostics_config
void count_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15478,18 +12753,14 @@
}
void count_VkDeviceDiagnosticsConfigCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceDiagnosticsConfigCreateInfoNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceDiagnosticsConfigCreateInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15501,18 +12772,14 @@
#endif
#ifdef VK_NV_fragment_shading_rate_enums
void count_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15522,18 +12789,14 @@
}
void count_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15541,18 +12804,14 @@
}
void count_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15563,12 +12822,9 @@
#endif
#ifdef VK_NV_ray_tracing_motion_blur
-void count_VkDeviceOrHostAddressConstKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceOrHostAddressConstKHR* toCount,
- size_t* count)
-{
+void count_VkDeviceOrHostAddressConstKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceOrHostAddressConstKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -15577,37 +12833,30 @@
}
void count_VkAccelerationStructureGeometryMotionTrianglesDataNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryMotionTrianglesDataNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureGeometryMotionTrianglesDataNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkDeviceOrHostAddressConstKHR(featureBits, rootType, (VkDeviceOrHostAddressConstKHR*)(&toCount->vertexData), count);
+ count_VkDeviceOrHostAddressConstKHR(
+ featureBits, rootType, (VkDeviceOrHostAddressConstKHR*)(&toCount->vertexData), count);
}
-void count_VkAccelerationStructureMotionInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureMotionInfoNV* toCount,
- size_t* count)
-{
+void count_VkAccelerationStructureMotionInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureMotionInfoNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15616,17 +12865,16 @@
}
void count_VkAccelerationStructureMatrixMotionInstanceNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureMatrixMotionInstanceNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureMatrixMotionInstanceNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
- count_VkTransformMatrixKHR(featureBits, rootType, (VkTransformMatrixKHR*)(&toCount->transformT0), count);
- count_VkTransformMatrixKHR(featureBits, rootType, (VkTransformMatrixKHR*)(&toCount->transformT1), count);
+ count_VkTransformMatrixKHR(featureBits, rootType,
+ (VkTransformMatrixKHR*)(&toCount->transformT0), count);
+ count_VkTransformMatrixKHR(featureBits, rootType,
+ (VkTransformMatrixKHR*)(&toCount->transformT1), count);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
*count += sizeof(uint32_t);
@@ -15634,12 +12882,8 @@
*count += sizeof(uint64_t);
}
-void count_VkSRTDataNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSRTDataNV* toCount,
- size_t* count)
-{
+void count_VkSRTDataNV(uint32_t featureBits, VkStructureType rootType, const VkSRTDataNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -15663,11 +12907,8 @@
}
void count_VkAccelerationStructureSRTMotionInstanceNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureSRTMotionInstanceNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureSRTMotionInstanceNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -15682,46 +12923,40 @@
}
void count_VkAccelerationStructureMotionInstanceDataNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureMotionInstanceDataNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureMotionInstanceDataNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
- count_VkAccelerationStructureInstanceKHR(featureBits, rootType, (VkAccelerationStructureInstanceKHR*)(&toCount->staticInstance), count);
+ count_VkAccelerationStructureInstanceKHR(
+ featureBits, rootType, (VkAccelerationStructureInstanceKHR*)(&toCount->staticInstance),
+ count);
}
void count_VkAccelerationStructureMotionInstanceNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureMotionInstanceNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureMotionInstanceNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkAccelerationStructureMotionInstanceTypeNV);
*count += sizeof(VkAccelerationStructureMotionInstanceFlagsNV);
- count_VkAccelerationStructureMotionInstanceDataNV(featureBits, rootType, (VkAccelerationStructureMotionInstanceDataNV*)(&toCount->data), count);
+ count_VkAccelerationStructureMotionInstanceDataNV(
+ featureBits, rootType, (VkAccelerationStructureMotionInstanceDataNV*)(&toCount->data),
+ count);
}
void count_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15732,18 +12967,14 @@
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
void count_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15753,18 +12984,14 @@
#endif
#ifdef VK_EXT_fragment_density_map2
void count_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15772,18 +12999,14 @@
}
void count_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15795,19 +13018,15 @@
#endif
#ifdef VK_QCOM_rotated_copy_commands
-void count_VkCopyCommandTransformInfoQCOM(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCopyCommandTransformInfoQCOM* toCount,
- size_t* count)
-{
+void count_VkCopyCommandTransformInfoQCOM(uint32_t featureBits, VkStructureType rootType,
+ const VkCopyCommandTransformInfoQCOM* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15817,18 +13036,14 @@
#endif
#ifdef VK_EXT_image_robustness
void count_VkPhysicalDeviceImageRobustnessFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceImageRobustnessFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceImageRobustnessFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15838,18 +13053,14 @@
#endif
#ifdef VK_EXT_4444_formats
void count_VkPhysicalDevice4444FormatsFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevice4444FormatsFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevice4444FormatsFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15860,18 +13071,14 @@
#endif
#ifdef VK_EXT_rgba10x6_formats
void count_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -15882,33 +13089,27 @@
#ifdef VK_NV_acquire_winrt_display
#endif
#ifdef VK_EXT_directfb_surface
-void count_VkDirectFBSurfaceCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDirectFBSurfaceCreateInfoEXT* toCount,
- size_t* count)
-{
+void count_VkDirectFBSurfaceCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDirectFBSurfaceCreateInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkDirectFBSurfaceCreateFlagsEXT);
// WARNING PTR CHECK
*count += 8;
- if (toCount->dfb)
- {
+ if (toCount->dfb) {
*count += sizeof(IDirectFB);
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->surface)
- {
+ if (toCount->surface) {
*count += sizeof(IDirectFBSurface);
}
}
@@ -15916,63 +13117,52 @@
#endif
#ifdef VK_VALVE_mutable_descriptor_type
void count_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
-void count_VkMutableDescriptorTypeListVALVE(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMutableDescriptorTypeListVALVE* toCount,
- size_t* count)
-{
+void count_VkMutableDescriptorTypeListVALVE(uint32_t featureBits, VkStructureType rootType,
+ const VkMutableDescriptorTypeListVALVE* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->descriptorTypeCount * sizeof(const VkDescriptorType);
}
}
void count_VkMutableDescriptorTypeCreateInfoVALVE(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMutableDescriptorTypeCreateInfoVALVE* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkMutableDescriptorTypeCreateInfoVALVE* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->mutableDescriptorTypeListCount; ++i)
- {
- count_VkMutableDescriptorTypeListVALVE(featureBits, rootType, (const VkMutableDescriptorTypeListVALVE*)(toCount->pMutableDescriptorTypeLists + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->mutableDescriptorTypeListCount; ++i) {
+ count_VkMutableDescriptorTypeListVALVE(
+ featureBits, rootType,
+ (const VkMutableDescriptorTypeListVALVE*)(toCount->pMutableDescriptorTypeLists + i),
+ count);
}
}
}
@@ -15980,37 +13170,29 @@
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
void count_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
-void count_VkVertexInputBindingDescription2EXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVertexInputBindingDescription2EXT* toCount,
- size_t* count)
-{
+void count_VkVertexInputBindingDescription2EXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVertexInputBindingDescription2EXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16021,18 +13203,14 @@
}
void count_VkVertexInputAttributeDescription2EXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVertexInputAttributeDescription2EXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVertexInputAttributeDescription2EXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16044,19 +13222,15 @@
#endif
#ifdef VK_EXT_physical_device_drm
-void count_VkPhysicalDeviceDrmPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDrmPropertiesEXT* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceDrmPropertiesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDrmPropertiesEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16071,18 +13245,14 @@
#endif
#ifdef VK_EXT_primitive_topology_list_restart
void count_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16093,18 +13263,14 @@
#endif
#ifdef VK_FUCHSIA_external_memory
void count_VkImportMemoryZirconHandleInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportMemoryZirconHandleInfoFUCHSIA* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkImportMemoryZirconHandleInfoFUCHSIA* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16113,37 +13279,29 @@
}
void count_VkMemoryZirconHandlePropertiesFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryZirconHandlePropertiesFUCHSIA* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryZirconHandlePropertiesFUCHSIA* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
-void count_VkMemoryGetZirconHandleInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryGetZirconHandleInfoFUCHSIA* toCount,
- size_t* count)
-{
+void count_VkMemoryGetZirconHandleInfoFUCHSIA(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16155,18 +13313,14 @@
#endif
#ifdef VK_FUCHSIA_external_semaphore
void count_VkImportSemaphoreZirconHandleInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportSemaphoreZirconHandleInfoFUCHSIA* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16178,18 +13332,14 @@
}
void count_VkSemaphoreGetZirconHandleInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSemaphoreGetZirconHandleInfoFUCHSIA* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16200,19 +13350,15 @@
#endif
#ifdef VK_FUCHSIA_buffer_collection
-void count_VkBufferCollectionCreateInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferCollectionCreateInfoFUCHSIA* toCount,
- size_t* count)
-{
+void count_VkBufferCollectionCreateInfoFUCHSIA(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferCollectionCreateInfoFUCHSIA* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16220,18 +13366,14 @@
}
void count_VkImportMemoryBufferCollectionFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportMemoryBufferCollectionFUCHSIA* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkImportMemoryBufferCollectionFUCHSIA* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16240,18 +13382,14 @@
}
void count_VkBufferCollectionImageCreateInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferCollectionImageCreateInfoFUCHSIA* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkBufferCollectionImageCreateInfoFUCHSIA* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16260,18 +13398,14 @@
}
void count_VkBufferCollectionConstraintsInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferCollectionConstraintsInfoFUCHSIA* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkBufferCollectionConstraintsInfoFUCHSIA* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16282,40 +13416,35 @@
*count += sizeof(uint32_t);
}
-void count_VkBufferConstraintsInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferConstraintsInfoFUCHSIA* toCount,
- size_t* count)
-{
+void count_VkBufferConstraintsInfoFUCHSIA(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferConstraintsInfoFUCHSIA* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkBufferCreateInfo(featureBits, rootType, (VkBufferCreateInfo*)(&toCount->createInfo), count);
+ count_VkBufferCreateInfo(featureBits, rootType, (VkBufferCreateInfo*)(&toCount->createInfo),
+ count);
*count += sizeof(VkFormatFeatureFlags);
- count_VkBufferCollectionConstraintsInfoFUCHSIA(featureBits, rootType, (VkBufferCollectionConstraintsInfoFUCHSIA*)(&toCount->bufferCollectionConstraints), count);
+ count_VkBufferCollectionConstraintsInfoFUCHSIA(
+ featureBits, rootType,
+ (VkBufferCollectionConstraintsInfoFUCHSIA*)(&toCount->bufferCollectionConstraints), count);
}
void count_VkBufferCollectionBufferCreateInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferCollectionBufferCreateInfoFUCHSIA* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkBufferCollectionBufferCreateInfoFUCHSIA* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16323,38 +13452,29 @@
*count += sizeof(uint32_t);
}
-void count_VkSysmemColorSpaceFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSysmemColorSpaceFUCHSIA* toCount,
- size_t* count)
-{
+void count_VkSysmemColorSpaceFUCHSIA(uint32_t featureBits, VkStructureType rootType,
+ const VkSysmemColorSpaceFUCHSIA* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
-void count_VkBufferCollectionPropertiesFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferCollectionPropertiesFUCHSIA* toCount,
- size_t* count)
-{
+void count_VkBufferCollectionPropertiesFUCHSIA(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferCollectionPropertiesFUCHSIA* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16363,81 +13483,78 @@
*count += sizeof(uint32_t);
*count += sizeof(uint64_t);
*count += sizeof(VkFormatFeatureFlags);
- count_VkSysmemColorSpaceFUCHSIA(featureBits, rootType, (VkSysmemColorSpaceFUCHSIA*)(&toCount->sysmemColorSpaceIndex), count);
- count_VkComponentMapping(featureBits, rootType, (VkComponentMapping*)(&toCount->samplerYcbcrConversionComponents), count);
+ count_VkSysmemColorSpaceFUCHSIA(featureBits, rootType,
+ (VkSysmemColorSpaceFUCHSIA*)(&toCount->sysmemColorSpaceIndex),
+ count);
+ count_VkComponentMapping(featureBits, rootType,
+ (VkComponentMapping*)(&toCount->samplerYcbcrConversionComponents),
+ count);
*count += sizeof(VkSamplerYcbcrModelConversion);
*count += sizeof(VkSamplerYcbcrRange);
*count += sizeof(VkChromaLocation);
*count += sizeof(VkChromaLocation);
}
-void count_VkImageFormatConstraintsInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageFormatConstraintsInfoFUCHSIA* toCount,
- size_t* count)
-{
+void count_VkImageFormatConstraintsInfoFUCHSIA(uint32_t featureBits, VkStructureType rootType,
+ const VkImageFormatConstraintsInfoFUCHSIA* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkImageCreateInfo(featureBits, rootType, (VkImageCreateInfo*)(&toCount->imageCreateInfo), count);
+ count_VkImageCreateInfo(featureBits, rootType, (VkImageCreateInfo*)(&toCount->imageCreateInfo),
+ count);
*count += sizeof(VkFormatFeatureFlags);
*count += sizeof(VkImageFormatConstraintsFlagsFUCHSIA);
*count += sizeof(uint64_t);
*count += sizeof(uint32_t);
- count_VkSysmemColorSpaceFUCHSIA(featureBits, rootType, (const VkSysmemColorSpaceFUCHSIA*)(toCount->pColorSpaces), count);
+ count_VkSysmemColorSpaceFUCHSIA(
+ featureBits, rootType, (const VkSysmemColorSpaceFUCHSIA*)(toCount->pColorSpaces), count);
}
-void count_VkImageConstraintsInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageConstraintsInfoFUCHSIA* toCount,
- size_t* count)
-{
+void count_VkImageConstraintsInfoFUCHSIA(uint32_t featureBits, VkStructureType rootType,
+ const VkImageConstraintsInfoFUCHSIA* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->formatConstraintsCount; ++i)
- {
- count_VkImageFormatConstraintsInfoFUCHSIA(featureBits, rootType, (const VkImageFormatConstraintsInfoFUCHSIA*)(toCount->pFormatConstraints + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->formatConstraintsCount; ++i) {
+ count_VkImageFormatConstraintsInfoFUCHSIA(
+ featureBits, rootType,
+ (const VkImageFormatConstraintsInfoFUCHSIA*)(toCount->pFormatConstraints + i),
+ count);
}
}
- count_VkBufferCollectionConstraintsInfoFUCHSIA(featureBits, rootType, (VkBufferCollectionConstraintsInfoFUCHSIA*)(&toCount->bufferCollectionConstraints), count);
+ count_VkBufferCollectionConstraintsInfoFUCHSIA(
+ featureBits, rootType,
+ (VkBufferCollectionConstraintsInfoFUCHSIA*)(&toCount->bufferCollectionConstraints), count);
*count += sizeof(VkImageConstraintsInfoFlagsFUCHSIA);
}
#endif
#ifdef VK_HUAWEI_subpass_shading
void count_VkSubpassShadingPipelineCreateInfoHUAWEI(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubpassShadingPipelineCreateInfoHUAWEI* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkSubpassShadingPipelineCreateInfoHUAWEI* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16447,18 +13564,14 @@
}
void count_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16466,18 +13579,14 @@
}
void count_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16487,18 +13596,14 @@
#endif
#ifdef VK_HUAWEI_invocation_mask
void count_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16507,19 +13612,15 @@
#endif
#ifdef VK_NV_external_memory_rdma
-void count_VkMemoryGetRemoteAddressInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryGetRemoteAddressInfoNV* toCount,
- size_t* count)
-{
+void count_VkMemoryGetRemoteAddressInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryGetRemoteAddressInfoNV* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16529,18 +13630,14 @@
}
void count_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16550,18 +13647,14 @@
#endif
#ifdef VK_EXT_extended_dynamic_state2
void count_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16572,33 +13665,27 @@
#endif
#ifdef VK_QNX_screen_surface
-void count_VkScreenSurfaceCreateInfoQNX(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkScreenSurfaceCreateInfoQNX* toCount,
- size_t* count)
-{
+void count_VkScreenSurfaceCreateInfoQNX(uint32_t featureBits, VkStructureType rootType,
+ const VkScreenSurfaceCreateInfoQNX* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkScreenSurfaceCreateFlagsQNX);
// WARNING PTR CHECK
*count += 8;
- if (toCount->context)
- {
+ if (toCount->context) {
*count += sizeof(_screen_context);
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->window)
- {
+ if (toCount->window) {
*count += sizeof(_screen_window);
}
}
@@ -16606,100 +13693,77 @@
#endif
#ifdef VK_EXT_color_write_enable
void count_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceColorWriteEnableFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceColorWriteEnableFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
}
-void count_VkPipelineColorWriteCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineColorWriteCreateInfoEXT* toCount,
- size_t* count)
-{
+void count_VkPipelineColorWriteCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineColorWriteCreateInfoEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
- if (toCount)
- {
+ if (toCount) {
*count += toCount->attachmentCount * sizeof(const VkBool32);
}
}
#endif
#ifdef VK_GOOGLE_gfxstream
-void count_VkImportColorBufferGOOGLE(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportColorBufferGOOGLE* toCount,
- size_t* count)
-{
+void count_VkImportColorBufferGOOGLE(uint32_t featureBits, VkStructureType rootType,
+ const VkImportColorBufferGOOGLE* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
-void count_VkImportBufferGOOGLE(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportBufferGOOGLE* toCount,
- size_t* count)
-{
+void count_VkImportBufferGOOGLE(uint32_t featureBits, VkStructureType rootType,
+ const VkImportBufferGOOGLE* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
-void count_VkImportPhysicalAddressGOOGLE(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportPhysicalAddressGOOGLE* toCount,
- size_t* count)
-{
+void count_VkImportPhysicalAddressGOOGLE(uint32_t featureBits, VkStructureType rootType,
+ const VkImportPhysicalAddressGOOGLE* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16713,18 +13777,14 @@
#endif
#ifdef VK_EXT_global_priority_query
void count_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16732,18 +13792,14 @@
}
void count_VkQueueFamilyGlobalPriorityPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkQueueFamilyGlobalPriorityPropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkQueueFamilyGlobalPriorityPropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16753,19 +13809,15 @@
#endif
#ifdef VK_EXT_multi_draw
-void count_VkPhysicalDeviceMultiDrawFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiDrawFeaturesEXT* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceMultiDrawFeaturesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMultiDrawFeaturesEXT* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16773,30 +13825,22 @@
}
void count_VkPhysicalDeviceMultiDrawPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiDrawPropertiesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMultiDrawPropertiesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
}
-void count_VkMultiDrawInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMultiDrawInfoEXT* toCount,
- size_t* count)
-{
+void count_VkMultiDrawInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkMultiDrawInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -16805,12 +13849,8 @@
*count += sizeof(uint32_t);
}
-void count_VkMultiDrawIndexedInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMultiDrawIndexedInfoEXT* toCount,
- size_t* count)
-{
+void count_VkMultiDrawIndexedInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkMultiDrawIndexedInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -16825,18 +13865,14 @@
#endif
#ifdef VK_EXT_border_color_swizzle
void count_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16845,40 +13881,33 @@
}
void count_VkSamplerBorderColorComponentMappingCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSamplerBorderColorComponentMappingCreateInfoEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkSamplerBorderColorComponentMappingCreateInfoEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkComponentMapping(featureBits, rootType, (VkComponentMapping*)(&toCount->components), count);
+ count_VkComponentMapping(featureBits, rootType, (VkComponentMapping*)(&toCount->components),
+ count);
*count += sizeof(VkBool32);
}
#endif
#ifdef VK_EXT_pageable_device_local_memory
void count_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -16887,12 +13916,8 @@
#endif
#ifdef VK_KHR_acceleration_structure
-void count_VkDeviceOrHostAddressKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceOrHostAddressKHR* toCount,
- size_t* count)
-{
+void count_VkDeviceOrHostAddressKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceOrHostAddressKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -16901,11 +13926,8 @@
}
void count_VkAccelerationStructureBuildRangeInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureBuildRangeInfoKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureBuildRangeInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -16917,117 +13939,103 @@
}
void count_VkAccelerationStructureGeometryTrianglesDataKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryTrianglesDataKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureGeometryTrianglesDataKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkFormat);
- count_VkDeviceOrHostAddressConstKHR(featureBits, rootType, (VkDeviceOrHostAddressConstKHR*)(&toCount->vertexData), count);
+ count_VkDeviceOrHostAddressConstKHR(
+ featureBits, rootType, (VkDeviceOrHostAddressConstKHR*)(&toCount->vertexData), count);
*count += sizeof(VkDeviceSize);
*count += sizeof(uint32_t);
*count += sizeof(VkIndexType);
- count_VkDeviceOrHostAddressConstKHR(featureBits, rootType, (VkDeviceOrHostAddressConstKHR*)(&toCount->indexData), count);
- count_VkDeviceOrHostAddressConstKHR(featureBits, rootType, (VkDeviceOrHostAddressConstKHR*)(&toCount->transformData), count);
+ count_VkDeviceOrHostAddressConstKHR(
+ featureBits, rootType, (VkDeviceOrHostAddressConstKHR*)(&toCount->indexData), count);
+ count_VkDeviceOrHostAddressConstKHR(
+ featureBits, rootType, (VkDeviceOrHostAddressConstKHR*)(&toCount->transformData), count);
}
void count_VkAccelerationStructureGeometryAabbsDataKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryAabbsDataKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureGeometryAabbsDataKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkDeviceOrHostAddressConstKHR(featureBits, rootType, (VkDeviceOrHostAddressConstKHR*)(&toCount->data), count);
+ count_VkDeviceOrHostAddressConstKHR(featureBits, rootType,
+ (VkDeviceOrHostAddressConstKHR*)(&toCount->data), count);
*count += sizeof(VkDeviceSize);
}
void count_VkAccelerationStructureGeometryInstancesDataKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryInstancesDataKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureGeometryInstancesDataKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkBool32);
- count_VkDeviceOrHostAddressConstKHR(featureBits, rootType, (VkDeviceOrHostAddressConstKHR*)(&toCount->data), count);
+ count_VkDeviceOrHostAddressConstKHR(featureBits, rootType,
+ (VkDeviceOrHostAddressConstKHR*)(&toCount->data), count);
}
void count_VkAccelerationStructureGeometryDataKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryDataKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureGeometryDataKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
- count_VkAccelerationStructureGeometryTrianglesDataKHR(featureBits, rootType, (VkAccelerationStructureGeometryTrianglesDataKHR*)(&toCount->triangles), count);
+ count_VkAccelerationStructureGeometryTrianglesDataKHR(
+ featureBits, rootType,
+ (VkAccelerationStructureGeometryTrianglesDataKHR*)(&toCount->triangles), count);
}
-void count_VkAccelerationStructureGeometryKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryKHR* toCount,
- size_t* count)
-{
+void count_VkAccelerationStructureGeometryKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureGeometryKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkGeometryTypeKHR);
- count_VkAccelerationStructureGeometryDataKHR(featureBits, rootType, (VkAccelerationStructureGeometryDataKHR*)(&toCount->geometry), count);
+ count_VkAccelerationStructureGeometryDataKHR(
+ featureBits, rootType, (VkAccelerationStructureGeometryDataKHR*)(&toCount->geometry),
+ count);
*count += sizeof(VkGeometryFlagsKHR);
}
void count_VkAccelerationStructureBuildGeometryInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureBuildGeometryInfoKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureBuildGeometryInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -17041,32 +14049,28 @@
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pGeometries)
- {
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->geometryCount; ++i)
- {
- count_VkAccelerationStructureGeometryKHR(featureBits, rootType, (const VkAccelerationStructureGeometryKHR*)(toCount->pGeometries + i), count);
+ if (toCount->pGeometries) {
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->geometryCount; ++i) {
+ count_VkAccelerationStructureGeometryKHR(
+ featureBits, rootType,
+ (const VkAccelerationStructureGeometryKHR*)(toCount->pGeometries + i), count);
}
}
}
- count_VkDeviceOrHostAddressKHR(featureBits, rootType, (VkDeviceOrHostAddressKHR*)(&toCount->scratchData), count);
+ count_VkDeviceOrHostAddressKHR(featureBits, rootType,
+ (VkDeviceOrHostAddressKHR*)(&toCount->scratchData), count);
}
-void count_VkAccelerationStructureCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureCreateInfoKHR* toCount,
- size_t* count)
-{
+void count_VkAccelerationStructureCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureCreateInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -17080,46 +14084,36 @@
}
void count_VkWriteDescriptorSetAccelerationStructureKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkWriteDescriptorSetAccelerationStructureKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkWriteDescriptorSetAccelerationStructureKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pAccelerationStructures)
- {
- if (toCount->accelerationStructureCount)
- {
+ if (toCount->pAccelerationStructures) {
+ if (toCount->accelerationStructureCount) {
*count += toCount->accelerationStructureCount * 8;
}
}
}
void count_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceAccelerationStructureFeaturesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceAccelerationStructureFeaturesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -17131,18 +14125,14 @@
}
void count_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceAccelerationStructurePropertiesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceAccelerationStructurePropertiesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -17157,18 +14147,14 @@
}
void count_VkAccelerationStructureDeviceAddressInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureDeviceAddressInfoKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureDeviceAddressInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -17177,84 +14163,69 @@
}
void count_VkAccelerationStructureVersionInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureVersionInfoKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureVersionInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- if (toCount)
- {
- *count += 2*VK_UUID_SIZE * sizeof(const uint8_t);
+ if (toCount) {
+ *count += 2 * VK_UUID_SIZE * sizeof(const uint8_t);
}
}
void count_VkCopyAccelerationStructureToMemoryInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCopyAccelerationStructureToMemoryInfoKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkCopyAccelerationStructureToMemoryInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
uint64_t cgen_var_0;
*count += 1 * 8;
- count_VkDeviceOrHostAddressKHR(featureBits, rootType, (VkDeviceOrHostAddressKHR*)(&toCount->dst), count);
+ count_VkDeviceOrHostAddressKHR(featureBits, rootType,
+ (VkDeviceOrHostAddressKHR*)(&toCount->dst), count);
*count += sizeof(VkCopyAccelerationStructureModeKHR);
}
void count_VkCopyMemoryToAccelerationStructureInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCopyMemoryToAccelerationStructureInfoKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkCopyMemoryToAccelerationStructureInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
- count_VkDeviceOrHostAddressConstKHR(featureBits, rootType, (VkDeviceOrHostAddressConstKHR*)(&toCount->src), count);
+ count_VkDeviceOrHostAddressConstKHR(featureBits, rootType,
+ (VkDeviceOrHostAddressConstKHR*)(&toCount->src), count);
uint64_t cgen_var_0;
*count += 1 * 8;
*count += sizeof(VkCopyAccelerationStructureModeKHR);
}
-void count_VkCopyAccelerationStructureInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCopyAccelerationStructureInfoKHR* toCount,
- size_t* count)
-{
+void count_VkCopyAccelerationStructureInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkCopyAccelerationStructureInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -17266,18 +14237,14 @@
}
void count_VkAccelerationStructureBuildSizesInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureBuildSizesInfoKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureBuildSizesInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -17288,19 +14255,15 @@
#endif
#ifdef VK_KHR_ray_tracing_pipeline
-void count_VkRayTracingShaderGroupCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRayTracingShaderGroupCreateInfoKHR* toCount,
- size_t* count)
-{
+void count_VkRayTracingShaderGroupCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkRayTracingShaderGroupCreateInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -17311,25 +14274,20 @@
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pShaderGroupCaptureReplayHandle)
- {
+ if (toCount->pShaderGroupCaptureReplayHandle) {
*count += sizeof(const uint8_t);
}
}
void count_VkRayTracingPipelineInterfaceCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRayTracingPipelineInterfaceCreateInfoKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkRayTracingPipelineInterfaceCreateInfoKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -17337,57 +14295,56 @@
*count += sizeof(uint32_t);
}
-void count_VkRayTracingPipelineCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRayTracingPipelineCreateInfoKHR* toCount,
- size_t* count)
-{
+void count_VkRayTracingPipelineCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkRayTracingPipelineCreateInfoKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
*count += sizeof(VkPipelineCreateFlags);
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->stageCount; ++i)
- {
- count_VkPipelineShaderStageCreateInfo(featureBits, rootType, (const VkPipelineShaderStageCreateInfo*)(toCount->pStages + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->stageCount; ++i) {
+ count_VkPipelineShaderStageCreateInfo(
+ featureBits, rootType,
+ (const VkPipelineShaderStageCreateInfo*)(toCount->pStages + i), count);
}
}
*count += sizeof(uint32_t);
- if (toCount)
- {
- for (uint32_t i = 0; i < (uint32_t)toCount->groupCount; ++i)
- {
- count_VkRayTracingShaderGroupCreateInfoKHR(featureBits, rootType, (const VkRayTracingShaderGroupCreateInfoKHR*)(toCount->pGroups + i), count);
+ if (toCount) {
+ for (uint32_t i = 0; i < (uint32_t)toCount->groupCount; ++i) {
+ count_VkRayTracingShaderGroupCreateInfoKHR(
+ featureBits, rootType,
+ (const VkRayTracingShaderGroupCreateInfoKHR*)(toCount->pGroups + i), count);
}
}
*count += sizeof(uint32_t);
// WARNING PTR CHECK
*count += 8;
- if (toCount->pLibraryInfo)
- {
- count_VkPipelineLibraryCreateInfoKHR(featureBits, rootType, (const VkPipelineLibraryCreateInfoKHR*)(toCount->pLibraryInfo), count);
+ if (toCount->pLibraryInfo) {
+ count_VkPipelineLibraryCreateInfoKHR(
+ featureBits, rootType, (const VkPipelineLibraryCreateInfoKHR*)(toCount->pLibraryInfo),
+ count);
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->pLibraryInterface)
- {
- count_VkRayTracingPipelineInterfaceCreateInfoKHR(featureBits, rootType, (const VkRayTracingPipelineInterfaceCreateInfoKHR*)(toCount->pLibraryInterface), count);
+ if (toCount->pLibraryInterface) {
+ count_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ featureBits, rootType,
+ (const VkRayTracingPipelineInterfaceCreateInfoKHR*)(toCount->pLibraryInterface), count);
}
// WARNING PTR CHECK
*count += 8;
- if (toCount->pDynamicState)
- {
- count_VkPipelineDynamicStateCreateInfo(featureBits, rootType, (const VkPipelineDynamicStateCreateInfo*)(toCount->pDynamicState), count);
+ if (toCount->pDynamicState) {
+ count_VkPipelineDynamicStateCreateInfo(
+ featureBits, rootType,
+ (const VkPipelineDynamicStateCreateInfo*)(toCount->pDynamicState), count);
}
uint64_t cgen_var_0;
*count += 1 * 8;
@@ -17397,18 +14354,14 @@
}
void count_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -17420,18 +14373,14 @@
}
void count_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toCount,
- size_t* count)
-{
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toCount, size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -17445,12 +14394,9 @@
*count += sizeof(uint32_t);
}
-void count_VkStridedDeviceAddressRegionKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkStridedDeviceAddressRegionKHR* toCount,
- size_t* count)
-{
+void count_VkStridedDeviceAddressRegionKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkStridedDeviceAddressRegionKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -17460,12 +14406,9 @@
*count += sizeof(VkDeviceSize);
}
-void count_VkTraceRaysIndirectCommandKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkTraceRaysIndirectCommandKHR* toCount,
- size_t* count)
-{
+void count_VkTraceRaysIndirectCommandKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkTraceRaysIndirectCommandKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
@@ -17477,19 +14420,15 @@
#endif
#ifdef VK_KHR_ray_query
-void count_VkPhysicalDeviceRayQueryFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceRayQueryFeaturesKHR* toCount,
- size_t* count)
-{
+void count_VkPhysicalDeviceRayQueryFeaturesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceRayQueryFeaturesKHR* toCount,
+ size_t* count) {
(void)featureBits;
(void)rootType;
(void)toCount;
(void)count;
*count += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = toCount->sType;
}
count_extension_struct(featureBits, rootType, toCount->pNext, count);
@@ -17497,1558 +14436,2098 @@
}
#endif
-void count_extension_struct(
- uint32_t featureBits,
- VkStructureType rootType,
- const void* structExtension,
- size_t* count)
-{
+void count_extension_struct(uint32_t featureBits, VkStructureType rootType,
+ const void* structExtension, size_t* count) {
VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension);
- size_t currExtSize = goldfish_vk_extension_struct_size_with_stream_features(featureBits, rootType, structExtension);
- if (!currExtSize && structExtension)
- {
+ size_t currExtSize = goldfish_vk_extension_struct_size_with_stream_features(
+ featureBits, rootType, structExtension);
+ if (!currExtSize && structExtension) {
// unknown struct extension; skip and call on its pNext field
count_extension_struct(featureBits, rootType, (void*)structAccess->pNext, count);
return;
- }
- else
- {
+ } else {
// known or null extension struct
*count += sizeof(uint32_t);
- if (!currExtSize)
- {
+ if (!currExtSize) {
// exit if this was a null extension struct (size == 0 in this branch)
return;
}
}
*count += sizeof(VkStructureType);
- if (!structExtension)
- {
+ if (!structExtension) {
return;
}
uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension);
- switch(structType)
- {
+ switch (structType) {
#ifdef VK_VERSION_1_1
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
- {
- count_VkPhysicalDeviceSubgroupProperties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
+ count_VkPhysicalDeviceSubgroupProperties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
- {
- count_VkPhysicalDevice16BitStorageFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
+ count_VkPhysicalDevice16BitStorageFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
- {
- count_VkMemoryDedicatedRequirements(featureBits, rootType, reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
+ count_VkMemoryDedicatedRequirements(
+ featureBits, rootType,
+ reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
- {
- count_VkMemoryDedicatedAllocateInfo(featureBits, rootType, reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: {
+ count_VkMemoryDedicatedAllocateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
- {
- count_VkMemoryAllocateFlagsInfo(featureBits, rootType, reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: {
+ count_VkMemoryAllocateFlagsInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
- {
- count_VkDeviceGroupRenderPassBeginInfo(featureBits, rootType, reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: {
+ count_VkDeviceGroupRenderPassBeginInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
- {
- count_VkDeviceGroupCommandBufferBeginInfo(featureBits, rootType, reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: {
+ count_VkDeviceGroupCommandBufferBeginInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
- {
- count_VkDeviceGroupSubmitInfo(featureBits, rootType, reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: {
+ count_VkDeviceGroupSubmitInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
- {
- count_VkDeviceGroupBindSparseInfo(featureBits, rootType, reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: {
+ count_VkDeviceGroupBindSparseInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
- {
- count_VkBindBufferMemoryDeviceGroupInfo(featureBits, rootType, reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: {
+ count_VkBindBufferMemoryDeviceGroupInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
- {
- count_VkBindImageMemoryDeviceGroupInfo(featureBits, rootType, reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: {
+ count_VkBindImageMemoryDeviceGroupInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
- {
- count_VkDeviceGroupDeviceCreateInfo(featureBits, rootType, reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: {
+ count_VkDeviceGroupDeviceCreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
- {
- count_VkPhysicalDeviceFeatures2(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
+ count_VkPhysicalDeviceFeatures2(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
- {
- count_VkPhysicalDevicePointClippingProperties(featureBits, rootType, reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: {
+ count_VkPhysicalDevicePointClippingProperties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
- {
- count_VkRenderPassInputAttachmentAspectCreateInfo(featureBits, rootType, reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: {
+ count_VkRenderPassInputAttachmentAspectCreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
- {
- count_VkImageViewUsageCreateInfo(featureBits, rootType, reinterpret_cast<const VkImageViewUsageCreateInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: {
+ count_VkImageViewUsageCreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkImageViewUsageCreateInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
- {
- count_VkPipelineTessellationDomainOriginStateCreateInfo(featureBits, rootType, reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: {
+ count_VkPipelineTessellationDomainOriginStateCreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
- {
- count_VkRenderPassMultiviewCreateInfo(featureBits, rootType, reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: {
+ count_VkRenderPassMultiviewCreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
- {
- count_VkPhysicalDeviceMultiviewFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
+ count_VkPhysicalDeviceMultiviewFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
- {
- count_VkPhysicalDeviceMultiviewProperties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: {
+ count_VkPhysicalDeviceMultiviewProperties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
- {
- count_VkPhysicalDeviceVariablePointersFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
+ count_VkPhysicalDeviceVariablePointersFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
- {
- count_VkPhysicalDeviceProtectedMemoryFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
+ count_VkPhysicalDeviceProtectedMemoryFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
- {
- count_VkPhysicalDeviceProtectedMemoryProperties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: {
+ count_VkPhysicalDeviceProtectedMemoryProperties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
- {
- count_VkProtectedSubmitInfo(featureBits, rootType, reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: {
+ count_VkProtectedSubmitInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
- {
- count_VkSamplerYcbcrConversionInfo(featureBits, rootType, reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: {
+ count_VkSamplerYcbcrConversionInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
- {
- count_VkBindImagePlaneMemoryInfo(featureBits, rootType, reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: {
+ count_VkBindImagePlaneMemoryInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
- {
- count_VkImagePlaneMemoryRequirementsInfo(featureBits, rootType, reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: {
+ count_VkImagePlaneMemoryRequirementsInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
- {
- count_VkPhysicalDeviceSamplerYcbcrConversionFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
+ count_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
- {
- count_VkSamplerYcbcrConversionImageFormatProperties(featureBits, rootType, reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: {
+ count_VkSamplerYcbcrConversionImageFormatProperties(
+ featureBits, rootType,
+ reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
- {
- count_VkPhysicalDeviceExternalImageFormatInfo(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: {
+ count_VkPhysicalDeviceExternalImageFormatInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
- {
- count_VkExternalImageFormatProperties(featureBits, rootType, reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: {
+ count_VkExternalImageFormatProperties(
+ featureBits, rootType,
+ reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
- {
- count_VkPhysicalDeviceIDProperties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: {
+ count_VkPhysicalDeviceIDProperties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
- {
- count_VkExternalMemoryImageCreateInfo(featureBits, rootType, reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: {
+ count_VkExternalMemoryImageCreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
- {
- count_VkExternalMemoryBufferCreateInfo(featureBits, rootType, reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: {
+ count_VkExternalMemoryBufferCreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
- {
- count_VkExportMemoryAllocateInfo(featureBits, rootType, reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: {
+ count_VkExportMemoryAllocateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
- {
- count_VkExportFenceCreateInfo(featureBits, rootType, reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: {
+ count_VkExportFenceCreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
- {
- count_VkExportSemaphoreCreateInfo(featureBits, rootType, reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: {
+ count_VkExportSemaphoreCreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
- {
- count_VkPhysicalDeviceMaintenance3Properties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: {
+ count_VkPhysicalDeviceMaintenance3Properties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
- {
- count_VkPhysicalDeviceShaderDrawParametersFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
+ count_VkPhysicalDeviceShaderDrawParametersFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_VERSION_1_2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
- {
- count_VkPhysicalDeviceVulkan11Features(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: {
+ count_VkPhysicalDeviceVulkan11Features(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
- {
- count_VkPhysicalDeviceVulkan11Properties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: {
+ count_VkPhysicalDeviceVulkan11Properties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
- {
- count_VkPhysicalDeviceVulkan12Features(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: {
+ count_VkPhysicalDeviceVulkan12Features(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
- {
- count_VkPhysicalDeviceVulkan12Properties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: {
+ count_VkPhysicalDeviceVulkan12Properties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
- {
- count_VkImageFormatListCreateInfo(featureBits, rootType, reinterpret_cast<const VkImageFormatListCreateInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: {
+ count_VkImageFormatListCreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkImageFormatListCreateInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
- {
- count_VkPhysicalDevice8BitStorageFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: {
+ count_VkPhysicalDevice8BitStorageFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
- {
- count_VkPhysicalDeviceDriverProperties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: {
+ count_VkPhysicalDeviceDriverProperties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
- {
- count_VkPhysicalDeviceShaderAtomicInt64Features(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: {
+ count_VkPhysicalDeviceShaderAtomicInt64Features(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
- {
- count_VkPhysicalDeviceShaderFloat16Int8Features(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: {
+ count_VkPhysicalDeviceShaderFloat16Int8Features(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
- {
- count_VkPhysicalDeviceFloatControlsProperties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: {
+ count_VkPhysicalDeviceFloatControlsProperties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
- {
- count_VkDescriptorSetLayoutBindingFlagsCreateInfo(featureBits, rootType, reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: {
+ count_VkDescriptorSetLayoutBindingFlagsCreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
- {
- count_VkPhysicalDeviceDescriptorIndexingFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: {
+ count_VkPhysicalDeviceDescriptorIndexingFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
- {
- count_VkPhysicalDeviceDescriptorIndexingProperties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: {
+ count_VkPhysicalDeviceDescriptorIndexingProperties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
- {
- count_VkDescriptorSetVariableDescriptorCountAllocateInfo(featureBits, rootType, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: {
+ count_VkDescriptorSetVariableDescriptorCountAllocateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
- {
- count_VkDescriptorSetVariableDescriptorCountLayoutSupport(featureBits, rootType, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: {
+ count_VkDescriptorSetVariableDescriptorCountLayoutSupport(
+ featureBits, rootType,
+ reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
- {
- count_VkSubpassDescriptionDepthStencilResolve(featureBits, rootType, reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: {
+ count_VkSubpassDescriptionDepthStencilResolve(
+ featureBits, rootType,
+ reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
- {
- count_VkPhysicalDeviceDepthStencilResolveProperties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: {
+ count_VkPhysicalDeviceDepthStencilResolveProperties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
- {
- count_VkPhysicalDeviceScalarBlockLayoutFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: {
+ count_VkPhysicalDeviceScalarBlockLayoutFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
- {
- count_VkImageStencilUsageCreateInfo(featureBits, rootType, reinterpret_cast<const VkImageStencilUsageCreateInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: {
+ count_VkImageStencilUsageCreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkImageStencilUsageCreateInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
- {
- count_VkSamplerReductionModeCreateInfo(featureBits, rootType, reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: {
+ count_VkSamplerReductionModeCreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
- {
- count_VkPhysicalDeviceSamplerFilterMinmaxProperties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: {
+ count_VkPhysicalDeviceSamplerFilterMinmaxProperties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
- {
- count_VkPhysicalDeviceVulkanMemoryModelFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: {
+ count_VkPhysicalDeviceVulkanMemoryModelFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
- {
- count_VkPhysicalDeviceImagelessFramebufferFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: {
+ count_VkPhysicalDeviceImagelessFramebufferFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
- {
- count_VkFramebufferAttachmentsCreateInfo(featureBits, rootType, reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: {
+ count_VkFramebufferAttachmentsCreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
- {
- count_VkRenderPassAttachmentBeginInfo(featureBits, rootType, reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: {
+ count_VkRenderPassAttachmentBeginInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
- {
- count_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: {
+ count_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
- {
- count_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: {
+ count_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
- {
- count_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: {
+ count_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
- {
- count_VkAttachmentReferenceStencilLayout(featureBits, rootType, reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: {
+ count_VkAttachmentReferenceStencilLayout(
+ featureBits, rootType,
+ reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
- {
- count_VkAttachmentDescriptionStencilLayout(featureBits, rootType, reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: {
+ count_VkAttachmentDescriptionStencilLayout(
+ featureBits, rootType,
+ reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
- {
- count_VkPhysicalDeviceHostQueryResetFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: {
+ count_VkPhysicalDeviceHostQueryResetFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
- {
- count_VkPhysicalDeviceTimelineSemaphoreFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: {
+ count_VkPhysicalDeviceTimelineSemaphoreFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
- {
- count_VkPhysicalDeviceTimelineSemaphoreProperties(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: {
+ count_VkPhysicalDeviceTimelineSemaphoreProperties(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
- {
- count_VkSemaphoreTypeCreateInfo(featureBits, rootType, reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: {
+ count_VkSemaphoreTypeCreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
- {
- count_VkTimelineSemaphoreSubmitInfo(featureBits, rootType, reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: {
+ count_VkTimelineSemaphoreSubmitInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
- {
- count_VkPhysicalDeviceBufferDeviceAddressFeatures(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: {
+ count_VkPhysicalDeviceBufferDeviceAddressFeatures(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
- {
- count_VkBufferOpaqueCaptureAddressCreateInfo(featureBits, rootType, reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: {
+ count_VkBufferOpaqueCaptureAddressCreateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
- {
- count_VkMemoryOpaqueCaptureAddressAllocateInfo(featureBits, rootType, reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: {
+ count_VkMemoryOpaqueCaptureAddressAllocateInfo(
+ featureBits, rootType,
+ reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_swapchain
- case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
- {
- count_VkImageSwapchainCreateInfoKHR(featureBits, rootType, reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
+ count_VkImageSwapchainCreateInfoKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
- {
- count_VkBindImageMemorySwapchainInfoKHR(featureBits, rootType, reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: {
+ count_VkBindImageMemorySwapchainInfoKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
- {
- count_VkDeviceGroupPresentInfoKHR(featureBits, rootType, reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: {
+ count_VkDeviceGroupPresentInfoKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
- {
- count_VkDeviceGroupSwapchainCreateInfoKHR(featureBits, rootType, reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: {
+ count_VkDeviceGroupSwapchainCreateInfoKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_display_swapchain
- case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
- {
- count_VkDisplayPresentInfoKHR(featureBits, rootType, reinterpret_cast<const VkDisplayPresentInfoKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: {
+ count_VkDisplayPresentInfoKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkDisplayPresentInfoKHR*>(structExtension), count);
break;
}
#endif
#ifdef VK_KHR_video_queue
- case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR:
- {
- count_VkVideoQueueFamilyProperties2KHR(featureBits, rootType, reinterpret_cast<const VkVideoQueueFamilyProperties2KHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: {
+ count_VkVideoQueueFamilyProperties2KHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoQueueFamilyProperties2KHR*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR:
- {
- count_VkVideoProfileKHR(featureBits, rootType, reinterpret_cast<const VkVideoProfileKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR: {
+ count_VkVideoProfileKHR(featureBits, rootType,
+ reinterpret_cast<const VkVideoProfileKHR*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR:
- {
- count_VkVideoProfilesKHR(featureBits, rootType, reinterpret_cast<const VkVideoProfilesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR: {
+ count_VkVideoProfilesKHR(featureBits, rootType,
+ reinterpret_cast<const VkVideoProfilesKHR*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_dynamic_rendering
- case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR:
- {
- count_VkPipelineRenderingCreateInfoKHR(featureBits, rootType, reinterpret_cast<const VkPipelineRenderingCreateInfoKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: {
+ count_VkPipelineRenderingCreateInfoKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineRenderingCreateInfoKHR*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR:
- {
- count_VkPhysicalDeviceDynamicRenderingFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: {
+ count_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR:
- {
- count_VkCommandBufferInheritanceRenderingInfoKHR(featureBits, rootType, reinterpret_cast<const VkCommandBufferInheritanceRenderingInfoKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: {
+ count_VkCommandBufferInheritanceRenderingInfoKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkCommandBufferInheritanceRenderingInfoKHR*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
- {
- count_VkRenderingFragmentShadingRateAttachmentInfoKHR(featureBits, rootType, reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
+ count_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
- {
- count_VkRenderingFragmentDensityMapAttachmentInfoEXT(featureBits, rootType, reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
+ count_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
- {
- count_VkAttachmentSampleCountInfoAMD(featureBits, rootType, reinterpret_cast<const VkAttachmentSampleCountInfoAMD*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
+ count_VkAttachmentSampleCountInfoAMD(
+ featureBits, rootType,
+ reinterpret_cast<const VkAttachmentSampleCountInfoAMD*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
- {
- count_VkMultiviewPerViewAttributesInfoNVX(featureBits, rootType, reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
+ count_VkMultiviewPerViewAttributesInfoNVX(
+ featureBits, rootType,
+ reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_external_memory_win32
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
- {
- count_VkImportMemoryWin32HandleInfoKHR(featureBits, rootType, reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
+ count_VkImportMemoryWin32HandleInfoKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
- {
- count_VkExportMemoryWin32HandleInfoKHR(featureBits, rootType, reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
+ count_VkExportMemoryWin32HandleInfoKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(structExtension), count);
break;
}
#endif
#ifdef VK_KHR_external_memory_fd
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
- {
- count_VkImportMemoryFdInfoKHR(featureBits, rootType, reinterpret_cast<const VkImportMemoryFdInfoKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: {
+ count_VkImportMemoryFdInfoKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkImportMemoryFdInfoKHR*>(structExtension), count);
break;
}
#endif
#ifdef VK_KHR_win32_keyed_mutex
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
- {
- count_VkWin32KeyedMutexAcquireReleaseInfoKHR(featureBits, rootType, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: {
+ count_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_external_semaphore_win32
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
- {
- count_VkExportSemaphoreWin32HandleInfoKHR(featureBits, rootType, reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: {
+ count_VkExportSemaphoreWin32HandleInfoKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
- {
- count_VkD3D12FenceSubmitInfoKHR(featureBits, rootType, reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: {
+ count_VkD3D12FenceSubmitInfoKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(structExtension), count);
break;
}
#endif
#ifdef VK_KHR_push_descriptor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
- {
- count_VkPhysicalDevicePushDescriptorPropertiesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: {
+ count_VkPhysicalDevicePushDescriptorPropertiesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_incremental_present
- case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
- {
- count_VkPresentRegionsKHR(featureBits, rootType, reinterpret_cast<const VkPresentRegionsKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: {
+ count_VkPresentRegionsKHR(featureBits, rootType,
+ reinterpret_cast<const VkPresentRegionsKHR*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_shared_presentable_image
- case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
- {
- count_VkSharedPresentSurfaceCapabilitiesKHR(featureBits, rootType, reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
+ count_VkSharedPresentSurfaceCapabilitiesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_external_fence_win32
- case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
- {
- count_VkExportFenceWin32HandleInfoKHR(featureBits, rootType, reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: {
+ count_VkExportFenceWin32HandleInfoKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(structExtension), count);
break;
}
#endif
#ifdef VK_KHR_performance_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
- {
- count_VkPhysicalDevicePerformanceQueryFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: {
+ count_VkPhysicalDevicePerformanceQueryFeaturesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
- {
- count_VkPhysicalDevicePerformanceQueryPropertiesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: {
+ count_VkPhysicalDevicePerformanceQueryPropertiesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
- {
- count_VkQueryPoolPerformanceCreateInfoKHR(featureBits, rootType, reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: {
+ count_VkQueryPoolPerformanceCreateInfoKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
- {
- count_VkPerformanceQuerySubmitInfoKHR(featureBits, rootType, reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: {
+ count_VkPerformanceQuerySubmitInfoKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>(structExtension), count);
break;
}
#endif
#ifdef VK_KHR_portability_subset
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
- {
- count_VkPhysicalDevicePortabilitySubsetFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
+ count_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
- {
- count_VkPhysicalDevicePortabilitySubsetPropertiesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
+ count_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_shader_clock
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
- {
- count_VkPhysicalDeviceShaderClockFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
+ count_VkPhysicalDeviceShaderClockFeaturesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_shader_terminate_invocation
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR:
- {
- count_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: {
+ count_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_fragment_shading_rate
- case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
- {
- count_VkFragmentShadingRateAttachmentInfoKHR(featureBits, rootType, reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
+ count_VkFragmentShadingRateAttachmentInfoKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
- {
- count_VkPipelineFragmentShadingRateStateCreateInfoKHR(featureBits, rootType, reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: {
+ count_VkPipelineFragmentShadingRateStateCreateInfoKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
- {
- count_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: {
+ count_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
- {
- count_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: {
+ count_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_surface_protected_capabilities
- case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
- {
- count_VkSurfaceProtectedCapabilitiesKHR(featureBits, rootType, reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: {
+ count_VkSurfaceProtectedCapabilitiesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(structExtension), count);
break;
}
#endif
#ifdef VK_KHR_present_wait
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
- {
- count_VkPhysicalDevicePresentWaitFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: {
+ count_VkPhysicalDevicePresentWaitFeaturesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
- {
- count_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: {
+ count_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_shader_integer_dot_product
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR:
- {
- count_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: {
+ count_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR:
- {
- count_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: {
+ count_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_present_id
- case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
- {
- count_VkPresentIdKHR(featureBits, rootType, reinterpret_cast<const VkPresentIdKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: {
+ count_VkPresentIdKHR(featureBits, rootType,
+ reinterpret_cast<const VkPresentIdKHR*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
- {
- count_VkPhysicalDevicePresentIdFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: {
+ count_VkPhysicalDevicePresentIdFeaturesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_video_encode_queue
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
- {
- count_VkVideoEncodeRateControlInfoKHR(featureBits, rootType, reinterpret_cast<const VkVideoEncodeRateControlInfoKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
+ count_VkVideoEncodeRateControlInfoKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoEncodeRateControlInfoKHR*>(structExtension), count);
break;
}
#endif
#ifdef VK_KHR_synchronization2
- case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR:
- {
- count_VkMemoryBarrier2KHR(featureBits, rootType, reinterpret_cast<const VkMemoryBarrier2KHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: {
+ count_VkMemoryBarrier2KHR(featureBits, rootType,
+ reinterpret_cast<const VkMemoryBarrier2KHR*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR:
- {
- count_VkPhysicalDeviceSynchronization2FeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceSynchronization2FeaturesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: {
+ count_VkPhysicalDeviceSynchronization2FeaturesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSynchronization2FeaturesKHR*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
- {
- count_VkQueueFamilyCheckpointProperties2NV(featureBits, rootType, reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
+ count_VkQueueFamilyCheckpointProperties2NV(
+ featureBits, rootType,
+ reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
- {
- count_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
+ count_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+ featureBits, rootType,
+ reinterpret_cast<
+ const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR:
- {
- count_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: {
+ count_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
- {
- count_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
+ count_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_format_feature_flags2
- case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR:
- {
- count_VkFormatProperties3KHR(featureBits, rootType, reinterpret_cast<const VkFormatProperties3KHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: {
+ count_VkFormatProperties3KHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkFormatProperties3KHR*>(structExtension), count);
break;
}
#endif
#ifdef VK_KHR_maintenance4
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR:
- {
- count_VkPhysicalDeviceMaintenance4FeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: {
+ count_VkPhysicalDeviceMaintenance4FeaturesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR:
- {
- count_VkPhysicalDeviceMaintenance4PropertiesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: {
+ count_VkPhysicalDeviceMaintenance4PropertiesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_ANDROID_native_buffer
- case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
- {
- count_VkNativeBufferANDROID(featureBits, rootType, reinterpret_cast<const VkNativeBufferANDROID*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
+ count_VkNativeBufferANDROID(
+ featureBits, rootType,
+ reinterpret_cast<const VkNativeBufferANDROID*>(structExtension), count);
break;
}
#endif
#ifdef VK_EXT_debug_report
- case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
- {
- count_VkDebugReportCallbackCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: {
+ count_VkDebugReportCallbackCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_AMD_rasterization_order
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
- {
- count_VkPipelineRasterizationStateRasterizationOrderAMD(featureBits, rootType, reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: {
+ count_VkPipelineRasterizationStateRasterizationOrderAMD(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_dedicated_allocation
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
- {
- count_VkDedicatedAllocationImageCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: {
+ count_VkDedicatedAllocationImageCreateInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
- {
- count_VkDedicatedAllocationBufferCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: {
+ count_VkDedicatedAllocationBufferCreateInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
- {
- count_VkDedicatedAllocationMemoryAllocateInfoNV(featureBits, rootType, reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: {
+ count_VkDedicatedAllocationMemoryAllocateInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_transform_feedback
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
- {
- count_VkPhysicalDeviceTransformFeedbackFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: {
+ count_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
- {
- count_VkPhysicalDeviceTransformFeedbackPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: {
+ count_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
- {
- count_VkPipelineRasterizationStateStreamCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: {
+ count_VkPipelineRasterizationStateStreamCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_video_encode_h264
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT:
- {
- count_VkVideoEncodeH264CapabilitiesEXT(featureBits, rootType, reinterpret_cast<const VkVideoEncodeH264CapabilitiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
+ count_VkVideoEncodeH264CapabilitiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoEncodeH264CapabilitiesEXT*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT:
- {
- count_VkVideoEncodeH264SessionCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: {
+ count_VkVideoEncodeH264SessionCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- count_VkVideoEncodeH264SessionParametersAddInfoEXT(featureBits, rootType, reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ count_VkVideoEncodeH264SessionParametersAddInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- count_VkVideoEncodeH264SessionParametersCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ count_VkVideoEncodeH264SessionParametersCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT:
- {
- count_VkVideoEncodeH264VclFrameInfoEXT(featureBits, rootType, reinterpret_cast<const VkVideoEncodeH264VclFrameInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
+ count_VkVideoEncodeH264VclFrameInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoEncodeH264VclFrameInfoEXT*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT:
- {
- count_VkVideoEncodeH264EmitPictureParametersEXT(featureBits, rootType, reinterpret_cast<const VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: {
+ count_VkVideoEncodeH264EmitPictureParametersEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT:
- {
- count_VkVideoEncodeH264ProfileEXT(featureBits, rootType, reinterpret_cast<const VkVideoEncodeH264ProfileEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT: {
+ count_VkVideoEncodeH264ProfileEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoEncodeH264ProfileEXT*>(structExtension), count);
break;
}
#endif
#ifdef VK_EXT_video_encode_h265
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT:
- {
- count_VkVideoEncodeH265CapabilitiesEXT(featureBits, rootType, reinterpret_cast<const VkVideoEncodeH265CapabilitiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
+ count_VkVideoEncodeH265CapabilitiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoEncodeH265CapabilitiesEXT*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT:
- {
- count_VkVideoEncodeH265SessionCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: {
+ count_VkVideoEncodeH265SessionCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- count_VkVideoEncodeH265SessionParametersAddInfoEXT(featureBits, rootType, reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ count_VkVideoEncodeH265SessionParametersAddInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- count_VkVideoEncodeH265SessionParametersCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ count_VkVideoEncodeH265SessionParametersCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT:
- {
- count_VkVideoEncodeH265VclFrameInfoEXT(featureBits, rootType, reinterpret_cast<const VkVideoEncodeH265VclFrameInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
+ count_VkVideoEncodeH265VclFrameInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoEncodeH265VclFrameInfoEXT*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT:
- {
- count_VkVideoEncodeH265EmitPictureParametersEXT(featureBits, rootType, reinterpret_cast<const VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: {
+ count_VkVideoEncodeH265EmitPictureParametersEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT:
- {
- count_VkVideoEncodeH265ProfileEXT(featureBits, rootType, reinterpret_cast<const VkVideoEncodeH265ProfileEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT: {
+ count_VkVideoEncodeH265ProfileEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoEncodeH265ProfileEXT*>(structExtension), count);
break;
}
#endif
#ifdef VK_EXT_video_decode_h264
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT:
- {
- count_VkVideoDecodeH264ProfileEXT(featureBits, rootType, reinterpret_cast<const VkVideoDecodeH264ProfileEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT: {
+ count_VkVideoDecodeH264ProfileEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoDecodeH264ProfileEXT*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT:
- {
- count_VkVideoDecodeH264CapabilitiesEXT(featureBits, rootType, reinterpret_cast<const VkVideoDecodeH264CapabilitiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: {
+ count_VkVideoDecodeH264CapabilitiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoDecodeH264CapabilitiesEXT*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT:
- {
- count_VkVideoDecodeH264SessionCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: {
+ count_VkVideoDecodeH264SessionCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- count_VkVideoDecodeH264SessionParametersAddInfoEXT(featureBits, rootType, reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ count_VkVideoDecodeH264SessionParametersAddInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- count_VkVideoDecodeH264SessionParametersCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ count_VkVideoDecodeH264SessionParametersCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT:
- {
- count_VkVideoDecodeH264PictureInfoEXT(featureBits, rootType, reinterpret_cast<const VkVideoDecodeH264PictureInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: {
+ count_VkVideoDecodeH264PictureInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoDecodeH264PictureInfoEXT*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT:
- {
- count_VkVideoDecodeH264MvcEXT(featureBits, rootType, reinterpret_cast<const VkVideoDecodeH264MvcEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT: {
+ count_VkVideoDecodeH264MvcEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoDecodeH264MvcEXT*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT:
- {
- count_VkVideoDecodeH264DpbSlotInfoEXT(featureBits, rootType, reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: {
+ count_VkVideoDecodeH264DpbSlotInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension), count);
break;
}
#endif
#ifdef VK_AMD_texture_gather_bias_lod
- case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
- {
- count_VkTextureLODGatherFormatPropertiesAMD(featureBits, rootType, reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
+ count_VkTextureLODGatherFormatPropertiesAMD(
+ featureBits, rootType,
+ reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_corner_sampled_image
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
- {
- count_VkPhysicalDeviceCornerSampledImageFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: {
+ count_VkPhysicalDeviceCornerSampledImageFeaturesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_external_memory
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
- {
- count_VkExternalMemoryImageCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: {
+ count_VkExternalMemoryImageCreateInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
- {
- count_VkExportMemoryAllocateInfoNV(featureBits, rootType, reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: {
+ count_VkExportMemoryAllocateInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(structExtension), count);
break;
}
#endif
#ifdef VK_NV_external_memory_win32
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
- {
- count_VkImportMemoryWin32HandleInfoNV(featureBits, rootType, reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
+ count_VkImportMemoryWin32HandleInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
- {
- count_VkExportMemoryWin32HandleInfoNV(featureBits, rootType, reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
+ count_VkExportMemoryWin32HandleInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(structExtension), count);
break;
}
#endif
#ifdef VK_NV_win32_keyed_mutex
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
- {
- count_VkWin32KeyedMutexAcquireReleaseInfoNV(featureBits, rootType, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: {
+ count_VkWin32KeyedMutexAcquireReleaseInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_validation_flags
- case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
- {
- count_VkValidationFlagsEXT(featureBits, rootType, reinterpret_cast<const VkValidationFlagsEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: {
+ count_VkValidationFlagsEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkValidationFlagsEXT*>(structExtension), count);
break;
}
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
- {
- count_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
+ count_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_astc_decode_mode
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
- {
- count_VkImageViewASTCDecodeModeEXT(featureBits, rootType, reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
+ count_VkImageViewASTCDecodeModeEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
- {
- count_VkPhysicalDeviceASTCDecodeFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: {
+ count_VkPhysicalDeviceASTCDecodeFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_conditional_rendering
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
- {
- count_VkPhysicalDeviceConditionalRenderingFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
+ count_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
- {
- count_VkCommandBufferInheritanceConditionalRenderingInfoEXT(featureBits, rootType, reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: {
+ count_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_clip_space_w_scaling
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
- {
- count_VkPipelineViewportWScalingStateCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: {
+ count_VkPipelineViewportWScalingStateCreateInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_display_control
- case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
- {
- count_VkSwapchainCounterCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: {
+ count_VkSwapchainCounterCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(structExtension), count);
break;
}
#endif
#ifdef VK_GOOGLE_display_timing
- case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
- {
- count_VkPresentTimesInfoGOOGLE(featureBits, rootType, reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: {
+ count_VkPresentTimesInfoGOOGLE(
+ featureBits, rootType,
+ reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(structExtension), count);
break;
}
#endif
#ifdef VK_NVX_multiview_per_view_attributes
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
- {
- count_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: {
+ count_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_viewport_swizzle
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
- {
- count_VkPipelineViewportSwizzleStateCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: {
+ count_VkPipelineViewportSwizzleStateCreateInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_discard_rectangles
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
- {
- count_VkPhysicalDeviceDiscardRectanglePropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: {
+ count_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
- {
- count_VkPipelineDiscardRectangleStateCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: {
+ count_VkPipelineDiscardRectangleStateCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_conservative_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
- {
- count_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: {
+ count_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
- {
- count_VkPipelineRasterizationConservativeStateCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: {
+ count_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_depth_clip_enable
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
- {
- count_VkPhysicalDeviceDepthClipEnableFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ count_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
- {
- count_VkPipelineRasterizationDepthClipStateCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ count_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_debug_utils
- case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
- {
- count_VkDebugUtilsMessengerCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
+ count_VkDebugUtilsMessengerCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
- {
- count_VkAndroidHardwareBufferUsageANDROID(featureBits, rootType, reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: {
+ count_VkAndroidHardwareBufferUsageANDROID(
+ featureBits, rootType,
+ reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
- {
- count_VkAndroidHardwareBufferFormatPropertiesANDROID(featureBits, rootType, reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: {
+ count_VkAndroidHardwareBufferFormatPropertiesANDROID(
+ featureBits, rootType,
+ reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
- {
- count_VkImportAndroidHardwareBufferInfoANDROID(featureBits, rootType, reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: {
+ count_VkImportAndroidHardwareBufferInfoANDROID(
+ featureBits, rootType,
+ reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
- {
- count_VkExternalFormatANDROID(featureBits, rootType, reinterpret_cast<const VkExternalFormatANDROID*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: {
+ count_VkExternalFormatANDROID(
+ featureBits, rootType,
+ reinterpret_cast<const VkExternalFormatANDROID*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
- {
- count_VkAndroidHardwareBufferFormatProperties2ANDROID(featureBits, rootType, reinterpret_cast<const VkAndroidHardwareBufferFormatProperties2ANDROID*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: {
+ count_VkAndroidHardwareBufferFormatProperties2ANDROID(
+ featureBits, rootType,
+ reinterpret_cast<const VkAndroidHardwareBufferFormatProperties2ANDROID*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_inline_uniform_block
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
- {
- count_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
+ count_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
- {
- count_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
+ count_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT:
- {
- count_VkWriteDescriptorSetInlineUniformBlockEXT(featureBits, rootType, reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
+ count_VkWriteDescriptorSetInlineUniformBlockEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT:
- {
- count_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
+ count_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_sample_locations
- case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
- {
- count_VkSampleLocationsInfoEXT(featureBits, rootType, reinterpret_cast<const VkSampleLocationsInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
+ count_VkSampleLocationsInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkSampleLocationsInfoEXT*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
- {
- count_VkRenderPassSampleLocationsBeginInfoEXT(featureBits, rootType, reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: {
+ count_VkRenderPassSampleLocationsBeginInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
- {
- count_VkPipelineSampleLocationsStateCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: {
+ count_VkPipelineSampleLocationsStateCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
- {
- count_VkPhysicalDeviceSampleLocationsPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: {
+ count_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_blend_operation_advanced
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
- {
- count_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: {
+ count_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
- {
- count_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: {
+ count_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
- {
- count_VkPipelineColorBlendAdvancedStateCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: {
+ count_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_fragment_coverage_to_color
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
- {
- count_VkPipelineCoverageToColorStateCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: {
+ count_VkPipelineCoverageToColorStateCreateInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_framebuffer_mixed_samples
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
- {
- count_VkPipelineCoverageModulationStateCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: {
+ count_VkPipelineCoverageModulationStateCreateInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_shader_sm_builtins
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
- {
- count_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: {
+ count_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
- {
- count_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: {
+ count_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_image_drm_format_modifier
- case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
- {
- count_VkDrmFormatModifierPropertiesListEXT(featureBits, rootType, reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: {
+ count_VkDrmFormatModifierPropertiesListEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
- {
- count_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: {
+ count_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
- {
- count_VkImageDrmFormatModifierListCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: {
+ count_VkImageDrmFormatModifierListCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
- {
- count_VkImageDrmFormatModifierExplicitCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: {
+ count_VkImageDrmFormatModifierExplicitCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
- {
- count_VkDrmFormatModifierPropertiesList2EXT(featureBits, rootType, reinterpret_cast<const VkDrmFormatModifierPropertiesList2EXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: {
+ count_VkDrmFormatModifierPropertiesList2EXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkDrmFormatModifierPropertiesList2EXT*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_validation_cache
- case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
- {
- count_VkShaderModuleValidationCacheCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: {
+ count_VkShaderModuleValidationCacheCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_shading_rate_image
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
- {
- count_VkPipelineViewportShadingRateImageStateCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: {
+ count_VkPipelineViewportShadingRateImageStateCreateInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
- {
- count_VkPhysicalDeviceShadingRateImageFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: {
+ count_VkPhysicalDeviceShadingRateImageFeaturesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
- {
- count_VkPhysicalDeviceShadingRateImagePropertiesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: {
+ count_VkPhysicalDeviceShadingRateImagePropertiesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
- {
- count_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: {
+ count_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_ray_tracing
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
- {
- count_VkWriteDescriptorSetAccelerationStructureNV(featureBits, rootType, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: {
+ count_VkWriteDescriptorSetAccelerationStructureNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
- {
- count_VkPhysicalDeviceRayTracingPropertiesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: {
+ count_VkPhysicalDeviceRayTracingPropertiesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_representative_fragment_test
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
- {
- count_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: {
+ count_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
- {
- count_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: {
+ count_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_filter_cubic
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
- {
- count_VkPhysicalDeviceImageViewImageFormatInfoEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: {
+ count_VkPhysicalDeviceImageViewImageFormatInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
- {
- count_VkFilterCubicImageViewImageFormatPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: {
+ count_VkFilterCubicImageViewImageFormatPropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_global_priority
- case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
- {
- count_VkDeviceQueueGlobalPriorityCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
+ count_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_external_memory_host
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
- {
- count_VkImportMemoryHostPointerInfoEXT(featureBits, rootType, reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
+ count_VkImportMemoryHostPointerInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
- {
- count_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: {
+ count_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_AMD_pipeline_compiler_control
- case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
- {
- count_VkPipelineCompilerControlCreateInfoAMD(featureBits, rootType, reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: {
+ count_VkPipelineCompilerControlCreateInfoAMD(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_AMD_shader_core_properties
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
- {
- count_VkPhysicalDeviceShaderCorePropertiesAMD(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: {
+ count_VkPhysicalDeviceShaderCorePropertiesAMD(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_video_decode_h265
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT:
- {
- count_VkVideoDecodeH265ProfileEXT(featureBits, rootType, reinterpret_cast<const VkVideoDecodeH265ProfileEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT: {
+ count_VkVideoDecodeH265ProfileEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoDecodeH265ProfileEXT*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT:
- {
- count_VkVideoDecodeH265CapabilitiesEXT(featureBits, rootType, reinterpret_cast<const VkVideoDecodeH265CapabilitiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: {
+ count_VkVideoDecodeH265CapabilitiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoDecodeH265CapabilitiesEXT*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT:
- {
- count_VkVideoDecodeH265SessionCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: {
+ count_VkVideoDecodeH265SessionCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- count_VkVideoDecodeH265SessionParametersAddInfoEXT(featureBits, rootType, reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ count_VkVideoDecodeH265SessionParametersAddInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- count_VkVideoDecodeH265SessionParametersCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ count_VkVideoDecodeH265SessionParametersCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT:
- {
- count_VkVideoDecodeH265PictureInfoEXT(featureBits, rootType, reinterpret_cast<const VkVideoDecodeH265PictureInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: {
+ count_VkVideoDecodeH265PictureInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoDecodeH265PictureInfoEXT*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT:
- {
- count_VkVideoDecodeH265DpbSlotInfoEXT(featureBits, rootType, reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: {
+ count_VkVideoDecodeH265DpbSlotInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension), count);
break;
}
#endif
#ifdef VK_AMD_memory_overallocation_behavior
- case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
- {
- count_VkDeviceMemoryOverallocationCreateInfoAMD(featureBits, rootType, reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
+ count_VkDeviceMemoryOverallocationCreateInfoAMD(
+ featureBits, rootType,
+ reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_vertex_attribute_divisor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
- {
- count_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
+ count_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
- {
- count_VkPipelineVertexInputDivisorStateCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: {
+ count_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
- {
- count_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: {
+ count_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_GGP_frame_token
- case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
- {
- count_VkPresentFrameTokenGGP(featureBits, rootType, reinterpret_cast<const VkPresentFrameTokenGGP*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: {
+ count_VkPresentFrameTokenGGP(
+ featureBits, rootType,
+ reinterpret_cast<const VkPresentFrameTokenGGP*>(structExtension), count);
break;
}
#endif
#ifdef VK_EXT_pipeline_creation_feedback
- case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT:
- {
- count_VkPipelineCreationFeedbackCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
+ count_VkPipelineCreationFeedbackCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_compute_shader_derivatives
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
- {
- count_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
+ count_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_mesh_shader
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
- {
- count_VkPhysicalDeviceMeshShaderFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: {
+ count_VkPhysicalDeviceMeshShaderFeaturesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
- {
- count_VkPhysicalDeviceMeshShaderPropertiesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: {
+ count_VkPhysicalDeviceMeshShaderPropertiesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_fragment_shader_barycentric
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV:
- {
- count_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
+ count_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_shader_image_footprint
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
- {
- count_VkPhysicalDeviceShaderImageFootprintFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
+ count_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_scissor_exclusive
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
- {
- count_VkPipelineViewportExclusiveScissorStateCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: {
+ count_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
- {
- count_VkPhysicalDeviceExclusiveScissorFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: {
+ count_VkPhysicalDeviceExclusiveScissorFeaturesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
- {
- count_VkQueueFamilyCheckpointPropertiesNV(featureBits, rootType, reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: {
+ count_VkQueueFamilyCheckpointPropertiesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_INTEL_shader_integer_functions2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
- {
- count_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: {
+ count_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_INTEL_performance_query
- case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
- {
- count_VkQueryPoolPerformanceQueryCreateInfoINTEL(featureBits, rootType, reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: {
+ count_VkQueryPoolPerformanceQueryCreateInfoINTEL(
+ featureBits, rootType,
+ reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_pci_bus_info
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
- {
- count_VkPhysicalDevicePCIBusInfoPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: {
+ count_VkPhysicalDevicePCIBusInfoPropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_AMD_display_native_hdr
- case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
- {
- count_VkDisplayNativeHdrSurfaceCapabilitiesAMD(featureBits, rootType, reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: {
+ count_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
+ featureBits, rootType,
+ reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
- {
- count_VkSwapchainDisplayNativeHdrCreateInfoAMD(featureBits, rootType, reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: {
+ count_VkSwapchainDisplayNativeHdrCreateInfoAMD(
+ featureBits, rootType,
+ reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_fragment_density_map
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
- {
- count_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
+ count_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
- {
- count_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: {
+ count_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
- count_VkImportColorBufferGOOGLE(featureBits, rootType, reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
+ count_VkImportColorBufferGOOGLE(
+ featureBits, rootType,
+ reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension), count);
break;
}
- default:
- {
- count_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension), count);
+ default: {
+ count_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
}
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2:
- {
- count_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: {
+ count_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
- count_VkImportPhysicalAddressGOOGLE(featureBits, rootType, reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
+ count_VkImportPhysicalAddressGOOGLE(
+ featureBits, rootType,
+ reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension),
+ count);
break;
}
- default:
- {
- count_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension), count);
+ default: {
+ count_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
+ structExtension),
+ count);
break;
}
}
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
- {
- count_VkRenderPassFragmentDensityMapCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: {
+ count_VkRenderPassFragmentDensityMapCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2:
- {
- count_VkRenderPassFragmentDensityMapCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: {
+ count_VkRenderPassFragmentDensityMapCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
- count_VkImportBufferGOOGLE(featureBits, rootType, reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
+ count_VkImportBufferGOOGLE(
+ featureBits, rootType,
+ reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension), count);
break;
}
- default:
- {
- count_VkRenderPassFragmentDensityMapCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension), count);
+ default: {
+ count_VkRenderPassFragmentDensityMapCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
}
@@ -19056,628 +16535,881 @@
}
#endif
#ifdef VK_EXT_subgroup_size_control
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
- {
- count_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
+ count_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
- {
- count_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: {
+ count_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:
- {
- count_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: {
+ count_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_AMD_shader_core_properties2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
- {
- count_VkPhysicalDeviceShaderCoreProperties2AMD(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
+ count_VkPhysicalDeviceShaderCoreProperties2AMD(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_AMD_device_coherent_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
- {
- count_VkPhysicalDeviceCoherentMemoryFeaturesAMD(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: {
+ count_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_shader_image_atomic_int64
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
- {
- count_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: {
+ count_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_memory_budget
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
- {
- count_VkPhysicalDeviceMemoryBudgetPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: {
+ count_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_memory_priority
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
- {
- count_VkPhysicalDeviceMemoryPriorityFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: {
+ count_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
- {
- count_VkMemoryPriorityAllocateInfoEXT(featureBits, rootType, reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: {
+ count_VkMemoryPriorityAllocateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>(structExtension), count);
break;
}
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
- {
- count_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: {
+ count_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_buffer_device_address
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
- {
- count_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: {
+ count_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
- {
- count_VkBufferDeviceAddressCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: {
+ count_VkBufferDeviceAddressCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_validation_features
- case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
- {
- count_VkValidationFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkValidationFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: {
+ count_VkValidationFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkValidationFeaturesEXT*>(structExtension), count);
break;
}
#endif
#ifdef VK_NV_cooperative_matrix
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
- {
- count_VkPhysicalDeviceCooperativeMatrixFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: {
+ count_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
- {
- count_VkPhysicalDeviceCooperativeMatrixPropertiesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: {
+ count_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_coverage_reduction_mode
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
- {
- count_VkPhysicalDeviceCoverageReductionModeFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: {
+ count_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
- {
- count_VkPipelineCoverageReductionStateCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: {
+ count_VkPipelineCoverageReductionStateCreateInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_fragment_shader_interlock
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
- {
- count_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: {
+ count_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_ycbcr_image_arrays
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
- {
- count_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: {
+ count_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_provoking_vertex
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
- {
- count_VkPhysicalDeviceProvokingVertexFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
+ count_VkPhysicalDeviceProvokingVertexFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
- {
- count_VkPhysicalDeviceProvokingVertexPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: {
+ count_VkPhysicalDeviceProvokingVertexPropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
- {
- count_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: {
+ count_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_full_screen_exclusive
- case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
- {
- count_VkSurfaceFullScreenExclusiveInfoEXT(featureBits, rootType, reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: {
+ count_VkSurfaceFullScreenExclusiveInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
- {
- count_VkSurfaceCapabilitiesFullScreenExclusiveEXT(featureBits, rootType, reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: {
+ count_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
- {
- count_VkSurfaceFullScreenExclusiveWin32InfoEXT(featureBits, rootType, reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: {
+ count_VkSurfaceFullScreenExclusiveWin32InfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_line_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
- {
- count_VkPhysicalDeviceLineRasterizationFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: {
+ count_VkPhysicalDeviceLineRasterizationFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
- {
- count_VkPhysicalDeviceLineRasterizationPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: {
+ count_VkPhysicalDeviceLineRasterizationPropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
- {
- count_VkPipelineRasterizationLineStateCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: {
+ count_VkPipelineRasterizationLineStateCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_shader_atomic_float
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
- {
- count_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: {
+ count_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_index_type_uint8
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
- {
- count_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: {
+ count_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
- {
- count_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: {
+ count_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_shader_atomic_float2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
- {
- count_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: {
+ count_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
- {
- count_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
+ count_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_device_generated_commands
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
- {
- count_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: {
+ count_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
- {
- count_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: {
+ count_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
- {
- count_VkGraphicsPipelineShaderGroupsCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: {
+ count_VkGraphicsPipelineShaderGroupsCreateInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_inherited_viewport_scissor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
- {
- count_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: {
+ count_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
- {
- count_VkCommandBufferInheritanceViewportScissorInfoNV(featureBits, rootType, reinterpret_cast<const VkCommandBufferInheritanceViewportScissorInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: {
+ count_VkCommandBufferInheritanceViewportScissorInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkCommandBufferInheritanceViewportScissorInfoNV*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_texel_buffer_alignment
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
- {
- count_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
+ count_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
- {
- count_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
+ count_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_QCOM_render_pass_transform
- case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
- {
- count_VkRenderPassTransformBeginInfoQCOM(featureBits, rootType, reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
+ count_VkRenderPassTransformBeginInfoQCOM(
+ featureBits, rootType,
+ reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
- {
- count_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(featureBits, rootType, reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: {
+ count_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
+ featureBits, rootType,
+ reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_device_memory_report
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
- {
- count_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: {
+ count_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
- {
- count_VkDeviceDeviceMemoryReportCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: {
+ count_VkDeviceDeviceMemoryReportCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_robustness2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
- {
- count_VkPhysicalDeviceRobustness2FeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: {
+ count_VkPhysicalDeviceRobustness2FeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
- {
- count_VkPhysicalDeviceRobustness2PropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: {
+ count_VkPhysicalDeviceRobustness2PropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_custom_border_color
- case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
- {
- count_VkSamplerCustomBorderColorCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: {
+ count_VkSamplerCustomBorderColorCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
- {
- count_VkPhysicalDeviceCustomBorderColorPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: {
+ count_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
- {
- count_VkPhysicalDeviceCustomBorderColorFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: {
+ count_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_private_data
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT:
- {
- count_VkPhysicalDevicePrivateDataFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
+ count_VkPhysicalDevicePrivateDataFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
- {
- count_VkDevicePrivateDataCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkDevicePrivateDataCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: {
+ count_VkDevicePrivateDataCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkDevicePrivateDataCreateInfoEXT*>(structExtension), count);
break;
}
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT:
- {
- count_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
+ count_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_device_diagnostics_config
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
- {
- count_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: {
+ count_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
- {
- count_VkDeviceDiagnosticsConfigCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: {
+ count_VkDeviceDiagnosticsConfigCreateInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_fragment_shading_rate_enums
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
- {
- count_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
+ count_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
- {
- count_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: {
+ count_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
- {
- count_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(featureBits, rootType, reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: {
+ count_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_ray_tracing_motion_blur
- case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
- {
- count_VkAccelerationStructureGeometryMotionTrianglesDataNV(featureBits, rootType, reinterpret_cast<const VkAccelerationStructureGeometryMotionTrianglesDataNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: {
+ count_VkAccelerationStructureGeometryMotionTrianglesDataNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkAccelerationStructureGeometryMotionTrianglesDataNV*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
- {
- count_VkAccelerationStructureMotionInfoNV(featureBits, rootType, reinterpret_cast<const VkAccelerationStructureMotionInfoNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: {
+ count_VkAccelerationStructureMotionInfoNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkAccelerationStructureMotionInfoNV*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
- {
- count_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: {
+ count_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
- {
- count_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: {
+ count_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_fragment_density_map2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
- {
- count_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: {
+ count_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
- {
- count_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: {
+ count_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_QCOM_rotated_copy_commands
- case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
- {
- count_VkCopyCommandTransformInfoQCOM(featureBits, rootType, reinterpret_cast<const VkCopyCommandTransformInfoQCOM*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: {
+ count_VkCopyCommandTransformInfoQCOM(
+ featureBits, rootType,
+ reinterpret_cast<const VkCopyCommandTransformInfoQCOM*>(structExtension), count);
break;
}
#endif
#ifdef VK_EXT_image_robustness
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:
- {
- count_VkPhysicalDeviceImageRobustnessFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
+ count_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_4444_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
- {
- count_VkPhysicalDevice4444FormatsFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: {
+ count_VkPhysicalDevice4444FormatsFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_rgba10x6_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
- {
- count_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
+ count_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_VALVE_mutable_descriptor_type
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE:
- {
- count_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: {
+ count_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE:
- {
- count_VkMutableDescriptorTypeCreateInfoVALVE(featureBits, rootType, reinterpret_cast<const VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: {
+ count_VkMutableDescriptorTypeCreateInfoVALVE(
+ featureBits, rootType,
+ reinterpret_cast<const VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
- {
- count_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: {
+ count_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_physical_device_drm
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
- {
- count_VkPhysicalDeviceDrmPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceDrmPropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: {
+ count_VkPhysicalDeviceDrmPropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDrmPropertiesEXT*>(structExtension), count);
break;
}
#endif
#ifdef VK_EXT_primitive_topology_list_restart
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
- {
- count_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
+ count_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_FUCHSIA_external_memory
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
- {
- count_VkImportMemoryZirconHandleInfoFUCHSIA(featureBits, rootType, reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: {
+ count_VkImportMemoryZirconHandleInfoFUCHSIA(
+ featureBits, rootType,
+ reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
- {
- count_VkImportMemoryBufferCollectionFUCHSIA(featureBits, rootType, reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIA*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: {
+ count_VkImportMemoryBufferCollectionFUCHSIA(
+ featureBits, rootType,
+ reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIA*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
- {
- count_VkBufferCollectionImageCreateInfoFUCHSIA(featureBits, rootType, reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIA*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: {
+ count_VkBufferCollectionImageCreateInfoFUCHSIA(
+ featureBits, rootType,
+ reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIA*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
- {
- count_VkBufferCollectionBufferCreateInfoFUCHSIA(featureBits, rootType, reinterpret_cast<const VkBufferCollectionBufferCreateInfoFUCHSIA*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: {
+ count_VkBufferCollectionBufferCreateInfoFUCHSIA(
+ featureBits, rootType,
+ reinterpret_cast<const VkBufferCollectionBufferCreateInfoFUCHSIA*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_HUAWEI_subpass_shading
- case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
- {
- count_VkSubpassShadingPipelineCreateInfoHUAWEI(featureBits, rootType, reinterpret_cast<const VkSubpassShadingPipelineCreateInfoHUAWEI*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: {
+ count_VkSubpassShadingPipelineCreateInfoHUAWEI(
+ featureBits, rootType,
+ reinterpret_cast<const VkSubpassShadingPipelineCreateInfoHUAWEI*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
- {
- count_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: {
+ count_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
- {
- count_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: {
+ count_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_HUAWEI_invocation_mask
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
- {
- count_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: {
+ count_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_NV_external_memory_rdma
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
- {
- count_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: {
+ count_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_extended_dynamic_state2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
- {
- count_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
+ count_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_color_write_enable
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
- {
- count_VkPhysicalDeviceColorWriteEnableFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: {
+ count_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
- {
- count_VkPipelineColorWriteCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkPipelineColorWriteCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: {
+ count_VkPipelineColorWriteCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPipelineColorWriteCreateInfoEXT*>(structExtension), count);
break;
}
#endif
#ifdef VK_GOOGLE_gfxstream
- case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
- {
- count_VkImportColorBufferGOOGLE(featureBits, rootType, reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
+ count_VkImportColorBufferGOOGLE(
+ featureBits, rootType,
+ reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
- {
- count_VkImportBufferGOOGLE(featureBits, rootType, reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE: {
+ count_VkImportBufferGOOGLE(
+ featureBits, rootType,
+ reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension), count);
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
- {
- count_VkImportPhysicalAddressGOOGLE(featureBits, rootType, reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE: {
+ count_VkImportPhysicalAddressGOOGLE(
+ featureBits, rootType,
+ reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension), count);
break;
}
#endif
#ifdef VK_EXT_global_priority_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT:
- {
- count_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
+ count_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT:
- {
- count_VkQueueFamilyGlobalPriorityPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: {
+ count_VkQueueFamilyGlobalPriorityPropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_multi_draw
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
- {
- count_VkPhysicalDeviceMultiDrawFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: {
+ count_VkPhysicalDeviceMultiDrawFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT*>(structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
- {
- count_VkPhysicalDeviceMultiDrawPropertiesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceMultiDrawPropertiesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: {
+ count_VkPhysicalDeviceMultiDrawPropertiesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMultiDrawPropertiesEXT*>(structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_border_color_swizzle
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
- {
- count_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
+ count_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
- {
- count_VkSamplerBorderColorComponentMappingCreateInfoEXT(featureBits, rootType, reinterpret_cast<const VkSamplerBorderColorComponentMappingCreateInfoEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: {
+ count_VkSamplerBorderColorComponentMappingCreateInfoEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkSamplerBorderColorComponentMappingCreateInfoEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_EXT_pageable_device_local_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
- {
- count_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(featureBits, rootType, reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: {
+ count_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_acceleration_structure
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
- {
- count_VkWriteDescriptorSetAccelerationStructureKHR(featureBits, rootType, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
+ count_VkWriteDescriptorSetAccelerationStructureKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
- {
- count_VkPhysicalDeviceAccelerationStructureFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: {
+ count_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
- {
- count_VkPhysicalDeviceAccelerationStructurePropertiesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: {
+ count_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
- {
- count_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
+ count_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
+ structExtension),
+ count);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
- {
- count_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: {
+ count_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(
+ structExtension),
+ count);
break;
}
#endif
#ifdef VK_KHR_ray_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
- {
- count_VkPhysicalDeviceRayQueryFeaturesKHR(featureBits, rootType, reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension), count);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: {
+ count_VkPhysicalDeviceRayQueryFeaturesKHR(
+ featureBits, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension),
+ count);
break;
}
#endif
- default:
- {
+ default: {
// fatal; the switch is only taken if the extension struct is known
abort();
}
}
}
-
-} // namespace goldfish_vk
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_counting_guest.h b/system/vulkan_enc/goldfish_vk_counting_guest.h
index 81d11da..6e959ad 100644
--- a/system/vulkan_enc/goldfish_vk_counting_guest.h
+++ b/system/vulkan_enc/goldfish_vk_counting_guest.h
@@ -14,1738 +14,1034 @@
// limitations under the License.
// Autogenerated module goldfish_vk_counting_guest
-// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal -o ../qemu/android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+//
+// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
+// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
-// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
-
+//
+// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
+// $CEREAL_OUTPUT_DIR
+//
#pragma once
-
#include <vulkan/vulkan.h>
-
-#include "vk_platform_compat.h"
#include "goldfish_vk_private_defs.h"
-
+#include "vk_platform_compat.h"
+#include "vulkan_gfxstream.h"
namespace goldfish_vk {
-
#ifdef VK_VERSION_1_0
-void count_VkExtent2D(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExtent2D* toCount,
- size_t* count);
+void count_VkExtent2D(uint32_t featureBits, VkStructureType rootType, const VkExtent2D* toCount,
+ size_t* count);
-void count_VkExtent3D(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExtent3D* toCount,
- size_t* count);
+void count_VkExtent3D(uint32_t featureBits, VkStructureType rootType, const VkExtent3D* toCount,
+ size_t* count);
-void count_VkOffset2D(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkOffset2D* toCount,
- size_t* count);
+void count_VkOffset2D(uint32_t featureBits, VkStructureType rootType, const VkOffset2D* toCount,
+ size_t* count);
-void count_VkOffset3D(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkOffset3D* toCount,
- size_t* count);
+void count_VkOffset3D(uint32_t featureBits, VkStructureType rootType, const VkOffset3D* toCount,
+ size_t* count);
-void count_VkRect2D(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRect2D* toCount,
- size_t* count);
+void count_VkRect2D(uint32_t featureBits, VkStructureType rootType, const VkRect2D* toCount,
+ size_t* count);
-void count_VkBaseInStructure(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBaseInStructure* toCount,
- size_t* count);
+void count_VkBaseInStructure(uint32_t featureBits, VkStructureType rootType,
+ const VkBaseInStructure* toCount, size_t* count);
-void count_VkBaseOutStructure(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBaseOutStructure* toCount,
- size_t* count);
+void count_VkBaseOutStructure(uint32_t featureBits, VkStructureType rootType,
+ const VkBaseOutStructure* toCount, size_t* count);
-void count_VkBufferMemoryBarrier(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferMemoryBarrier* toCount,
- size_t* count);
+void count_VkBufferMemoryBarrier(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferMemoryBarrier* toCount, size_t* count);
-void count_VkDispatchIndirectCommand(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDispatchIndirectCommand* toCount,
- size_t* count);
+void count_VkDispatchIndirectCommand(uint32_t featureBits, VkStructureType rootType,
+ const VkDispatchIndirectCommand* toCount, size_t* count);
-void count_VkDrawIndexedIndirectCommand(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDrawIndexedIndirectCommand* toCount,
- size_t* count);
+void count_VkDrawIndexedIndirectCommand(uint32_t featureBits, VkStructureType rootType,
+ const VkDrawIndexedIndirectCommand* toCount, size_t* count);
-void count_VkDrawIndirectCommand(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDrawIndirectCommand* toCount,
- size_t* count);
+void count_VkDrawIndirectCommand(uint32_t featureBits, VkStructureType rootType,
+ const VkDrawIndirectCommand* toCount, size_t* count);
-void count_VkImageSubresourceRange(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageSubresourceRange* toCount,
- size_t* count);
+void count_VkImageSubresourceRange(uint32_t featureBits, VkStructureType rootType,
+ const VkImageSubresourceRange* toCount, size_t* count);
-void count_VkImageMemoryBarrier(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageMemoryBarrier* toCount,
- size_t* count);
+void count_VkImageMemoryBarrier(uint32_t featureBits, VkStructureType rootType,
+ const VkImageMemoryBarrier* toCount, size_t* count);
-void count_VkMemoryBarrier(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryBarrier* toCount,
- size_t* count);
+void count_VkMemoryBarrier(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryBarrier* toCount, size_t* count);
-void count_VkPipelineCacheHeaderVersionOne(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineCacheHeaderVersionOne* toCount,
- size_t* count);
+void count_VkPipelineCacheHeaderVersionOne(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineCacheHeaderVersionOne* toCount,
+ size_t* count);
-void count_VkAllocationCallbacks(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAllocationCallbacks* toCount,
- size_t* count);
+void count_VkAllocationCallbacks(uint32_t featureBits, VkStructureType rootType,
+ const VkAllocationCallbacks* toCount, size_t* count);
-void count_VkApplicationInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkApplicationInfo* toCount,
- size_t* count);
+void count_VkApplicationInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkApplicationInfo* toCount, size_t* count);
-void count_VkFormatProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFormatProperties* toCount,
- size_t* count);
+void count_VkFormatProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkFormatProperties* toCount, size_t* count);
-void count_VkImageFormatProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageFormatProperties* toCount,
- size_t* count);
+void count_VkImageFormatProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkImageFormatProperties* toCount, size_t* count);
-void count_VkInstanceCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkInstanceCreateInfo* toCount,
- size_t* count);
+void count_VkInstanceCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkInstanceCreateInfo* toCount, size_t* count);
-void count_VkMemoryHeap(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryHeap* toCount,
- size_t* count);
+void count_VkMemoryHeap(uint32_t featureBits, VkStructureType rootType, const VkMemoryHeap* toCount,
+ size_t* count);
-void count_VkMemoryType(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryType* toCount,
- size_t* count);
+void count_VkMemoryType(uint32_t featureBits, VkStructureType rootType, const VkMemoryType* toCount,
+ size_t* count);
-void count_VkPhysicalDeviceFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFeatures* toCount,
- size_t* count);
+void count_VkPhysicalDeviceFeatures(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFeatures* toCount, size_t* count);
-void count_VkPhysicalDeviceLimits(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceLimits* toCount,
- size_t* count);
+void count_VkPhysicalDeviceLimits(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceLimits* toCount, size_t* count);
-void count_VkPhysicalDeviceMemoryProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryProperties* toCount,
- size_t* count);
+void count_VkPhysicalDeviceMemoryProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryProperties* toCount,
+ size_t* count);
-void count_VkPhysicalDeviceSparseProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSparseProperties* toCount,
- size_t* count);
+void count_VkPhysicalDeviceSparseProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSparseProperties* toCount,
+ size_t* count);
-void count_VkPhysicalDeviceProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceProperties* toCount,
- size_t* count);
+void count_VkPhysicalDeviceProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceProperties* toCount, size_t* count);
-void count_VkQueueFamilyProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkQueueFamilyProperties* toCount,
- size_t* count);
+void count_VkQueueFamilyProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkQueueFamilyProperties* toCount, size_t* count);
-void count_VkDeviceQueueCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceQueueCreateInfo* toCount,
- size_t* count);
+void count_VkDeviceQueueCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceQueueCreateInfo* toCount, size_t* count);
-void count_VkDeviceCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceCreateInfo* toCount,
- size_t* count);
+void count_VkDeviceCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceCreateInfo* toCount, size_t* count);
-void count_VkExtensionProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExtensionProperties* toCount,
- size_t* count);
+void count_VkExtensionProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkExtensionProperties* toCount, size_t* count);
-void count_VkLayerProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkLayerProperties* toCount,
- size_t* count);
+void count_VkLayerProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkLayerProperties* toCount, size_t* count);
-void count_VkSubmitInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubmitInfo* toCount,
- size_t* count);
+void count_VkSubmitInfo(uint32_t featureBits, VkStructureType rootType, const VkSubmitInfo* toCount,
+ size_t* count);
-void count_VkMappedMemoryRange(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMappedMemoryRange* toCount,
- size_t* count);
+void count_VkMappedMemoryRange(uint32_t featureBits, VkStructureType rootType,
+ const VkMappedMemoryRange* toCount, size_t* count);
-void count_VkMemoryAllocateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryAllocateInfo* toCount,
- size_t* count);
+void count_VkMemoryAllocateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryAllocateInfo* toCount, size_t* count);
-void count_VkMemoryRequirements(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryRequirements* toCount,
- size_t* count);
+void count_VkMemoryRequirements(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryRequirements* toCount, size_t* count);
-void count_VkSparseMemoryBind(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSparseMemoryBind* toCount,
- size_t* count);
+void count_VkSparseMemoryBind(uint32_t featureBits, VkStructureType rootType,
+ const VkSparseMemoryBind* toCount, size_t* count);
-void count_VkSparseBufferMemoryBindInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSparseBufferMemoryBindInfo* toCount,
- size_t* count);
+void count_VkSparseBufferMemoryBindInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSparseBufferMemoryBindInfo* toCount, size_t* count);
-void count_VkSparseImageOpaqueMemoryBindInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSparseImageOpaqueMemoryBindInfo* toCount,
- size_t* count);
+void count_VkSparseImageOpaqueMemoryBindInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSparseImageOpaqueMemoryBindInfo* toCount,
+ size_t* count);
-void count_VkImageSubresource(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageSubresource* toCount,
- size_t* count);
+void count_VkImageSubresource(uint32_t featureBits, VkStructureType rootType,
+ const VkImageSubresource* toCount, size_t* count);
-void count_VkSparseImageMemoryBind(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSparseImageMemoryBind* toCount,
- size_t* count);
+void count_VkSparseImageMemoryBind(uint32_t featureBits, VkStructureType rootType,
+ const VkSparseImageMemoryBind* toCount, size_t* count);
-void count_VkSparseImageMemoryBindInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSparseImageMemoryBindInfo* toCount,
- size_t* count);
+void count_VkSparseImageMemoryBindInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSparseImageMemoryBindInfo* toCount, size_t* count);
-void count_VkBindSparseInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindSparseInfo* toCount,
- size_t* count);
+void count_VkBindSparseInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBindSparseInfo* toCount, size_t* count);
-void count_VkSparseImageFormatProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSparseImageFormatProperties* toCount,
- size_t* count);
+void count_VkSparseImageFormatProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkSparseImageFormatProperties* toCount,
+ size_t* count);
-void count_VkSparseImageMemoryRequirements(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSparseImageMemoryRequirements* toCount,
- size_t* count);
+void count_VkSparseImageMemoryRequirements(uint32_t featureBits, VkStructureType rootType,
+ const VkSparseImageMemoryRequirements* toCount,
+ size_t* count);
-void count_VkFenceCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFenceCreateInfo* toCount,
- size_t* count);
+void count_VkFenceCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkFenceCreateInfo* toCount, size_t* count);
-void count_VkSemaphoreCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSemaphoreCreateInfo* toCount,
- size_t* count);
+void count_VkSemaphoreCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSemaphoreCreateInfo* toCount, size_t* count);
-void count_VkEventCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkEventCreateInfo* toCount,
- size_t* count);
+void count_VkEventCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkEventCreateInfo* toCount, size_t* count);
-void count_VkQueryPoolCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkQueryPoolCreateInfo* toCount,
- size_t* count);
+void count_VkQueryPoolCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkQueryPoolCreateInfo* toCount, size_t* count);
-void count_VkBufferCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferCreateInfo* toCount,
- size_t* count);
+void count_VkBufferCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferCreateInfo* toCount, size_t* count);
-void count_VkBufferViewCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferViewCreateInfo* toCount,
- size_t* count);
+void count_VkBufferViewCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferViewCreateInfo* toCount, size_t* count);
-void count_VkImageCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageCreateInfo* toCount,
- size_t* count);
+void count_VkImageCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkImageCreateInfo* toCount, size_t* count);
-void count_VkSubresourceLayout(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubresourceLayout* toCount,
- size_t* count);
+void count_VkSubresourceLayout(uint32_t featureBits, VkStructureType rootType,
+ const VkSubresourceLayout* toCount, size_t* count);
-void count_VkComponentMapping(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkComponentMapping* toCount,
- size_t* count);
+void count_VkComponentMapping(uint32_t featureBits, VkStructureType rootType,
+ const VkComponentMapping* toCount, size_t* count);
-void count_VkImageViewCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageViewCreateInfo* toCount,
- size_t* count);
+void count_VkImageViewCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkImageViewCreateInfo* toCount, size_t* count);
-void count_VkShaderModuleCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkShaderModuleCreateInfo* toCount,
- size_t* count);
+void count_VkShaderModuleCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkShaderModuleCreateInfo* toCount, size_t* count);
-void count_VkPipelineCacheCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineCacheCreateInfo* toCount,
- size_t* count);
+void count_VkPipelineCacheCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineCacheCreateInfo* toCount, size_t* count);
-void count_VkSpecializationMapEntry(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSpecializationMapEntry* toCount,
- size_t* count);
+void count_VkSpecializationMapEntry(uint32_t featureBits, VkStructureType rootType,
+ const VkSpecializationMapEntry* toCount, size_t* count);
-void count_VkSpecializationInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSpecializationInfo* toCount,
- size_t* count);
+void count_VkSpecializationInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSpecializationInfo* toCount, size_t* count);
-void count_VkPipelineShaderStageCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineShaderStageCreateInfo* toCount,
- size_t* count);
+void count_VkPipelineShaderStageCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineShaderStageCreateInfo* toCount,
+ size_t* count);
-void count_VkComputePipelineCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkComputePipelineCreateInfo* toCount,
- size_t* count);
+void count_VkComputePipelineCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkComputePipelineCreateInfo* toCount, size_t* count);
-void count_VkVertexInputBindingDescription(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVertexInputBindingDescription* toCount,
- size_t* count);
+void count_VkVertexInputBindingDescription(uint32_t featureBits, VkStructureType rootType,
+ const VkVertexInputBindingDescription* toCount,
+ size_t* count);
-void count_VkVertexInputAttributeDescription(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVertexInputAttributeDescription* toCount,
- size_t* count);
+void count_VkVertexInputAttributeDescription(uint32_t featureBits, VkStructureType rootType,
+ const VkVertexInputAttributeDescription* toCount,
+ size_t* count);
-void count_VkPipelineVertexInputStateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineVertexInputStateCreateInfo* toCount,
- size_t* count);
+void count_VkPipelineVertexInputStateCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineVertexInputStateCreateInfo* toCount,
+ size_t* count);
void count_VkPipelineInputAssemblyStateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineInputAssemblyStateCreateInfo* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineInputAssemblyStateCreateInfo* toCount, size_t* count);
void count_VkPipelineTessellationStateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineTessellationStateCreateInfo* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineTessellationStateCreateInfo* toCount, size_t* count);
-void count_VkViewport(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkViewport* toCount,
- size_t* count);
+void count_VkViewport(uint32_t featureBits, VkStructureType rootType, const VkViewport* toCount,
+ size_t* count);
-void count_VkPipelineViewportStateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineViewportStateCreateInfo* toCount,
- size_t* count);
+void count_VkPipelineViewportStateCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineViewportStateCreateInfo* toCount,
+ size_t* count);
void count_VkPipelineRasterizationStateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineRasterizationStateCreateInfo* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRasterizationStateCreateInfo* toCount, size_t* count);
-void count_VkPipelineMultisampleStateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineMultisampleStateCreateInfo* toCount,
- size_t* count);
+void count_VkPipelineMultisampleStateCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineMultisampleStateCreateInfo* toCount,
+ size_t* count);
-void count_VkStencilOpState(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkStencilOpState* toCount,
- size_t* count);
+void count_VkStencilOpState(uint32_t featureBits, VkStructureType rootType,
+ const VkStencilOpState* toCount, size_t* count);
void count_VkPipelineDepthStencilStateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineDepthStencilStateCreateInfo* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineDepthStencilStateCreateInfo* toCount, size_t* count);
-void count_VkPipelineColorBlendAttachmentState(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineColorBlendAttachmentState* toCount,
- size_t* count);
+void count_VkPipelineColorBlendAttachmentState(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineColorBlendAttachmentState* toCount,
+ size_t* count);
-void count_VkPipelineColorBlendStateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineColorBlendStateCreateInfo* toCount,
- size_t* count);
+void count_VkPipelineColorBlendStateCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineColorBlendStateCreateInfo* toCount,
+ size_t* count);
-void count_VkPipelineDynamicStateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineDynamicStateCreateInfo* toCount,
- size_t* count);
+void count_VkPipelineDynamicStateCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineDynamicStateCreateInfo* toCount,
+ size_t* count);
-void count_VkGraphicsPipelineCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkGraphicsPipelineCreateInfo* toCount,
- size_t* count);
+void count_VkGraphicsPipelineCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkGraphicsPipelineCreateInfo* toCount, size_t* count);
-void count_VkPushConstantRange(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPushConstantRange* toCount,
- size_t* count);
+void count_VkPushConstantRange(uint32_t featureBits, VkStructureType rootType,
+ const VkPushConstantRange* toCount, size_t* count);
-void count_VkPipelineLayoutCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineLayoutCreateInfo* toCount,
- size_t* count);
+void count_VkPipelineLayoutCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineLayoutCreateInfo* toCount, size_t* count);
-void count_VkSamplerCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSamplerCreateInfo* toCount,
- size_t* count);
+void count_VkSamplerCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSamplerCreateInfo* toCount, size_t* count);
-void count_VkCopyDescriptorSet(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCopyDescriptorSet* toCount,
- size_t* count);
+void count_VkCopyDescriptorSet(uint32_t featureBits, VkStructureType rootType,
+ const VkCopyDescriptorSet* toCount, size_t* count);
-void count_VkDescriptorBufferInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorBufferInfo* toCount,
- size_t* count);
+void count_VkDescriptorBufferInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorBufferInfo* toCount, size_t* count);
-void count_VkDescriptorImageInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorImageInfo* toCount,
- size_t* count);
+void count_VkDescriptorImageInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorImageInfo* toCount, size_t* count);
-void count_VkDescriptorPoolSize(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorPoolSize* toCount,
- size_t* count);
+void count_VkDescriptorPoolSize(uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorPoolSize* toCount, size_t* count);
-void count_VkDescriptorPoolCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorPoolCreateInfo* toCount,
- size_t* count);
+void count_VkDescriptorPoolCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorPoolCreateInfo* toCount, size_t* count);
-void count_VkDescriptorSetAllocateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorSetAllocateInfo* toCount,
- size_t* count);
+void count_VkDescriptorSetAllocateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorSetAllocateInfo* toCount, size_t* count);
-void count_VkDescriptorSetLayoutBinding(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorSetLayoutBinding* toCount,
- size_t* count);
+void count_VkDescriptorSetLayoutBinding(uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorSetLayoutBinding* toCount, size_t* count);
-void count_VkDescriptorSetLayoutCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorSetLayoutCreateInfo* toCount,
- size_t* count);
+void count_VkDescriptorSetLayoutCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorSetLayoutCreateInfo* toCount,
+ size_t* count);
-void count_VkWriteDescriptorSet(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkWriteDescriptorSet* toCount,
- size_t* count);
+void count_VkWriteDescriptorSet(uint32_t featureBits, VkStructureType rootType,
+ const VkWriteDescriptorSet* toCount, size_t* count);
-void count_VkAttachmentDescription(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAttachmentDescription* toCount,
- size_t* count);
+void count_VkAttachmentDescription(uint32_t featureBits, VkStructureType rootType,
+ const VkAttachmentDescription* toCount, size_t* count);
-void count_VkAttachmentReference(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAttachmentReference* toCount,
- size_t* count);
+void count_VkAttachmentReference(uint32_t featureBits, VkStructureType rootType,
+ const VkAttachmentReference* toCount, size_t* count);
-void count_VkFramebufferCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFramebufferCreateInfo* toCount,
- size_t* count);
+void count_VkFramebufferCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkFramebufferCreateInfo* toCount, size_t* count);
-void count_VkSubpassDescription(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubpassDescription* toCount,
- size_t* count);
+void count_VkSubpassDescription(uint32_t featureBits, VkStructureType rootType,
+ const VkSubpassDescription* toCount, size_t* count);
-void count_VkSubpassDependency(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubpassDependency* toCount,
- size_t* count);
+void count_VkSubpassDependency(uint32_t featureBits, VkStructureType rootType,
+ const VkSubpassDependency* toCount, size_t* count);
-void count_VkRenderPassCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderPassCreateInfo* toCount,
- size_t* count);
+void count_VkRenderPassCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderPassCreateInfo* toCount, size_t* count);
-void count_VkCommandPoolCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCommandPoolCreateInfo* toCount,
- size_t* count);
+void count_VkCommandPoolCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkCommandPoolCreateInfo* toCount, size_t* count);
-void count_VkCommandBufferAllocateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCommandBufferAllocateInfo* toCount,
- size_t* count);
+void count_VkCommandBufferAllocateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkCommandBufferAllocateInfo* toCount, size_t* count);
-void count_VkCommandBufferInheritanceInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCommandBufferInheritanceInfo* toCount,
- size_t* count);
+void count_VkCommandBufferInheritanceInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkCommandBufferInheritanceInfo* toCount,
+ size_t* count);
-void count_VkCommandBufferBeginInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCommandBufferBeginInfo* toCount,
- size_t* count);
+void count_VkCommandBufferBeginInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkCommandBufferBeginInfo* toCount, size_t* count);
-void count_VkBufferCopy(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferCopy* toCount,
- size_t* count);
+void count_VkBufferCopy(uint32_t featureBits, VkStructureType rootType, const VkBufferCopy* toCount,
+ size_t* count);
-void count_VkImageSubresourceLayers(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageSubresourceLayers* toCount,
- size_t* count);
+void count_VkImageSubresourceLayers(uint32_t featureBits, VkStructureType rootType,
+ const VkImageSubresourceLayers* toCount, size_t* count);
-void count_VkBufferImageCopy(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferImageCopy* toCount,
- size_t* count);
+void count_VkBufferImageCopy(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferImageCopy* toCount, size_t* count);
-void count_VkClearColorValue(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkClearColorValue* toCount,
- size_t* count);
+void count_VkClearColorValue(uint32_t featureBits, VkStructureType rootType,
+ const VkClearColorValue* toCount, size_t* count);
-void count_VkClearDepthStencilValue(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkClearDepthStencilValue* toCount,
- size_t* count);
+void count_VkClearDepthStencilValue(uint32_t featureBits, VkStructureType rootType,
+ const VkClearDepthStencilValue* toCount, size_t* count);
-void count_VkClearValue(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkClearValue* toCount,
- size_t* count);
+void count_VkClearValue(uint32_t featureBits, VkStructureType rootType, const VkClearValue* toCount,
+ size_t* count);
-void count_VkClearAttachment(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkClearAttachment* toCount,
- size_t* count);
+void count_VkClearAttachment(uint32_t featureBits, VkStructureType rootType,
+ const VkClearAttachment* toCount, size_t* count);
-void count_VkClearRect(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkClearRect* toCount,
- size_t* count);
+void count_VkClearRect(uint32_t featureBits, VkStructureType rootType, const VkClearRect* toCount,
+ size_t* count);
-void count_VkImageBlit(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageBlit* toCount,
- size_t* count);
+void count_VkImageBlit(uint32_t featureBits, VkStructureType rootType, const VkImageBlit* toCount,
+ size_t* count);
-void count_VkImageCopy(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageCopy* toCount,
- size_t* count);
+void count_VkImageCopy(uint32_t featureBits, VkStructureType rootType, const VkImageCopy* toCount,
+ size_t* count);
-void count_VkImageResolve(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageResolve* toCount,
- size_t* count);
+void count_VkImageResolve(uint32_t featureBits, VkStructureType rootType,
+ const VkImageResolve* toCount, size_t* count);
-void count_VkRenderPassBeginInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderPassBeginInfo* toCount,
- size_t* count);
+void count_VkRenderPassBeginInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderPassBeginInfo* toCount, size_t* count);
#endif
#ifdef VK_VERSION_1_1
-void count_VkPhysicalDeviceSubgroupProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSubgroupProperties* toCount,
- size_t* count);
+void count_VkPhysicalDeviceSubgroupProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSubgroupProperties* toCount,
+ size_t* count);
-void count_VkBindBufferMemoryInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindBufferMemoryInfo* toCount,
- size_t* count);
+void count_VkBindBufferMemoryInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBindBufferMemoryInfo* toCount, size_t* count);
-void count_VkBindImageMemoryInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindImageMemoryInfo* toCount,
- size_t* count);
+void count_VkBindImageMemoryInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBindImageMemoryInfo* toCount, size_t* count);
-void count_VkPhysicalDevice16BitStorageFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevice16BitStorageFeatures* toCount,
- size_t* count);
+void count_VkPhysicalDevice16BitStorageFeatures(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevice16BitStorageFeatures* toCount,
+ size_t* count);
-void count_VkMemoryDedicatedRequirements(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryDedicatedRequirements* toCount,
- size_t* count);
+void count_VkMemoryDedicatedRequirements(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryDedicatedRequirements* toCount,
+ size_t* count);
-void count_VkMemoryDedicatedAllocateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryDedicatedAllocateInfo* toCount,
- size_t* count);
+void count_VkMemoryDedicatedAllocateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryDedicatedAllocateInfo* toCount,
+ size_t* count);
-void count_VkMemoryAllocateFlagsInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryAllocateFlagsInfo* toCount,
- size_t* count);
+void count_VkMemoryAllocateFlagsInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryAllocateFlagsInfo* toCount, size_t* count);
-void count_VkDeviceGroupRenderPassBeginInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceGroupRenderPassBeginInfo* toCount,
- size_t* count);
+void count_VkDeviceGroupRenderPassBeginInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceGroupRenderPassBeginInfo* toCount,
+ size_t* count);
-void count_VkDeviceGroupCommandBufferBeginInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceGroupCommandBufferBeginInfo* toCount,
- size_t* count);
+void count_VkDeviceGroupCommandBufferBeginInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceGroupCommandBufferBeginInfo* toCount,
+ size_t* count);
-void count_VkDeviceGroupSubmitInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceGroupSubmitInfo* toCount,
- size_t* count);
+void count_VkDeviceGroupSubmitInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceGroupSubmitInfo* toCount, size_t* count);
-void count_VkDeviceGroupBindSparseInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceGroupBindSparseInfo* toCount,
- size_t* count);
+void count_VkDeviceGroupBindSparseInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceGroupBindSparseInfo* toCount, size_t* count);
-void count_VkBindBufferMemoryDeviceGroupInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindBufferMemoryDeviceGroupInfo* toCount,
- size_t* count);
+void count_VkBindBufferMemoryDeviceGroupInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBindBufferMemoryDeviceGroupInfo* toCount,
+ size_t* count);
-void count_VkBindImageMemoryDeviceGroupInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindImageMemoryDeviceGroupInfo* toCount,
- size_t* count);
+void count_VkBindImageMemoryDeviceGroupInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBindImageMemoryDeviceGroupInfo* toCount,
+ size_t* count);
-void count_VkPhysicalDeviceGroupProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceGroupProperties* toCount,
- size_t* count);
+void count_VkPhysicalDeviceGroupProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceGroupProperties* toCount,
+ size_t* count);
-void count_VkDeviceGroupDeviceCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceGroupDeviceCreateInfo* toCount,
- size_t* count);
+void count_VkDeviceGroupDeviceCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceGroupDeviceCreateInfo* toCount,
+ size_t* count);
-void count_VkBufferMemoryRequirementsInfo2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferMemoryRequirementsInfo2* toCount,
- size_t* count);
+void count_VkBufferMemoryRequirementsInfo2(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferMemoryRequirementsInfo2* toCount,
+ size_t* count);
-void count_VkImageMemoryRequirementsInfo2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageMemoryRequirementsInfo2* toCount,
- size_t* count);
+void count_VkImageMemoryRequirementsInfo2(uint32_t featureBits, VkStructureType rootType,
+ const VkImageMemoryRequirementsInfo2* toCount,
+ size_t* count);
-void count_VkImageSparseMemoryRequirementsInfo2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageSparseMemoryRequirementsInfo2* toCount,
- size_t* count);
+void count_VkImageSparseMemoryRequirementsInfo2(uint32_t featureBits, VkStructureType rootType,
+ const VkImageSparseMemoryRequirementsInfo2* toCount,
+ size_t* count);
-void count_VkMemoryRequirements2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryRequirements2* toCount,
- size_t* count);
+void count_VkMemoryRequirements2(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryRequirements2* toCount, size_t* count);
-void count_VkSparseImageMemoryRequirements2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSparseImageMemoryRequirements2* toCount,
- size_t* count);
+void count_VkSparseImageMemoryRequirements2(uint32_t featureBits, VkStructureType rootType,
+ const VkSparseImageMemoryRequirements2* toCount,
+ size_t* count);
-void count_VkPhysicalDeviceFeatures2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFeatures2* toCount,
- size_t* count);
+void count_VkPhysicalDeviceFeatures2(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFeatures2* toCount, size_t* count);
-void count_VkPhysicalDeviceProperties2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceProperties2* toCount,
- size_t* count);
+void count_VkPhysicalDeviceProperties2(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceProperties2* toCount, size_t* count);
-void count_VkFormatProperties2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFormatProperties2* toCount,
- size_t* count);
+void count_VkFormatProperties2(uint32_t featureBits, VkStructureType rootType,
+ const VkFormatProperties2* toCount, size_t* count);
-void count_VkImageFormatProperties2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageFormatProperties2* toCount,
- size_t* count);
+void count_VkImageFormatProperties2(uint32_t featureBits, VkStructureType rootType,
+ const VkImageFormatProperties2* toCount, size_t* count);
-void count_VkPhysicalDeviceImageFormatInfo2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceImageFormatInfo2* toCount,
- size_t* count);
+void count_VkPhysicalDeviceImageFormatInfo2(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceImageFormatInfo2* toCount,
+ size_t* count);
-void count_VkQueueFamilyProperties2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkQueueFamilyProperties2* toCount,
- size_t* count);
+void count_VkQueueFamilyProperties2(uint32_t featureBits, VkStructureType rootType,
+ const VkQueueFamilyProperties2* toCount, size_t* count);
-void count_VkPhysicalDeviceMemoryProperties2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryProperties2* toCount,
- size_t* count);
+void count_VkPhysicalDeviceMemoryProperties2(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryProperties2* toCount,
+ size_t* count);
-void count_VkSparseImageFormatProperties2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSparseImageFormatProperties2* toCount,
- size_t* count);
+void count_VkSparseImageFormatProperties2(uint32_t featureBits, VkStructureType rootType,
+ const VkSparseImageFormatProperties2* toCount,
+ size_t* count);
void count_VkPhysicalDeviceSparseImageFormatInfo2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSparseImageFormatInfo2* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSparseImageFormatInfo2* toCount, size_t* count);
void count_VkPhysicalDevicePointClippingProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePointClippingProperties* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePointClippingProperties* toCount, size_t* count);
-void count_VkInputAttachmentAspectReference(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkInputAttachmentAspectReference* toCount,
- size_t* count);
+void count_VkInputAttachmentAspectReference(uint32_t featureBits, VkStructureType rootType,
+ const VkInputAttachmentAspectReference* toCount,
+ size_t* count);
void count_VkRenderPassInputAttachmentAspectCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderPassInputAttachmentAspectCreateInfo* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkRenderPassInputAttachmentAspectCreateInfo* toCount, size_t* count);
-void count_VkImageViewUsageCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageViewUsageCreateInfo* toCount,
- size_t* count);
+void count_VkImageViewUsageCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkImageViewUsageCreateInfo* toCount, size_t* count);
void count_VkPipelineTessellationDomainOriginStateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineTessellationDomainOriginStateCreateInfo* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineTessellationDomainOriginStateCreateInfo* toCount, size_t* count);
-void count_VkRenderPassMultiviewCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderPassMultiviewCreateInfo* toCount,
- size_t* count);
+void count_VkRenderPassMultiviewCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderPassMultiviewCreateInfo* toCount,
+ size_t* count);
-void count_VkPhysicalDeviceMultiviewFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiviewFeatures* toCount,
- size_t* count);
+void count_VkPhysicalDeviceMultiviewFeatures(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMultiviewFeatures* toCount,
+ size_t* count);
-void count_VkPhysicalDeviceMultiviewProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiviewProperties* toCount,
- size_t* count);
+void count_VkPhysicalDeviceMultiviewProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMultiviewProperties* toCount,
+ size_t* count);
void count_VkPhysicalDeviceVariablePointersFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceVariablePointersFeatures* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVariablePointersFeatures* toCount, size_t* count);
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceVariablePointersFeatures, count_VkPhysicalDeviceVariablePointerFeatures)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceVariablePointersFeatures,
+ count_VkPhysicalDeviceVariablePointerFeatures)
void count_VkPhysicalDeviceProtectedMemoryFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceProtectedMemoryFeatures* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceProtectedMemoryFeatures* toCount, size_t* count);
void count_VkPhysicalDeviceProtectedMemoryProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceProtectedMemoryProperties* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceProtectedMemoryProperties* toCount, size_t* count);
-void count_VkDeviceQueueInfo2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceQueueInfo2* toCount,
- size_t* count);
+void count_VkDeviceQueueInfo2(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceQueueInfo2* toCount, size_t* count);
-void count_VkProtectedSubmitInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkProtectedSubmitInfo* toCount,
- size_t* count);
+void count_VkProtectedSubmitInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkProtectedSubmitInfo* toCount, size_t* count);
-void count_VkSamplerYcbcrConversionCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSamplerYcbcrConversionCreateInfo* toCount,
- size_t* count);
+void count_VkSamplerYcbcrConversionCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSamplerYcbcrConversionCreateInfo* toCount,
+ size_t* count);
-void count_VkSamplerYcbcrConversionInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSamplerYcbcrConversionInfo* toCount,
- size_t* count);
+void count_VkSamplerYcbcrConversionInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSamplerYcbcrConversionInfo* toCount, size_t* count);
-void count_VkBindImagePlaneMemoryInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindImagePlaneMemoryInfo* toCount,
- size_t* count);
+void count_VkBindImagePlaneMemoryInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBindImagePlaneMemoryInfo* toCount, size_t* count);
-void count_VkImagePlaneMemoryRequirementsInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImagePlaneMemoryRequirementsInfo* toCount,
- size_t* count);
+void count_VkImagePlaneMemoryRequirementsInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkImagePlaneMemoryRequirementsInfo* toCount,
+ size_t* count);
void count_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSamplerYcbcrConversionFeatures* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSamplerYcbcrConversionFeatures* toCount, size_t* count);
void count_VkSamplerYcbcrConversionImageFormatProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSamplerYcbcrConversionImageFormatProperties* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkSamplerYcbcrConversionImageFormatProperties* toCount, size_t* count);
-void count_VkDescriptorUpdateTemplateEntry(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorUpdateTemplateEntry* toCount,
- size_t* count);
+void count_VkDescriptorUpdateTemplateEntry(uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorUpdateTemplateEntry* toCount,
+ size_t* count);
-void count_VkDescriptorUpdateTemplateCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorUpdateTemplateCreateInfo* toCount,
- size_t* count);
+void count_VkDescriptorUpdateTemplateCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorUpdateTemplateCreateInfo* toCount,
+ size_t* count);
-void count_VkExternalMemoryProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExternalMemoryProperties* toCount,
- size_t* count);
+void count_VkExternalMemoryProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkExternalMemoryProperties* toCount, size_t* count);
void count_VkPhysicalDeviceExternalImageFormatInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalImageFormatInfo* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceExternalImageFormatInfo* toCount, size_t* count);
-void count_VkExternalImageFormatProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExternalImageFormatProperties* toCount,
- size_t* count);
+void count_VkExternalImageFormatProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkExternalImageFormatProperties* toCount,
+ size_t* count);
-void count_VkPhysicalDeviceExternalBufferInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalBufferInfo* toCount,
- size_t* count);
+void count_VkPhysicalDeviceExternalBufferInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceExternalBufferInfo* toCount,
+ size_t* count);
-void count_VkExternalBufferProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExternalBufferProperties* toCount,
- size_t* count);
+void count_VkExternalBufferProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkExternalBufferProperties* toCount, size_t* count);
-void count_VkPhysicalDeviceIDProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceIDProperties* toCount,
- size_t* count);
+void count_VkPhysicalDeviceIDProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceIDProperties* toCount, size_t* count);
-void count_VkExternalMemoryImageCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExternalMemoryImageCreateInfo* toCount,
- size_t* count);
+void count_VkExternalMemoryImageCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkExternalMemoryImageCreateInfo* toCount,
+ size_t* count);
-void count_VkExternalMemoryBufferCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExternalMemoryBufferCreateInfo* toCount,
- size_t* count);
+void count_VkExternalMemoryBufferCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkExternalMemoryBufferCreateInfo* toCount,
+ size_t* count);
-void count_VkExportMemoryAllocateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExportMemoryAllocateInfo* toCount,
- size_t* count);
+void count_VkExportMemoryAllocateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkExportMemoryAllocateInfo* toCount, size_t* count);
-void count_VkPhysicalDeviceExternalFenceInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalFenceInfo* toCount,
- size_t* count);
+void count_VkPhysicalDeviceExternalFenceInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceExternalFenceInfo* toCount,
+ size_t* count);
-void count_VkExternalFenceProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExternalFenceProperties* toCount,
- size_t* count);
+void count_VkExternalFenceProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkExternalFenceProperties* toCount, size_t* count);
-void count_VkExportFenceCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExportFenceCreateInfo* toCount,
- size_t* count);
+void count_VkExportFenceCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkExportFenceCreateInfo* toCount, size_t* count);
-void count_VkExportSemaphoreCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExportSemaphoreCreateInfo* toCount,
- size_t* count);
+void count_VkExportSemaphoreCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkExportSemaphoreCreateInfo* toCount, size_t* count);
void count_VkPhysicalDeviceExternalSemaphoreInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalSemaphoreInfo* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceExternalSemaphoreInfo* toCount, size_t* count);
-void count_VkExternalSemaphoreProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExternalSemaphoreProperties* toCount,
- size_t* count);
+void count_VkExternalSemaphoreProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkExternalSemaphoreProperties* toCount,
+ size_t* count);
void count_VkPhysicalDeviceMaintenance3Properties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMaintenance3Properties* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance3Properties* toCount, size_t* count);
-void count_VkDescriptorSetLayoutSupport(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorSetLayoutSupport* toCount,
- size_t* count);
+void count_VkDescriptorSetLayoutSupport(uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorSetLayoutSupport* toCount, size_t* count);
void count_VkPhysicalDeviceShaderDrawParametersFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderDrawParametersFeatures* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderDrawParametersFeatures* toCount, size_t* count);
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceShaderDrawParametersFeatures, count_VkPhysicalDeviceShaderDrawParameterFeatures)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceShaderDrawParametersFeatures,
+ count_VkPhysicalDeviceShaderDrawParameterFeatures)
#endif
#ifdef VK_VERSION_1_2
-void count_VkPhysicalDeviceVulkan11Features(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan11Features* toCount,
- size_t* count);
+void count_VkPhysicalDeviceVulkan11Features(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan11Features* toCount,
+ size_t* count);
-void count_VkPhysicalDeviceVulkan11Properties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan11Properties* toCount,
- size_t* count);
+void count_VkPhysicalDeviceVulkan11Properties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan11Properties* toCount,
+ size_t* count);
-void count_VkPhysicalDeviceVulkan12Features(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan12Features* toCount,
- size_t* count);
+void count_VkPhysicalDeviceVulkan12Features(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan12Features* toCount,
+ size_t* count);
-void count_VkConformanceVersion(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkConformanceVersion* toCount,
- size_t* count);
+void count_VkConformanceVersion(uint32_t featureBits, VkStructureType rootType,
+ const VkConformanceVersion* toCount, size_t* count);
-void count_VkPhysicalDeviceVulkan12Properties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan12Properties* toCount,
- size_t* count);
+void count_VkPhysicalDeviceVulkan12Properties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan12Properties* toCount,
+ size_t* count);
-void count_VkImageFormatListCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageFormatListCreateInfo* toCount,
- size_t* count);
+void count_VkImageFormatListCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkImageFormatListCreateInfo* toCount, size_t* count);
-void count_VkAttachmentDescription2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAttachmentDescription2* toCount,
- size_t* count);
+void count_VkAttachmentDescription2(uint32_t featureBits, VkStructureType rootType,
+ const VkAttachmentDescription2* toCount, size_t* count);
-void count_VkAttachmentReference2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAttachmentReference2* toCount,
- size_t* count);
+void count_VkAttachmentReference2(uint32_t featureBits, VkStructureType rootType,
+ const VkAttachmentReference2* toCount, size_t* count);
-void count_VkSubpassDescription2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubpassDescription2* toCount,
- size_t* count);
+void count_VkSubpassDescription2(uint32_t featureBits, VkStructureType rootType,
+ const VkSubpassDescription2* toCount, size_t* count);
-void count_VkSubpassDependency2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubpassDependency2* toCount,
- size_t* count);
+void count_VkSubpassDependency2(uint32_t featureBits, VkStructureType rootType,
+ const VkSubpassDependency2* toCount, size_t* count);
-void count_VkRenderPassCreateInfo2(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderPassCreateInfo2* toCount,
- size_t* count);
+void count_VkRenderPassCreateInfo2(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderPassCreateInfo2* toCount, size_t* count);
-void count_VkSubpassBeginInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubpassBeginInfo* toCount,
- size_t* count);
+void count_VkSubpassBeginInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSubpassBeginInfo* toCount, size_t* count);
-void count_VkSubpassEndInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubpassEndInfo* toCount,
- size_t* count);
+void count_VkSubpassEndInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSubpassEndInfo* toCount, size_t* count);
-void count_VkPhysicalDevice8BitStorageFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevice8BitStorageFeatures* toCount,
- size_t* count);
+void count_VkPhysicalDevice8BitStorageFeatures(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevice8BitStorageFeatures* toCount,
+ size_t* count);
-void count_VkPhysicalDeviceDriverProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDriverProperties* toCount,
- size_t* count);
+void count_VkPhysicalDeviceDriverProperties(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDriverProperties* toCount,
+ size_t* count);
void count_VkPhysicalDeviceShaderAtomicInt64Features(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderAtomicInt64Features* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderAtomicInt64Features* toCount, size_t* count);
void count_VkPhysicalDeviceShaderFloat16Int8Features(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderFloat16Int8Features* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderFloat16Int8Features* toCount, size_t* count);
void count_VkPhysicalDeviceFloatControlsProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFloatControlsProperties* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFloatControlsProperties* toCount, size_t* count);
void count_VkDescriptorSetLayoutBindingFlagsCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorSetLayoutBindingFlagsCreateInfo* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorSetLayoutBindingFlagsCreateInfo* toCount, size_t* count);
void count_VkPhysicalDeviceDescriptorIndexingFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDescriptorIndexingFeatures* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDescriptorIndexingFeatures* toCount, size_t* count);
void count_VkPhysicalDeviceDescriptorIndexingProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDescriptorIndexingProperties* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDescriptorIndexingProperties* toCount, size_t* count);
void count_VkDescriptorSetVariableDescriptorCountAllocateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorSetVariableDescriptorCountAllocateInfo* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorSetVariableDescriptorCountAllocateInfo* toCount, size_t* count);
void count_VkDescriptorSetVariableDescriptorCountLayoutSupport(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorSetVariableDescriptorCountLayoutSupport* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorSetVariableDescriptorCountLayoutSupport* toCount, size_t* count);
void count_VkSubpassDescriptionDepthStencilResolve(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubpassDescriptionDepthStencilResolve* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkSubpassDescriptionDepthStencilResolve* toCount, size_t* count);
void count_VkPhysicalDeviceDepthStencilResolveProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDepthStencilResolveProperties* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDepthStencilResolveProperties* toCount, size_t* count);
void count_VkPhysicalDeviceScalarBlockLayoutFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceScalarBlockLayoutFeatures* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceScalarBlockLayoutFeatures* toCount, size_t* count);
-void count_VkImageStencilUsageCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageStencilUsageCreateInfo* toCount,
- size_t* count);
+void count_VkImageStencilUsageCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkImageStencilUsageCreateInfo* toCount,
+ size_t* count);
-void count_VkSamplerReductionModeCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSamplerReductionModeCreateInfo* toCount,
- size_t* count);
+void count_VkSamplerReductionModeCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSamplerReductionModeCreateInfo* toCount,
+ size_t* count);
void count_VkPhysicalDeviceSamplerFilterMinmaxProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSamplerFilterMinmaxProperties* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSamplerFilterMinmaxProperties* toCount, size_t* count);
void count_VkPhysicalDeviceVulkanMemoryModelFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkanMemoryModelFeatures* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVulkanMemoryModelFeatures* toCount, size_t* count);
void count_VkPhysicalDeviceImagelessFramebufferFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceImagelessFramebufferFeatures* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceImagelessFramebufferFeatures* toCount, size_t* count);
-void count_VkFramebufferAttachmentImageInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFramebufferAttachmentImageInfo* toCount,
- size_t* count);
+void count_VkFramebufferAttachmentImageInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkFramebufferAttachmentImageInfo* toCount,
+ size_t* count);
-void count_VkFramebufferAttachmentsCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFramebufferAttachmentsCreateInfo* toCount,
- size_t* count);
+void count_VkFramebufferAttachmentsCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkFramebufferAttachmentsCreateInfo* toCount,
+ size_t* count);
-void count_VkRenderPassAttachmentBeginInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderPassAttachmentBeginInfo* toCount,
- size_t* count);
+void count_VkRenderPassAttachmentBeginInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderPassAttachmentBeginInfo* toCount,
+ size_t* count);
void count_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* toCount, size_t* count);
void count_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* toCount, size_t* count);
void count_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* toCount, size_t* count);
-void count_VkAttachmentReferenceStencilLayout(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAttachmentReferenceStencilLayout* toCount,
- size_t* count);
+void count_VkAttachmentReferenceStencilLayout(uint32_t featureBits, VkStructureType rootType,
+ const VkAttachmentReferenceStencilLayout* toCount,
+ size_t* count);
-void count_VkAttachmentDescriptionStencilLayout(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAttachmentDescriptionStencilLayout* toCount,
- size_t* count);
+void count_VkAttachmentDescriptionStencilLayout(uint32_t featureBits, VkStructureType rootType,
+ const VkAttachmentDescriptionStencilLayout* toCount,
+ size_t* count);
void count_VkPhysicalDeviceHostQueryResetFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceHostQueryResetFeatures* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceHostQueryResetFeatures* toCount, size_t* count);
void count_VkPhysicalDeviceTimelineSemaphoreFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceTimelineSemaphoreFeatures* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceTimelineSemaphoreFeatures* toCount, size_t* count);
void count_VkPhysicalDeviceTimelineSemaphoreProperties(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceTimelineSemaphoreProperties* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceTimelineSemaphoreProperties* toCount, size_t* count);
-void count_VkSemaphoreTypeCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSemaphoreTypeCreateInfo* toCount,
- size_t* count);
+void count_VkSemaphoreTypeCreateInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSemaphoreTypeCreateInfo* toCount, size_t* count);
-void count_VkTimelineSemaphoreSubmitInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkTimelineSemaphoreSubmitInfo* toCount,
- size_t* count);
+void count_VkTimelineSemaphoreSubmitInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkTimelineSemaphoreSubmitInfo* toCount,
+ size_t* count);
-void count_VkSemaphoreWaitInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSemaphoreWaitInfo* toCount,
- size_t* count);
+void count_VkSemaphoreWaitInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSemaphoreWaitInfo* toCount, size_t* count);
-void count_VkSemaphoreSignalInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSemaphoreSignalInfo* toCount,
- size_t* count);
+void count_VkSemaphoreSignalInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkSemaphoreSignalInfo* toCount, size_t* count);
void count_VkPhysicalDeviceBufferDeviceAddressFeatures(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceBufferDeviceAddressFeatures* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceBufferDeviceAddressFeatures* toCount, size_t* count);
-void count_VkBufferDeviceAddressInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferDeviceAddressInfo* toCount,
- size_t* count);
+void count_VkBufferDeviceAddressInfo(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferDeviceAddressInfo* toCount, size_t* count);
void count_VkBufferOpaqueCaptureAddressCreateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferOpaqueCaptureAddressCreateInfo* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkBufferOpaqueCaptureAddressCreateInfo* toCount, size_t* count);
void count_VkMemoryOpaqueCaptureAddressAllocateInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryOpaqueCaptureAddressAllocateInfo* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryOpaqueCaptureAddressAllocateInfo* toCount, size_t* count);
void count_VkDeviceMemoryOpaqueCaptureAddressInfo(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceMemoryOpaqueCaptureAddressInfo* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceMemoryOpaqueCaptureAddressInfo* toCount, size_t* count);
#endif
#ifdef VK_KHR_surface
-void count_VkSurfaceCapabilitiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSurfaceCapabilitiesKHR* toCount,
- size_t* count);
+void count_VkSurfaceCapabilitiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkSurfaceCapabilitiesKHR* toCount, size_t* count);
-void count_VkSurfaceFormatKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSurfaceFormatKHR* toCount,
- size_t* count);
+void count_VkSurfaceFormatKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkSurfaceFormatKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_swapchain
-void count_VkSwapchainCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSwapchainCreateInfoKHR* toCount,
- size_t* count);
+void count_VkSwapchainCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkSwapchainCreateInfoKHR* toCount, size_t* count);
-void count_VkPresentInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPresentInfoKHR* toCount,
- size_t* count);
+void count_VkPresentInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPresentInfoKHR* toCount, size_t* count);
-void count_VkImageSwapchainCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageSwapchainCreateInfoKHR* toCount,
- size_t* count);
+void count_VkImageSwapchainCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImageSwapchainCreateInfoKHR* toCount,
+ size_t* count);
-void count_VkBindImageMemorySwapchainInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindImageMemorySwapchainInfoKHR* toCount,
- size_t* count);
+void count_VkBindImageMemorySwapchainInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkBindImageMemorySwapchainInfoKHR* toCount,
+ size_t* count);
-void count_VkAcquireNextImageInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAcquireNextImageInfoKHR* toCount,
- size_t* count);
+void count_VkAcquireNextImageInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkAcquireNextImageInfoKHR* toCount, size_t* count);
-void count_VkDeviceGroupPresentCapabilitiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceGroupPresentCapabilitiesKHR* toCount,
- size_t* count);
+void count_VkDeviceGroupPresentCapabilitiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceGroupPresentCapabilitiesKHR* toCount,
+ size_t* count);
-void count_VkDeviceGroupPresentInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceGroupPresentInfoKHR* toCount,
- size_t* count);
+void count_VkDeviceGroupPresentInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceGroupPresentInfoKHR* toCount, size_t* count);
-void count_VkDeviceGroupSwapchainCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceGroupSwapchainCreateInfoKHR* toCount,
- size_t* count);
+void count_VkDeviceGroupSwapchainCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceGroupSwapchainCreateInfoKHR* toCount,
+ size_t* count);
#endif
#ifdef VK_KHR_display
-void count_VkDisplayModeParametersKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayModeParametersKHR* toCount,
- size_t* count);
+void count_VkDisplayModeParametersKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayModeParametersKHR* toCount, size_t* count);
-void count_VkDisplayModeCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayModeCreateInfoKHR* toCount,
- size_t* count);
+void count_VkDisplayModeCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayModeCreateInfoKHR* toCount, size_t* count);
-void count_VkDisplayModePropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayModePropertiesKHR* toCount,
- size_t* count);
+void count_VkDisplayModePropertiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayModePropertiesKHR* toCount, size_t* count);
-void count_VkDisplayPlaneCapabilitiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayPlaneCapabilitiesKHR* toCount,
- size_t* count);
+void count_VkDisplayPlaneCapabilitiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayPlaneCapabilitiesKHR* toCount,
+ size_t* count);
-void count_VkDisplayPlanePropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayPlanePropertiesKHR* toCount,
- size_t* count);
+void count_VkDisplayPlanePropertiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayPlanePropertiesKHR* toCount, size_t* count);
-void count_VkDisplayPropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayPropertiesKHR* toCount,
- size_t* count);
+void count_VkDisplayPropertiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayPropertiesKHR* toCount, size_t* count);
-void count_VkDisplaySurfaceCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplaySurfaceCreateInfoKHR* toCount,
- size_t* count);
+void count_VkDisplaySurfaceCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplaySurfaceCreateInfoKHR* toCount,
+ size_t* count);
#endif
#ifdef VK_KHR_display_swapchain
-void count_VkDisplayPresentInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayPresentInfoKHR* toCount,
- size_t* count);
+void count_VkDisplayPresentInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayPresentInfoKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_xlib_surface
-void count_VkXlibSurfaceCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkXlibSurfaceCreateInfoKHR* toCount,
- size_t* count);
+void count_VkXlibSurfaceCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkXlibSurfaceCreateInfoKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_xcb_surface
-void count_VkXcbSurfaceCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkXcbSurfaceCreateInfoKHR* toCount,
- size_t* count);
+void count_VkXcbSurfaceCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkXcbSurfaceCreateInfoKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_wayland_surface
-void count_VkWaylandSurfaceCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkWaylandSurfaceCreateInfoKHR* toCount,
- size_t* count);
+void count_VkWaylandSurfaceCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkWaylandSurfaceCreateInfoKHR* toCount,
+ size_t* count);
#endif
#ifdef VK_KHR_android_surface
-void count_VkAndroidSurfaceCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAndroidSurfaceCreateInfoKHR* toCount,
- size_t* count);
+void count_VkAndroidSurfaceCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkAndroidSurfaceCreateInfoKHR* toCount,
+ size_t* count);
#endif
#ifdef VK_KHR_win32_surface
-void count_VkWin32SurfaceCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkWin32SurfaceCreateInfoKHR* toCount,
- size_t* count);
+void count_VkWin32SurfaceCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkWin32SurfaceCreateInfoKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_sampler_mirror_clamp_to_edge
#endif
#ifdef VK_KHR_video_queue
-void count_VkVideoQueueFamilyProperties2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoQueueFamilyProperties2KHR* toCount,
- size_t* count);
+void count_VkVideoQueueFamilyProperties2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoQueueFamilyProperties2KHR* toCount,
+ size_t* count);
-void count_VkVideoProfileKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoProfileKHR* toCount,
- size_t* count);
+void count_VkVideoProfileKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoProfileKHR* toCount, size_t* count);
-void count_VkVideoProfilesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoProfilesKHR* toCount,
- size_t* count);
+void count_VkVideoProfilesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoProfilesKHR* toCount, size_t* count);
-void count_VkVideoCapabilitiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoCapabilitiesKHR* toCount,
- size_t* count);
+void count_VkVideoCapabilitiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoCapabilitiesKHR* toCount, size_t* count);
-void count_VkPhysicalDeviceVideoFormatInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceVideoFormatInfoKHR* toCount,
- size_t* count);
+void count_VkPhysicalDeviceVideoFormatInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVideoFormatInfoKHR* toCount,
+ size_t* count);
-void count_VkVideoFormatPropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoFormatPropertiesKHR* toCount,
- size_t* count);
+void count_VkVideoFormatPropertiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoFormatPropertiesKHR* toCount, size_t* count);
-void count_VkVideoPictureResourceKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoPictureResourceKHR* toCount,
- size_t* count);
+void count_VkVideoPictureResourceKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoPictureResourceKHR* toCount, size_t* count);
-void count_VkVideoReferenceSlotKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoReferenceSlotKHR* toCount,
- size_t* count);
+void count_VkVideoReferenceSlotKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoReferenceSlotKHR* toCount, size_t* count);
-void count_VkVideoGetMemoryPropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoGetMemoryPropertiesKHR* toCount,
- size_t* count);
+void count_VkVideoGetMemoryPropertiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoGetMemoryPropertiesKHR* toCount,
+ size_t* count);
-void count_VkVideoBindMemoryKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoBindMemoryKHR* toCount,
- size_t* count);
+void count_VkVideoBindMemoryKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoBindMemoryKHR* toCount, size_t* count);
-void count_VkVideoSessionCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoSessionCreateInfoKHR* toCount,
- size_t* count);
+void count_VkVideoSessionCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoSessionCreateInfoKHR* toCount, size_t* count);
void count_VkVideoSessionParametersCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoSessionParametersCreateInfoKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoSessionParametersCreateInfoKHR* toCount, size_t* count);
void count_VkVideoSessionParametersUpdateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoSessionParametersUpdateInfoKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoSessionParametersUpdateInfoKHR* toCount, size_t* count);
-void count_VkVideoBeginCodingInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoBeginCodingInfoKHR* toCount,
- size_t* count);
+void count_VkVideoBeginCodingInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoBeginCodingInfoKHR* toCount, size_t* count);
-void count_VkVideoEndCodingInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEndCodingInfoKHR* toCount,
- size_t* count);
+void count_VkVideoEndCodingInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEndCodingInfoKHR* toCount, size_t* count);
-void count_VkVideoCodingControlInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoCodingControlInfoKHR* toCount,
- size_t* count);
+void count_VkVideoCodingControlInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoCodingControlInfoKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_video_decode_queue
-void count_VkVideoDecodeInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeInfoKHR* toCount,
- size_t* count);
+void count_VkVideoDecodeInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeInfoKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_dynamic_rendering
-void count_VkRenderingAttachmentInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderingAttachmentInfoKHR* toCount,
- size_t* count);
+void count_VkRenderingAttachmentInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderingAttachmentInfoKHR* toCount, size_t* count);
-void count_VkRenderingInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderingInfoKHR* toCount,
- size_t* count);
+void count_VkRenderingInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderingInfoKHR* toCount, size_t* count);
-void count_VkPipelineRenderingCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineRenderingCreateInfoKHR* toCount,
- size_t* count);
+void count_VkPipelineRenderingCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRenderingCreateInfoKHR* toCount,
+ size_t* count);
void count_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDynamicRenderingFeaturesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDynamicRenderingFeaturesKHR* toCount, size_t* count);
void count_VkCommandBufferInheritanceRenderingInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCommandBufferInheritanceRenderingInfoKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkCommandBufferInheritanceRenderingInfoKHR* toCount, size_t* count);
void count_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderingFragmentShadingRateAttachmentInfoKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkRenderingFragmentShadingRateAttachmentInfoKHR* toCount, size_t* count);
void count_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderingFragmentDensityMapAttachmentInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkRenderingFragmentDensityMapAttachmentInfoEXT* toCount, size_t* count);
-void count_VkAttachmentSampleCountInfoAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAttachmentSampleCountInfoAMD* toCount,
- size_t* count);
+void count_VkAttachmentSampleCountInfoAMD(uint32_t featureBits, VkStructureType rootType,
+ const VkAttachmentSampleCountInfoAMD* toCount,
+ size_t* count);
DEFINE_ALIAS_FUNCTION(count_VkAttachmentSampleCountInfoAMD, count_VkAttachmentSampleCountInfoNV)
-void count_VkMultiviewPerViewAttributesInfoNVX(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMultiviewPerViewAttributesInfoNVX* toCount,
- size_t* count);
+void count_VkMultiviewPerViewAttributesInfoNVX(uint32_t featureBits, VkStructureType rootType,
+ const VkMultiviewPerViewAttributesInfoNVX* toCount,
+ size_t* count);
#endif
#ifdef VK_KHR_multiview
-DEFINE_ALIAS_FUNCTION(count_VkRenderPassMultiviewCreateInfo, count_VkRenderPassMultiviewCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkRenderPassMultiviewCreateInfo,
+ count_VkRenderPassMultiviewCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceMultiviewFeatures, count_VkPhysicalDeviceMultiviewFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceMultiviewFeatures,
+ count_VkPhysicalDeviceMultiviewFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceMultiviewProperties, count_VkPhysicalDeviceMultiviewPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceMultiviewProperties,
+ count_VkPhysicalDeviceMultiviewPropertiesKHR)
#endif
#ifdef VK_KHR_get_physical_device_properties2
@@ -1757,31 +1053,38 @@
DEFINE_ALIAS_FUNCTION(count_VkImageFormatProperties2, count_VkImageFormatProperties2KHR)
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceImageFormatInfo2, count_VkPhysicalDeviceImageFormatInfo2KHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceImageFormatInfo2,
+ count_VkPhysicalDeviceImageFormatInfo2KHR)
DEFINE_ALIAS_FUNCTION(count_VkQueueFamilyProperties2, count_VkQueueFamilyProperties2KHR)
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceMemoryProperties2, count_VkPhysicalDeviceMemoryProperties2KHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceMemoryProperties2,
+ count_VkPhysicalDeviceMemoryProperties2KHR)
DEFINE_ALIAS_FUNCTION(count_VkSparseImageFormatProperties2, count_VkSparseImageFormatProperties2KHR)
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceSparseImageFormatInfo2, count_VkPhysicalDeviceSparseImageFormatInfo2KHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceSparseImageFormatInfo2,
+ count_VkPhysicalDeviceSparseImageFormatInfo2KHR)
#endif
#ifdef VK_KHR_device_group
DEFINE_ALIAS_FUNCTION(count_VkMemoryAllocateFlagsInfo, count_VkMemoryAllocateFlagsInfoKHR)
-DEFINE_ALIAS_FUNCTION(count_VkDeviceGroupRenderPassBeginInfo, count_VkDeviceGroupRenderPassBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkDeviceGroupRenderPassBeginInfo,
+ count_VkDeviceGroupRenderPassBeginInfoKHR)
-DEFINE_ALIAS_FUNCTION(count_VkDeviceGroupCommandBufferBeginInfo, count_VkDeviceGroupCommandBufferBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkDeviceGroupCommandBufferBeginInfo,
+ count_VkDeviceGroupCommandBufferBeginInfoKHR)
DEFINE_ALIAS_FUNCTION(count_VkDeviceGroupSubmitInfo, count_VkDeviceGroupSubmitInfoKHR)
DEFINE_ALIAS_FUNCTION(count_VkDeviceGroupBindSparseInfo, count_VkDeviceGroupBindSparseInfoKHR)
-DEFINE_ALIAS_FUNCTION(count_VkBindBufferMemoryDeviceGroupInfo, count_VkBindBufferMemoryDeviceGroupInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkBindBufferMemoryDeviceGroupInfo,
+ count_VkBindBufferMemoryDeviceGroupInfoKHR)
-DEFINE_ALIAS_FUNCTION(count_VkBindImageMemoryDeviceGroupInfo, count_VkBindImageMemoryDeviceGroupInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkBindImageMemoryDeviceGroupInfo,
+ count_VkBindImageMemoryDeviceGroupInfoKHR)
#endif
#ifdef VK_KHR_shader_draw_parameters
@@ -1789,7 +1092,8 @@
#ifdef VK_KHR_maintenance1
#endif
#ifdef VK_KHR_device_group_creation
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceGroupProperties, count_VkPhysicalDeviceGroupPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceGroupProperties,
+ count_VkPhysicalDeviceGroupPropertiesKHR)
DEFINE_ALIAS_FUNCTION(count_VkDeviceGroupDeviceCreateInfo, count_VkDeviceGroupDeviceCreateInfoKHR)
@@ -1797,11 +1101,14 @@
#ifdef VK_KHR_external_memory_capabilities
DEFINE_ALIAS_FUNCTION(count_VkExternalMemoryProperties, count_VkExternalMemoryPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceExternalImageFormatInfo, count_VkPhysicalDeviceExternalImageFormatInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceExternalImageFormatInfo,
+ count_VkPhysicalDeviceExternalImageFormatInfoKHR)
-DEFINE_ALIAS_FUNCTION(count_VkExternalImageFormatProperties, count_VkExternalImageFormatPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkExternalImageFormatProperties,
+ count_VkExternalImageFormatPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceExternalBufferInfo, count_VkPhysicalDeviceExternalBufferInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceExternalBufferInfo,
+ count_VkPhysicalDeviceExternalBufferInfoKHR)
DEFINE_ALIAS_FUNCTION(count_VkExternalBufferProperties, count_VkExternalBufferPropertiesKHR)
@@ -1809,69 +1116,53 @@
#endif
#ifdef VK_KHR_external_memory
-DEFINE_ALIAS_FUNCTION(count_VkExternalMemoryImageCreateInfo, count_VkExternalMemoryImageCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkExternalMemoryImageCreateInfo,
+ count_VkExternalMemoryImageCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(count_VkExternalMemoryBufferCreateInfo, count_VkExternalMemoryBufferCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkExternalMemoryBufferCreateInfo,
+ count_VkExternalMemoryBufferCreateInfoKHR)
DEFINE_ALIAS_FUNCTION(count_VkExportMemoryAllocateInfo, count_VkExportMemoryAllocateInfoKHR)
#endif
#ifdef VK_KHR_external_memory_win32
-void count_VkImportMemoryWin32HandleInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportMemoryWin32HandleInfoKHR* toCount,
- size_t* count);
+void count_VkImportMemoryWin32HandleInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImportMemoryWin32HandleInfoKHR* toCount,
+ size_t* count);
-void count_VkExportMemoryWin32HandleInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExportMemoryWin32HandleInfoKHR* toCount,
- size_t* count);
+void count_VkExportMemoryWin32HandleInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkExportMemoryWin32HandleInfoKHR* toCount,
+ size_t* count);
-void count_VkMemoryWin32HandlePropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryWin32HandlePropertiesKHR* toCount,
- size_t* count);
+void count_VkMemoryWin32HandlePropertiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryWin32HandlePropertiesKHR* toCount,
+ size_t* count);
-void count_VkMemoryGetWin32HandleInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryGetWin32HandleInfoKHR* toCount,
- size_t* count);
+void count_VkMemoryGetWin32HandleInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryGetWin32HandleInfoKHR* toCount,
+ size_t* count);
#endif
#ifdef VK_KHR_external_memory_fd
-void count_VkImportMemoryFdInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportMemoryFdInfoKHR* toCount,
- size_t* count);
+void count_VkImportMemoryFdInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImportMemoryFdInfoKHR* toCount, size_t* count);
-void count_VkMemoryFdPropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryFdPropertiesKHR* toCount,
- size_t* count);
+void count_VkMemoryFdPropertiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryFdPropertiesKHR* toCount, size_t* count);
-void count_VkMemoryGetFdInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryGetFdInfoKHR* toCount,
- size_t* count);
+void count_VkMemoryGetFdInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryGetFdInfoKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_win32_keyed_mutex
void count_VkWin32KeyedMutexAcquireReleaseInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkWin32KeyedMutexAcquireReleaseInfoKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkWin32KeyedMutexAcquireReleaseInfoKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_external_semaphore_capabilities
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceExternalSemaphoreInfo, count_VkPhysicalDeviceExternalSemaphoreInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceExternalSemaphoreInfo,
+ count_VkPhysicalDeviceExternalSemaphoreInfoKHR)
DEFINE_ALIAS_FUNCTION(count_VkExternalSemaphoreProperties, count_VkExternalSemaphorePropertiesKHR)
@@ -1881,97 +1172,80 @@
#endif
#ifdef VK_KHR_external_semaphore_win32
-void count_VkImportSemaphoreWin32HandleInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportSemaphoreWin32HandleInfoKHR* toCount,
- size_t* count);
+void count_VkImportSemaphoreWin32HandleInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImportSemaphoreWin32HandleInfoKHR* toCount,
+ size_t* count);
-void count_VkExportSemaphoreWin32HandleInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExportSemaphoreWin32HandleInfoKHR* toCount,
- size_t* count);
+void count_VkExportSemaphoreWin32HandleInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkExportSemaphoreWin32HandleInfoKHR* toCount,
+ size_t* count);
-void count_VkD3D12FenceSubmitInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkD3D12FenceSubmitInfoKHR* toCount,
- size_t* count);
+void count_VkD3D12FenceSubmitInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkD3D12FenceSubmitInfoKHR* toCount, size_t* count);
-void count_VkSemaphoreGetWin32HandleInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSemaphoreGetWin32HandleInfoKHR* toCount,
- size_t* count);
+void count_VkSemaphoreGetWin32HandleInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkSemaphoreGetWin32HandleInfoKHR* toCount,
+ size_t* count);
#endif
#ifdef VK_KHR_external_semaphore_fd
-void count_VkImportSemaphoreFdInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportSemaphoreFdInfoKHR* toCount,
- size_t* count);
+void count_VkImportSemaphoreFdInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImportSemaphoreFdInfoKHR* toCount, size_t* count);
-void count_VkSemaphoreGetFdInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSemaphoreGetFdInfoKHR* toCount,
- size_t* count);
+void count_VkSemaphoreGetFdInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkSemaphoreGetFdInfoKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_push_descriptor
void count_VkPhysicalDevicePushDescriptorPropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePushDescriptorPropertiesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePushDescriptorPropertiesKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_shader_float16_int8
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceShaderFloat16Int8Features, count_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceShaderFloat16Int8Features,
+ count_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR)
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceShaderFloat16Int8Features, count_VkPhysicalDeviceFloat16Int8FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceShaderFloat16Int8Features,
+ count_VkPhysicalDeviceFloat16Int8FeaturesKHR)
#endif
#ifdef VK_KHR_16bit_storage
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDevice16BitStorageFeatures, count_VkPhysicalDevice16BitStorageFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDevice16BitStorageFeatures,
+ count_VkPhysicalDevice16BitStorageFeaturesKHR)
#endif
#ifdef VK_KHR_incremental_present
-void count_VkRectLayerKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRectLayerKHR* toCount,
- size_t* count);
+void count_VkRectLayerKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkRectLayerKHR* toCount, size_t* count);
-void count_VkPresentRegionKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPresentRegionKHR* toCount,
- size_t* count);
+void count_VkPresentRegionKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPresentRegionKHR* toCount, size_t* count);
-void count_VkPresentRegionsKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPresentRegionsKHR* toCount,
- size_t* count);
+void count_VkPresentRegionsKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPresentRegionsKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_descriptor_update_template
-DEFINE_ALIAS_FUNCTION(count_VkDescriptorUpdateTemplateEntry, count_VkDescriptorUpdateTemplateEntryKHR)
+DEFINE_ALIAS_FUNCTION(count_VkDescriptorUpdateTemplateEntry,
+ count_VkDescriptorUpdateTemplateEntryKHR)
-DEFINE_ALIAS_FUNCTION(count_VkDescriptorUpdateTemplateCreateInfo, count_VkDescriptorUpdateTemplateCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkDescriptorUpdateTemplateCreateInfo,
+ count_VkDescriptorUpdateTemplateCreateInfoKHR)
#endif
#ifdef VK_KHR_imageless_framebuffer
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceImagelessFramebufferFeatures, count_VkPhysicalDeviceImagelessFramebufferFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceImagelessFramebufferFeatures,
+ count_VkPhysicalDeviceImagelessFramebufferFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(count_VkFramebufferAttachmentsCreateInfo, count_VkFramebufferAttachmentsCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkFramebufferAttachmentsCreateInfo,
+ count_VkFramebufferAttachmentsCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(count_VkFramebufferAttachmentImageInfo, count_VkFramebufferAttachmentImageInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkFramebufferAttachmentImageInfo,
+ count_VkFramebufferAttachmentImageInfoKHR)
-DEFINE_ALIAS_FUNCTION(count_VkRenderPassAttachmentBeginInfo, count_VkRenderPassAttachmentBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkRenderPassAttachmentBeginInfo,
+ count_VkRenderPassAttachmentBeginInfoKHR)
#endif
#ifdef VK_KHR_create_renderpass2
@@ -1992,14 +1266,13 @@
#endif
#ifdef VK_KHR_shared_presentable_image
void count_VkSharedPresentSurfaceCapabilitiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSharedPresentSurfaceCapabilitiesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkSharedPresentSurfaceCapabilitiesKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_external_fence_capabilities
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceExternalFenceInfo, count_VkPhysicalDeviceExternalFenceInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceExternalFenceInfo,
+ count_VkPhysicalDeviceExternalFenceInfoKHR)
DEFINE_ALIAS_FUNCTION(count_VkExternalFenceProperties, count_VkExternalFencePropertiesKHR)
@@ -2009,157 +1282,111 @@
#endif
#ifdef VK_KHR_external_fence_win32
-void count_VkImportFenceWin32HandleInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportFenceWin32HandleInfoKHR* toCount,
- size_t* count);
+void count_VkImportFenceWin32HandleInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImportFenceWin32HandleInfoKHR* toCount,
+ size_t* count);
-void count_VkExportFenceWin32HandleInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExportFenceWin32HandleInfoKHR* toCount,
- size_t* count);
+void count_VkExportFenceWin32HandleInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkExportFenceWin32HandleInfoKHR* toCount,
+ size_t* count);
-void count_VkFenceGetWin32HandleInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFenceGetWin32HandleInfoKHR* toCount,
- size_t* count);
+void count_VkFenceGetWin32HandleInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkFenceGetWin32HandleInfoKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_external_fence_fd
-void count_VkImportFenceFdInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportFenceFdInfoKHR* toCount,
- size_t* count);
+void count_VkImportFenceFdInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImportFenceFdInfoKHR* toCount, size_t* count);
-void count_VkFenceGetFdInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFenceGetFdInfoKHR* toCount,
- size_t* count);
+void count_VkFenceGetFdInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkFenceGetFdInfoKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_performance_query
void count_VkPhysicalDevicePerformanceQueryFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePerformanceQueryFeaturesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePerformanceQueryFeaturesKHR* toCount, size_t* count);
void count_VkPhysicalDevicePerformanceQueryPropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePerformanceQueryPropertiesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePerformanceQueryPropertiesKHR* toCount, size_t* count);
-void count_VkPerformanceCounterKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPerformanceCounterKHR* toCount,
- size_t* count);
+void count_VkPerformanceCounterKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPerformanceCounterKHR* toCount, size_t* count);
-void count_VkPerformanceCounterDescriptionKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPerformanceCounterDescriptionKHR* toCount,
- size_t* count);
+void count_VkPerformanceCounterDescriptionKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPerformanceCounterDescriptionKHR* toCount,
+ size_t* count);
-void count_VkQueryPoolPerformanceCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkQueryPoolPerformanceCreateInfoKHR* toCount,
- size_t* count);
+void count_VkQueryPoolPerformanceCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkQueryPoolPerformanceCreateInfoKHR* toCount,
+ size_t* count);
-void count_VkPerformanceCounterResultKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPerformanceCounterResultKHR* toCount,
- size_t* count);
+void count_VkPerformanceCounterResultKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPerformanceCounterResultKHR* toCount,
+ size_t* count);
-void count_VkAcquireProfilingLockInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAcquireProfilingLockInfoKHR* toCount,
- size_t* count);
+void count_VkAcquireProfilingLockInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkAcquireProfilingLockInfoKHR* toCount,
+ size_t* count);
-void count_VkPerformanceQuerySubmitInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPerformanceQuerySubmitInfoKHR* toCount,
- size_t* count);
+void count_VkPerformanceQuerySubmitInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPerformanceQuerySubmitInfoKHR* toCount,
+ size_t* count);
#endif
#ifdef VK_KHR_maintenance2
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDevicePointClippingProperties, count_VkPhysicalDevicePointClippingPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDevicePointClippingProperties,
+ count_VkPhysicalDevicePointClippingPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(count_VkRenderPassInputAttachmentAspectCreateInfo, count_VkRenderPassInputAttachmentAspectCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkRenderPassInputAttachmentAspectCreateInfo,
+ count_VkRenderPassInputAttachmentAspectCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(count_VkInputAttachmentAspectReference, count_VkInputAttachmentAspectReferenceKHR)
+DEFINE_ALIAS_FUNCTION(count_VkInputAttachmentAspectReference,
+ count_VkInputAttachmentAspectReferenceKHR)
DEFINE_ALIAS_FUNCTION(count_VkImageViewUsageCreateInfo, count_VkImageViewUsageCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(count_VkPipelineTessellationDomainOriginStateCreateInfo, count_VkPipelineTessellationDomainOriginStateCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPipelineTessellationDomainOriginStateCreateInfo,
+ count_VkPipelineTessellationDomainOriginStateCreateInfoKHR)
#endif
#ifdef VK_KHR_get_surface_capabilities2
-void count_VkPhysicalDeviceSurfaceInfo2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSurfaceInfo2KHR* toCount,
- size_t* count);
+void count_VkPhysicalDeviceSurfaceInfo2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSurfaceInfo2KHR* toCount,
+ size_t* count);
-void count_VkSurfaceCapabilities2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSurfaceCapabilities2KHR* toCount,
- size_t* count);
+void count_VkSurfaceCapabilities2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkSurfaceCapabilities2KHR* toCount, size_t* count);
-void count_VkSurfaceFormat2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSurfaceFormat2KHR* toCount,
- size_t* count);
+void count_VkSurfaceFormat2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkSurfaceFormat2KHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_variable_pointers
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceVariablePointersFeatures, count_VkPhysicalDeviceVariablePointerFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceVariablePointersFeatures,
+ count_VkPhysicalDeviceVariablePointerFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceVariablePointersFeatures, count_VkPhysicalDeviceVariablePointersFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceVariablePointersFeatures,
+ count_VkPhysicalDeviceVariablePointersFeaturesKHR)
#endif
#ifdef VK_KHR_get_display_properties2
-void count_VkDisplayProperties2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayProperties2KHR* toCount,
- size_t* count);
+void count_VkDisplayProperties2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayProperties2KHR* toCount, size_t* count);
-void count_VkDisplayPlaneProperties2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayPlaneProperties2KHR* toCount,
- size_t* count);
+void count_VkDisplayPlaneProperties2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayPlaneProperties2KHR* toCount, size_t* count);
-void count_VkDisplayModeProperties2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayModeProperties2KHR* toCount,
- size_t* count);
+void count_VkDisplayModeProperties2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayModeProperties2KHR* toCount, size_t* count);
-void count_VkDisplayPlaneInfo2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayPlaneInfo2KHR* toCount,
- size_t* count);
+void count_VkDisplayPlaneInfo2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayPlaneInfo2KHR* toCount, size_t* count);
-void count_VkDisplayPlaneCapabilities2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayPlaneCapabilities2KHR* toCount,
- size_t* count);
+void count_VkDisplayPlaneCapabilities2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayPlaneCapabilities2KHR* toCount,
+ size_t* count);
#endif
#ifdef VK_KHR_dedicated_allocation
@@ -2173,15 +1400,18 @@
#ifdef VK_KHR_relaxed_block_layout
#endif
#ifdef VK_KHR_get_memory_requirements2
-DEFINE_ALIAS_FUNCTION(count_VkBufferMemoryRequirementsInfo2, count_VkBufferMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(count_VkBufferMemoryRequirementsInfo2,
+ count_VkBufferMemoryRequirementsInfo2KHR)
DEFINE_ALIAS_FUNCTION(count_VkImageMemoryRequirementsInfo2, count_VkImageMemoryRequirementsInfo2KHR)
-DEFINE_ALIAS_FUNCTION(count_VkImageSparseMemoryRequirementsInfo2, count_VkImageSparseMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(count_VkImageSparseMemoryRequirementsInfo2,
+ count_VkImageSparseMemoryRequirementsInfo2KHR)
DEFINE_ALIAS_FUNCTION(count_VkMemoryRequirements2, count_VkMemoryRequirements2KHR)
-DEFINE_ALIAS_FUNCTION(count_VkSparseImageMemoryRequirements2, count_VkSparseImageMemoryRequirements2KHR)
+DEFINE_ALIAS_FUNCTION(count_VkSparseImageMemoryRequirements2,
+ count_VkSparseImageMemoryRequirements2KHR)
#endif
#ifdef VK_KHR_image_format_list
@@ -2189,17 +1419,21 @@
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
-DEFINE_ALIAS_FUNCTION(count_VkSamplerYcbcrConversionCreateInfo, count_VkSamplerYcbcrConversionCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkSamplerYcbcrConversionCreateInfo,
+ count_VkSamplerYcbcrConversionCreateInfoKHR)
DEFINE_ALIAS_FUNCTION(count_VkSamplerYcbcrConversionInfo, count_VkSamplerYcbcrConversionInfoKHR)
DEFINE_ALIAS_FUNCTION(count_VkBindImagePlaneMemoryInfo, count_VkBindImagePlaneMemoryInfoKHR)
-DEFINE_ALIAS_FUNCTION(count_VkImagePlaneMemoryRequirementsInfo, count_VkImagePlaneMemoryRequirementsInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkImagePlaneMemoryRequirementsInfo,
+ count_VkImagePlaneMemoryRequirementsInfoKHR)
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceSamplerYcbcrConversionFeatures, count_VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceSamplerYcbcrConversionFeatures,
+ count_VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(count_VkSamplerYcbcrConversionImageFormatProperties, count_VkSamplerYcbcrConversionImageFormatPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkSamplerYcbcrConversionImageFormatProperties,
+ count_VkSamplerYcbcrConversionImageFormatPropertiesKHR)
#endif
#ifdef VK_KHR_bind_memory2
@@ -2210,20 +1444,17 @@
#endif
#ifdef VK_KHR_portability_subset
void count_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePortabilitySubsetFeaturesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePortabilitySubsetFeaturesKHR* toCount, size_t* count);
void count_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePortabilitySubsetPropertiesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePortabilitySubsetPropertiesKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_maintenance3
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceMaintenance3Properties, count_VkPhysicalDeviceMaintenance3PropertiesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceMaintenance3Properties,
+ count_VkPhysicalDeviceMaintenance3PropertiesKHR)
DEFINE_ALIAS_FUNCTION(count_VkDescriptorSetLayoutSupport, count_VkDescriptorSetLayoutSupportKHR)
@@ -2231,47 +1462,54 @@
#ifdef VK_KHR_draw_indirect_count
#endif
#ifdef VK_KHR_shader_subgroup_extended_types
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, count_VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures,
+ count_VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)
#endif
#ifdef VK_KHR_8bit_storage
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDevice8BitStorageFeatures, count_VkPhysicalDevice8BitStorageFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDevice8BitStorageFeatures,
+ count_VkPhysicalDevice8BitStorageFeaturesKHR)
#endif
#ifdef VK_KHR_shader_atomic_int64
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceShaderAtomicInt64Features, count_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceShaderAtomicInt64Features,
+ count_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR)
#endif
#ifdef VK_KHR_shader_clock
void count_VkPhysicalDeviceShaderClockFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderClockFeaturesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderClockFeaturesKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_driver_properties
DEFINE_ALIAS_FUNCTION(count_VkConformanceVersion, count_VkConformanceVersionKHR)
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceDriverProperties, count_VkPhysicalDeviceDriverPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceDriverProperties,
+ count_VkPhysicalDeviceDriverPropertiesKHR)
#endif
#ifdef VK_KHR_shader_float_controls
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceFloatControlsProperties, count_VkPhysicalDeviceFloatControlsPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceFloatControlsProperties,
+ count_VkPhysicalDeviceFloatControlsPropertiesKHR)
#endif
#ifdef VK_KHR_depth_stencil_resolve
-DEFINE_ALIAS_FUNCTION(count_VkSubpassDescriptionDepthStencilResolve, count_VkSubpassDescriptionDepthStencilResolveKHR)
+DEFINE_ALIAS_FUNCTION(count_VkSubpassDescriptionDepthStencilResolve,
+ count_VkSubpassDescriptionDepthStencilResolveKHR)
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceDepthStencilResolveProperties, count_VkPhysicalDeviceDepthStencilResolvePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceDepthStencilResolveProperties,
+ count_VkPhysicalDeviceDepthStencilResolvePropertiesKHR)
#endif
#ifdef VK_KHR_swapchain_mutable_format
#endif
#ifdef VK_KHR_timeline_semaphore
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceTimelineSemaphoreFeatures, count_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceTimelineSemaphoreFeatures,
+ count_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceTimelineSemaphoreProperties, count_VkPhysicalDeviceTimelineSemaphorePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceTimelineSemaphoreProperties,
+ count_VkPhysicalDeviceTimelineSemaphorePropertiesKHR)
DEFINE_ALIAS_FUNCTION(count_VkSemaphoreTypeCreateInfo, count_VkSemaphoreTypeCreateInfoKHR)
@@ -2283,391 +1521,269 @@
#endif
#ifdef VK_KHR_vulkan_memory_model
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceVulkanMemoryModelFeatures, count_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceVulkanMemoryModelFeatures,
+ count_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR)
#endif
#ifdef VK_KHR_shader_terminate_invocation
void count_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_fragment_shading_rate
void count_VkFragmentShadingRateAttachmentInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFragmentShadingRateAttachmentInfoKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkFragmentShadingRateAttachmentInfoKHR* toCount, size_t* count);
void count_VkPipelineFragmentShadingRateStateCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineFragmentShadingRateStateCreateInfoKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineFragmentShadingRateStateCreateInfoKHR* toCount, size_t* count);
void count_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* toCount, size_t* count);
void count_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* toCount, size_t* count);
void count_VkPhysicalDeviceFragmentShadingRateKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRateKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_spirv_1_4
#endif
#ifdef VK_KHR_surface_protected_capabilities
-void count_VkSurfaceProtectedCapabilitiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSurfaceProtectedCapabilitiesKHR* toCount,
- size_t* count);
+void count_VkSurfaceProtectedCapabilitiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkSurfaceProtectedCapabilitiesKHR* toCount,
+ size_t* count);
#endif
#ifdef VK_KHR_separate_depth_stencil_layouts
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, count_VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures,
+ count_VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(count_VkAttachmentReferenceStencilLayout, count_VkAttachmentReferenceStencilLayoutKHR)
+DEFINE_ALIAS_FUNCTION(count_VkAttachmentReferenceStencilLayout,
+ count_VkAttachmentReferenceStencilLayoutKHR)
-DEFINE_ALIAS_FUNCTION(count_VkAttachmentDescriptionStencilLayout, count_VkAttachmentDescriptionStencilLayoutKHR)
+DEFINE_ALIAS_FUNCTION(count_VkAttachmentDescriptionStencilLayout,
+ count_VkAttachmentDescriptionStencilLayoutKHR)
#endif
#ifdef VK_KHR_present_wait
void count_VkPhysicalDevicePresentWaitFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePresentWaitFeaturesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePresentWaitFeaturesKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_uniform_buffer_standard_layout
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceUniformBufferStandardLayoutFeatures, count_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceUniformBufferStandardLayoutFeatures,
+ count_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)
#endif
#ifdef VK_KHR_buffer_device_address
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceBufferDeviceAddressFeatures, count_VkPhysicalDeviceBufferDeviceAddressFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceBufferDeviceAddressFeatures,
+ count_VkPhysicalDeviceBufferDeviceAddressFeaturesKHR)
DEFINE_ALIAS_FUNCTION(count_VkBufferDeviceAddressInfo, count_VkBufferDeviceAddressInfoKHR)
-DEFINE_ALIAS_FUNCTION(count_VkBufferOpaqueCaptureAddressCreateInfo, count_VkBufferOpaqueCaptureAddressCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkBufferOpaqueCaptureAddressCreateInfo,
+ count_VkBufferOpaqueCaptureAddressCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(count_VkMemoryOpaqueCaptureAddressAllocateInfo, count_VkMemoryOpaqueCaptureAddressAllocateInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkMemoryOpaqueCaptureAddressAllocateInfo,
+ count_VkMemoryOpaqueCaptureAddressAllocateInfoKHR)
-DEFINE_ALIAS_FUNCTION(count_VkDeviceMemoryOpaqueCaptureAddressInfo, count_VkDeviceMemoryOpaqueCaptureAddressInfoKHR)
+DEFINE_ALIAS_FUNCTION(count_VkDeviceMemoryOpaqueCaptureAddressInfo,
+ count_VkDeviceMemoryOpaqueCaptureAddressInfoKHR)
#endif
#ifdef VK_KHR_deferred_host_operations
#endif
#ifdef VK_KHR_pipeline_executable_properties
void count_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* toCount, size_t* count);
-void count_VkPipelineInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineInfoKHR* toCount,
- size_t* count);
+void count_VkPipelineInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineInfoKHR* toCount, size_t* count);
-void count_VkPipelineExecutablePropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineExecutablePropertiesKHR* toCount,
- size_t* count);
+void count_VkPipelineExecutablePropertiesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineExecutablePropertiesKHR* toCount,
+ size_t* count);
-void count_VkPipelineExecutableInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineExecutableInfoKHR* toCount,
- size_t* count);
+void count_VkPipelineExecutableInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineExecutableInfoKHR* toCount, size_t* count);
void count_VkPipelineExecutableStatisticValueKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineExecutableStatisticValueKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineExecutableStatisticValueKHR* toCount, size_t* count);
-void count_VkPipelineExecutableStatisticKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineExecutableStatisticKHR* toCount,
- size_t* count);
+void count_VkPipelineExecutableStatisticKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineExecutableStatisticKHR* toCount,
+ size_t* count);
void count_VkPipelineExecutableInternalRepresentationKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineExecutableInternalRepresentationKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineExecutableInternalRepresentationKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_shader_integer_dot_product
void count_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* toCount, size_t* count);
void count_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_pipeline_library
-void count_VkPipelineLibraryCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineLibraryCreateInfoKHR* toCount,
- size_t* count);
+void count_VkPipelineLibraryCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineLibraryCreateInfoKHR* toCount,
+ size_t* count);
#endif
#ifdef VK_KHR_shader_non_semantic_info
#endif
#ifdef VK_KHR_present_id
-void count_VkPresentIdKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPresentIdKHR* toCount,
- size_t* count);
+void count_VkPresentIdKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPresentIdKHR* toCount, size_t* count);
-void count_VkPhysicalDevicePresentIdFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePresentIdFeaturesKHR* toCount,
- size_t* count);
+void count_VkPhysicalDevicePresentIdFeaturesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePresentIdFeaturesKHR* toCount,
+ size_t* count);
#endif
#ifdef VK_KHR_video_encode_queue
-void count_VkVideoEncodeInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeInfoKHR* toCount,
- size_t* count);
+void count_VkVideoEncodeInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeInfoKHR* toCount, size_t* count);
-void count_VkVideoEncodeRateControlInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeRateControlInfoKHR* toCount,
- size_t* count);
+void count_VkVideoEncodeRateControlInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeRateControlInfoKHR* toCount,
+ size_t* count);
#endif
#ifdef VK_KHR_synchronization2
-void count_VkMemoryBarrier2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryBarrier2KHR* toCount,
- size_t* count);
+void count_VkMemoryBarrier2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryBarrier2KHR* toCount, size_t* count);
-void count_VkBufferMemoryBarrier2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferMemoryBarrier2KHR* toCount,
- size_t* count);
+void count_VkBufferMemoryBarrier2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferMemoryBarrier2KHR* toCount, size_t* count);
-void count_VkImageMemoryBarrier2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageMemoryBarrier2KHR* toCount,
- size_t* count);
+void count_VkImageMemoryBarrier2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImageMemoryBarrier2KHR* toCount, size_t* count);
-void count_VkDependencyInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDependencyInfoKHR* toCount,
- size_t* count);
+void count_VkDependencyInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDependencyInfoKHR* toCount, size_t* count);
-void count_VkSemaphoreSubmitInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSemaphoreSubmitInfoKHR* toCount,
- size_t* count);
+void count_VkSemaphoreSubmitInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkSemaphoreSubmitInfoKHR* toCount, size_t* count);
-void count_VkCommandBufferSubmitInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCommandBufferSubmitInfoKHR* toCount,
- size_t* count);
+void count_VkCommandBufferSubmitInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkCommandBufferSubmitInfoKHR* toCount, size_t* count);
-void count_VkSubmitInfo2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubmitInfo2KHR* toCount,
- size_t* count);
+void count_VkSubmitInfo2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkSubmitInfo2KHR* toCount, size_t* count);
void count_VkPhysicalDeviceSynchronization2FeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSynchronization2FeaturesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSynchronization2FeaturesKHR* toCount, size_t* count);
-void count_VkQueueFamilyCheckpointProperties2NV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkQueueFamilyCheckpointProperties2NV* toCount,
- size_t* count);
+void count_VkQueueFamilyCheckpointProperties2NV(uint32_t featureBits, VkStructureType rootType,
+ const VkQueueFamilyCheckpointProperties2NV* toCount,
+ size_t* count);
-void count_VkCheckpointData2NV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCheckpointData2NV* toCount,
- size_t* count);
+void count_VkCheckpointData2NV(uint32_t featureBits, VkStructureType rootType,
+ const VkCheckpointData2NV* toCount, size_t* count);
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
void count_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
void count_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
void count_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_copy_commands2
-void count_VkBufferCopy2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferCopy2KHR* toCount,
- size_t* count);
+void count_VkBufferCopy2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferCopy2KHR* toCount, size_t* count);
-void count_VkCopyBufferInfo2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCopyBufferInfo2KHR* toCount,
- size_t* count);
+void count_VkCopyBufferInfo2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkCopyBufferInfo2KHR* toCount, size_t* count);
-void count_VkImageCopy2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageCopy2KHR* toCount,
- size_t* count);
+void count_VkImageCopy2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImageCopy2KHR* toCount, size_t* count);
-void count_VkCopyImageInfo2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCopyImageInfo2KHR* toCount,
- size_t* count);
+void count_VkCopyImageInfo2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkCopyImageInfo2KHR* toCount, size_t* count);
-void count_VkBufferImageCopy2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferImageCopy2KHR* toCount,
- size_t* count);
+void count_VkBufferImageCopy2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferImageCopy2KHR* toCount, size_t* count);
-void count_VkCopyBufferToImageInfo2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCopyBufferToImageInfo2KHR* toCount,
- size_t* count);
+void count_VkCopyBufferToImageInfo2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkCopyBufferToImageInfo2KHR* toCount, size_t* count);
-void count_VkCopyImageToBufferInfo2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCopyImageToBufferInfo2KHR* toCount,
- size_t* count);
+void count_VkCopyImageToBufferInfo2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkCopyImageToBufferInfo2KHR* toCount, size_t* count);
-void count_VkImageBlit2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageBlit2KHR* toCount,
- size_t* count);
+void count_VkImageBlit2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImageBlit2KHR* toCount, size_t* count);
-void count_VkBlitImageInfo2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBlitImageInfo2KHR* toCount,
- size_t* count);
+void count_VkBlitImageInfo2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkBlitImageInfo2KHR* toCount, size_t* count);
-void count_VkImageResolve2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageResolve2KHR* toCount,
- size_t* count);
+void count_VkImageResolve2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkImageResolve2KHR* toCount, size_t* count);
-void count_VkResolveImageInfo2KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkResolveImageInfo2KHR* toCount,
- size_t* count);
+void count_VkResolveImageInfo2KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkResolveImageInfo2KHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_format_feature_flags2
-void count_VkFormatProperties3KHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFormatProperties3KHR* toCount,
- size_t* count);
+void count_VkFormatProperties3KHR(uint32_t featureBits, VkStructureType rootType,
+ const VkFormatProperties3KHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_maintenance4
void count_VkPhysicalDeviceMaintenance4FeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMaintenance4FeaturesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance4FeaturesKHR* toCount, size_t* count);
void count_VkPhysicalDeviceMaintenance4PropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMaintenance4PropertiesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance4PropertiesKHR* toCount, size_t* count);
-void count_VkDeviceBufferMemoryRequirementsKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceBufferMemoryRequirementsKHR* toCount,
- size_t* count);
+void count_VkDeviceBufferMemoryRequirementsKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceBufferMemoryRequirementsKHR* toCount,
+ size_t* count);
-void count_VkDeviceImageMemoryRequirementsKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceImageMemoryRequirementsKHR* toCount,
- size_t* count);
+void count_VkDeviceImageMemoryRequirementsKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceImageMemoryRequirementsKHR* toCount,
+ size_t* count);
#endif
#ifdef VK_ANDROID_native_buffer
-void count_VkNativeBufferANDROID(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkNativeBufferANDROID* toCount,
- size_t* count);
+void count_VkNativeBufferANDROID(uint32_t featureBits, VkStructureType rootType,
+ const VkNativeBufferANDROID* toCount, size_t* count);
#endif
#ifdef VK_EXT_debug_report
-void count_VkDebugReportCallbackCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDebugReportCallbackCreateInfoEXT* toCount,
- size_t* count);
+void count_VkDebugReportCallbackCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDebugReportCallbackCreateInfoEXT* toCount,
+ size_t* count);
#endif
#ifdef VK_NV_glsl_shader
@@ -2678,10 +1794,8 @@
#endif
#ifdef VK_AMD_rasterization_order
void count_VkPipelineRasterizationStateRasterizationOrderAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineRasterizationStateRasterizationOrderAMD* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRasterizationStateRasterizationOrderAMD* toCount, size_t* count);
#endif
#ifdef VK_AMD_shader_trinary_minmax
@@ -2689,99 +1803,66 @@
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
-void count_VkDebugMarkerObjectNameInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDebugMarkerObjectNameInfoEXT* toCount,
- size_t* count);
+void count_VkDebugMarkerObjectNameInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDebugMarkerObjectNameInfoEXT* toCount,
+ size_t* count);
-void count_VkDebugMarkerObjectTagInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDebugMarkerObjectTagInfoEXT* toCount,
- size_t* count);
+void count_VkDebugMarkerObjectTagInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDebugMarkerObjectTagInfoEXT* toCount,
+ size_t* count);
-void count_VkDebugMarkerMarkerInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDebugMarkerMarkerInfoEXT* toCount,
- size_t* count);
+void count_VkDebugMarkerMarkerInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDebugMarkerMarkerInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_AMD_gcn_shader
#endif
#ifdef VK_NV_dedicated_allocation
void count_VkDedicatedAllocationImageCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDedicatedAllocationImageCreateInfoNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDedicatedAllocationImageCreateInfoNV* toCount, size_t* count);
void count_VkDedicatedAllocationBufferCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDedicatedAllocationBufferCreateInfoNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDedicatedAllocationBufferCreateInfoNV* toCount, size_t* count);
void count_VkDedicatedAllocationMemoryAllocateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDedicatedAllocationMemoryAllocateInfoNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDedicatedAllocationMemoryAllocateInfoNV* toCount, size_t* count);
#endif
#ifdef VK_EXT_transform_feedback
void count_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceTransformFeedbackFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceTransformFeedbackFeaturesEXT* toCount, size_t* count);
void count_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceTransformFeedbackPropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceTransformFeedbackPropertiesEXT* toCount, size_t* count);
void count_VkPipelineRasterizationStateStreamCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineRasterizationStateStreamCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRasterizationStateStreamCreateInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_NVX_binary_import
-void count_VkCuModuleCreateInfoNVX(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCuModuleCreateInfoNVX* toCount,
- size_t* count);
+void count_VkCuModuleCreateInfoNVX(uint32_t featureBits, VkStructureType rootType,
+ const VkCuModuleCreateInfoNVX* toCount, size_t* count);
-void count_VkCuFunctionCreateInfoNVX(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCuFunctionCreateInfoNVX* toCount,
- size_t* count);
+void count_VkCuFunctionCreateInfoNVX(uint32_t featureBits, VkStructureType rootType,
+ const VkCuFunctionCreateInfoNVX* toCount, size_t* count);
-void count_VkCuLaunchInfoNVX(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCuLaunchInfoNVX* toCount,
- size_t* count);
+void count_VkCuLaunchInfoNVX(uint32_t featureBits, VkStructureType rootType,
+ const VkCuLaunchInfoNVX* toCount, size_t* count);
#endif
#ifdef VK_NVX_image_view_handle
-void count_VkImageViewHandleInfoNVX(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageViewHandleInfoNVX* toCount,
- size_t* count);
+void count_VkImageViewHandleInfoNVX(uint32_t featureBits, VkStructureType rootType,
+ const VkImageViewHandleInfoNVX* toCount, size_t* count);
-void count_VkImageViewAddressPropertiesNVX(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageViewAddressPropertiesNVX* toCount,
- size_t* count);
+void count_VkImageViewAddressPropertiesNVX(uint32_t featureBits, VkStructureType rootType,
+ const VkImageViewAddressPropertiesNVX* toCount,
+ size_t* count);
#endif
#ifdef VK_AMD_draw_indirect_count
@@ -2793,273 +1874,184 @@
#ifdef VK_AMD_shader_ballot
#endif
#ifdef VK_EXT_video_encode_h264
-void count_VkVideoEncodeH264CapabilitiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH264CapabilitiesEXT* toCount,
- size_t* count);
+void count_VkVideoEncodeH264CapabilitiesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH264CapabilitiesEXT* toCount,
+ size_t* count);
void count_VkVideoEncodeH264SessionCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH264SessionCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH264SessionCreateInfoEXT* toCount, size_t* count);
void count_VkVideoEncodeH264SessionParametersAddInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH264SessionParametersAddInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH264SessionParametersAddInfoEXT* toCount, size_t* count);
void count_VkVideoEncodeH264SessionParametersCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH264SessionParametersCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH264SessionParametersCreateInfoEXT* toCount, size_t* count);
-void count_VkVideoEncodeH264DpbSlotInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH264DpbSlotInfoEXT* toCount,
- size_t* count);
+void count_VkVideoEncodeH264DpbSlotInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH264DpbSlotInfoEXT* toCount,
+ size_t* count);
-void count_VkVideoEncodeH264NaluSliceEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH264NaluSliceEXT* toCount,
- size_t* count);
+void count_VkVideoEncodeH264NaluSliceEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH264NaluSliceEXT* toCount,
+ size_t* count);
-void count_VkVideoEncodeH264VclFrameInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH264VclFrameInfoEXT* toCount,
- size_t* count);
+void count_VkVideoEncodeH264VclFrameInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH264VclFrameInfoEXT* toCount,
+ size_t* count);
void count_VkVideoEncodeH264EmitPictureParametersEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH264EmitPictureParametersEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH264EmitPictureParametersEXT* toCount, size_t* count);
-void count_VkVideoEncodeH264ProfileEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH264ProfileEXT* toCount,
- size_t* count);
+void count_VkVideoEncodeH264ProfileEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH264ProfileEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_video_encode_h265
-void count_VkVideoEncodeH265CapabilitiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH265CapabilitiesEXT* toCount,
- size_t* count);
+void count_VkVideoEncodeH265CapabilitiesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH265CapabilitiesEXT* toCount,
+ size_t* count);
void count_VkVideoEncodeH265SessionCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH265SessionCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH265SessionCreateInfoEXT* toCount, size_t* count);
void count_VkVideoEncodeH265SessionParametersAddInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH265SessionParametersAddInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH265SessionParametersAddInfoEXT* toCount, size_t* count);
void count_VkVideoEncodeH265SessionParametersCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH265SessionParametersCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH265SessionParametersCreateInfoEXT* toCount, size_t* count);
-void count_VkVideoEncodeH265DpbSlotInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH265DpbSlotInfoEXT* toCount,
- size_t* count);
+void count_VkVideoEncodeH265DpbSlotInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH265DpbSlotInfoEXT* toCount,
+ size_t* count);
-void count_VkVideoEncodeH265ReferenceListsEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH265ReferenceListsEXT* toCount,
- size_t* count);
+void count_VkVideoEncodeH265ReferenceListsEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH265ReferenceListsEXT* toCount,
+ size_t* count);
-void count_VkVideoEncodeH265NaluSliceEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH265NaluSliceEXT* toCount,
- size_t* count);
+void count_VkVideoEncodeH265NaluSliceEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH265NaluSliceEXT* toCount,
+ size_t* count);
-void count_VkVideoEncodeH265VclFrameInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH265VclFrameInfoEXT* toCount,
- size_t* count);
+void count_VkVideoEncodeH265VclFrameInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH265VclFrameInfoEXT* toCount,
+ size_t* count);
void count_VkVideoEncodeH265EmitPictureParametersEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH265EmitPictureParametersEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH265EmitPictureParametersEXT* toCount, size_t* count);
-void count_VkVideoEncodeH265ProfileEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoEncodeH265ProfileEXT* toCount,
- size_t* count);
+void count_VkVideoEncodeH265ProfileEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoEncodeH265ProfileEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_video_decode_h264
-void count_VkVideoDecodeH264ProfileEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH264ProfileEXT* toCount,
- size_t* count);
+void count_VkVideoDecodeH264ProfileEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH264ProfileEXT* toCount, size_t* count);
-void count_VkVideoDecodeH264CapabilitiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH264CapabilitiesEXT* toCount,
- size_t* count);
+void count_VkVideoDecodeH264CapabilitiesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH264CapabilitiesEXT* toCount,
+ size_t* count);
void count_VkVideoDecodeH264SessionCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH264SessionCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH264SessionCreateInfoEXT* toCount, size_t* count);
void count_VkVideoDecodeH264SessionParametersAddInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH264SessionParametersAddInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH264SessionParametersAddInfoEXT* toCount, size_t* count);
void count_VkVideoDecodeH264SessionParametersCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH264SessionParametersCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH264SessionParametersCreateInfoEXT* toCount, size_t* count);
-void count_VkVideoDecodeH264PictureInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH264PictureInfoEXT* toCount,
- size_t* count);
+void count_VkVideoDecodeH264PictureInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH264PictureInfoEXT* toCount,
+ size_t* count);
-void count_VkVideoDecodeH264MvcEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH264MvcEXT* toCount,
- size_t* count);
+void count_VkVideoDecodeH264MvcEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH264MvcEXT* toCount, size_t* count);
-void count_VkVideoDecodeH264DpbSlotInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH264DpbSlotInfoEXT* toCount,
- size_t* count);
+void count_VkVideoDecodeH264DpbSlotInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH264DpbSlotInfoEXT* toCount,
+ size_t* count);
#endif
#ifdef VK_AMD_texture_gather_bias_lod
void count_VkTextureLODGatherFormatPropertiesAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkTextureLODGatherFormatPropertiesAMD* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkTextureLODGatherFormatPropertiesAMD* toCount, size_t* count);
#endif
#ifdef VK_AMD_shader_info
-void count_VkShaderResourceUsageAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkShaderResourceUsageAMD* toCount,
- size_t* count);
+void count_VkShaderResourceUsageAMD(uint32_t featureBits, VkStructureType rootType,
+ const VkShaderResourceUsageAMD* toCount, size_t* count);
-void count_VkShaderStatisticsInfoAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkShaderStatisticsInfoAMD* toCount,
- size_t* count);
+void count_VkShaderStatisticsInfoAMD(uint32_t featureBits, VkStructureType rootType,
+ const VkShaderStatisticsInfoAMD* toCount, size_t* count);
#endif
#ifdef VK_AMD_shader_image_load_store_lod
#endif
#ifdef VK_GGP_stream_descriptor_surface
void count_VkStreamDescriptorSurfaceCreateInfoGGP(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkStreamDescriptorSurfaceCreateInfoGGP* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkStreamDescriptorSurfaceCreateInfoGGP* toCount, size_t* count);
#endif
#ifdef VK_NV_corner_sampled_image
void count_VkPhysicalDeviceCornerSampledImageFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceCornerSampledImageFeaturesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceCornerSampledImageFeaturesNV* toCount, size_t* count);
#endif
#ifdef VK_IMG_format_pvrtc
#endif
#ifdef VK_NV_external_memory_capabilities
-void count_VkExternalImageFormatPropertiesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExternalImageFormatPropertiesNV* toCount,
- size_t* count);
+void count_VkExternalImageFormatPropertiesNV(uint32_t featureBits, VkStructureType rootType,
+ const VkExternalImageFormatPropertiesNV* toCount,
+ size_t* count);
#endif
#ifdef VK_NV_external_memory
-void count_VkExternalMemoryImageCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExternalMemoryImageCreateInfoNV* toCount,
- size_t* count);
+void count_VkExternalMemoryImageCreateInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkExternalMemoryImageCreateInfoNV* toCount,
+ size_t* count);
-void count_VkExportMemoryAllocateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExportMemoryAllocateInfoNV* toCount,
- size_t* count);
+void count_VkExportMemoryAllocateInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkExportMemoryAllocateInfoNV* toCount, size_t* count);
#endif
#ifdef VK_NV_external_memory_win32
-void count_VkImportMemoryWin32HandleInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportMemoryWin32HandleInfoNV* toCount,
- size_t* count);
+void count_VkImportMemoryWin32HandleInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkImportMemoryWin32HandleInfoNV* toCount,
+ size_t* count);
-void count_VkExportMemoryWin32HandleInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExportMemoryWin32HandleInfoNV* toCount,
- size_t* count);
+void count_VkExportMemoryWin32HandleInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkExportMemoryWin32HandleInfoNV* toCount,
+ size_t* count);
#endif
#ifdef VK_NV_win32_keyed_mutex
void count_VkWin32KeyedMutexAcquireReleaseInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkWin32KeyedMutexAcquireReleaseInfoNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkWin32KeyedMutexAcquireReleaseInfoNV* toCount, size_t* count);
#endif
#ifdef VK_EXT_validation_flags
-void count_VkValidationFlagsEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkValidationFlagsEXT* toCount,
- size_t* count);
+void count_VkValidationFlagsEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkValidationFlagsEXT* toCount, size_t* count);
#endif
#ifdef VK_NN_vi_surface
-void count_VkViSurfaceCreateInfoNN(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkViSurfaceCreateInfoNN* toCount,
- size_t* count);
+void count_VkViSurfaceCreateInfoNN(uint32_t featureBits, VkStructureType rootType,
+ const VkViSurfaceCreateInfoNN* toCount, size_t* count);
#endif
#ifdef VK_EXT_shader_subgroup_ballot
@@ -3068,58 +2060,40 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
void count_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_astc_decode_mode
-void count_VkImageViewASTCDecodeModeEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageViewASTCDecodeModeEXT* toCount,
- size_t* count);
+void count_VkImageViewASTCDecodeModeEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkImageViewASTCDecodeModeEXT* toCount, size_t* count);
void count_VkPhysicalDeviceASTCDecodeFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceASTCDecodeFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceASTCDecodeFeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_conditional_rendering
-void count_VkConditionalRenderingBeginInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkConditionalRenderingBeginInfoEXT* toCount,
- size_t* count);
+void count_VkConditionalRenderingBeginInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkConditionalRenderingBeginInfoEXT* toCount,
+ size_t* count);
void count_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceConditionalRenderingFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceConditionalRenderingFeaturesEXT* toCount, size_t* count);
void count_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCommandBufferInheritanceConditionalRenderingInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkCommandBufferInheritanceConditionalRenderingInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_NV_clip_space_w_scaling
-void count_VkViewportWScalingNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkViewportWScalingNV* toCount,
- size_t* count);
+void count_VkViewportWScalingNV(uint32_t featureBits, VkStructureType rootType,
+ const VkViewportWScalingNV* toCount, size_t* count);
void count_VkPipelineViewportWScalingStateCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineViewportWScalingStateCreateInfoNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineViewportWScalingStateCreateInfoNV* toCount, size_t* count);
#endif
#ifdef VK_EXT_direct_mode_display
@@ -3127,63 +2101,38 @@
#ifdef VK_EXT_acquire_xlib_display
#endif
#ifdef VK_EXT_display_surface_counter
-void count_VkSurfaceCapabilities2EXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSurfaceCapabilities2EXT* toCount,
- size_t* count);
+void count_VkSurfaceCapabilities2EXT(uint32_t featureBits, VkStructureType rootType,
+ const VkSurfaceCapabilities2EXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_display_control
-void count_VkDisplayPowerInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayPowerInfoEXT* toCount,
- size_t* count);
+void count_VkDisplayPowerInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayPowerInfoEXT* toCount, size_t* count);
-void count_VkDeviceEventInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceEventInfoEXT* toCount,
- size_t* count);
+void count_VkDeviceEventInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceEventInfoEXT* toCount, size_t* count);
-void count_VkDisplayEventInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayEventInfoEXT* toCount,
- size_t* count);
+void count_VkDisplayEventInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayEventInfoEXT* toCount, size_t* count);
-void count_VkSwapchainCounterCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSwapchainCounterCreateInfoEXT* toCount,
- size_t* count);
+void count_VkSwapchainCounterCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkSwapchainCounterCreateInfoEXT* toCount,
+ size_t* count);
#endif
#ifdef VK_GOOGLE_display_timing
-void count_VkRefreshCycleDurationGOOGLE(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRefreshCycleDurationGOOGLE* toCount,
- size_t* count);
+void count_VkRefreshCycleDurationGOOGLE(uint32_t featureBits, VkStructureType rootType,
+ const VkRefreshCycleDurationGOOGLE* toCount, size_t* count);
-void count_VkPastPresentationTimingGOOGLE(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPastPresentationTimingGOOGLE* toCount,
- size_t* count);
+void count_VkPastPresentationTimingGOOGLE(uint32_t featureBits, VkStructureType rootType,
+ const VkPastPresentationTimingGOOGLE* toCount,
+ size_t* count);
-void count_VkPresentTimeGOOGLE(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPresentTimeGOOGLE* toCount,
- size_t* count);
+void count_VkPresentTimeGOOGLE(uint32_t featureBits, VkStructureType rootType,
+ const VkPresentTimeGOOGLE* toCount, size_t* count);
-void count_VkPresentTimesInfoGOOGLE(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPresentTimesInfoGOOGLE* toCount,
- size_t* count);
+void count_VkPresentTimesInfoGOOGLE(uint32_t featureBits, VkStructureType rootType,
+ const VkPresentTimesInfoGOOGLE* toCount, size_t* count);
#endif
#ifdef VK_NV_sample_mask_override_coverage
@@ -3194,98 +2143,67 @@
#endif
#ifdef VK_NVX_multiview_per_view_attributes
void count_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toCount, size_t* count);
#endif
#ifdef VK_NV_viewport_swizzle
-void count_VkViewportSwizzleNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkViewportSwizzleNV* toCount,
- size_t* count);
+void count_VkViewportSwizzleNV(uint32_t featureBits, VkStructureType rootType,
+ const VkViewportSwizzleNV* toCount, size_t* count);
void count_VkPipelineViewportSwizzleStateCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineViewportSwizzleStateCreateInfoNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineViewportSwizzleStateCreateInfoNV* toCount, size_t* count);
#endif
#ifdef VK_EXT_discard_rectangles
void count_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDiscardRectanglePropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDiscardRectanglePropertiesEXT* toCount, size_t* count);
void count_VkPipelineDiscardRectangleStateCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineDiscardRectangleStateCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineDiscardRectangleStateCreateInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_conservative_rasterization
void count_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* toCount, size_t* count);
void count_VkPipelineRasterizationConservativeStateCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineRasterizationConservativeStateCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRasterizationConservativeStateCreateInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_depth_clip_enable
void count_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDepthClipEnableFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDepthClipEnableFeaturesEXT* toCount, size_t* count);
void count_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineRasterizationDepthClipStateCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRasterizationDepthClipStateCreateInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
-void count_VkXYColorEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkXYColorEXT* toCount,
- size_t* count);
+void count_VkXYColorEXT(uint32_t featureBits, VkStructureType rootType, const VkXYColorEXT* toCount,
+ size_t* count);
-void count_VkHdrMetadataEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkHdrMetadataEXT* toCount,
- size_t* count);
+void count_VkHdrMetadataEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkHdrMetadataEXT* toCount, size_t* count);
#endif
#ifdef VK_MVK_ios_surface
-void count_VkIOSSurfaceCreateInfoMVK(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkIOSSurfaceCreateInfoMVK* toCount,
- size_t* count);
+void count_VkIOSSurfaceCreateInfoMVK(uint32_t featureBits, VkStructureType rootType,
+ const VkIOSSurfaceCreateInfoMVK* toCount, size_t* count);
#endif
#ifdef VK_MVK_macos_surface
-void count_VkMacOSSurfaceCreateInfoMVK(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMacOSSurfaceCreateInfoMVK* toCount,
- size_t* count);
+void count_VkMacOSSurfaceCreateInfoMVK(uint32_t featureBits, VkStructureType rootType,
+ const VkMacOSSurfaceCreateInfoMVK* toCount, size_t* count);
#endif
#ifdef VK_MVK_moltenvk
@@ -3295,85 +2213,60 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
-void count_VkDebugUtilsLabelEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDebugUtilsLabelEXT* toCount,
- size_t* count);
+void count_VkDebugUtilsLabelEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDebugUtilsLabelEXT* toCount, size_t* count);
-void count_VkDebugUtilsObjectNameInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDebugUtilsObjectNameInfoEXT* toCount,
- size_t* count);
+void count_VkDebugUtilsObjectNameInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDebugUtilsObjectNameInfoEXT* toCount,
+ size_t* count);
-void count_VkDebugUtilsMessengerCallbackDataEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDebugUtilsMessengerCallbackDataEXT* toCount,
- size_t* count);
+void count_VkDebugUtilsMessengerCallbackDataEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDebugUtilsMessengerCallbackDataEXT* toCount,
+ size_t* count);
-void count_VkDebugUtilsMessengerCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDebugUtilsMessengerCreateInfoEXT* toCount,
- size_t* count);
+void count_VkDebugUtilsMessengerCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDebugUtilsMessengerCreateInfoEXT* toCount,
+ size_t* count);
-void count_VkDebugUtilsObjectTagInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDebugUtilsObjectTagInfoEXT* toCount,
- size_t* count);
+void count_VkDebugUtilsObjectTagInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDebugUtilsObjectTagInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
-void count_VkAndroidHardwareBufferUsageANDROID(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAndroidHardwareBufferUsageANDROID* toCount,
- size_t* count);
+void count_VkAndroidHardwareBufferUsageANDROID(uint32_t featureBits, VkStructureType rootType,
+ const VkAndroidHardwareBufferUsageANDROID* toCount,
+ size_t* count);
void count_VkAndroidHardwareBufferPropertiesANDROID(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAndroidHardwareBufferPropertiesANDROID* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAndroidHardwareBufferPropertiesANDROID* toCount, size_t* count);
void count_VkAndroidHardwareBufferFormatPropertiesANDROID(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAndroidHardwareBufferFormatPropertiesANDROID* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAndroidHardwareBufferFormatPropertiesANDROID* toCount, size_t* count);
void count_VkImportAndroidHardwareBufferInfoANDROID(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportAndroidHardwareBufferInfoANDROID* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkImportAndroidHardwareBufferInfoANDROID* toCount, size_t* count);
void count_VkMemoryGetAndroidHardwareBufferInfoANDROID(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryGetAndroidHardwareBufferInfoANDROID* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryGetAndroidHardwareBufferInfoANDROID* toCount, size_t* count);
-void count_VkExternalFormatANDROID(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkExternalFormatANDROID* toCount,
- size_t* count);
+void count_VkExternalFormatANDROID(uint32_t featureBits, VkStructureType rootType,
+ const VkExternalFormatANDROID* toCount, size_t* count);
void count_VkAndroidHardwareBufferFormatProperties2ANDROID(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAndroidHardwareBufferFormatProperties2ANDROID* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAndroidHardwareBufferFormatProperties2ANDROID* toCount, size_t* count);
#endif
#ifdef VK_EXT_sampler_filter_minmax
-DEFINE_ALIAS_FUNCTION(count_VkSamplerReductionModeCreateInfo, count_VkSamplerReductionModeCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(count_VkSamplerReductionModeCreateInfo,
+ count_VkSamplerReductionModeCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceSamplerFilterMinmaxProperties, count_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceSamplerFilterMinmaxProperties,
+ count_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT)
#endif
#ifdef VK_AMD_gpu_shader_int16
@@ -3384,734 +2277,513 @@
#endif
#ifdef VK_EXT_inline_uniform_block
void count_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toCount, size_t* count);
void count_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toCount, size_t* count);
void count_VkWriteDescriptorSetInlineUniformBlockEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkWriteDescriptorSetInlineUniformBlockEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkWriteDescriptorSetInlineUniformBlockEXT* toCount, size_t* count);
void count_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
-void count_VkSampleLocationEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSampleLocationEXT* toCount,
- size_t* count);
+void count_VkSampleLocationEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkSampleLocationEXT* toCount, size_t* count);
-void count_VkSampleLocationsInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSampleLocationsInfoEXT* toCount,
- size_t* count);
+void count_VkSampleLocationsInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkSampleLocationsInfoEXT* toCount, size_t* count);
-void count_VkAttachmentSampleLocationsEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAttachmentSampleLocationsEXT* toCount,
- size_t* count);
+void count_VkAttachmentSampleLocationsEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkAttachmentSampleLocationsEXT* toCount,
+ size_t* count);
-void count_VkSubpassSampleLocationsEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubpassSampleLocationsEXT* toCount,
- size_t* count);
+void count_VkSubpassSampleLocationsEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkSubpassSampleLocationsEXT* toCount, size_t* count);
void count_VkRenderPassSampleLocationsBeginInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderPassSampleLocationsBeginInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkRenderPassSampleLocationsBeginInfoEXT* toCount, size_t* count);
void count_VkPipelineSampleLocationsStateCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineSampleLocationsStateCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineSampleLocationsStateCreateInfoEXT* toCount, size_t* count);
void count_VkPhysicalDeviceSampleLocationsPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSampleLocationsPropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSampleLocationsPropertiesEXT* toCount, size_t* count);
-void count_VkMultisamplePropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMultisamplePropertiesEXT* toCount,
- size_t* count);
+void count_VkMultisamplePropertiesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkMultisamplePropertiesEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_blend_operation_advanced
void count_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* toCount, size_t* count);
void count_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toCount, size_t* count);
void count_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineColorBlendAdvancedStateCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineColorBlendAdvancedStateCreateInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_NV_fragment_coverage_to_color
void count_VkPipelineCoverageToColorStateCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineCoverageToColorStateCreateInfoNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineCoverageToColorStateCreateInfoNV* toCount, size_t* count);
#endif
#ifdef VK_NV_framebuffer_mixed_samples
void count_VkPipelineCoverageModulationStateCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineCoverageModulationStateCreateInfoNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineCoverageModulationStateCreateInfoNV* toCount, size_t* count);
#endif
#ifdef VK_NV_fill_rectangle
#endif
#ifdef VK_NV_shader_sm_builtins
void count_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* toCount, size_t* count);
void count_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* toCount, size_t* count);
#endif
#ifdef VK_EXT_post_depth_coverage
#endif
#ifdef VK_EXT_image_drm_format_modifier
-void count_VkDrmFormatModifierPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesEXT* toCount,
- size_t* count);
+void count_VkDrmFormatModifierPropertiesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDrmFormatModifierPropertiesEXT* toCount,
+ size_t* count);
-void count_VkDrmFormatModifierPropertiesListEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesListEXT* toCount,
- size_t* count);
+void count_VkDrmFormatModifierPropertiesListEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDrmFormatModifierPropertiesListEXT* toCount,
+ size_t* count);
void count_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* toCount, size_t* count);
void count_VkImageDrmFormatModifierListCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageDrmFormatModifierListCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkImageDrmFormatModifierListCreateInfoEXT* toCount, size_t* count);
void count_VkImageDrmFormatModifierExplicitCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageDrmFormatModifierExplicitCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkImageDrmFormatModifierExplicitCreateInfoEXT* toCount, size_t* count);
void count_VkImageDrmFormatModifierPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageDrmFormatModifierPropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkImageDrmFormatModifierPropertiesEXT* toCount, size_t* count);
-void count_VkDrmFormatModifierProperties2EXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDrmFormatModifierProperties2EXT* toCount,
- size_t* count);
+void count_VkDrmFormatModifierProperties2EXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDrmFormatModifierProperties2EXT* toCount,
+ size_t* count);
void count_VkDrmFormatModifierPropertiesList2EXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesList2EXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDrmFormatModifierPropertiesList2EXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_validation_cache
-void count_VkValidationCacheCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkValidationCacheCreateInfoEXT* toCount,
- size_t* count);
+void count_VkValidationCacheCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkValidationCacheCreateInfoEXT* toCount,
+ size_t* count);
void count_VkShaderModuleValidationCacheCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkShaderModuleValidationCacheCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkShaderModuleValidationCacheCreateInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_descriptor_indexing
-DEFINE_ALIAS_FUNCTION(count_VkDescriptorSetLayoutBindingFlagsCreateInfo, count_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(count_VkDescriptorSetLayoutBindingFlagsCreateInfo,
+ count_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceDescriptorIndexingFeatures, count_VkPhysicalDeviceDescriptorIndexingFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceDescriptorIndexingFeatures,
+ count_VkPhysicalDeviceDescriptorIndexingFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceDescriptorIndexingProperties, count_VkPhysicalDeviceDescriptorIndexingPropertiesEXT)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceDescriptorIndexingProperties,
+ count_VkPhysicalDeviceDescriptorIndexingPropertiesEXT)
-DEFINE_ALIAS_FUNCTION(count_VkDescriptorSetVariableDescriptorCountAllocateInfo, count_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT)
+DEFINE_ALIAS_FUNCTION(count_VkDescriptorSetVariableDescriptorCountAllocateInfo,
+ count_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT)
-DEFINE_ALIAS_FUNCTION(count_VkDescriptorSetVariableDescriptorCountLayoutSupport, count_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT)
+DEFINE_ALIAS_FUNCTION(count_VkDescriptorSetVariableDescriptorCountLayoutSupport,
+ count_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT)
#endif
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_NV_shading_rate_image
-void count_VkShadingRatePaletteNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkShadingRatePaletteNV* toCount,
- size_t* count);
+void count_VkShadingRatePaletteNV(uint32_t featureBits, VkStructureType rootType,
+ const VkShadingRatePaletteNV* toCount, size_t* count);
void count_VkPipelineViewportShadingRateImageStateCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineViewportShadingRateImageStateCreateInfoNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineViewportShadingRateImageStateCreateInfoNV* toCount, size_t* count);
void count_VkPhysicalDeviceShadingRateImageFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShadingRateImageFeaturesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShadingRateImageFeaturesNV* toCount, size_t* count);
void count_VkPhysicalDeviceShadingRateImagePropertiesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShadingRateImagePropertiesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShadingRateImagePropertiesNV* toCount, size_t* count);
-void count_VkCoarseSampleLocationNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCoarseSampleLocationNV* toCount,
- size_t* count);
+void count_VkCoarseSampleLocationNV(uint32_t featureBits, VkStructureType rootType,
+ const VkCoarseSampleLocationNV* toCount, size_t* count);
-void count_VkCoarseSampleOrderCustomNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCoarseSampleOrderCustomNV* toCount,
- size_t* count);
+void count_VkCoarseSampleOrderCustomNV(uint32_t featureBits, VkStructureType rootType,
+ const VkCoarseSampleOrderCustomNV* toCount, size_t* count);
void count_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* toCount, size_t* count);
#endif
#ifdef VK_NV_ray_tracing
-void count_VkRayTracingShaderGroupCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRayTracingShaderGroupCreateInfoNV* toCount,
- size_t* count);
+void count_VkRayTracingShaderGroupCreateInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkRayTracingShaderGroupCreateInfoNV* toCount,
+ size_t* count);
-void count_VkRayTracingPipelineCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRayTracingPipelineCreateInfoNV* toCount,
- size_t* count);
+void count_VkRayTracingPipelineCreateInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkRayTracingPipelineCreateInfoNV* toCount,
+ size_t* count);
-void count_VkGeometryTrianglesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkGeometryTrianglesNV* toCount,
- size_t* count);
+void count_VkGeometryTrianglesNV(uint32_t featureBits, VkStructureType rootType,
+ const VkGeometryTrianglesNV* toCount, size_t* count);
-void count_VkGeometryAABBNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkGeometryAABBNV* toCount,
- size_t* count);
+void count_VkGeometryAABBNV(uint32_t featureBits, VkStructureType rootType,
+ const VkGeometryAABBNV* toCount, size_t* count);
-void count_VkGeometryDataNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkGeometryDataNV* toCount,
- size_t* count);
+void count_VkGeometryDataNV(uint32_t featureBits, VkStructureType rootType,
+ const VkGeometryDataNV* toCount, size_t* count);
-void count_VkGeometryNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkGeometryNV* toCount,
- size_t* count);
+void count_VkGeometryNV(uint32_t featureBits, VkStructureType rootType, const VkGeometryNV* toCount,
+ size_t* count);
-void count_VkAccelerationStructureInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureInfoNV* toCount,
- size_t* count);
+void count_VkAccelerationStructureInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureInfoNV* toCount,
+ size_t* count);
-void count_VkAccelerationStructureCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureCreateInfoNV* toCount,
- size_t* count);
+void count_VkAccelerationStructureCreateInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureCreateInfoNV* toCount,
+ size_t* count);
void count_VkBindAccelerationStructureMemoryInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindAccelerationStructureMemoryInfoNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkBindAccelerationStructureMemoryInfoNV* toCount, size_t* count);
void count_VkWriteDescriptorSetAccelerationStructureNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkWriteDescriptorSetAccelerationStructureNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkWriteDescriptorSetAccelerationStructureNV* toCount, size_t* count);
void count_VkAccelerationStructureMemoryRequirementsInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureMemoryRequirementsInfoNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureMemoryRequirementsInfoNV* toCount, size_t* count);
void count_VkPhysicalDeviceRayTracingPropertiesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingPropertiesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPropertiesNV* toCount, size_t* count);
-void count_VkTransformMatrixKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkTransformMatrixKHR* toCount,
- size_t* count);
+void count_VkTransformMatrixKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkTransformMatrixKHR* toCount, size_t* count);
DEFINE_ALIAS_FUNCTION(count_VkTransformMatrixKHR, count_VkTransformMatrixNV)
-void count_VkAabbPositionsKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAabbPositionsKHR* toCount,
- size_t* count);
+void count_VkAabbPositionsKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkAabbPositionsKHR* toCount, size_t* count);
DEFINE_ALIAS_FUNCTION(count_VkAabbPositionsKHR, count_VkAabbPositionsNV)
-void count_VkAccelerationStructureInstanceKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureInstanceKHR* toCount,
- size_t* count);
+void count_VkAccelerationStructureInstanceKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureInstanceKHR* toCount,
+ size_t* count);
-DEFINE_ALIAS_FUNCTION(count_VkAccelerationStructureInstanceKHR, count_VkAccelerationStructureInstanceNV)
+DEFINE_ALIAS_FUNCTION(count_VkAccelerationStructureInstanceKHR,
+ count_VkAccelerationStructureInstanceNV)
#endif
#ifdef VK_NV_representative_fragment_test
void count_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* toCount, size_t* count);
void count_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* toCount, size_t* count);
#endif
#ifdef VK_EXT_filter_cubic
void count_VkPhysicalDeviceImageViewImageFormatInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceImageViewImageFormatInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceImageViewImageFormatInfoEXT* toCount, size_t* count);
void count_VkFilterCubicImageViewImageFormatPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFilterCubicImageViewImageFormatPropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkFilterCubicImageViewImageFormatPropertiesEXT* toCount, size_t* count);
#endif
#ifdef VK_QCOM_render_pass_shader_resolve
#endif
#ifdef VK_EXT_global_priority
void count_VkDeviceQueueGlobalPriorityCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceQueueGlobalPriorityCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceQueueGlobalPriorityCreateInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_external_memory_host
-void count_VkImportMemoryHostPointerInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportMemoryHostPointerInfoEXT* toCount,
- size_t* count);
+void count_VkImportMemoryHostPointerInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkImportMemoryHostPointerInfoEXT* toCount,
+ size_t* count);
-void count_VkMemoryHostPointerPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryHostPointerPropertiesEXT* toCount,
- size_t* count);
+void count_VkMemoryHostPointerPropertiesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryHostPointerPropertiesEXT* toCount,
+ size_t* count);
void count_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toCount, size_t* count);
#endif
#ifdef VK_AMD_buffer_marker
#endif
#ifdef VK_AMD_pipeline_compiler_control
void count_VkPipelineCompilerControlCreateInfoAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineCompilerControlCreateInfoAMD* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineCompilerControlCreateInfoAMD* toCount, size_t* count);
#endif
#ifdef VK_EXT_calibrated_timestamps
-void count_VkCalibratedTimestampInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCalibratedTimestampInfoEXT* toCount,
- size_t* count);
+void count_VkCalibratedTimestampInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkCalibratedTimestampInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_AMD_shader_core_properties
void count_VkPhysicalDeviceShaderCorePropertiesAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderCorePropertiesAMD* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderCorePropertiesAMD* toCount, size_t* count);
#endif
#ifdef VK_EXT_video_decode_h265
-void count_VkVideoDecodeH265ProfileEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH265ProfileEXT* toCount,
- size_t* count);
+void count_VkVideoDecodeH265ProfileEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH265ProfileEXT* toCount, size_t* count);
-void count_VkVideoDecodeH265CapabilitiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH265CapabilitiesEXT* toCount,
- size_t* count);
+void count_VkVideoDecodeH265CapabilitiesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH265CapabilitiesEXT* toCount,
+ size_t* count);
void count_VkVideoDecodeH265SessionCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH265SessionCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH265SessionCreateInfoEXT* toCount, size_t* count);
void count_VkVideoDecodeH265SessionParametersAddInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH265SessionParametersAddInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH265SessionParametersAddInfoEXT* toCount, size_t* count);
void count_VkVideoDecodeH265SessionParametersCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH265SessionParametersCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH265SessionParametersCreateInfoEXT* toCount, size_t* count);
-void count_VkVideoDecodeH265PictureInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH265PictureInfoEXT* toCount,
- size_t* count);
+void count_VkVideoDecodeH265PictureInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH265PictureInfoEXT* toCount,
+ size_t* count);
-void count_VkVideoDecodeH265DpbSlotInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVideoDecodeH265DpbSlotInfoEXT* toCount,
- size_t* count);
+void count_VkVideoDecodeH265DpbSlotInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVideoDecodeH265DpbSlotInfoEXT* toCount,
+ size_t* count);
#endif
#ifdef VK_AMD_memory_overallocation_behavior
void count_VkDeviceMemoryOverallocationCreateInfoAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceMemoryOverallocationCreateInfoAMD* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceMemoryOverallocationCreateInfoAMD* toCount, size_t* count);
#endif
#ifdef VK_EXT_vertex_attribute_divisor
void count_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toCount, size_t* count);
void count_VkVertexInputBindingDivisorDescriptionEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVertexInputBindingDivisorDescriptionEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVertexInputBindingDivisorDescriptionEXT* toCount, size_t* count);
void count_VkPipelineVertexInputDivisorStateCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineVertexInputDivisorStateCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineVertexInputDivisorStateCreateInfoEXT* toCount, size_t* count);
void count_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_GGP_frame_token
-void count_VkPresentFrameTokenGGP(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPresentFrameTokenGGP* toCount,
- size_t* count);
+void count_VkPresentFrameTokenGGP(uint32_t featureBits, VkStructureType rootType,
+ const VkPresentFrameTokenGGP* toCount, size_t* count);
#endif
#ifdef VK_EXT_pipeline_creation_feedback
-void count_VkPipelineCreationFeedbackEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineCreationFeedbackEXT* toCount,
- size_t* count);
+void count_VkPipelineCreationFeedbackEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineCreationFeedbackEXT* toCount,
+ size_t* count);
void count_VkPipelineCreationFeedbackCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineCreationFeedbackCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineCreationFeedbackCreateInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_NV_shader_subgroup_partitioned
#endif
#ifdef VK_NV_compute_shader_derivatives
void count_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* toCount, size_t* count);
#endif
#ifdef VK_NV_mesh_shader
-void count_VkPhysicalDeviceMeshShaderFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMeshShaderFeaturesNV* toCount,
- size_t* count);
+void count_VkPhysicalDeviceMeshShaderFeaturesNV(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMeshShaderFeaturesNV* toCount,
+ size_t* count);
void count_VkPhysicalDeviceMeshShaderPropertiesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMeshShaderPropertiesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMeshShaderPropertiesNV* toCount, size_t* count);
-void count_VkDrawMeshTasksIndirectCommandNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDrawMeshTasksIndirectCommandNV* toCount,
- size_t* count);
+void count_VkDrawMeshTasksIndirectCommandNV(uint32_t featureBits, VkStructureType rootType,
+ const VkDrawMeshTasksIndirectCommandNV* toCount,
+ size_t* count);
#endif
#ifdef VK_NV_fragment_shader_barycentric
void count_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toCount, size_t* count);
#endif
#ifdef VK_NV_shader_image_footprint
void count_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderImageFootprintFeaturesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderImageFootprintFeaturesNV* toCount, size_t* count);
#endif
#ifdef VK_NV_scissor_exclusive
void count_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineViewportExclusiveScissorStateCreateInfoNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineViewportExclusiveScissorStateCreateInfoNV* toCount, size_t* count);
void count_VkPhysicalDeviceExclusiveScissorFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceExclusiveScissorFeaturesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceExclusiveScissorFeaturesNV* toCount, size_t* count);
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
-void count_VkQueueFamilyCheckpointPropertiesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkQueueFamilyCheckpointPropertiesNV* toCount,
- size_t* count);
+void count_VkQueueFamilyCheckpointPropertiesNV(uint32_t featureBits, VkStructureType rootType,
+ const VkQueueFamilyCheckpointPropertiesNV* toCount,
+ size_t* count);
-void count_VkCheckpointDataNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCheckpointDataNV* toCount,
- size_t* count);
+void count_VkCheckpointDataNV(uint32_t featureBits, VkStructureType rootType,
+ const VkCheckpointDataNV* toCount, size_t* count);
#endif
#ifdef VK_INTEL_shader_integer_functions2
void count_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* toCount, size_t* count);
#endif
#ifdef VK_INTEL_performance_query
-void count_VkPerformanceValueDataINTEL(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPerformanceValueDataINTEL* toCount,
- size_t* count);
+void count_VkPerformanceValueDataINTEL(uint32_t featureBits, VkStructureType rootType,
+ const VkPerformanceValueDataINTEL* toCount, size_t* count);
-void count_VkPerformanceValueINTEL(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPerformanceValueINTEL* toCount,
- size_t* count);
+void count_VkPerformanceValueINTEL(uint32_t featureBits, VkStructureType rootType,
+ const VkPerformanceValueINTEL* toCount, size_t* count);
-void count_VkInitializePerformanceApiInfoINTEL(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkInitializePerformanceApiInfoINTEL* toCount,
- size_t* count);
+void count_VkInitializePerformanceApiInfoINTEL(uint32_t featureBits, VkStructureType rootType,
+ const VkInitializePerformanceApiInfoINTEL* toCount,
+ size_t* count);
void count_VkQueryPoolPerformanceQueryCreateInfoINTEL(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkQueryPoolPerformanceQueryCreateInfoINTEL* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkQueryPoolPerformanceQueryCreateInfoINTEL* toCount, size_t* count);
-DEFINE_ALIAS_FUNCTION(count_VkQueryPoolPerformanceQueryCreateInfoINTEL, count_VkQueryPoolCreateInfoINTEL)
+DEFINE_ALIAS_FUNCTION(count_VkQueryPoolPerformanceQueryCreateInfoINTEL,
+ count_VkQueryPoolCreateInfoINTEL)
-void count_VkPerformanceMarkerInfoINTEL(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPerformanceMarkerInfoINTEL* toCount,
- size_t* count);
+void count_VkPerformanceMarkerInfoINTEL(uint32_t featureBits, VkStructureType rootType,
+ const VkPerformanceMarkerInfoINTEL* toCount, size_t* count);
-void count_VkPerformanceStreamMarkerInfoINTEL(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPerformanceStreamMarkerInfoINTEL* toCount,
- size_t* count);
+void count_VkPerformanceStreamMarkerInfoINTEL(uint32_t featureBits, VkStructureType rootType,
+ const VkPerformanceStreamMarkerInfoINTEL* toCount,
+ size_t* count);
-void count_VkPerformanceOverrideInfoINTEL(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPerformanceOverrideInfoINTEL* toCount,
- size_t* count);
+void count_VkPerformanceOverrideInfoINTEL(uint32_t featureBits, VkStructureType rootType,
+ const VkPerformanceOverrideInfoINTEL* toCount,
+ size_t* count);
void count_VkPerformanceConfigurationAcquireInfoINTEL(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPerformanceConfigurationAcquireInfoINTEL* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPerformanceConfigurationAcquireInfoINTEL* toCount, size_t* count);
#endif
#ifdef VK_EXT_pci_bus_info
void count_VkPhysicalDevicePCIBusInfoPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePCIBusInfoPropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePCIBusInfoPropertiesEXT* toCount, size_t* count);
#endif
#ifdef VK_AMD_display_native_hdr
void count_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDisplayNativeHdrSurfaceCapabilitiesAMD* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDisplayNativeHdrSurfaceCapabilitiesAMD* toCount, size_t* count);
void count_VkSwapchainDisplayNativeHdrCreateInfoAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSwapchainDisplayNativeHdrCreateInfoAMD* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkSwapchainDisplayNativeHdrCreateInfoAMD* toCount, size_t* count);
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
-void count_VkImagePipeSurfaceCreateInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImagePipeSurfaceCreateInfoFUCHSIA* toCount,
- size_t* count);
+void count_VkImagePipeSurfaceCreateInfoFUCHSIA(uint32_t featureBits, VkStructureType rootType,
+ const VkImagePipeSurfaceCreateInfoFUCHSIA* toCount,
+ size_t* count);
#endif
#ifdef VK_EXT_metal_surface
-void count_VkMetalSurfaceCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMetalSurfaceCreateInfoEXT* toCount,
- size_t* count);
+void count_VkMetalSurfaceCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkMetalSurfaceCreateInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_fragment_density_map
void count_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toCount, size_t* count);
void count_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toCount, size_t* count);
void count_VkRenderPassFragmentDensityMapCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderPassFragmentDensityMapCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkRenderPassFragmentDensityMapCreateInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_scalar_block_layout
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceScalarBlockLayoutFeatures, count_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceScalarBlockLayoutFeatures,
+ count_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT)
#endif
#ifdef VK_GOOGLE_hlsl_functionality1
@@ -4120,102 +2792,77 @@
#endif
#ifdef VK_EXT_subgroup_size_control
void count_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toCount, size_t* count);
void count_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* toCount, size_t* count);
void count_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_AMD_shader_core_properties2
void count_VkPhysicalDeviceShaderCoreProperties2AMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderCoreProperties2AMD* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderCoreProperties2AMD* toCount, size_t* count);
#endif
#ifdef VK_AMD_device_coherent_memory
void count_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceCoherentMemoryFeaturesAMD* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceCoherentMemoryFeaturesAMD* toCount, size_t* count);
#endif
#ifdef VK_EXT_shader_image_atomic_int64
void count_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_memory_budget
void count_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryBudgetPropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryBudgetPropertiesEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_memory_priority
void count_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryPriorityFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryPriorityFeaturesEXT* toCount, size_t* count);
-void count_VkMemoryPriorityAllocateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryPriorityAllocateInfoEXT* toCount,
- size_t* count);
+void count_VkMemoryPriorityAllocateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryPriorityAllocateInfoEXT* toCount,
+ size_t* count);
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
void count_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* toCount, size_t* count);
#endif
#ifdef VK_EXT_buffer_device_address
void count_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* toCount, size_t* count);
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, count_VkPhysicalDeviceBufferAddressFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT,
+ count_VkPhysicalDeviceBufferAddressFeaturesEXT)
DEFINE_ALIAS_FUNCTION(count_VkBufferDeviceAddressInfo, count_VkBufferDeviceAddressInfoEXT)
-void count_VkBufferDeviceAddressCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferDeviceAddressCreateInfoEXT* toCount,
- size_t* count);
+void count_VkBufferDeviceAddressCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferDeviceAddressCreateInfoEXT* toCount,
+ size_t* count);
#endif
#ifdef VK_EXT_tooling_info
-void count_VkPhysicalDeviceToolPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceToolPropertiesEXT* toCount,
- size_t* count);
+void count_VkPhysicalDeviceToolPropertiesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceToolPropertiesEXT* toCount,
+ size_t* count);
#endif
#ifdef VK_EXT_separate_stencil_usage
@@ -4223,1014 +2870,708 @@
#endif
#ifdef VK_EXT_validation_features
-void count_VkValidationFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkValidationFeaturesEXT* toCount,
- size_t* count);
+void count_VkValidationFeaturesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkValidationFeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_NV_cooperative_matrix
-void count_VkCooperativeMatrixPropertiesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCooperativeMatrixPropertiesNV* toCount,
- size_t* count);
+void count_VkCooperativeMatrixPropertiesNV(uint32_t featureBits, VkStructureType rootType,
+ const VkCooperativeMatrixPropertiesNV* toCount,
+ size_t* count);
void count_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceCooperativeMatrixFeaturesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceCooperativeMatrixFeaturesNV* toCount, size_t* count);
void count_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceCooperativeMatrixPropertiesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceCooperativeMatrixPropertiesNV* toCount, size_t* count);
#endif
#ifdef VK_NV_coverage_reduction_mode
void count_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceCoverageReductionModeFeaturesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceCoverageReductionModeFeaturesNV* toCount, size_t* count);
void count_VkPipelineCoverageReductionStateCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineCoverageReductionStateCreateInfoNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineCoverageReductionStateCreateInfoNV* toCount, size_t* count);
void count_VkFramebufferMixedSamplesCombinationNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkFramebufferMixedSamplesCombinationNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkFramebufferMixedSamplesCombinationNV* toCount, size_t* count);
#endif
#ifdef VK_EXT_fragment_shader_interlock
void count_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_ycbcr_image_arrays
void count_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_provoking_vertex
void count_VkPhysicalDeviceProvokingVertexFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceProvokingVertexFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceProvokingVertexFeaturesEXT* toCount, size_t* count);
void count_VkPhysicalDeviceProvokingVertexPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceProvokingVertexPropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceProvokingVertexPropertiesEXT* toCount, size_t* count);
void count_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_full_screen_exclusive
-void count_VkSurfaceFullScreenExclusiveInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSurfaceFullScreenExclusiveInfoEXT* toCount,
- size_t* count);
+void count_VkSurfaceFullScreenExclusiveInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkSurfaceFullScreenExclusiveInfoEXT* toCount,
+ size_t* count);
void count_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSurfaceCapabilitiesFullScreenExclusiveEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkSurfaceCapabilitiesFullScreenExclusiveEXT* toCount, size_t* count);
void count_VkSurfaceFullScreenExclusiveWin32InfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSurfaceFullScreenExclusiveWin32InfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkSurfaceFullScreenExclusiveWin32InfoEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_headless_surface
-void count_VkHeadlessSurfaceCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkHeadlessSurfaceCreateInfoEXT* toCount,
- size_t* count);
+void count_VkHeadlessSurfaceCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkHeadlessSurfaceCreateInfoEXT* toCount,
+ size_t* count);
#endif
#ifdef VK_EXT_line_rasterization
void count_VkPhysicalDeviceLineRasterizationFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationFeaturesEXT* toCount, size_t* count);
void count_VkPhysicalDeviceLineRasterizationPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationPropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationPropertiesEXT* toCount, size_t* count);
void count_VkPipelineRasterizationLineStateCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineRasterizationLineStateCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineRasterizationLineStateCreateInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_shader_atomic_float
void count_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_host_query_reset
-DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceHostQueryResetFeatures, count_VkPhysicalDeviceHostQueryResetFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(count_VkPhysicalDeviceHostQueryResetFeatures,
+ count_VkPhysicalDeviceHostQueryResetFeaturesEXT)
#endif
#ifdef VK_EXT_index_type_uint8
void count_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_extended_dynamic_state
void count_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_shader_atomic_float2
void count_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
void count_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_NV_device_generated_commands
void count_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* toCount, size_t* count);
void count_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* toCount, size_t* count);
-void count_VkGraphicsShaderGroupCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkGraphicsShaderGroupCreateInfoNV* toCount,
- size_t* count);
+void count_VkGraphicsShaderGroupCreateInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkGraphicsShaderGroupCreateInfoNV* toCount,
+ size_t* count);
void count_VkGraphicsPipelineShaderGroupsCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkGraphicsPipelineShaderGroupsCreateInfoNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkGraphicsPipelineShaderGroupsCreateInfoNV* toCount, size_t* count);
-void count_VkBindShaderGroupIndirectCommandNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindShaderGroupIndirectCommandNV* toCount,
- size_t* count);
+void count_VkBindShaderGroupIndirectCommandNV(uint32_t featureBits, VkStructureType rootType,
+ const VkBindShaderGroupIndirectCommandNV* toCount,
+ size_t* count);
-void count_VkBindIndexBufferIndirectCommandNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindIndexBufferIndirectCommandNV* toCount,
- size_t* count);
+void count_VkBindIndexBufferIndirectCommandNV(uint32_t featureBits, VkStructureType rootType,
+ const VkBindIndexBufferIndirectCommandNV* toCount,
+ size_t* count);
-void count_VkBindVertexBufferIndirectCommandNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBindVertexBufferIndirectCommandNV* toCount,
- size_t* count);
+void count_VkBindVertexBufferIndirectCommandNV(uint32_t featureBits, VkStructureType rootType,
+ const VkBindVertexBufferIndirectCommandNV* toCount,
+ size_t* count);
-void count_VkSetStateFlagsIndirectCommandNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSetStateFlagsIndirectCommandNV* toCount,
- size_t* count);
+void count_VkSetStateFlagsIndirectCommandNV(uint32_t featureBits, VkStructureType rootType,
+ const VkSetStateFlagsIndirectCommandNV* toCount,
+ size_t* count);
-void count_VkIndirectCommandsStreamNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkIndirectCommandsStreamNV* toCount,
- size_t* count);
+void count_VkIndirectCommandsStreamNV(uint32_t featureBits, VkStructureType rootType,
+ const VkIndirectCommandsStreamNV* toCount, size_t* count);
-void count_VkIndirectCommandsLayoutTokenNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkIndirectCommandsLayoutTokenNV* toCount,
- size_t* count);
+void count_VkIndirectCommandsLayoutTokenNV(uint32_t featureBits, VkStructureType rootType,
+ const VkIndirectCommandsLayoutTokenNV* toCount,
+ size_t* count);
-void count_VkIndirectCommandsLayoutCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkIndirectCommandsLayoutCreateInfoNV* toCount,
- size_t* count);
+void count_VkIndirectCommandsLayoutCreateInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkIndirectCommandsLayoutCreateInfoNV* toCount,
+ size_t* count);
-void count_VkGeneratedCommandsInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkGeneratedCommandsInfoNV* toCount,
- size_t* count);
+void count_VkGeneratedCommandsInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkGeneratedCommandsInfoNV* toCount, size_t* count);
void count_VkGeneratedCommandsMemoryRequirementsInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkGeneratedCommandsMemoryRequirementsInfoNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkGeneratedCommandsMemoryRequirementsInfoNV* toCount, size_t* count);
#endif
#ifdef VK_NV_inherited_viewport_scissor
void count_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* toCount, size_t* count);
void count_VkCommandBufferInheritanceViewportScissorInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCommandBufferInheritanceViewportScissorInfoNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkCommandBufferInheritanceViewportScissorInfoNV* toCount, size_t* count);
#endif
#ifdef VK_EXT_texel_buffer_alignment
void count_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toCount, size_t* count);
void count_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* toCount, size_t* count);
#endif
#ifdef VK_QCOM_render_pass_transform
-void count_VkRenderPassTransformBeginInfoQCOM(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRenderPassTransformBeginInfoQCOM* toCount,
- size_t* count);
+void count_VkRenderPassTransformBeginInfoQCOM(uint32_t featureBits, VkStructureType rootType,
+ const VkRenderPassTransformBeginInfoQCOM* toCount,
+ size_t* count);
void count_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* toCount, size_t* count);
#endif
#ifdef VK_EXT_device_memory_report
void count_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* toCount, size_t* count);
-void count_VkDeviceMemoryReportCallbackDataEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceMemoryReportCallbackDataEXT* toCount,
- size_t* count);
+void count_VkDeviceMemoryReportCallbackDataEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceMemoryReportCallbackDataEXT* toCount,
+ size_t* count);
void count_VkDeviceDeviceMemoryReportCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceDeviceMemoryReportCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceDeviceMemoryReportCreateInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_acquire_drm_display
#endif
#ifdef VK_EXT_robustness2
void count_VkPhysicalDeviceRobustness2FeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceRobustness2FeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceRobustness2FeaturesEXT* toCount, size_t* count);
void count_VkPhysicalDeviceRobustness2PropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceRobustness2PropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceRobustness2PropertiesEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_custom_border_color
void count_VkSamplerCustomBorderColorCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSamplerCustomBorderColorCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkSamplerCustomBorderColorCreateInfoEXT* toCount, size_t* count);
void count_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceCustomBorderColorPropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceCustomBorderColorPropertiesEXT* toCount, size_t* count);
void count_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceCustomBorderColorFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceCustomBorderColorFeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_GOOGLE_user_type
#endif
#ifdef VK_EXT_private_data
void count_VkPhysicalDevicePrivateDataFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePrivateDataFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePrivateDataFeaturesEXT* toCount, size_t* count);
-void count_VkDevicePrivateDataCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDevicePrivateDataCreateInfoEXT* toCount,
- size_t* count);
+void count_VkDevicePrivateDataCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDevicePrivateDataCreateInfoEXT* toCount,
+ size_t* count);
-void count_VkPrivateDataSlotCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPrivateDataSlotCreateInfoEXT* toCount,
- size_t* count);
+void count_VkPrivateDataSlotCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkPrivateDataSlotCreateInfoEXT* toCount,
+ size_t* count);
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
void count_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_NV_device_diagnostics_config
void count_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toCount, size_t* count);
void count_VkDeviceDiagnosticsConfigCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceDiagnosticsConfigCreateInfoNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceDiagnosticsConfigCreateInfoNV* toCount, size_t* count);
#endif
#ifdef VK_QCOM_render_pass_store_ops
#endif
#ifdef VK_NV_fragment_shading_rate_enums
void count_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* toCount, size_t* count);
void count_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* toCount, size_t* count);
void count_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* toCount, size_t* count);
#endif
#ifdef VK_NV_ray_tracing_motion_blur
-void count_VkDeviceOrHostAddressConstKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceOrHostAddressConstKHR* toCount,
- size_t* count);
+void count_VkDeviceOrHostAddressConstKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceOrHostAddressConstKHR* toCount,
+ size_t* count);
void count_VkAccelerationStructureGeometryMotionTrianglesDataNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryMotionTrianglesDataNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureGeometryMotionTrianglesDataNV* toCount, size_t* count);
-void count_VkAccelerationStructureMotionInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureMotionInfoNV* toCount,
- size_t* count);
+void count_VkAccelerationStructureMotionInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureMotionInfoNV* toCount,
+ size_t* count);
void count_VkAccelerationStructureMatrixMotionInstanceNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureMatrixMotionInstanceNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureMatrixMotionInstanceNV* toCount, size_t* count);
-void count_VkSRTDataNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSRTDataNV* toCount,
- size_t* count);
+void count_VkSRTDataNV(uint32_t featureBits, VkStructureType rootType, const VkSRTDataNV* toCount,
+ size_t* count);
void count_VkAccelerationStructureSRTMotionInstanceNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureSRTMotionInstanceNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureSRTMotionInstanceNV* toCount, size_t* count);
void count_VkAccelerationStructureMotionInstanceDataNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureMotionInstanceDataNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureMotionInstanceDataNV* toCount, size_t* count);
void count_VkAccelerationStructureMotionInstanceNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureMotionInstanceNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureMotionInstanceNV* toCount, size_t* count);
void count_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* toCount, size_t* count);
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
void count_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_fragment_density_map2
void count_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* toCount, size_t* count);
void count_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* toCount, size_t* count);
#endif
#ifdef VK_QCOM_rotated_copy_commands
-void count_VkCopyCommandTransformInfoQCOM(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCopyCommandTransformInfoQCOM* toCount,
- size_t* count);
+void count_VkCopyCommandTransformInfoQCOM(uint32_t featureBits, VkStructureType rootType,
+ const VkCopyCommandTransformInfoQCOM* toCount,
+ size_t* count);
#endif
#ifdef VK_EXT_image_robustness
void count_VkPhysicalDeviceImageRobustnessFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceImageRobustnessFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceImageRobustnessFeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_4444_formats
void count_VkPhysicalDevice4444FormatsFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevice4444FormatsFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevice4444FormatsFeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_rgba10x6_formats
void count_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_NV_acquire_winrt_display
#endif
#ifdef VK_EXT_directfb_surface
-void count_VkDirectFBSurfaceCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDirectFBSurfaceCreateInfoEXT* toCount,
- size_t* count);
+void count_VkDirectFBSurfaceCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkDirectFBSurfaceCreateInfoEXT* toCount,
+ size_t* count);
#endif
#ifdef VK_VALVE_mutable_descriptor_type
void count_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* toCount, size_t* count);
-void count_VkMutableDescriptorTypeListVALVE(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMutableDescriptorTypeListVALVE* toCount,
- size_t* count);
+void count_VkMutableDescriptorTypeListVALVE(uint32_t featureBits, VkStructureType rootType,
+ const VkMutableDescriptorTypeListVALVE* toCount,
+ size_t* count);
void count_VkMutableDescriptorTypeCreateInfoVALVE(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMutableDescriptorTypeCreateInfoVALVE* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkMutableDescriptorTypeCreateInfoVALVE* toCount, size_t* count);
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
void count_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* toCount, size_t* count);
-void count_VkVertexInputBindingDescription2EXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVertexInputBindingDescription2EXT* toCount,
- size_t* count);
+void count_VkVertexInputBindingDescription2EXT(uint32_t featureBits, VkStructureType rootType,
+ const VkVertexInputBindingDescription2EXT* toCount,
+ size_t* count);
void count_VkVertexInputAttributeDescription2EXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkVertexInputAttributeDescription2EXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkVertexInputAttributeDescription2EXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_physical_device_drm
-void count_VkPhysicalDeviceDrmPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceDrmPropertiesEXT* toCount,
- size_t* count);
+void count_VkPhysicalDeviceDrmPropertiesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceDrmPropertiesEXT* toCount,
+ size_t* count);
#endif
#ifdef VK_EXT_primitive_topology_list_restart
void count_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_FUCHSIA_external_memory
void count_VkImportMemoryZirconHandleInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportMemoryZirconHandleInfoFUCHSIA* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkImportMemoryZirconHandleInfoFUCHSIA* toCount, size_t* count);
void count_VkMemoryZirconHandlePropertiesFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryZirconHandlePropertiesFUCHSIA* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryZirconHandlePropertiesFUCHSIA* toCount, size_t* count);
-void count_VkMemoryGetZirconHandleInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryGetZirconHandleInfoFUCHSIA* toCount,
- size_t* count);
+void count_VkMemoryGetZirconHandleInfoFUCHSIA(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* toCount,
+ size_t* count);
#endif
#ifdef VK_FUCHSIA_external_semaphore
void count_VkImportSemaphoreZirconHandleInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportSemaphoreZirconHandleInfoFUCHSIA* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* toCount, size_t* count);
void count_VkSemaphoreGetZirconHandleInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSemaphoreGetZirconHandleInfoFUCHSIA* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA* toCount, size_t* count);
#endif
#ifdef VK_FUCHSIA_buffer_collection
-void count_VkBufferCollectionCreateInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferCollectionCreateInfoFUCHSIA* toCount,
- size_t* count);
+void count_VkBufferCollectionCreateInfoFUCHSIA(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferCollectionCreateInfoFUCHSIA* toCount,
+ size_t* count);
void count_VkImportMemoryBufferCollectionFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportMemoryBufferCollectionFUCHSIA* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkImportMemoryBufferCollectionFUCHSIA* toCount, size_t* count);
void count_VkBufferCollectionImageCreateInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferCollectionImageCreateInfoFUCHSIA* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkBufferCollectionImageCreateInfoFUCHSIA* toCount, size_t* count);
void count_VkBufferCollectionConstraintsInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferCollectionConstraintsInfoFUCHSIA* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkBufferCollectionConstraintsInfoFUCHSIA* toCount, size_t* count);
-void count_VkBufferConstraintsInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferConstraintsInfoFUCHSIA* toCount,
- size_t* count);
+void count_VkBufferConstraintsInfoFUCHSIA(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferConstraintsInfoFUCHSIA* toCount,
+ size_t* count);
void count_VkBufferCollectionBufferCreateInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferCollectionBufferCreateInfoFUCHSIA* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkBufferCollectionBufferCreateInfoFUCHSIA* toCount, size_t* count);
-void count_VkSysmemColorSpaceFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSysmemColorSpaceFUCHSIA* toCount,
- size_t* count);
+void count_VkSysmemColorSpaceFUCHSIA(uint32_t featureBits, VkStructureType rootType,
+ const VkSysmemColorSpaceFUCHSIA* toCount, size_t* count);
-void count_VkBufferCollectionPropertiesFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkBufferCollectionPropertiesFUCHSIA* toCount,
- size_t* count);
+void count_VkBufferCollectionPropertiesFUCHSIA(uint32_t featureBits, VkStructureType rootType,
+ const VkBufferCollectionPropertiesFUCHSIA* toCount,
+ size_t* count);
-void count_VkImageFormatConstraintsInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageFormatConstraintsInfoFUCHSIA* toCount,
- size_t* count);
+void count_VkImageFormatConstraintsInfoFUCHSIA(uint32_t featureBits, VkStructureType rootType,
+ const VkImageFormatConstraintsInfoFUCHSIA* toCount,
+ size_t* count);
-void count_VkImageConstraintsInfoFUCHSIA(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImageConstraintsInfoFUCHSIA* toCount,
- size_t* count);
+void count_VkImageConstraintsInfoFUCHSIA(uint32_t featureBits, VkStructureType rootType,
+ const VkImageConstraintsInfoFUCHSIA* toCount,
+ size_t* count);
#endif
#ifdef VK_HUAWEI_subpass_shading
void count_VkSubpassShadingPipelineCreateInfoHUAWEI(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSubpassShadingPipelineCreateInfoHUAWEI* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkSubpassShadingPipelineCreateInfoHUAWEI* toCount, size_t* count);
void count_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* toCount, size_t* count);
void count_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* toCount, size_t* count);
#endif
#ifdef VK_HUAWEI_invocation_mask
void count_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* toCount, size_t* count);
#endif
#ifdef VK_NV_external_memory_rdma
-void count_VkMemoryGetRemoteAddressInfoNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMemoryGetRemoteAddressInfoNV* toCount,
- size_t* count);
+void count_VkMemoryGetRemoteAddressInfoNV(uint32_t featureBits, VkStructureType rootType,
+ const VkMemoryGetRemoteAddressInfoNV* toCount,
+ size_t* count);
void count_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* toCount, size_t* count);
#endif
#ifdef VK_EXT_extended_dynamic_state2
void count_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_QNX_screen_surface
-void count_VkScreenSurfaceCreateInfoQNX(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkScreenSurfaceCreateInfoQNX* toCount,
- size_t* count);
+void count_VkScreenSurfaceCreateInfoQNX(uint32_t featureBits, VkStructureType rootType,
+ const VkScreenSurfaceCreateInfoQNX* toCount, size_t* count);
#endif
#ifdef VK_EXT_color_write_enable
void count_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceColorWriteEnableFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceColorWriteEnableFeaturesEXT* toCount, size_t* count);
-void count_VkPipelineColorWriteCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPipelineColorWriteCreateInfoEXT* toCount,
- size_t* count);
+void count_VkPipelineColorWriteCreateInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkPipelineColorWriteCreateInfoEXT* toCount,
+ size_t* count);
#endif
#ifdef VK_GOOGLE_gfxstream
-void count_VkImportColorBufferGOOGLE(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportColorBufferGOOGLE* toCount,
- size_t* count);
+void count_VkImportColorBufferGOOGLE(uint32_t featureBits, VkStructureType rootType,
+ const VkImportColorBufferGOOGLE* toCount, size_t* count);
-void count_VkImportBufferGOOGLE(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportBufferGOOGLE* toCount,
- size_t* count);
+void count_VkImportBufferGOOGLE(uint32_t featureBits, VkStructureType rootType,
+ const VkImportBufferGOOGLE* toCount, size_t* count);
-void count_VkImportPhysicalAddressGOOGLE(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkImportPhysicalAddressGOOGLE* toCount,
- size_t* count);
+void count_VkImportPhysicalAddressGOOGLE(uint32_t featureBits, VkStructureType rootType,
+ const VkImportPhysicalAddressGOOGLE* toCount,
+ size_t* count);
#endif
#ifdef VK_EXT_global_priority_query
void count_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toCount, size_t* count);
void count_VkQueueFamilyGlobalPriorityPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkQueueFamilyGlobalPriorityPropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkQueueFamilyGlobalPriorityPropertiesEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_multi_draw
-void count_VkPhysicalDeviceMultiDrawFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiDrawFeaturesEXT* toCount,
- size_t* count);
+void count_VkPhysicalDeviceMultiDrawFeaturesEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMultiDrawFeaturesEXT* toCount,
+ size_t* count);
void count_VkPhysicalDeviceMultiDrawPropertiesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiDrawPropertiesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceMultiDrawPropertiesEXT* toCount, size_t* count);
-void count_VkMultiDrawInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMultiDrawInfoEXT* toCount,
- size_t* count);
+void count_VkMultiDrawInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkMultiDrawInfoEXT* toCount, size_t* count);
-void count_VkMultiDrawIndexedInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkMultiDrawIndexedInfoEXT* toCount,
- size_t* count);
+void count_VkMultiDrawIndexedInfoEXT(uint32_t featureBits, VkStructureType rootType,
+ const VkMultiDrawIndexedInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_load_store_op_none
#endif
#ifdef VK_EXT_border_color_swizzle
void count_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* toCount, size_t* count);
void count_VkSamplerBorderColorComponentMappingCreateInfoEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkSamplerBorderColorComponentMappingCreateInfoEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkSamplerBorderColorComponentMappingCreateInfoEXT* toCount, size_t* count);
#endif
#ifdef VK_EXT_pageable_device_local_memory
void count_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* toCount, size_t* count);
#endif
#ifdef VK_KHR_acceleration_structure
-void count_VkDeviceOrHostAddressKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkDeviceOrHostAddressKHR* toCount,
- size_t* count);
+void count_VkDeviceOrHostAddressKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkDeviceOrHostAddressKHR* toCount, size_t* count);
void count_VkAccelerationStructureBuildRangeInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureBuildRangeInfoKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureBuildRangeInfoKHR* toCount, size_t* count);
void count_VkAccelerationStructureGeometryTrianglesDataKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryTrianglesDataKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureGeometryTrianglesDataKHR* toCount, size_t* count);
void count_VkAccelerationStructureGeometryAabbsDataKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryAabbsDataKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureGeometryAabbsDataKHR* toCount, size_t* count);
void count_VkAccelerationStructureGeometryInstancesDataKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryInstancesDataKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureGeometryInstancesDataKHR* toCount, size_t* count);
void count_VkAccelerationStructureGeometryDataKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryDataKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureGeometryDataKHR* toCount, size_t* count);
-void count_VkAccelerationStructureGeometryKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryKHR* toCount,
- size_t* count);
+void count_VkAccelerationStructureGeometryKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureGeometryKHR* toCount,
+ size_t* count);
void count_VkAccelerationStructureBuildGeometryInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureBuildGeometryInfoKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureBuildGeometryInfoKHR* toCount, size_t* count);
-void count_VkAccelerationStructureCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureCreateInfoKHR* toCount,
- size_t* count);
+void count_VkAccelerationStructureCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureCreateInfoKHR* toCount,
+ size_t* count);
void count_VkWriteDescriptorSetAccelerationStructureKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkWriteDescriptorSetAccelerationStructureKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkWriteDescriptorSetAccelerationStructureKHR* toCount, size_t* count);
void count_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceAccelerationStructureFeaturesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceAccelerationStructureFeaturesKHR* toCount, size_t* count);
void count_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceAccelerationStructurePropertiesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceAccelerationStructurePropertiesKHR* toCount, size_t* count);
void count_VkAccelerationStructureDeviceAddressInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureDeviceAddressInfoKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureDeviceAddressInfoKHR* toCount, size_t* count);
void count_VkAccelerationStructureVersionInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureVersionInfoKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureVersionInfoKHR* toCount, size_t* count);
void count_VkCopyAccelerationStructureToMemoryInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCopyAccelerationStructureToMemoryInfoKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkCopyAccelerationStructureToMemoryInfoKHR* toCount, size_t* count);
void count_VkCopyMemoryToAccelerationStructureInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCopyMemoryToAccelerationStructureInfoKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkCopyMemoryToAccelerationStructureInfoKHR* toCount, size_t* count);
-void count_VkCopyAccelerationStructureInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkCopyAccelerationStructureInfoKHR* toCount,
- size_t* count);
+void count_VkCopyAccelerationStructureInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkCopyAccelerationStructureInfoKHR* toCount,
+ size_t* count);
void count_VkAccelerationStructureBuildSizesInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkAccelerationStructureBuildSizesInfoKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkAccelerationStructureBuildSizesInfoKHR* toCount, size_t* count);
#endif
#ifdef VK_KHR_ray_tracing_pipeline
-void count_VkRayTracingShaderGroupCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRayTracingShaderGroupCreateInfoKHR* toCount,
- size_t* count);
+void count_VkRayTracingShaderGroupCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkRayTracingShaderGroupCreateInfoKHR* toCount,
+ size_t* count);
void count_VkRayTracingPipelineInterfaceCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRayTracingPipelineInterfaceCreateInfoKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkRayTracingPipelineInterfaceCreateInfoKHR* toCount, size_t* count);
-void count_VkRayTracingPipelineCreateInfoKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkRayTracingPipelineCreateInfoKHR* toCount,
- size_t* count);
+void count_VkRayTracingPipelineCreateInfoKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkRayTracingPipelineCreateInfoKHR* toCount,
+ size_t* count);
void count_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toCount, size_t* count);
void count_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toCount,
- size_t* count);
+ uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toCount, size_t* count);
-void count_VkStridedDeviceAddressRegionKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkStridedDeviceAddressRegionKHR* toCount,
- size_t* count);
+void count_VkStridedDeviceAddressRegionKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkStridedDeviceAddressRegionKHR* toCount,
+ size_t* count);
-void count_VkTraceRaysIndirectCommandKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkTraceRaysIndirectCommandKHR* toCount,
- size_t* count);
+void count_VkTraceRaysIndirectCommandKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkTraceRaysIndirectCommandKHR* toCount,
+ size_t* count);
#endif
#ifdef VK_KHR_ray_query
-void count_VkPhysicalDeviceRayQueryFeaturesKHR(
- uint32_t featureBits,
- VkStructureType rootType,
- const VkPhysicalDeviceRayQueryFeaturesKHR* toCount,
- size_t* count);
+void count_VkPhysicalDeviceRayQueryFeaturesKHR(uint32_t featureBits, VkStructureType rootType,
+ const VkPhysicalDeviceRayQueryFeaturesKHR* toCount,
+ size_t* count);
#endif
-} // namespace goldfish_vk
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp b/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
index adc2318..c88a3cf 100644
--- a/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
@@ -14,85 +14,65 @@
// limitations under the License.
// Autogenerated module goldfish_vk_deepcopy_guest
-// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal -o ../qemu/android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+//
+// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
+// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
-// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+//
+// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
+// $CEREAL_OUTPUT_DIR
+//
#include "goldfish_vk_deepcopy_guest.h"
+#include <cstring>
#include "goldfish_vk_extension_structs_guest.h"
#include "goldfish_vk_private_defs.h"
-
-#include <cstring>
-
#include "vk_util.h"
-
namespace goldfish_vk {
-void deepcopy_extension_struct(
- Allocator* alloc,
- VkStructureType rootType,
- const void* structExtension,
- void* structExtension_out);
+void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
+ const void* structExtension, void* structExtension_out);
#ifdef VK_VERSION_1_0
-void deepcopy_VkExtent2D(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExtent2D* from,
- VkExtent2D* to)
-{
+void deepcopy_VkExtent2D(Allocator* alloc, VkStructureType rootType, const VkExtent2D* from,
+ VkExtent2D* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkExtent3D(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExtent3D* from,
- VkExtent3D* to)
-{
+void deepcopy_VkExtent3D(Allocator* alloc, VkStructureType rootType, const VkExtent3D* from,
+ VkExtent3D* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkOffset2D(
- Allocator* alloc,
- VkStructureType rootType,
- const VkOffset2D* from,
- VkOffset2D* to)
-{
+void deepcopy_VkOffset2D(Allocator* alloc, VkStructureType rootType, const VkOffset2D* from,
+ VkOffset2D* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkOffset3D(
- Allocator* alloc,
- VkStructureType rootType,
- const VkOffset3D* from,
- VkOffset3D* to)
-{
+void deepcopy_VkOffset3D(Allocator* alloc, VkStructureType rootType, const VkOffset3D* from,
+ VkOffset3D* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkRect2D(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRect2D* from,
- VkRect2D* to)
-{
+void deepcopy_VkRect2D(Allocator* alloc, VkStructureType rootType, const VkRect2D* from,
+ VkRect2D* to) {
(void)alloc;
(void)rootType;
*to = *from;
@@ -100,363 +80,271 @@
deepcopy_VkExtent2D(alloc, rootType, &from->extent, (VkExtent2D*)(&to->extent));
}
-void deepcopy_VkBaseInStructure(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBaseInStructure* from,
- VkBaseInStructure* to)
-{
+void deepcopy_VkBaseInStructure(Allocator* alloc, VkStructureType rootType,
+ const VkBaseInStructure* from, VkBaseInStructure* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (VkBaseInStructure*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkBaseOutStructure(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBaseOutStructure* from,
- VkBaseOutStructure* to)
-{
+void deepcopy_VkBaseOutStructure(Allocator* alloc, VkStructureType rootType,
+ const VkBaseOutStructure* from, VkBaseOutStructure* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (VkBaseOutStructure*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkBufferMemoryBarrier(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferMemoryBarrier* from,
- VkBufferMemoryBarrier* to)
-{
+void deepcopy_VkBufferMemoryBarrier(Allocator* alloc, VkStructureType rootType,
+ const VkBufferMemoryBarrier* from, VkBufferMemoryBarrier* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkDispatchIndirectCommand(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDispatchIndirectCommand* from,
- VkDispatchIndirectCommand* to)
-{
+void deepcopy_VkDispatchIndirectCommand(Allocator* alloc, VkStructureType rootType,
+ const VkDispatchIndirectCommand* from,
+ VkDispatchIndirectCommand* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkDrawIndexedIndirectCommand(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDrawIndexedIndirectCommand* from,
- VkDrawIndexedIndirectCommand* to)
-{
+void deepcopy_VkDrawIndexedIndirectCommand(Allocator* alloc, VkStructureType rootType,
+ const VkDrawIndexedIndirectCommand* from,
+ VkDrawIndexedIndirectCommand* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkDrawIndirectCommand(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDrawIndirectCommand* from,
- VkDrawIndirectCommand* to)
-{
+void deepcopy_VkDrawIndirectCommand(Allocator* alloc, VkStructureType rootType,
+ const VkDrawIndirectCommand* from, VkDrawIndirectCommand* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkImageSubresourceRange(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageSubresourceRange* from,
- VkImageSubresourceRange* to)
-{
+void deepcopy_VkImageSubresourceRange(Allocator* alloc, VkStructureType rootType,
+ const VkImageSubresourceRange* from,
+ VkImageSubresourceRange* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkImageMemoryBarrier(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageMemoryBarrier* from,
- VkImageMemoryBarrier* to)
-{
+void deepcopy_VkImageMemoryBarrier(Allocator* alloc, VkStructureType rootType,
+ const VkImageMemoryBarrier* from, VkImageMemoryBarrier* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkImageSubresourceRange(alloc, rootType, &from->subresourceRange, (VkImageSubresourceRange*)(&to->subresourceRange));
+ deepcopy_VkImageSubresourceRange(alloc, rootType, &from->subresourceRange,
+ (VkImageSubresourceRange*)(&to->subresourceRange));
}
-void deepcopy_VkMemoryBarrier(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryBarrier* from,
- VkMemoryBarrier* to)
-{
+void deepcopy_VkMemoryBarrier(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryBarrier* from, VkMemoryBarrier* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkPipelineCacheHeaderVersionOne(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineCacheHeaderVersionOne* from,
- VkPipelineCacheHeaderVersionOne* to)
-{
+void deepcopy_VkPipelineCacheHeaderVersionOne(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineCacheHeaderVersionOne* from,
+ VkPipelineCacheHeaderVersionOne* to) {
(void)alloc;
(void)rootType;
*to = *from;
memcpy(to->pipelineCacheUUID, from->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
}
-void deepcopy_VkAllocationCallbacks(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAllocationCallbacks* from,
- VkAllocationCallbacks* to)
-{
+void deepcopy_VkAllocationCallbacks(Allocator* alloc, VkStructureType rootType,
+ const VkAllocationCallbacks* from, VkAllocationCallbacks* to) {
(void)alloc;
(void)rootType;
*to = *from;
to->pUserData = nullptr;
- if (from->pUserData)
- {
+ if (from->pUserData) {
to->pUserData = (void*)alloc->dupArray(from->pUserData, sizeof(uint8_t));
}
}
-void deepcopy_VkApplicationInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkApplicationInfo* from,
- VkApplicationInfo* to)
-{
+void deepcopy_VkApplicationInfo(Allocator* alloc, VkStructureType rootType,
+ const VkApplicationInfo* from, VkApplicationInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pApplicationName = nullptr;
- if (from->pApplicationName)
- {
+ if (from->pApplicationName) {
to->pApplicationName = alloc->strDup(from->pApplicationName);
}
to->pEngineName = nullptr;
- if (from->pEngineName)
- {
+ if (from->pEngineName) {
to->pEngineName = alloc->strDup(from->pEngineName);
}
}
-void deepcopy_VkFormatProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFormatProperties* from,
- VkFormatProperties* to)
-{
+void deepcopy_VkFormatProperties(Allocator* alloc, VkStructureType rootType,
+ const VkFormatProperties* from, VkFormatProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkImageFormatProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageFormatProperties* from,
- VkImageFormatProperties* to)
-{
+void deepcopy_VkImageFormatProperties(Allocator* alloc, VkStructureType rootType,
+ const VkImageFormatProperties* from,
+ VkImageFormatProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
deepcopy_VkExtent3D(alloc, rootType, &from->maxExtent, (VkExtent3D*)(&to->maxExtent));
}
-void deepcopy_VkInstanceCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkInstanceCreateInfo* from,
- VkInstanceCreateInfo* to)
-{
+void deepcopy_VkInstanceCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkInstanceCreateInfo* from, VkInstanceCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pApplicationInfo = nullptr;
- if (from->pApplicationInfo)
- {
+ if (from->pApplicationInfo) {
to->pApplicationInfo = (VkApplicationInfo*)alloc->alloc(sizeof(const VkApplicationInfo));
- deepcopy_VkApplicationInfo(alloc, rootType, from->pApplicationInfo, (VkApplicationInfo*)(to->pApplicationInfo));
+ deepcopy_VkApplicationInfo(alloc, rootType, from->pApplicationInfo,
+ (VkApplicationInfo*)(to->pApplicationInfo));
}
to->ppEnabledLayerNames = nullptr;
- if (from->ppEnabledLayerNames && from->enabledLayerCount)
- {
- to->ppEnabledLayerNames = alloc->strDupArray(from->ppEnabledLayerNames, from->enabledLayerCount);
+ if (from->ppEnabledLayerNames && from->enabledLayerCount) {
+ to->ppEnabledLayerNames =
+ alloc->strDupArray(from->ppEnabledLayerNames, from->enabledLayerCount);
}
to->ppEnabledExtensionNames = nullptr;
- if (from->ppEnabledExtensionNames && from->enabledExtensionCount)
- {
- to->ppEnabledExtensionNames = alloc->strDupArray(from->ppEnabledExtensionNames, from->enabledExtensionCount);
+ if (from->ppEnabledExtensionNames && from->enabledExtensionCount) {
+ to->ppEnabledExtensionNames =
+ alloc->strDupArray(from->ppEnabledExtensionNames, from->enabledExtensionCount);
}
}
-void deepcopy_VkMemoryHeap(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryHeap* from,
- VkMemoryHeap* to)
-{
+void deepcopy_VkMemoryHeap(Allocator* alloc, VkStructureType rootType, const VkMemoryHeap* from,
+ VkMemoryHeap* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkMemoryType(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryType* from,
- VkMemoryType* to)
-{
+void deepcopy_VkMemoryType(Allocator* alloc, VkStructureType rootType, const VkMemoryType* from,
+ VkMemoryType* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkPhysicalDeviceFeatures(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceFeatures* from,
- VkPhysicalDeviceFeatures* to)
-{
+void deepcopy_VkPhysicalDeviceFeatures(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceFeatures* from,
+ VkPhysicalDeviceFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkPhysicalDeviceLimits(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceLimits* from,
- VkPhysicalDeviceLimits* to)
-{
+void deepcopy_VkPhysicalDeviceLimits(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceLimits* from,
+ VkPhysicalDeviceLimits* to) {
(void)alloc;
(void)rootType;
*to = *from;
@@ -468,171 +356,143 @@
memcpy(to->lineWidthRange, from->lineWidthRange, 2 * sizeof(float));
}
-void deepcopy_VkPhysicalDeviceMemoryProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryProperties* from,
- VkPhysicalDeviceMemoryProperties* to)
-{
+void deepcopy_VkPhysicalDeviceMemoryProperties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryProperties* from,
+ VkPhysicalDeviceMemoryProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i)
- {
- deepcopy_VkMemoryType(alloc, rootType, from->memoryTypes + i, (VkMemoryType*)(to->memoryTypes + i));
+ for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i) {
+ deepcopy_VkMemoryType(alloc, rootType, from->memoryTypes + i,
+ (VkMemoryType*)(to->memoryTypes + i));
}
- for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i)
- {
- deepcopy_VkMemoryHeap(alloc, rootType, from->memoryHeaps + i, (VkMemoryHeap*)(to->memoryHeaps + i));
+ for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i) {
+ deepcopy_VkMemoryHeap(alloc, rootType, from->memoryHeaps + i,
+ (VkMemoryHeap*)(to->memoryHeaps + i));
}
}
-void deepcopy_VkPhysicalDeviceSparseProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceSparseProperties* from,
- VkPhysicalDeviceSparseProperties* to)
-{
+void deepcopy_VkPhysicalDeviceSparseProperties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceSparseProperties* from,
+ VkPhysicalDeviceSparseProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkPhysicalDeviceProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceProperties* from,
- VkPhysicalDeviceProperties* to)
-{
+void deepcopy_VkPhysicalDeviceProperties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceProperties* from,
+ VkPhysicalDeviceProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
memcpy(to->deviceName, from->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
memcpy(to->pipelineCacheUUID, from->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
- deepcopy_VkPhysicalDeviceLimits(alloc, rootType, &from->limits, (VkPhysicalDeviceLimits*)(&to->limits));
- deepcopy_VkPhysicalDeviceSparseProperties(alloc, rootType, &from->sparseProperties, (VkPhysicalDeviceSparseProperties*)(&to->sparseProperties));
+ deepcopy_VkPhysicalDeviceLimits(alloc, rootType, &from->limits,
+ (VkPhysicalDeviceLimits*)(&to->limits));
+ deepcopy_VkPhysicalDeviceSparseProperties(
+ alloc, rootType, &from->sparseProperties,
+ (VkPhysicalDeviceSparseProperties*)(&to->sparseProperties));
}
-void deepcopy_VkQueueFamilyProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkQueueFamilyProperties* from,
- VkQueueFamilyProperties* to)
-{
+void deepcopy_VkQueueFamilyProperties(Allocator* alloc, VkStructureType rootType,
+ const VkQueueFamilyProperties* from,
+ VkQueueFamilyProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- deepcopy_VkExtent3D(alloc, rootType, &from->minImageTransferGranularity, (VkExtent3D*)(&to->minImageTransferGranularity));
+ deepcopy_VkExtent3D(alloc, rootType, &from->minImageTransferGranularity,
+ (VkExtent3D*)(&to->minImageTransferGranularity));
}
-void deepcopy_VkDeviceQueueCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceQueueCreateInfo* from,
- VkDeviceQueueCreateInfo* to)
-{
+void deepcopy_VkDeviceQueueCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceQueueCreateInfo* from,
+ VkDeviceQueueCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pQueuePriorities = nullptr;
- if (from->pQueuePriorities)
- {
- to->pQueuePriorities = (float*)alloc->dupArray(from->pQueuePriorities, from->queueCount * sizeof(const float));
+ if (from->pQueuePriorities) {
+ to->pQueuePriorities =
+ (float*)alloc->dupArray(from->pQueuePriorities, from->queueCount * sizeof(const float));
}
}
-void deepcopy_VkDeviceCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceCreateInfo* from,
- VkDeviceCreateInfo* to)
-{
+void deepcopy_VkDeviceCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceCreateInfo* from, VkDeviceCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pQueueCreateInfos = nullptr;
- if (from->pQueueCreateInfos)
- {
- to->pQueueCreateInfos = (VkDeviceQueueCreateInfo*)alloc->alloc(from->queueCreateInfoCount * sizeof(const VkDeviceQueueCreateInfo));
+ if (from->pQueueCreateInfos) {
+ to->pQueueCreateInfos = (VkDeviceQueueCreateInfo*)alloc->alloc(
+ from->queueCreateInfoCount * sizeof(const VkDeviceQueueCreateInfo));
to->queueCreateInfoCount = from->queueCreateInfoCount;
- for (uint32_t i = 0; i < (uint32_t)from->queueCreateInfoCount; ++i)
- {
- deepcopy_VkDeviceQueueCreateInfo(alloc, rootType, from->pQueueCreateInfos + i, (VkDeviceQueueCreateInfo*)(to->pQueueCreateInfos + i));
+ for (uint32_t i = 0; i < (uint32_t)from->queueCreateInfoCount; ++i) {
+ deepcopy_VkDeviceQueueCreateInfo(
+ alloc, rootType, from->pQueueCreateInfos + i,
+ (VkDeviceQueueCreateInfo*)(to->pQueueCreateInfos + i));
}
}
}
to->ppEnabledLayerNames = nullptr;
- if (from->ppEnabledLayerNames && from->enabledLayerCount)
- {
- to->ppEnabledLayerNames = alloc->strDupArray(from->ppEnabledLayerNames, from->enabledLayerCount);
+ if (from->ppEnabledLayerNames && from->enabledLayerCount) {
+ to->ppEnabledLayerNames =
+ alloc->strDupArray(from->ppEnabledLayerNames, from->enabledLayerCount);
}
to->ppEnabledExtensionNames = nullptr;
- if (from->ppEnabledExtensionNames && from->enabledExtensionCount)
- {
- to->ppEnabledExtensionNames = alloc->strDupArray(from->ppEnabledExtensionNames, from->enabledExtensionCount);
+ if (from->ppEnabledExtensionNames && from->enabledExtensionCount) {
+ to->ppEnabledExtensionNames =
+ alloc->strDupArray(from->ppEnabledExtensionNames, from->enabledExtensionCount);
}
to->pEnabledFeatures = nullptr;
- if (from->pEnabledFeatures)
- {
- to->pEnabledFeatures = (VkPhysicalDeviceFeatures*)alloc->alloc(sizeof(const VkPhysicalDeviceFeatures));
- deepcopy_VkPhysicalDeviceFeatures(alloc, rootType, from->pEnabledFeatures, (VkPhysicalDeviceFeatures*)(to->pEnabledFeatures));
+ if (from->pEnabledFeatures) {
+ to->pEnabledFeatures =
+ (VkPhysicalDeviceFeatures*)alloc->alloc(sizeof(const VkPhysicalDeviceFeatures));
+ deepcopy_VkPhysicalDeviceFeatures(alloc, rootType, from->pEnabledFeatures,
+ (VkPhysicalDeviceFeatures*)(to->pEnabledFeatures));
}
}
-void deepcopy_VkExtensionProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExtensionProperties* from,
- VkExtensionProperties* to)
-{
+void deepcopy_VkExtensionProperties(Allocator* alloc, VkStructureType rootType,
+ const VkExtensionProperties* from, VkExtensionProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
memcpy(to->extensionName, from->extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
}
-void deepcopy_VkLayerProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkLayerProperties* from,
- VkLayerProperties* to)
-{
+void deepcopy_VkLayerProperties(Allocator* alloc, VkStructureType rootType,
+ const VkLayerProperties* from, VkLayerProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
@@ -640,1055 +500,848 @@
memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
}
-void deepcopy_VkSubmitInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubmitInfo* from,
- VkSubmitInfo* to)
-{
+void deepcopy_VkSubmitInfo(Allocator* alloc, VkStructureType rootType, const VkSubmitInfo* from,
+ VkSubmitInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pWaitSemaphores = nullptr;
- if (from->pWaitSemaphores)
- {
- to->pWaitSemaphores = (VkSemaphore*)alloc->dupArray(from->pWaitSemaphores, from->waitSemaphoreCount * sizeof(const VkSemaphore));
+ if (from->pWaitSemaphores) {
+ to->pWaitSemaphores = (VkSemaphore*)alloc->dupArray(
+ from->pWaitSemaphores, from->waitSemaphoreCount * sizeof(const VkSemaphore));
}
to->pWaitDstStageMask = nullptr;
- if (from->pWaitDstStageMask)
- {
- to->pWaitDstStageMask = (VkPipelineStageFlags*)alloc->dupArray(from->pWaitDstStageMask, from->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
+ if (from->pWaitDstStageMask) {
+ to->pWaitDstStageMask = (VkPipelineStageFlags*)alloc->dupArray(
+ from->pWaitDstStageMask, from->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
}
to->pCommandBuffers = nullptr;
- if (from->pCommandBuffers)
- {
- to->pCommandBuffers = (VkCommandBuffer*)alloc->dupArray(from->pCommandBuffers, from->commandBufferCount * sizeof(const VkCommandBuffer));
+ if (from->pCommandBuffers) {
+ to->pCommandBuffers = (VkCommandBuffer*)alloc->dupArray(
+ from->pCommandBuffers, from->commandBufferCount * sizeof(const VkCommandBuffer));
}
to->pSignalSemaphores = nullptr;
- if (from->pSignalSemaphores)
- {
- to->pSignalSemaphores = (VkSemaphore*)alloc->dupArray(from->pSignalSemaphores, from->signalSemaphoreCount * sizeof(const VkSemaphore));
+ if (from->pSignalSemaphores) {
+ to->pSignalSemaphores = (VkSemaphore*)alloc->dupArray(
+ from->pSignalSemaphores, from->signalSemaphoreCount * sizeof(const VkSemaphore));
}
}
-void deepcopy_VkMappedMemoryRange(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMappedMemoryRange* from,
- VkMappedMemoryRange* to)
-{
+void deepcopy_VkMappedMemoryRange(Allocator* alloc, VkStructureType rootType,
+ const VkMappedMemoryRange* from, VkMappedMemoryRange* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkMemoryAllocateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryAllocateInfo* from,
- VkMemoryAllocateInfo* to)
-{
+void deepcopy_VkMemoryAllocateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryAllocateInfo* from, VkMemoryAllocateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkMemoryRequirements(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryRequirements* from,
- VkMemoryRequirements* to)
-{
+void deepcopy_VkMemoryRequirements(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryRequirements* from, VkMemoryRequirements* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkSparseMemoryBind(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSparseMemoryBind* from,
- VkSparseMemoryBind* to)
-{
+void deepcopy_VkSparseMemoryBind(Allocator* alloc, VkStructureType rootType,
+ const VkSparseMemoryBind* from, VkSparseMemoryBind* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkSparseBufferMemoryBindInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSparseBufferMemoryBindInfo* from,
- VkSparseBufferMemoryBindInfo* to)
-{
+void deepcopy_VkSparseBufferMemoryBindInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSparseBufferMemoryBindInfo* from,
+ VkSparseBufferMemoryBindInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (from)
- {
+ if (from) {
to->pBinds = nullptr;
- if (from->pBinds)
- {
- to->pBinds = (VkSparseMemoryBind*)alloc->alloc(from->bindCount * sizeof(const VkSparseMemoryBind));
+ if (from->pBinds) {
+ to->pBinds = (VkSparseMemoryBind*)alloc->alloc(from->bindCount *
+ sizeof(const VkSparseMemoryBind));
to->bindCount = from->bindCount;
- for (uint32_t i = 0; i < (uint32_t)from->bindCount; ++i)
- {
- deepcopy_VkSparseMemoryBind(alloc, rootType, from->pBinds + i, (VkSparseMemoryBind*)(to->pBinds + i));
+ for (uint32_t i = 0; i < (uint32_t)from->bindCount; ++i) {
+ deepcopy_VkSparseMemoryBind(alloc, rootType, from->pBinds + i,
+ (VkSparseMemoryBind*)(to->pBinds + i));
}
}
}
}
-void deepcopy_VkSparseImageOpaqueMemoryBindInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSparseImageOpaqueMemoryBindInfo* from,
- VkSparseImageOpaqueMemoryBindInfo* to)
-{
+void deepcopy_VkSparseImageOpaqueMemoryBindInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSparseImageOpaqueMemoryBindInfo* from,
+ VkSparseImageOpaqueMemoryBindInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (from)
- {
+ if (from) {
to->pBinds = nullptr;
- if (from->pBinds)
- {
- to->pBinds = (VkSparseMemoryBind*)alloc->alloc(from->bindCount * sizeof(const VkSparseMemoryBind));
+ if (from->pBinds) {
+ to->pBinds = (VkSparseMemoryBind*)alloc->alloc(from->bindCount *
+ sizeof(const VkSparseMemoryBind));
to->bindCount = from->bindCount;
- for (uint32_t i = 0; i < (uint32_t)from->bindCount; ++i)
- {
- deepcopy_VkSparseMemoryBind(alloc, rootType, from->pBinds + i, (VkSparseMemoryBind*)(to->pBinds + i));
+ for (uint32_t i = 0; i < (uint32_t)from->bindCount; ++i) {
+ deepcopy_VkSparseMemoryBind(alloc, rootType, from->pBinds + i,
+ (VkSparseMemoryBind*)(to->pBinds + i));
}
}
}
}
-void deepcopy_VkImageSubresource(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageSubresource* from,
- VkImageSubresource* to)
-{
+void deepcopy_VkImageSubresource(Allocator* alloc, VkStructureType rootType,
+ const VkImageSubresource* from, VkImageSubresource* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkSparseImageMemoryBind(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSparseImageMemoryBind* from,
- VkSparseImageMemoryBind* to)
-{
+void deepcopy_VkSparseImageMemoryBind(Allocator* alloc, VkStructureType rootType,
+ const VkSparseImageMemoryBind* from,
+ VkSparseImageMemoryBind* to) {
(void)alloc;
(void)rootType;
*to = *from;
- deepcopy_VkImageSubresource(alloc, rootType, &from->subresource, (VkImageSubresource*)(&to->subresource));
+ deepcopy_VkImageSubresource(alloc, rootType, &from->subresource,
+ (VkImageSubresource*)(&to->subresource));
deepcopy_VkOffset3D(alloc, rootType, &from->offset, (VkOffset3D*)(&to->offset));
deepcopy_VkExtent3D(alloc, rootType, &from->extent, (VkExtent3D*)(&to->extent));
}
-void deepcopy_VkSparseImageMemoryBindInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSparseImageMemoryBindInfo* from,
- VkSparseImageMemoryBindInfo* to)
-{
+void deepcopy_VkSparseImageMemoryBindInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSparseImageMemoryBindInfo* from,
+ VkSparseImageMemoryBindInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (from)
- {
+ if (from) {
to->pBinds = nullptr;
- if (from->pBinds)
- {
- to->pBinds = (VkSparseImageMemoryBind*)alloc->alloc(from->bindCount * sizeof(const VkSparseImageMemoryBind));
+ if (from->pBinds) {
+ to->pBinds = (VkSparseImageMemoryBind*)alloc->alloc(
+ from->bindCount * sizeof(const VkSparseImageMemoryBind));
to->bindCount = from->bindCount;
- for (uint32_t i = 0; i < (uint32_t)from->bindCount; ++i)
- {
- deepcopy_VkSparseImageMemoryBind(alloc, rootType, from->pBinds + i, (VkSparseImageMemoryBind*)(to->pBinds + i));
+ for (uint32_t i = 0; i < (uint32_t)from->bindCount; ++i) {
+ deepcopy_VkSparseImageMemoryBind(alloc, rootType, from->pBinds + i,
+ (VkSparseImageMemoryBind*)(to->pBinds + i));
}
}
}
}
-void deepcopy_VkBindSparseInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindSparseInfo* from,
- VkBindSparseInfo* to)
-{
+void deepcopy_VkBindSparseInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBindSparseInfo* from, VkBindSparseInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pWaitSemaphores = nullptr;
- if (from->pWaitSemaphores)
- {
- to->pWaitSemaphores = (VkSemaphore*)alloc->dupArray(from->pWaitSemaphores, from->waitSemaphoreCount * sizeof(const VkSemaphore));
+ if (from->pWaitSemaphores) {
+ to->pWaitSemaphores = (VkSemaphore*)alloc->dupArray(
+ from->pWaitSemaphores, from->waitSemaphoreCount * sizeof(const VkSemaphore));
}
- if (from)
- {
+ if (from) {
to->pBufferBinds = nullptr;
- if (from->pBufferBinds)
- {
- to->pBufferBinds = (VkSparseBufferMemoryBindInfo*)alloc->alloc(from->bufferBindCount * sizeof(const VkSparseBufferMemoryBindInfo));
+ if (from->pBufferBinds) {
+ to->pBufferBinds = (VkSparseBufferMemoryBindInfo*)alloc->alloc(
+ from->bufferBindCount * sizeof(const VkSparseBufferMemoryBindInfo));
to->bufferBindCount = from->bufferBindCount;
- for (uint32_t i = 0; i < (uint32_t)from->bufferBindCount; ++i)
- {
- deepcopy_VkSparseBufferMemoryBindInfo(alloc, rootType, from->pBufferBinds + i, (VkSparseBufferMemoryBindInfo*)(to->pBufferBinds + i));
+ for (uint32_t i = 0; i < (uint32_t)from->bufferBindCount; ++i) {
+ deepcopy_VkSparseBufferMemoryBindInfo(
+ alloc, rootType, from->pBufferBinds + i,
+ (VkSparseBufferMemoryBindInfo*)(to->pBufferBinds + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pImageOpaqueBinds = nullptr;
- if (from->pImageOpaqueBinds)
- {
- to->pImageOpaqueBinds = (VkSparseImageOpaqueMemoryBindInfo*)alloc->alloc(from->imageOpaqueBindCount * sizeof(const VkSparseImageOpaqueMemoryBindInfo));
+ if (from->pImageOpaqueBinds) {
+ to->pImageOpaqueBinds = (VkSparseImageOpaqueMemoryBindInfo*)alloc->alloc(
+ from->imageOpaqueBindCount * sizeof(const VkSparseImageOpaqueMemoryBindInfo));
to->imageOpaqueBindCount = from->imageOpaqueBindCount;
- for (uint32_t i = 0; i < (uint32_t)from->imageOpaqueBindCount; ++i)
- {
- deepcopy_VkSparseImageOpaqueMemoryBindInfo(alloc, rootType, from->pImageOpaqueBinds + i, (VkSparseImageOpaqueMemoryBindInfo*)(to->pImageOpaqueBinds + i));
+ for (uint32_t i = 0; i < (uint32_t)from->imageOpaqueBindCount; ++i) {
+ deepcopy_VkSparseImageOpaqueMemoryBindInfo(
+ alloc, rootType, from->pImageOpaqueBinds + i,
+ (VkSparseImageOpaqueMemoryBindInfo*)(to->pImageOpaqueBinds + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pImageBinds = nullptr;
- if (from->pImageBinds)
- {
- to->pImageBinds = (VkSparseImageMemoryBindInfo*)alloc->alloc(from->imageBindCount * sizeof(const VkSparseImageMemoryBindInfo));
+ if (from->pImageBinds) {
+ to->pImageBinds = (VkSparseImageMemoryBindInfo*)alloc->alloc(
+ from->imageBindCount * sizeof(const VkSparseImageMemoryBindInfo));
to->imageBindCount = from->imageBindCount;
- for (uint32_t i = 0; i < (uint32_t)from->imageBindCount; ++i)
- {
- deepcopy_VkSparseImageMemoryBindInfo(alloc, rootType, from->pImageBinds + i, (VkSparseImageMemoryBindInfo*)(to->pImageBinds + i));
+ for (uint32_t i = 0; i < (uint32_t)from->imageBindCount; ++i) {
+ deepcopy_VkSparseImageMemoryBindInfo(
+ alloc, rootType, from->pImageBinds + i,
+ (VkSparseImageMemoryBindInfo*)(to->pImageBinds + i));
}
}
}
to->pSignalSemaphores = nullptr;
- if (from->pSignalSemaphores)
- {
- to->pSignalSemaphores = (VkSemaphore*)alloc->dupArray(from->pSignalSemaphores, from->signalSemaphoreCount * sizeof(const VkSemaphore));
+ if (from->pSignalSemaphores) {
+ to->pSignalSemaphores = (VkSemaphore*)alloc->dupArray(
+ from->pSignalSemaphores, from->signalSemaphoreCount * sizeof(const VkSemaphore));
}
}
-void deepcopy_VkSparseImageFormatProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSparseImageFormatProperties* from,
- VkSparseImageFormatProperties* to)
-{
+void deepcopy_VkSparseImageFormatProperties(Allocator* alloc, VkStructureType rootType,
+ const VkSparseImageFormatProperties* from,
+ VkSparseImageFormatProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- deepcopy_VkExtent3D(alloc, rootType, &from->imageGranularity, (VkExtent3D*)(&to->imageGranularity));
+ deepcopy_VkExtent3D(alloc, rootType, &from->imageGranularity,
+ (VkExtent3D*)(&to->imageGranularity));
}
-void deepcopy_VkSparseImageMemoryRequirements(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSparseImageMemoryRequirements* from,
- VkSparseImageMemoryRequirements* to)
-{
+void deepcopy_VkSparseImageMemoryRequirements(Allocator* alloc, VkStructureType rootType,
+ const VkSparseImageMemoryRequirements* from,
+ VkSparseImageMemoryRequirements* to) {
(void)alloc;
(void)rootType;
*to = *from;
- deepcopy_VkSparseImageFormatProperties(alloc, rootType, &from->formatProperties, (VkSparseImageFormatProperties*)(&to->formatProperties));
+ deepcopy_VkSparseImageFormatProperties(alloc, rootType, &from->formatProperties,
+ (VkSparseImageFormatProperties*)(&to->formatProperties));
}
-void deepcopy_VkFenceCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFenceCreateInfo* from,
- VkFenceCreateInfo* to)
-{
+void deepcopy_VkFenceCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkFenceCreateInfo* from, VkFenceCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkSemaphoreCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSemaphoreCreateInfo* from,
- VkSemaphoreCreateInfo* to)
-{
+void deepcopy_VkSemaphoreCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSemaphoreCreateInfo* from, VkSemaphoreCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkEventCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkEventCreateInfo* from,
- VkEventCreateInfo* to)
-{
+void deepcopy_VkEventCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkEventCreateInfo* from, VkEventCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkQueryPoolCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkQueryPoolCreateInfo* from,
- VkQueryPoolCreateInfo* to)
-{
+void deepcopy_VkQueryPoolCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkQueryPoolCreateInfo* from, VkQueryPoolCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkBufferCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferCreateInfo* from,
- VkBufferCreateInfo* to)
-{
+void deepcopy_VkBufferCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBufferCreateInfo* from, VkBufferCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pQueueFamilyIndices = nullptr;
- if (from->pQueueFamilyIndices)
- {
- to->pQueueFamilyIndices = (uint32_t*)alloc->dupArray(from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
+ if (from->pQueueFamilyIndices) {
+ to->pQueueFamilyIndices = (uint32_t*)alloc->dupArray(
+ from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
}
}
-void deepcopy_VkBufferViewCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferViewCreateInfo* from,
- VkBufferViewCreateInfo* to)
-{
+void deepcopy_VkBufferViewCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBufferViewCreateInfo* from,
+ VkBufferViewCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkImageCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageCreateInfo* from,
- VkImageCreateInfo* to)
-{
+void deepcopy_VkImageCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkImageCreateInfo* from, VkImageCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
deepcopy_VkExtent3D(alloc, rootType, &from->extent, (VkExtent3D*)(&to->extent));
to->pQueueFamilyIndices = nullptr;
- if (from->pQueueFamilyIndices)
- {
- to->pQueueFamilyIndices = (uint32_t*)alloc->dupArray(from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
+ if (from->pQueueFamilyIndices) {
+ to->pQueueFamilyIndices = (uint32_t*)alloc->dupArray(
+ from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
}
}
-void deepcopy_VkSubresourceLayout(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubresourceLayout* from,
- VkSubresourceLayout* to)
-{
+void deepcopy_VkSubresourceLayout(Allocator* alloc, VkStructureType rootType,
+ const VkSubresourceLayout* from, VkSubresourceLayout* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkComponentMapping(
- Allocator* alloc,
- VkStructureType rootType,
- const VkComponentMapping* from,
- VkComponentMapping* to)
-{
+void deepcopy_VkComponentMapping(Allocator* alloc, VkStructureType rootType,
+ const VkComponentMapping* from, VkComponentMapping* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkImageViewCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageViewCreateInfo* from,
- VkImageViewCreateInfo* to)
-{
+void deepcopy_VkImageViewCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkImageViewCreateInfo* from, VkImageViewCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkComponentMapping(alloc, rootType, &from->components, (VkComponentMapping*)(&to->components));
- deepcopy_VkImageSubresourceRange(alloc, rootType, &from->subresourceRange, (VkImageSubresourceRange*)(&to->subresourceRange));
+ deepcopy_VkComponentMapping(alloc, rootType, &from->components,
+ (VkComponentMapping*)(&to->components));
+ deepcopy_VkImageSubresourceRange(alloc, rootType, &from->subresourceRange,
+ (VkImageSubresourceRange*)(&to->subresourceRange));
}
-void deepcopy_VkShaderModuleCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkShaderModuleCreateInfo* from,
- VkShaderModuleCreateInfo* to)
-{
+void deepcopy_VkShaderModuleCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkShaderModuleCreateInfo* from,
+ VkShaderModuleCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pCode = nullptr;
- if (from->pCode)
- {
- to->pCode = (uint32_t*)alloc->dupArray(from->pCode, (from->codeSize / 4) * sizeof(const uint32_t));
+ if (from->pCode) {
+ to->pCode =
+ (uint32_t*)alloc->dupArray(from->pCode, (from->codeSize / 4) * sizeof(const uint32_t));
}
}
-void deepcopy_VkPipelineCacheCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineCacheCreateInfo* from,
- VkPipelineCacheCreateInfo* to)
-{
+void deepcopy_VkPipelineCacheCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineCacheCreateInfo* from,
+ VkPipelineCacheCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pInitialData = nullptr;
- if (from->pInitialData)
- {
- to->pInitialData = (void*)alloc->dupArray(from->pInitialData, from->initialDataSize * sizeof(const uint8_t));
+ if (from->pInitialData) {
+ to->pInitialData = (void*)alloc->dupArray(from->pInitialData,
+ from->initialDataSize * sizeof(const uint8_t));
}
}
-void deepcopy_VkSpecializationMapEntry(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSpecializationMapEntry* from,
- VkSpecializationMapEntry* to)
-{
+void deepcopy_VkSpecializationMapEntry(Allocator* alloc, VkStructureType rootType,
+ const VkSpecializationMapEntry* from,
+ VkSpecializationMapEntry* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkSpecializationInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSpecializationInfo* from,
- VkSpecializationInfo* to)
-{
+void deepcopy_VkSpecializationInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSpecializationInfo* from, VkSpecializationInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (from)
- {
+ if (from) {
to->pMapEntries = nullptr;
- if (from->pMapEntries)
- {
- to->pMapEntries = (VkSpecializationMapEntry*)alloc->alloc(from->mapEntryCount * sizeof(const VkSpecializationMapEntry));
+ if (from->pMapEntries) {
+ to->pMapEntries = (VkSpecializationMapEntry*)alloc->alloc(
+ from->mapEntryCount * sizeof(const VkSpecializationMapEntry));
to->mapEntryCount = from->mapEntryCount;
- for (uint32_t i = 0; i < (uint32_t)from->mapEntryCount; ++i)
- {
- deepcopy_VkSpecializationMapEntry(alloc, rootType, from->pMapEntries + i, (VkSpecializationMapEntry*)(to->pMapEntries + i));
+ for (uint32_t i = 0; i < (uint32_t)from->mapEntryCount; ++i) {
+ deepcopy_VkSpecializationMapEntry(alloc, rootType, from->pMapEntries + i,
+ (VkSpecializationMapEntry*)(to->pMapEntries + i));
}
}
}
to->pData = nullptr;
- if (from->pData)
- {
+ if (from->pData) {
to->pData = (void*)alloc->dupArray(from->pData, from->dataSize * sizeof(const uint8_t));
}
}
-void deepcopy_VkPipelineShaderStageCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineShaderStageCreateInfo* from,
- VkPipelineShaderStageCreateInfo* to)
-{
+void deepcopy_VkPipelineShaderStageCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineShaderStageCreateInfo* from,
+ VkPipelineShaderStageCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pName = nullptr;
- if (from->pName)
- {
+ if (from->pName) {
to->pName = alloc->strDup(from->pName);
}
to->pSpecializationInfo = nullptr;
- if (from->pSpecializationInfo)
- {
- to->pSpecializationInfo = (VkSpecializationInfo*)alloc->alloc(sizeof(const VkSpecializationInfo));
- deepcopy_VkSpecializationInfo(alloc, rootType, from->pSpecializationInfo, (VkSpecializationInfo*)(to->pSpecializationInfo));
+ if (from->pSpecializationInfo) {
+ to->pSpecializationInfo =
+ (VkSpecializationInfo*)alloc->alloc(sizeof(const VkSpecializationInfo));
+ deepcopy_VkSpecializationInfo(alloc, rootType, from->pSpecializationInfo,
+ (VkSpecializationInfo*)(to->pSpecializationInfo));
}
}
-void deepcopy_VkComputePipelineCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkComputePipelineCreateInfo* from,
- VkComputePipelineCreateInfo* to)
-{
+void deepcopy_VkComputePipelineCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkComputePipelineCreateInfo* from,
+ VkComputePipelineCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkPipelineShaderStageCreateInfo(alloc, rootType, &from->stage, (VkPipelineShaderStageCreateInfo*)(&to->stage));
+ deepcopy_VkPipelineShaderStageCreateInfo(alloc, rootType, &from->stage,
+ (VkPipelineShaderStageCreateInfo*)(&to->stage));
}
-void deepcopy_VkVertexInputBindingDescription(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVertexInputBindingDescription* from,
- VkVertexInputBindingDescription* to)
-{
+void deepcopy_VkVertexInputBindingDescription(Allocator* alloc, VkStructureType rootType,
+ const VkVertexInputBindingDescription* from,
+ VkVertexInputBindingDescription* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkVertexInputAttributeDescription(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVertexInputAttributeDescription* from,
- VkVertexInputAttributeDescription* to)
-{
+void deepcopy_VkVertexInputAttributeDescription(Allocator* alloc, VkStructureType rootType,
+ const VkVertexInputAttributeDescription* from,
+ VkVertexInputAttributeDescription* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkPipelineVertexInputStateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineVertexInputStateCreateInfo* from,
- VkPipelineVertexInputStateCreateInfo* to)
-{
+void deepcopy_VkPipelineVertexInputStateCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineVertexInputStateCreateInfo* from,
+ VkPipelineVertexInputStateCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pVertexBindingDescriptions = nullptr;
- if (from->pVertexBindingDescriptions)
- {
- to->pVertexBindingDescriptions = (VkVertexInputBindingDescription*)alloc->alloc(from->vertexBindingDescriptionCount * sizeof(const VkVertexInputBindingDescription));
+ if (from->pVertexBindingDescriptions) {
+ to->pVertexBindingDescriptions = (VkVertexInputBindingDescription*)alloc->alloc(
+ from->vertexBindingDescriptionCount *
+ sizeof(const VkVertexInputBindingDescription));
to->vertexBindingDescriptionCount = from->vertexBindingDescriptionCount;
- for (uint32_t i = 0; i < (uint32_t)from->vertexBindingDescriptionCount; ++i)
- {
- deepcopy_VkVertexInputBindingDescription(alloc, rootType, from->pVertexBindingDescriptions + i, (VkVertexInputBindingDescription*)(to->pVertexBindingDescriptions + i));
+ for (uint32_t i = 0; i < (uint32_t)from->vertexBindingDescriptionCount; ++i) {
+ deepcopy_VkVertexInputBindingDescription(
+ alloc, rootType, from->pVertexBindingDescriptions + i,
+ (VkVertexInputBindingDescription*)(to->pVertexBindingDescriptions + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pVertexAttributeDescriptions = nullptr;
- if (from->pVertexAttributeDescriptions)
- {
- to->pVertexAttributeDescriptions = (VkVertexInputAttributeDescription*)alloc->alloc(from->vertexAttributeDescriptionCount * sizeof(const VkVertexInputAttributeDescription));
+ if (from->pVertexAttributeDescriptions) {
+ to->pVertexAttributeDescriptions = (VkVertexInputAttributeDescription*)alloc->alloc(
+ from->vertexAttributeDescriptionCount *
+ sizeof(const VkVertexInputAttributeDescription));
to->vertexAttributeDescriptionCount = from->vertexAttributeDescriptionCount;
- for (uint32_t i = 0; i < (uint32_t)from->vertexAttributeDescriptionCount; ++i)
- {
- deepcopy_VkVertexInputAttributeDescription(alloc, rootType, from->pVertexAttributeDescriptions + i, (VkVertexInputAttributeDescription*)(to->pVertexAttributeDescriptions + i));
+ for (uint32_t i = 0; i < (uint32_t)from->vertexAttributeDescriptionCount; ++i) {
+ deepcopy_VkVertexInputAttributeDescription(
+ alloc, rootType, from->pVertexAttributeDescriptions + i,
+ (VkVertexInputAttributeDescription*)(to->pVertexAttributeDescriptions + i));
}
}
}
}
void deepcopy_VkPipelineInputAssemblyStateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineInputAssemblyStateCreateInfo* from,
- VkPipelineInputAssemblyStateCreateInfo* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPipelineInputAssemblyStateCreateInfo* from,
+ VkPipelineInputAssemblyStateCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineTessellationStateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineTessellationStateCreateInfo* from,
- VkPipelineTessellationStateCreateInfo* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPipelineTessellationStateCreateInfo* from,
+ VkPipelineTessellationStateCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkViewport(
- Allocator* alloc,
- VkStructureType rootType,
- const VkViewport* from,
- VkViewport* to)
-{
+void deepcopy_VkViewport(Allocator* alloc, VkStructureType rootType, const VkViewport* from,
+ VkViewport* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkPipelineViewportStateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineViewportStateCreateInfo* from,
- VkPipelineViewportStateCreateInfo* to)
-{
+void deepcopy_VkPipelineViewportStateCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineViewportStateCreateInfo* from,
+ VkPipelineViewportStateCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pViewports = nullptr;
- if (from->pViewports)
- {
- to->pViewports = (VkViewport*)alloc->alloc(from->viewportCount * sizeof(const VkViewport));
+ if (from->pViewports) {
+ to->pViewports =
+ (VkViewport*)alloc->alloc(from->viewportCount * sizeof(const VkViewport));
to->viewportCount = from->viewportCount;
- for (uint32_t i = 0; i < (uint32_t)from->viewportCount; ++i)
- {
- deepcopy_VkViewport(alloc, rootType, from->pViewports + i, (VkViewport*)(to->pViewports + i));
+ for (uint32_t i = 0; i < (uint32_t)from->viewportCount; ++i) {
+ deepcopy_VkViewport(alloc, rootType, from->pViewports + i,
+ (VkViewport*)(to->pViewports + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pScissors = nullptr;
- if (from->pScissors)
- {
+ if (from->pScissors) {
to->pScissors = (VkRect2D*)alloc->alloc(from->scissorCount * sizeof(const VkRect2D));
to->scissorCount = from->scissorCount;
- for (uint32_t i = 0; i < (uint32_t)from->scissorCount; ++i)
- {
- deepcopy_VkRect2D(alloc, rootType, from->pScissors + i, (VkRect2D*)(to->pScissors + i));
+ for (uint32_t i = 0; i < (uint32_t)from->scissorCount; ++i) {
+ deepcopy_VkRect2D(alloc, rootType, from->pScissors + i,
+ (VkRect2D*)(to->pScissors + i));
}
}
}
}
void deepcopy_VkPipelineRasterizationStateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineRasterizationStateCreateInfo* from,
- VkPipelineRasterizationStateCreateInfo* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPipelineRasterizationStateCreateInfo* from,
+ VkPipelineRasterizationStateCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkPipelineMultisampleStateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineMultisampleStateCreateInfo* from,
- VkPipelineMultisampleStateCreateInfo* to)
-{
+void deepcopy_VkPipelineMultisampleStateCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineMultisampleStateCreateInfo* from,
+ VkPipelineMultisampleStateCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pSampleMask = nullptr;
- if (from->pSampleMask)
- {
- to->pSampleMask = (VkSampleMask*)alloc->dupArray(from->pSampleMask, (((from->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
+ if (from->pSampleMask) {
+ to->pSampleMask = (VkSampleMask*)alloc->dupArray(
+ from->pSampleMask,
+ (((from->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
}
}
-void deepcopy_VkStencilOpState(
- Allocator* alloc,
- VkStructureType rootType,
- const VkStencilOpState* from,
- VkStencilOpState* to)
-{
+void deepcopy_VkStencilOpState(Allocator* alloc, VkStructureType rootType,
+ const VkStencilOpState* from, VkStencilOpState* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
void deepcopy_VkPipelineDepthStencilStateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineDepthStencilStateCreateInfo* from,
- VkPipelineDepthStencilStateCreateInfo* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPipelineDepthStencilStateCreateInfo* from,
+ VkPipelineDepthStencilStateCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -1696,877 +1349,740 @@
deepcopy_VkStencilOpState(alloc, rootType, &from->back, (VkStencilOpState*)(&to->back));
}
-void deepcopy_VkPipelineColorBlendAttachmentState(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineColorBlendAttachmentState* from,
- VkPipelineColorBlendAttachmentState* to)
-{
+void deepcopy_VkPipelineColorBlendAttachmentState(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineColorBlendAttachmentState* from,
+ VkPipelineColorBlendAttachmentState* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkPipelineColorBlendStateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineColorBlendStateCreateInfo* from,
- VkPipelineColorBlendStateCreateInfo* to)
-{
+void deepcopy_VkPipelineColorBlendStateCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineColorBlendStateCreateInfo* from,
+ VkPipelineColorBlendStateCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pAttachments = nullptr;
- if (from->pAttachments)
- {
- to->pAttachments = (VkPipelineColorBlendAttachmentState*)alloc->alloc(from->attachmentCount * sizeof(const VkPipelineColorBlendAttachmentState));
+ if (from->pAttachments) {
+ to->pAttachments = (VkPipelineColorBlendAttachmentState*)alloc->alloc(
+ from->attachmentCount * sizeof(const VkPipelineColorBlendAttachmentState));
to->attachmentCount = from->attachmentCount;
- for (uint32_t i = 0; i < (uint32_t)from->attachmentCount; ++i)
- {
- deepcopy_VkPipelineColorBlendAttachmentState(alloc, rootType, from->pAttachments + i, (VkPipelineColorBlendAttachmentState*)(to->pAttachments + i));
+ for (uint32_t i = 0; i < (uint32_t)from->attachmentCount; ++i) {
+ deepcopy_VkPipelineColorBlendAttachmentState(
+ alloc, rootType, from->pAttachments + i,
+ (VkPipelineColorBlendAttachmentState*)(to->pAttachments + i));
}
}
}
memcpy(to->blendConstants, from->blendConstants, 4 * sizeof(float));
}
-void deepcopy_VkPipelineDynamicStateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineDynamicStateCreateInfo* from,
- VkPipelineDynamicStateCreateInfo* to)
-{
+void deepcopy_VkPipelineDynamicStateCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineDynamicStateCreateInfo* from,
+ VkPipelineDynamicStateCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pDynamicStates = nullptr;
- if (from->pDynamicStates)
- {
- to->pDynamicStates = (VkDynamicState*)alloc->dupArray(from->pDynamicStates, from->dynamicStateCount * sizeof(const VkDynamicState));
+ if (from->pDynamicStates) {
+ to->pDynamicStates = (VkDynamicState*)alloc->dupArray(
+ from->pDynamicStates, from->dynamicStateCount * sizeof(const VkDynamicState));
}
}
-void deepcopy_VkGraphicsPipelineCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkGraphicsPipelineCreateInfo* from,
- VkGraphicsPipelineCreateInfo* to)
-{
+void deepcopy_VkGraphicsPipelineCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkGraphicsPipelineCreateInfo* from,
+ VkGraphicsPipelineCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pStages = nullptr;
- if (from->pStages)
- {
- to->pStages = (VkPipelineShaderStageCreateInfo*)alloc->alloc(from->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
+ if (from->pStages) {
+ to->pStages = (VkPipelineShaderStageCreateInfo*)alloc->alloc(
+ from->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
to->stageCount = from->stageCount;
- for (uint32_t i = 0; i < (uint32_t)from->stageCount; ++i)
- {
- deepcopy_VkPipelineShaderStageCreateInfo(alloc, rootType, from->pStages + i, (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
+ for (uint32_t i = 0; i < (uint32_t)from->stageCount; ++i) {
+ deepcopy_VkPipelineShaderStageCreateInfo(
+ alloc, rootType, from->pStages + i,
+ (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
}
}
}
to->pVertexInputState = nullptr;
- if (from->pVertexInputState)
- {
- to->pVertexInputState = (VkPipelineVertexInputStateCreateInfo*)alloc->alloc(sizeof(const VkPipelineVertexInputStateCreateInfo));
- deepcopy_VkPipelineVertexInputStateCreateInfo(alloc, rootType, from->pVertexInputState, (VkPipelineVertexInputStateCreateInfo*)(to->pVertexInputState));
+ if (from->pVertexInputState) {
+ to->pVertexInputState = (VkPipelineVertexInputStateCreateInfo*)alloc->alloc(
+ sizeof(const VkPipelineVertexInputStateCreateInfo));
+ deepcopy_VkPipelineVertexInputStateCreateInfo(
+ alloc, rootType, from->pVertexInputState,
+ (VkPipelineVertexInputStateCreateInfo*)(to->pVertexInputState));
}
to->pInputAssemblyState = nullptr;
- if (from->pInputAssemblyState)
- {
- to->pInputAssemblyState = (VkPipelineInputAssemblyStateCreateInfo*)alloc->alloc(sizeof(const VkPipelineInputAssemblyStateCreateInfo));
- deepcopy_VkPipelineInputAssemblyStateCreateInfo(alloc, rootType, from->pInputAssemblyState, (VkPipelineInputAssemblyStateCreateInfo*)(to->pInputAssemblyState));
+ if (from->pInputAssemblyState) {
+ to->pInputAssemblyState = (VkPipelineInputAssemblyStateCreateInfo*)alloc->alloc(
+ sizeof(const VkPipelineInputAssemblyStateCreateInfo));
+ deepcopy_VkPipelineInputAssemblyStateCreateInfo(
+ alloc, rootType, from->pInputAssemblyState,
+ (VkPipelineInputAssemblyStateCreateInfo*)(to->pInputAssemblyState));
}
to->pTessellationState = nullptr;
- if (from->pTessellationState)
- {
- to->pTessellationState = (VkPipelineTessellationStateCreateInfo*)alloc->alloc(sizeof(const VkPipelineTessellationStateCreateInfo));
- deepcopy_VkPipelineTessellationStateCreateInfo(alloc, rootType, from->pTessellationState, (VkPipelineTessellationStateCreateInfo*)(to->pTessellationState));
+ if (from->pTessellationState) {
+ to->pTessellationState = (VkPipelineTessellationStateCreateInfo*)alloc->alloc(
+ sizeof(const VkPipelineTessellationStateCreateInfo));
+ deepcopy_VkPipelineTessellationStateCreateInfo(
+ alloc, rootType, from->pTessellationState,
+ (VkPipelineTessellationStateCreateInfo*)(to->pTessellationState));
}
to->pViewportState = nullptr;
- if (from->pViewportState)
- {
- to->pViewportState = (VkPipelineViewportStateCreateInfo*)alloc->alloc(sizeof(const VkPipelineViewportStateCreateInfo));
- deepcopy_VkPipelineViewportStateCreateInfo(alloc, rootType, from->pViewportState, (VkPipelineViewportStateCreateInfo*)(to->pViewportState));
+ if (from->pViewportState) {
+ to->pViewportState = (VkPipelineViewportStateCreateInfo*)alloc->alloc(
+ sizeof(const VkPipelineViewportStateCreateInfo));
+ deepcopy_VkPipelineViewportStateCreateInfo(
+ alloc, rootType, from->pViewportState,
+ (VkPipelineViewportStateCreateInfo*)(to->pViewportState));
}
to->pRasterizationState = nullptr;
- if (from->pRasterizationState)
- {
- to->pRasterizationState = (VkPipelineRasterizationStateCreateInfo*)alloc->alloc(sizeof(const VkPipelineRasterizationStateCreateInfo));
- deepcopy_VkPipelineRasterizationStateCreateInfo(alloc, rootType, from->pRasterizationState, (VkPipelineRasterizationStateCreateInfo*)(to->pRasterizationState));
+ if (from->pRasterizationState) {
+ to->pRasterizationState = (VkPipelineRasterizationStateCreateInfo*)alloc->alloc(
+ sizeof(const VkPipelineRasterizationStateCreateInfo));
+ deepcopy_VkPipelineRasterizationStateCreateInfo(
+ alloc, rootType, from->pRasterizationState,
+ (VkPipelineRasterizationStateCreateInfo*)(to->pRasterizationState));
}
to->pMultisampleState = nullptr;
- if (from->pMultisampleState)
- {
- to->pMultisampleState = (VkPipelineMultisampleStateCreateInfo*)alloc->alloc(sizeof(const VkPipelineMultisampleStateCreateInfo));
- deepcopy_VkPipelineMultisampleStateCreateInfo(alloc, rootType, from->pMultisampleState, (VkPipelineMultisampleStateCreateInfo*)(to->pMultisampleState));
+ if (from->pMultisampleState) {
+ to->pMultisampleState = (VkPipelineMultisampleStateCreateInfo*)alloc->alloc(
+ sizeof(const VkPipelineMultisampleStateCreateInfo));
+ deepcopy_VkPipelineMultisampleStateCreateInfo(
+ alloc, rootType, from->pMultisampleState,
+ (VkPipelineMultisampleStateCreateInfo*)(to->pMultisampleState));
}
to->pDepthStencilState = nullptr;
- if (from->pDepthStencilState)
- {
- to->pDepthStencilState = (VkPipelineDepthStencilStateCreateInfo*)alloc->alloc(sizeof(const VkPipelineDepthStencilStateCreateInfo));
- deepcopy_VkPipelineDepthStencilStateCreateInfo(alloc, rootType, from->pDepthStencilState, (VkPipelineDepthStencilStateCreateInfo*)(to->pDepthStencilState));
+ if (from->pDepthStencilState) {
+ to->pDepthStencilState = (VkPipelineDepthStencilStateCreateInfo*)alloc->alloc(
+ sizeof(const VkPipelineDepthStencilStateCreateInfo));
+ deepcopy_VkPipelineDepthStencilStateCreateInfo(
+ alloc, rootType, from->pDepthStencilState,
+ (VkPipelineDepthStencilStateCreateInfo*)(to->pDepthStencilState));
}
to->pColorBlendState = nullptr;
- if (from->pColorBlendState)
- {
- to->pColorBlendState = (VkPipelineColorBlendStateCreateInfo*)alloc->alloc(sizeof(const VkPipelineColorBlendStateCreateInfo));
- deepcopy_VkPipelineColorBlendStateCreateInfo(alloc, rootType, from->pColorBlendState, (VkPipelineColorBlendStateCreateInfo*)(to->pColorBlendState));
+ if (from->pColorBlendState) {
+ to->pColorBlendState = (VkPipelineColorBlendStateCreateInfo*)alloc->alloc(
+ sizeof(const VkPipelineColorBlendStateCreateInfo));
+ deepcopy_VkPipelineColorBlendStateCreateInfo(
+ alloc, rootType, from->pColorBlendState,
+ (VkPipelineColorBlendStateCreateInfo*)(to->pColorBlendState));
}
to->pDynamicState = nullptr;
- if (from->pDynamicState)
- {
- to->pDynamicState = (VkPipelineDynamicStateCreateInfo*)alloc->alloc(sizeof(const VkPipelineDynamicStateCreateInfo));
- deepcopy_VkPipelineDynamicStateCreateInfo(alloc, rootType, from->pDynamicState, (VkPipelineDynamicStateCreateInfo*)(to->pDynamicState));
+ if (from->pDynamicState) {
+ to->pDynamicState = (VkPipelineDynamicStateCreateInfo*)alloc->alloc(
+ sizeof(const VkPipelineDynamicStateCreateInfo));
+ deepcopy_VkPipelineDynamicStateCreateInfo(
+ alloc, rootType, from->pDynamicState,
+ (VkPipelineDynamicStateCreateInfo*)(to->pDynamicState));
}
}
-void deepcopy_VkPushConstantRange(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPushConstantRange* from,
- VkPushConstantRange* to)
-{
+void deepcopy_VkPushConstantRange(Allocator* alloc, VkStructureType rootType,
+ const VkPushConstantRange* from, VkPushConstantRange* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkPipelineLayoutCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineLayoutCreateInfo* from,
- VkPipelineLayoutCreateInfo* to)
-{
+void deepcopy_VkPipelineLayoutCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineLayoutCreateInfo* from,
+ VkPipelineLayoutCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pSetLayouts = nullptr;
- if (from->pSetLayouts)
- {
- to->pSetLayouts = (VkDescriptorSetLayout*)alloc->dupArray(from->pSetLayouts, from->setLayoutCount * sizeof(const VkDescriptorSetLayout));
+ if (from->pSetLayouts) {
+ to->pSetLayouts = (VkDescriptorSetLayout*)alloc->dupArray(
+ from->pSetLayouts, from->setLayoutCount * sizeof(const VkDescriptorSetLayout));
}
- if (from)
- {
+ if (from) {
to->pPushConstantRanges = nullptr;
- if (from->pPushConstantRanges)
- {
- to->pPushConstantRanges = (VkPushConstantRange*)alloc->alloc(from->pushConstantRangeCount * sizeof(const VkPushConstantRange));
+ if (from->pPushConstantRanges) {
+ to->pPushConstantRanges = (VkPushConstantRange*)alloc->alloc(
+ from->pushConstantRangeCount * sizeof(const VkPushConstantRange));
to->pushConstantRangeCount = from->pushConstantRangeCount;
- for (uint32_t i = 0; i < (uint32_t)from->pushConstantRangeCount; ++i)
- {
- deepcopy_VkPushConstantRange(alloc, rootType, from->pPushConstantRanges + i, (VkPushConstantRange*)(to->pPushConstantRanges + i));
+ for (uint32_t i = 0; i < (uint32_t)from->pushConstantRangeCount; ++i) {
+ deepcopy_VkPushConstantRange(alloc, rootType, from->pPushConstantRanges + i,
+ (VkPushConstantRange*)(to->pPushConstantRanges + i));
}
}
}
}
-void deepcopy_VkSamplerCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSamplerCreateInfo* from,
- VkSamplerCreateInfo* to)
-{
+void deepcopy_VkSamplerCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSamplerCreateInfo* from, VkSamplerCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkCopyDescriptorSet(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCopyDescriptorSet* from,
- VkCopyDescriptorSet* to)
-{
+void deepcopy_VkCopyDescriptorSet(Allocator* alloc, VkStructureType rootType,
+ const VkCopyDescriptorSet* from, VkCopyDescriptorSet* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkDescriptorBufferInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDescriptorBufferInfo* from,
- VkDescriptorBufferInfo* to)
-{
+void deepcopy_VkDescriptorBufferInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDescriptorBufferInfo* from,
+ VkDescriptorBufferInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkDescriptorImageInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDescriptorImageInfo* from,
- VkDescriptorImageInfo* to)
-{
+void deepcopy_VkDescriptorImageInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDescriptorImageInfo* from, VkDescriptorImageInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkDescriptorPoolSize(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDescriptorPoolSize* from,
- VkDescriptorPoolSize* to)
-{
+void deepcopy_VkDescriptorPoolSize(Allocator* alloc, VkStructureType rootType,
+ const VkDescriptorPoolSize* from, VkDescriptorPoolSize* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkDescriptorPoolCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDescriptorPoolCreateInfo* from,
- VkDescriptorPoolCreateInfo* to)
-{
+void deepcopy_VkDescriptorPoolCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDescriptorPoolCreateInfo* from,
+ VkDescriptorPoolCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pPoolSizes = nullptr;
- if (from->pPoolSizes)
- {
- to->pPoolSizes = (VkDescriptorPoolSize*)alloc->alloc(from->poolSizeCount * sizeof(const VkDescriptorPoolSize));
+ if (from->pPoolSizes) {
+ to->pPoolSizes = (VkDescriptorPoolSize*)alloc->alloc(
+ from->poolSizeCount * sizeof(const VkDescriptorPoolSize));
to->poolSizeCount = from->poolSizeCount;
- for (uint32_t i = 0; i < (uint32_t)from->poolSizeCount; ++i)
- {
- deepcopy_VkDescriptorPoolSize(alloc, rootType, from->pPoolSizes + i, (VkDescriptorPoolSize*)(to->pPoolSizes + i));
+ for (uint32_t i = 0; i < (uint32_t)from->poolSizeCount; ++i) {
+ deepcopy_VkDescriptorPoolSize(alloc, rootType, from->pPoolSizes + i,
+ (VkDescriptorPoolSize*)(to->pPoolSizes + i));
}
}
}
}
-void deepcopy_VkDescriptorSetAllocateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDescriptorSetAllocateInfo* from,
- VkDescriptorSetAllocateInfo* to)
-{
+void deepcopy_VkDescriptorSetAllocateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDescriptorSetAllocateInfo* from,
+ VkDescriptorSetAllocateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pSetLayouts = nullptr;
- if (from->pSetLayouts)
- {
- to->pSetLayouts = (VkDescriptorSetLayout*)alloc->dupArray(from->pSetLayouts, from->descriptorSetCount * sizeof(const VkDescriptorSetLayout));
+ if (from->pSetLayouts) {
+ to->pSetLayouts = (VkDescriptorSetLayout*)alloc->dupArray(
+ from->pSetLayouts, from->descriptorSetCount * sizeof(const VkDescriptorSetLayout));
}
}
-void deepcopy_VkDescriptorSetLayoutBinding(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDescriptorSetLayoutBinding* from,
- VkDescriptorSetLayoutBinding* to)
-{
+void deepcopy_VkDescriptorSetLayoutBinding(Allocator* alloc, VkStructureType rootType,
+ const VkDescriptorSetLayoutBinding* from,
+ VkDescriptorSetLayoutBinding* to) {
(void)alloc;
(void)rootType;
*to = *from;
to->pImmutableSamplers = nullptr;
- if (from->pImmutableSamplers)
- {
- to->pImmutableSamplers = (VkSampler*)alloc->dupArray(from->pImmutableSamplers, from->descriptorCount * sizeof(const VkSampler));
+ if (from->pImmutableSamplers) {
+ to->pImmutableSamplers = (VkSampler*)alloc->dupArray(
+ from->pImmutableSamplers, from->descriptorCount * sizeof(const VkSampler));
}
}
-void deepcopy_VkDescriptorSetLayoutCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDescriptorSetLayoutCreateInfo* from,
- VkDescriptorSetLayoutCreateInfo* to)
-{
+void deepcopy_VkDescriptorSetLayoutCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDescriptorSetLayoutCreateInfo* from,
+ VkDescriptorSetLayoutCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pBindings = nullptr;
- if (from->pBindings)
- {
- to->pBindings = (VkDescriptorSetLayoutBinding*)alloc->alloc(from->bindingCount * sizeof(const VkDescriptorSetLayoutBinding));
+ if (from->pBindings) {
+ to->pBindings = (VkDescriptorSetLayoutBinding*)alloc->alloc(
+ from->bindingCount * sizeof(const VkDescriptorSetLayoutBinding));
to->bindingCount = from->bindingCount;
- for (uint32_t i = 0; i < (uint32_t)from->bindingCount; ++i)
- {
- deepcopy_VkDescriptorSetLayoutBinding(alloc, rootType, from->pBindings + i, (VkDescriptorSetLayoutBinding*)(to->pBindings + i));
+ for (uint32_t i = 0; i < (uint32_t)from->bindingCount; ++i) {
+ deepcopy_VkDescriptorSetLayoutBinding(
+ alloc, rootType, from->pBindings + i,
+ (VkDescriptorSetLayoutBinding*)(to->pBindings + i));
}
}
}
}
-void deepcopy_VkWriteDescriptorSet(
- Allocator* alloc,
- VkStructureType rootType,
- const VkWriteDescriptorSet* from,
- VkWriteDescriptorSet* to)
-{
+void deepcopy_VkWriteDescriptorSet(Allocator* alloc, VkStructureType rootType,
+ const VkWriteDescriptorSet* from, VkWriteDescriptorSet* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pImageInfo = nullptr;
- if (from->pImageInfo)
- {
- to->pImageInfo = (VkDescriptorImageInfo*)alloc->alloc(from->descriptorCount * sizeof(const VkDescriptorImageInfo));
+ if (from->pImageInfo) {
+ to->pImageInfo = (VkDescriptorImageInfo*)alloc->alloc(
+ from->descriptorCount * sizeof(const VkDescriptorImageInfo));
to->descriptorCount = from->descriptorCount;
- for (uint32_t i = 0; i < (uint32_t)from->descriptorCount; ++i)
- {
- deepcopy_VkDescriptorImageInfo(alloc, rootType, from->pImageInfo + i, (VkDescriptorImageInfo*)(to->pImageInfo + i));
+ for (uint32_t i = 0; i < (uint32_t)from->descriptorCount; ++i) {
+ deepcopy_VkDescriptorImageInfo(alloc, rootType, from->pImageInfo + i,
+ (VkDescriptorImageInfo*)(to->pImageInfo + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pBufferInfo = nullptr;
- if (from->pBufferInfo)
- {
- to->pBufferInfo = (VkDescriptorBufferInfo*)alloc->alloc(from->descriptorCount * sizeof(const VkDescriptorBufferInfo));
+ if (from->pBufferInfo) {
+ to->pBufferInfo = (VkDescriptorBufferInfo*)alloc->alloc(
+ from->descriptorCount * sizeof(const VkDescriptorBufferInfo));
to->descriptorCount = from->descriptorCount;
- for (uint32_t i = 0; i < (uint32_t)from->descriptorCount; ++i)
- {
- deepcopy_VkDescriptorBufferInfo(alloc, rootType, from->pBufferInfo + i, (VkDescriptorBufferInfo*)(to->pBufferInfo + i));
+ for (uint32_t i = 0; i < (uint32_t)from->descriptorCount; ++i) {
+ deepcopy_VkDescriptorBufferInfo(alloc, rootType, from->pBufferInfo + i,
+ (VkDescriptorBufferInfo*)(to->pBufferInfo + i));
}
}
}
to->pTexelBufferView = nullptr;
- if (from->pTexelBufferView)
- {
- to->pTexelBufferView = (VkBufferView*)alloc->dupArray(from->pTexelBufferView, from->descriptorCount * sizeof(const VkBufferView));
+ if (from->pTexelBufferView) {
+ to->pTexelBufferView = (VkBufferView*)alloc->dupArray(
+ from->pTexelBufferView, from->descriptorCount * sizeof(const VkBufferView));
}
}
-void deepcopy_VkAttachmentDescription(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAttachmentDescription* from,
- VkAttachmentDescription* to)
-{
+void deepcopy_VkAttachmentDescription(Allocator* alloc, VkStructureType rootType,
+ const VkAttachmentDescription* from,
+ VkAttachmentDescription* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkAttachmentReference(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAttachmentReference* from,
- VkAttachmentReference* to)
-{
+void deepcopy_VkAttachmentReference(Allocator* alloc, VkStructureType rootType,
+ const VkAttachmentReference* from, VkAttachmentReference* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkFramebufferCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFramebufferCreateInfo* from,
- VkFramebufferCreateInfo* to)
-{
+void deepcopy_VkFramebufferCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkFramebufferCreateInfo* from,
+ VkFramebufferCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pAttachments = nullptr;
- if (from->pAttachments)
- {
- to->pAttachments = (VkImageView*)alloc->dupArray(from->pAttachments, from->attachmentCount * sizeof(const VkImageView));
+ if (from->pAttachments) {
+ to->pAttachments = (VkImageView*)alloc->dupArray(
+ from->pAttachments, from->attachmentCount * sizeof(const VkImageView));
}
}
-void deepcopy_VkSubpassDescription(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubpassDescription* from,
- VkSubpassDescription* to)
-{
+void deepcopy_VkSubpassDescription(Allocator* alloc, VkStructureType rootType,
+ const VkSubpassDescription* from, VkSubpassDescription* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (from)
- {
+ if (from) {
to->pInputAttachments = nullptr;
- if (from->pInputAttachments)
- {
- to->pInputAttachments = (VkAttachmentReference*)alloc->alloc(from->inputAttachmentCount * sizeof(const VkAttachmentReference));
+ if (from->pInputAttachments) {
+ to->pInputAttachments = (VkAttachmentReference*)alloc->alloc(
+ from->inputAttachmentCount * sizeof(const VkAttachmentReference));
to->inputAttachmentCount = from->inputAttachmentCount;
- for (uint32_t i = 0; i < (uint32_t)from->inputAttachmentCount; ++i)
- {
- deepcopy_VkAttachmentReference(alloc, rootType, from->pInputAttachments + i, (VkAttachmentReference*)(to->pInputAttachments + i));
+ for (uint32_t i = 0; i < (uint32_t)from->inputAttachmentCount; ++i) {
+ deepcopy_VkAttachmentReference(alloc, rootType, from->pInputAttachments + i,
+ (VkAttachmentReference*)(to->pInputAttachments + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pColorAttachments = nullptr;
- if (from->pColorAttachments)
- {
- to->pColorAttachments = (VkAttachmentReference*)alloc->alloc(from->colorAttachmentCount * sizeof(const VkAttachmentReference));
+ if (from->pColorAttachments) {
+ to->pColorAttachments = (VkAttachmentReference*)alloc->alloc(
+ from->colorAttachmentCount * sizeof(const VkAttachmentReference));
to->colorAttachmentCount = from->colorAttachmentCount;
- for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i)
- {
- deepcopy_VkAttachmentReference(alloc, rootType, from->pColorAttachments + i, (VkAttachmentReference*)(to->pColorAttachments + i));
+ for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i) {
+ deepcopy_VkAttachmentReference(alloc, rootType, from->pColorAttachments + i,
+ (VkAttachmentReference*)(to->pColorAttachments + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pResolveAttachments = nullptr;
- if (from->pResolveAttachments)
- {
- to->pResolveAttachments = (VkAttachmentReference*)alloc->alloc(from->colorAttachmentCount * sizeof(const VkAttachmentReference));
+ if (from->pResolveAttachments) {
+ to->pResolveAttachments = (VkAttachmentReference*)alloc->alloc(
+ from->colorAttachmentCount * sizeof(const VkAttachmentReference));
to->colorAttachmentCount = from->colorAttachmentCount;
- for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i)
- {
- deepcopy_VkAttachmentReference(alloc, rootType, from->pResolveAttachments + i, (VkAttachmentReference*)(to->pResolveAttachments + i));
+ for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i) {
+ deepcopy_VkAttachmentReference(
+ alloc, rootType, from->pResolveAttachments + i,
+ (VkAttachmentReference*)(to->pResolveAttachments + i));
}
}
}
to->pDepthStencilAttachment = nullptr;
- if (from->pDepthStencilAttachment)
- {
- to->pDepthStencilAttachment = (VkAttachmentReference*)alloc->alloc(sizeof(const VkAttachmentReference));
- deepcopy_VkAttachmentReference(alloc, rootType, from->pDepthStencilAttachment, (VkAttachmentReference*)(to->pDepthStencilAttachment));
+ if (from->pDepthStencilAttachment) {
+ to->pDepthStencilAttachment =
+ (VkAttachmentReference*)alloc->alloc(sizeof(const VkAttachmentReference));
+ deepcopy_VkAttachmentReference(alloc, rootType, from->pDepthStencilAttachment,
+ (VkAttachmentReference*)(to->pDepthStencilAttachment));
}
to->pPreserveAttachments = nullptr;
- if (from->pPreserveAttachments)
- {
- to->pPreserveAttachments = (uint32_t*)alloc->dupArray(from->pPreserveAttachments, from->preserveAttachmentCount * sizeof(const uint32_t));
+ if (from->pPreserveAttachments) {
+ to->pPreserveAttachments = (uint32_t*)alloc->dupArray(
+ from->pPreserveAttachments, from->preserveAttachmentCount * sizeof(const uint32_t));
}
}
-void deepcopy_VkSubpassDependency(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubpassDependency* from,
- VkSubpassDependency* to)
-{
+void deepcopy_VkSubpassDependency(Allocator* alloc, VkStructureType rootType,
+ const VkSubpassDependency* from, VkSubpassDependency* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkRenderPassCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRenderPassCreateInfo* from,
- VkRenderPassCreateInfo* to)
-{
+void deepcopy_VkRenderPassCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkRenderPassCreateInfo* from,
+ VkRenderPassCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pAttachments = nullptr;
- if (from->pAttachments)
- {
- to->pAttachments = (VkAttachmentDescription*)alloc->alloc(from->attachmentCount * sizeof(const VkAttachmentDescription));
+ if (from->pAttachments) {
+ to->pAttachments = (VkAttachmentDescription*)alloc->alloc(
+ from->attachmentCount * sizeof(const VkAttachmentDescription));
to->attachmentCount = from->attachmentCount;
- for (uint32_t i = 0; i < (uint32_t)from->attachmentCount; ++i)
- {
- deepcopy_VkAttachmentDescription(alloc, rootType, from->pAttachments + i, (VkAttachmentDescription*)(to->pAttachments + i));
+ for (uint32_t i = 0; i < (uint32_t)from->attachmentCount; ++i) {
+ deepcopy_VkAttachmentDescription(alloc, rootType, from->pAttachments + i,
+ (VkAttachmentDescription*)(to->pAttachments + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pSubpasses = nullptr;
- if (from->pSubpasses)
- {
- to->pSubpasses = (VkSubpassDescription*)alloc->alloc(from->subpassCount * sizeof(const VkSubpassDescription));
+ if (from->pSubpasses) {
+ to->pSubpasses = (VkSubpassDescription*)alloc->alloc(
+ from->subpassCount * sizeof(const VkSubpassDescription));
to->subpassCount = from->subpassCount;
- for (uint32_t i = 0; i < (uint32_t)from->subpassCount; ++i)
- {
- deepcopy_VkSubpassDescription(alloc, rootType, from->pSubpasses + i, (VkSubpassDescription*)(to->pSubpasses + i));
+ for (uint32_t i = 0; i < (uint32_t)from->subpassCount; ++i) {
+ deepcopy_VkSubpassDescription(alloc, rootType, from->pSubpasses + i,
+ (VkSubpassDescription*)(to->pSubpasses + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pDependencies = nullptr;
- if (from->pDependencies)
- {
- to->pDependencies = (VkSubpassDependency*)alloc->alloc(from->dependencyCount * sizeof(const VkSubpassDependency));
+ if (from->pDependencies) {
+ to->pDependencies = (VkSubpassDependency*)alloc->alloc(
+ from->dependencyCount * sizeof(const VkSubpassDependency));
to->dependencyCount = from->dependencyCount;
- for (uint32_t i = 0; i < (uint32_t)from->dependencyCount; ++i)
- {
- deepcopy_VkSubpassDependency(alloc, rootType, from->pDependencies + i, (VkSubpassDependency*)(to->pDependencies + i));
+ for (uint32_t i = 0; i < (uint32_t)from->dependencyCount; ++i) {
+ deepcopy_VkSubpassDependency(alloc, rootType, from->pDependencies + i,
+ (VkSubpassDependency*)(to->pDependencies + i));
}
}
}
}
-void deepcopy_VkCommandPoolCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCommandPoolCreateInfo* from,
- VkCommandPoolCreateInfo* to)
-{
+void deepcopy_VkCommandPoolCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkCommandPoolCreateInfo* from,
+ VkCommandPoolCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkCommandBufferAllocateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCommandBufferAllocateInfo* from,
- VkCommandBufferAllocateInfo* to)
-{
+void deepcopy_VkCommandBufferAllocateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkCommandBufferAllocateInfo* from,
+ VkCommandBufferAllocateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkCommandBufferInheritanceInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCommandBufferInheritanceInfo* from,
- VkCommandBufferInheritanceInfo* to)
-{
+void deepcopy_VkCommandBufferInheritanceInfo(Allocator* alloc, VkStructureType rootType,
+ const VkCommandBufferInheritanceInfo* from,
+ VkCommandBufferInheritanceInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkCommandBufferBeginInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCommandBufferBeginInfo* from,
- VkCommandBufferBeginInfo* to)
-{
+void deepcopy_VkCommandBufferBeginInfo(Allocator* alloc, VkStructureType rootType,
+ const VkCommandBufferBeginInfo* from,
+ VkCommandBufferBeginInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pInheritanceInfo = nullptr;
- if (from->pInheritanceInfo)
- {
- to->pInheritanceInfo = (VkCommandBufferInheritanceInfo*)alloc->alloc(sizeof(const VkCommandBufferInheritanceInfo));
- deepcopy_VkCommandBufferInheritanceInfo(alloc, rootType, from->pInheritanceInfo, (VkCommandBufferInheritanceInfo*)(to->pInheritanceInfo));
+ if (from->pInheritanceInfo) {
+ to->pInheritanceInfo = (VkCommandBufferInheritanceInfo*)alloc->alloc(
+ sizeof(const VkCommandBufferInheritanceInfo));
+ deepcopy_VkCommandBufferInheritanceInfo(
+ alloc, rootType, from->pInheritanceInfo,
+ (VkCommandBufferInheritanceInfo*)(to->pInheritanceInfo));
}
}
-void deepcopy_VkBufferCopy(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferCopy* from,
- VkBufferCopy* to)
-{
+void deepcopy_VkBufferCopy(Allocator* alloc, VkStructureType rootType, const VkBufferCopy* from,
+ VkBufferCopy* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkImageSubresourceLayers(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageSubresourceLayers* from,
- VkImageSubresourceLayers* to)
-{
+void deepcopy_VkImageSubresourceLayers(Allocator* alloc, VkStructureType rootType,
+ const VkImageSubresourceLayers* from,
+ VkImageSubresourceLayers* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkBufferImageCopy(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferImageCopy* from,
- VkBufferImageCopy* to)
-{
+void deepcopy_VkBufferImageCopy(Allocator* alloc, VkStructureType rootType,
+ const VkBufferImageCopy* from, VkBufferImageCopy* to) {
(void)alloc;
(void)rootType;
*to = *from;
- deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->imageSubresource, (VkImageSubresourceLayers*)(&to->imageSubresource));
+ deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->imageSubresource,
+ (VkImageSubresourceLayers*)(&to->imageSubresource));
deepcopy_VkOffset3D(alloc, rootType, &from->imageOffset, (VkOffset3D*)(&to->imageOffset));
deepcopy_VkExtent3D(alloc, rootType, &from->imageExtent, (VkExtent3D*)(&to->imageExtent));
}
-void deepcopy_VkClearColorValue(
- Allocator* alloc,
- VkStructureType rootType,
- const VkClearColorValue* from,
- VkClearColorValue* to)
-{
+void deepcopy_VkClearColorValue(Allocator* alloc, VkStructureType rootType,
+ const VkClearColorValue* from, VkClearColorValue* to) {
(void)alloc;
(void)rootType;
*to = *from;
@@ -2575,144 +2091,116 @@
memcpy(to->uint32, from->uint32, 4 * sizeof(uint32_t));
}
-void deepcopy_VkClearDepthStencilValue(
- Allocator* alloc,
- VkStructureType rootType,
- const VkClearDepthStencilValue* from,
- VkClearDepthStencilValue* to)
-{
+void deepcopy_VkClearDepthStencilValue(Allocator* alloc, VkStructureType rootType,
+ const VkClearDepthStencilValue* from,
+ VkClearDepthStencilValue* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkClearValue(
- Allocator* alloc,
- VkStructureType rootType,
- const VkClearValue* from,
- VkClearValue* to)
-{
+void deepcopy_VkClearValue(Allocator* alloc, VkStructureType rootType, const VkClearValue* from,
+ VkClearValue* to) {
(void)alloc;
(void)rootType;
*to = *from;
deepcopy_VkClearColorValue(alloc, rootType, &from->color, (VkClearColorValue*)(&to->color));
- deepcopy_VkClearDepthStencilValue(alloc, rootType, &from->depthStencil, (VkClearDepthStencilValue*)(&to->depthStencil));
+ deepcopy_VkClearDepthStencilValue(alloc, rootType, &from->depthStencil,
+ (VkClearDepthStencilValue*)(&to->depthStencil));
}
-void deepcopy_VkClearAttachment(
- Allocator* alloc,
- VkStructureType rootType,
- const VkClearAttachment* from,
- VkClearAttachment* to)
-{
+void deepcopy_VkClearAttachment(Allocator* alloc, VkStructureType rootType,
+ const VkClearAttachment* from, VkClearAttachment* to) {
(void)alloc;
(void)rootType;
*to = *from;
deepcopy_VkClearValue(alloc, rootType, &from->clearValue, (VkClearValue*)(&to->clearValue));
}
-void deepcopy_VkClearRect(
- Allocator* alloc,
- VkStructureType rootType,
- const VkClearRect* from,
- VkClearRect* to)
-{
+void deepcopy_VkClearRect(Allocator* alloc, VkStructureType rootType, const VkClearRect* from,
+ VkClearRect* to) {
(void)alloc;
(void)rootType;
*to = *from;
deepcopy_VkRect2D(alloc, rootType, &from->rect, (VkRect2D*)(&to->rect));
}
-void deepcopy_VkImageBlit(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageBlit* from,
- VkImageBlit* to)
-{
+void deepcopy_VkImageBlit(Allocator* alloc, VkStructureType rootType, const VkImageBlit* from,
+ VkImageBlit* to) {
(void)alloc;
(void)rootType;
*to = *from;
- deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
- deepcopy_VkOffset3D(alloc, rootType, from->srcOffsets + i, (VkOffset3D*)(to->srcOffsets + i));
+ deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->srcSubresource,
+ (VkImageSubresourceLayers*)(&to->srcSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+ deepcopy_VkOffset3D(alloc, rootType, from->srcOffsets + i,
+ (VkOffset3D*)(to->srcOffsets + i));
}
- deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
- deepcopy_VkOffset3D(alloc, rootType, from->dstOffsets + i, (VkOffset3D*)(to->dstOffsets + i));
+ deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->dstSubresource,
+ (VkImageSubresourceLayers*)(&to->dstSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+ deepcopy_VkOffset3D(alloc, rootType, from->dstOffsets + i,
+ (VkOffset3D*)(to->dstOffsets + i));
}
}
-void deepcopy_VkImageCopy(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageCopy* from,
- VkImageCopy* to)
-{
+void deepcopy_VkImageCopy(Allocator* alloc, VkStructureType rootType, const VkImageCopy* from,
+ VkImageCopy* to) {
(void)alloc;
(void)rootType;
*to = *from;
- deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
+ deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->srcSubresource,
+ (VkImageSubresourceLayers*)(&to->srcSubresource));
deepcopy_VkOffset3D(alloc, rootType, &from->srcOffset, (VkOffset3D*)(&to->srcOffset));
- deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
+ deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->dstSubresource,
+ (VkImageSubresourceLayers*)(&to->dstSubresource));
deepcopy_VkOffset3D(alloc, rootType, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
deepcopy_VkExtent3D(alloc, rootType, &from->extent, (VkExtent3D*)(&to->extent));
}
-void deepcopy_VkImageResolve(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageResolve* from,
- VkImageResolve* to)
-{
+void deepcopy_VkImageResolve(Allocator* alloc, VkStructureType rootType, const VkImageResolve* from,
+ VkImageResolve* to) {
(void)alloc;
(void)rootType;
*to = *from;
- deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
+ deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->srcSubresource,
+ (VkImageSubresourceLayers*)(&to->srcSubresource));
deepcopy_VkOffset3D(alloc, rootType, &from->srcOffset, (VkOffset3D*)(&to->srcOffset));
- deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
+ deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->dstSubresource,
+ (VkImageSubresourceLayers*)(&to->dstSubresource));
deepcopy_VkOffset3D(alloc, rootType, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
deepcopy_VkExtent3D(alloc, rootType, &from->extent, (VkExtent3D*)(&to->extent));
}
-void deepcopy_VkRenderPassBeginInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRenderPassBeginInfo* from,
- VkRenderPassBeginInfo* to)
-{
+void deepcopy_VkRenderPassBeginInfo(Allocator* alloc, VkStructureType rootType,
+ const VkRenderPassBeginInfo* from, VkRenderPassBeginInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
deepcopy_VkRect2D(alloc, rootType, &from->renderArea, (VkRect2D*)(&to->renderArea));
- if (from)
- {
+ if (from) {
to->pClearValues = nullptr;
- if (from->pClearValues)
- {
- to->pClearValues = (VkClearValue*)alloc->alloc(from->clearValueCount * sizeof(const VkClearValue));
+ if (from->pClearValues) {
+ to->pClearValues =
+ (VkClearValue*)alloc->alloc(from->clearValueCount * sizeof(const VkClearValue));
to->clearValueCount = from->clearValueCount;
- for (uint32_t i = 0; i < (uint32_t)from->clearValueCount; ++i)
- {
- deepcopy_VkClearValue(alloc, rootType, from->pClearValues + i, (VkClearValue*)(to->pClearValues + i));
+ for (uint32_t i = 0; i < (uint32_t)from->clearValueCount; ++i) {
+ deepcopy_VkClearValue(alloc, rootType, from->pClearValues + i,
+ (VkClearValue*)(to->pClearValues + i));
}
}
}
@@ -2720,1628 +2208,1318 @@
#endif
#ifdef VK_VERSION_1_1
-void deepcopy_VkPhysicalDeviceSubgroupProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceSubgroupProperties* from,
- VkPhysicalDeviceSubgroupProperties* to)
-{
+void deepcopy_VkPhysicalDeviceSubgroupProperties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceSubgroupProperties* from,
+ VkPhysicalDeviceSubgroupProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkBindBufferMemoryInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindBufferMemoryInfo* from,
- VkBindBufferMemoryInfo* to)
-{
+void deepcopy_VkBindBufferMemoryInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBindBufferMemoryInfo* from,
+ VkBindBufferMemoryInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkBindImageMemoryInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindImageMemoryInfo* from,
- VkBindImageMemoryInfo* to)
-{
+void deepcopy_VkBindImageMemoryInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBindImageMemoryInfo* from, VkBindImageMemoryInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkPhysicalDevice16BitStorageFeatures(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDevice16BitStorageFeatures* from,
- VkPhysicalDevice16BitStorageFeatures* to)
-{
+void deepcopy_VkPhysicalDevice16BitStorageFeatures(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDevice16BitStorageFeatures* from,
+ VkPhysicalDevice16BitStorageFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkMemoryDedicatedRequirements(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryDedicatedRequirements* from,
- VkMemoryDedicatedRequirements* to)
-{
+void deepcopy_VkMemoryDedicatedRequirements(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryDedicatedRequirements* from,
+ VkMemoryDedicatedRequirements* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkMemoryDedicatedAllocateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryDedicatedAllocateInfo* from,
- VkMemoryDedicatedAllocateInfo* to)
-{
+void deepcopy_VkMemoryDedicatedAllocateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryDedicatedAllocateInfo* from,
+ VkMemoryDedicatedAllocateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkMemoryAllocateFlagsInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryAllocateFlagsInfo* from,
- VkMemoryAllocateFlagsInfo* to)
-{
+void deepcopy_VkMemoryAllocateFlagsInfo(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryAllocateFlagsInfo* from,
+ VkMemoryAllocateFlagsInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkDeviceGroupRenderPassBeginInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceGroupRenderPassBeginInfo* from,
- VkDeviceGroupRenderPassBeginInfo* to)
-{
+void deepcopy_VkDeviceGroupRenderPassBeginInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceGroupRenderPassBeginInfo* from,
+ VkDeviceGroupRenderPassBeginInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pDeviceRenderAreas = nullptr;
- if (from->pDeviceRenderAreas)
- {
- to->pDeviceRenderAreas = (VkRect2D*)alloc->alloc(from->deviceRenderAreaCount * sizeof(const VkRect2D));
+ if (from->pDeviceRenderAreas) {
+ to->pDeviceRenderAreas =
+ (VkRect2D*)alloc->alloc(from->deviceRenderAreaCount * sizeof(const VkRect2D));
to->deviceRenderAreaCount = from->deviceRenderAreaCount;
- for (uint32_t i = 0; i < (uint32_t)from->deviceRenderAreaCount; ++i)
- {
- deepcopy_VkRect2D(alloc, rootType, from->pDeviceRenderAreas + i, (VkRect2D*)(to->pDeviceRenderAreas + i));
+ for (uint32_t i = 0; i < (uint32_t)from->deviceRenderAreaCount; ++i) {
+ deepcopy_VkRect2D(alloc, rootType, from->pDeviceRenderAreas + i,
+ (VkRect2D*)(to->pDeviceRenderAreas + i));
}
}
}
}
-void deepcopy_VkDeviceGroupCommandBufferBeginInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceGroupCommandBufferBeginInfo* from,
- VkDeviceGroupCommandBufferBeginInfo* to)
-{
+void deepcopy_VkDeviceGroupCommandBufferBeginInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceGroupCommandBufferBeginInfo* from,
+ VkDeviceGroupCommandBufferBeginInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkDeviceGroupSubmitInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceGroupSubmitInfo* from,
- VkDeviceGroupSubmitInfo* to)
-{
+void deepcopy_VkDeviceGroupSubmitInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceGroupSubmitInfo* from,
+ VkDeviceGroupSubmitInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pWaitSemaphoreDeviceIndices = nullptr;
- if (from->pWaitSemaphoreDeviceIndices)
- {
- to->pWaitSemaphoreDeviceIndices = (uint32_t*)alloc->dupArray(from->pWaitSemaphoreDeviceIndices, from->waitSemaphoreCount * sizeof(const uint32_t));
+ if (from->pWaitSemaphoreDeviceIndices) {
+ to->pWaitSemaphoreDeviceIndices = (uint32_t*)alloc->dupArray(
+ from->pWaitSemaphoreDeviceIndices, from->waitSemaphoreCount * sizeof(const uint32_t));
}
to->pCommandBufferDeviceMasks = nullptr;
- if (from->pCommandBufferDeviceMasks)
- {
- to->pCommandBufferDeviceMasks = (uint32_t*)alloc->dupArray(from->pCommandBufferDeviceMasks, from->commandBufferCount * sizeof(const uint32_t));
+ if (from->pCommandBufferDeviceMasks) {
+ to->pCommandBufferDeviceMasks = (uint32_t*)alloc->dupArray(
+ from->pCommandBufferDeviceMasks, from->commandBufferCount * sizeof(const uint32_t));
}
to->pSignalSemaphoreDeviceIndices = nullptr;
- if (from->pSignalSemaphoreDeviceIndices)
- {
- to->pSignalSemaphoreDeviceIndices = (uint32_t*)alloc->dupArray(from->pSignalSemaphoreDeviceIndices, from->signalSemaphoreCount * sizeof(const uint32_t));
+ if (from->pSignalSemaphoreDeviceIndices) {
+ to->pSignalSemaphoreDeviceIndices =
+ (uint32_t*)alloc->dupArray(from->pSignalSemaphoreDeviceIndices,
+ from->signalSemaphoreCount * sizeof(const uint32_t));
}
}
-void deepcopy_VkDeviceGroupBindSparseInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceGroupBindSparseInfo* from,
- VkDeviceGroupBindSparseInfo* to)
-{
+void deepcopy_VkDeviceGroupBindSparseInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceGroupBindSparseInfo* from,
+ VkDeviceGroupBindSparseInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkBindBufferMemoryDeviceGroupInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindBufferMemoryDeviceGroupInfo* from,
- VkBindBufferMemoryDeviceGroupInfo* to)
-{
+void deepcopy_VkBindBufferMemoryDeviceGroupInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBindBufferMemoryDeviceGroupInfo* from,
+ VkBindBufferMemoryDeviceGroupInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pDeviceIndices = nullptr;
- if (from->pDeviceIndices)
- {
- to->pDeviceIndices = (uint32_t*)alloc->dupArray(from->pDeviceIndices, from->deviceIndexCount * sizeof(const uint32_t));
+ if (from->pDeviceIndices) {
+ to->pDeviceIndices = (uint32_t*)alloc->dupArray(
+ from->pDeviceIndices, from->deviceIndexCount * sizeof(const uint32_t));
}
}
-void deepcopy_VkBindImageMemoryDeviceGroupInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindImageMemoryDeviceGroupInfo* from,
- VkBindImageMemoryDeviceGroupInfo* to)
-{
+void deepcopy_VkBindImageMemoryDeviceGroupInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBindImageMemoryDeviceGroupInfo* from,
+ VkBindImageMemoryDeviceGroupInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pDeviceIndices = nullptr;
- if (from->pDeviceIndices)
- {
- to->pDeviceIndices = (uint32_t*)alloc->dupArray(from->pDeviceIndices, from->deviceIndexCount * sizeof(const uint32_t));
+ if (from->pDeviceIndices) {
+ to->pDeviceIndices = (uint32_t*)alloc->dupArray(
+ from->pDeviceIndices, from->deviceIndexCount * sizeof(const uint32_t));
}
- if (from)
- {
+ if (from) {
to->pSplitInstanceBindRegions = nullptr;
- if (from->pSplitInstanceBindRegions)
- {
- to->pSplitInstanceBindRegions = (VkRect2D*)alloc->alloc(from->splitInstanceBindRegionCount * sizeof(const VkRect2D));
+ if (from->pSplitInstanceBindRegions) {
+ to->pSplitInstanceBindRegions = (VkRect2D*)alloc->alloc(
+ from->splitInstanceBindRegionCount * sizeof(const VkRect2D));
to->splitInstanceBindRegionCount = from->splitInstanceBindRegionCount;
- for (uint32_t i = 0; i < (uint32_t)from->splitInstanceBindRegionCount; ++i)
- {
- deepcopy_VkRect2D(alloc, rootType, from->pSplitInstanceBindRegions + i, (VkRect2D*)(to->pSplitInstanceBindRegions + i));
+ for (uint32_t i = 0; i < (uint32_t)from->splitInstanceBindRegionCount; ++i) {
+ deepcopy_VkRect2D(alloc, rootType, from->pSplitInstanceBindRegions + i,
+ (VkRect2D*)(to->pSplitInstanceBindRegions + i));
}
}
}
}
-void deepcopy_VkPhysicalDeviceGroupProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceGroupProperties* from,
- VkPhysicalDeviceGroupProperties* to)
-{
+void deepcopy_VkPhysicalDeviceGroupProperties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceGroupProperties* from,
+ VkPhysicalDeviceGroupProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- memcpy(to->physicalDevices, from->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice));
+ memcpy(to->physicalDevices, from->physicalDevices,
+ VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice));
}
-void deepcopy_VkDeviceGroupDeviceCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceGroupDeviceCreateInfo* from,
- VkDeviceGroupDeviceCreateInfo* to)
-{
+void deepcopy_VkDeviceGroupDeviceCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceGroupDeviceCreateInfo* from,
+ VkDeviceGroupDeviceCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pPhysicalDevices = nullptr;
- if (from->pPhysicalDevices)
- {
- to->pPhysicalDevices = (VkPhysicalDevice*)alloc->dupArray(from->pPhysicalDevices, from->physicalDeviceCount * sizeof(const VkPhysicalDevice));
+ if (from->pPhysicalDevices) {
+ to->pPhysicalDevices = (VkPhysicalDevice*)alloc->dupArray(
+ from->pPhysicalDevices, from->physicalDeviceCount * sizeof(const VkPhysicalDevice));
}
}
-void deepcopy_VkBufferMemoryRequirementsInfo2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferMemoryRequirementsInfo2* from,
- VkBufferMemoryRequirementsInfo2* to)
-{
+void deepcopy_VkBufferMemoryRequirementsInfo2(Allocator* alloc, VkStructureType rootType,
+ const VkBufferMemoryRequirementsInfo2* from,
+ VkBufferMemoryRequirementsInfo2* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkImageMemoryRequirementsInfo2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageMemoryRequirementsInfo2* from,
- VkImageMemoryRequirementsInfo2* to)
-{
+void deepcopy_VkImageMemoryRequirementsInfo2(Allocator* alloc, VkStructureType rootType,
+ const VkImageMemoryRequirementsInfo2* from,
+ VkImageMemoryRequirementsInfo2* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkImageSparseMemoryRequirementsInfo2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageSparseMemoryRequirementsInfo2* from,
- VkImageSparseMemoryRequirementsInfo2* to)
-{
+void deepcopy_VkImageSparseMemoryRequirementsInfo2(Allocator* alloc, VkStructureType rootType,
+ const VkImageSparseMemoryRequirementsInfo2* from,
+ VkImageSparseMemoryRequirementsInfo2* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkMemoryRequirements2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryRequirements2* from,
- VkMemoryRequirements2* to)
-{
+void deepcopy_VkMemoryRequirements2(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryRequirements2* from, VkMemoryRequirements2* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkMemoryRequirements(alloc, rootType, &from->memoryRequirements, (VkMemoryRequirements*)(&to->memoryRequirements));
+ deepcopy_VkMemoryRequirements(alloc, rootType, &from->memoryRequirements,
+ (VkMemoryRequirements*)(&to->memoryRequirements));
}
-void deepcopy_VkSparseImageMemoryRequirements2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSparseImageMemoryRequirements2* from,
- VkSparseImageMemoryRequirements2* to)
-{
+void deepcopy_VkSparseImageMemoryRequirements2(Allocator* alloc, VkStructureType rootType,
+ const VkSparseImageMemoryRequirements2* from,
+ VkSparseImageMemoryRequirements2* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkSparseImageMemoryRequirements(alloc, rootType, &from->memoryRequirements, (VkSparseImageMemoryRequirements*)(&to->memoryRequirements));
+ deepcopy_VkSparseImageMemoryRequirements(
+ alloc, rootType, &from->memoryRequirements,
+ (VkSparseImageMemoryRequirements*)(&to->memoryRequirements));
}
-void deepcopy_VkPhysicalDeviceFeatures2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceFeatures2* from,
- VkPhysicalDeviceFeatures2* to)
-{
+void deepcopy_VkPhysicalDeviceFeatures2(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceFeatures2* from,
+ VkPhysicalDeviceFeatures2* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkPhysicalDeviceFeatures(alloc, rootType, &from->features, (VkPhysicalDeviceFeatures*)(&to->features));
+ deepcopy_VkPhysicalDeviceFeatures(alloc, rootType, &from->features,
+ (VkPhysicalDeviceFeatures*)(&to->features));
}
-void deepcopy_VkPhysicalDeviceProperties2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceProperties2* from,
- VkPhysicalDeviceProperties2* to)
-{
+void deepcopy_VkPhysicalDeviceProperties2(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceProperties2* from,
+ VkPhysicalDeviceProperties2* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkPhysicalDeviceProperties(alloc, rootType, &from->properties, (VkPhysicalDeviceProperties*)(&to->properties));
+ deepcopy_VkPhysicalDeviceProperties(alloc, rootType, &from->properties,
+ (VkPhysicalDeviceProperties*)(&to->properties));
}
-void deepcopy_VkFormatProperties2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFormatProperties2* from,
- VkFormatProperties2* to)
-{
+void deepcopy_VkFormatProperties2(Allocator* alloc, VkStructureType rootType,
+ const VkFormatProperties2* from, VkFormatProperties2* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkFormatProperties(alloc, rootType, &from->formatProperties, (VkFormatProperties*)(&to->formatProperties));
+ deepcopy_VkFormatProperties(alloc, rootType, &from->formatProperties,
+ (VkFormatProperties*)(&to->formatProperties));
}
-void deepcopy_VkImageFormatProperties2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageFormatProperties2* from,
- VkImageFormatProperties2* to)
-{
+void deepcopy_VkImageFormatProperties2(Allocator* alloc, VkStructureType rootType,
+ const VkImageFormatProperties2* from,
+ VkImageFormatProperties2* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkImageFormatProperties(alloc, rootType, &from->imageFormatProperties, (VkImageFormatProperties*)(&to->imageFormatProperties));
+ deepcopy_VkImageFormatProperties(alloc, rootType, &from->imageFormatProperties,
+ (VkImageFormatProperties*)(&to->imageFormatProperties));
}
-void deepcopy_VkPhysicalDeviceImageFormatInfo2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceImageFormatInfo2* from,
- VkPhysicalDeviceImageFormatInfo2* to)
-{
+void deepcopy_VkPhysicalDeviceImageFormatInfo2(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceImageFormatInfo2* from,
+ VkPhysicalDeviceImageFormatInfo2* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkQueueFamilyProperties2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkQueueFamilyProperties2* from,
- VkQueueFamilyProperties2* to)
-{
+void deepcopy_VkQueueFamilyProperties2(Allocator* alloc, VkStructureType rootType,
+ const VkQueueFamilyProperties2* from,
+ VkQueueFamilyProperties2* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkQueueFamilyProperties(alloc, rootType, &from->queueFamilyProperties, (VkQueueFamilyProperties*)(&to->queueFamilyProperties));
+ deepcopy_VkQueueFamilyProperties(alloc, rootType, &from->queueFamilyProperties,
+ (VkQueueFamilyProperties*)(&to->queueFamilyProperties));
}
-void deepcopy_VkPhysicalDeviceMemoryProperties2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryProperties2* from,
- VkPhysicalDeviceMemoryProperties2* to)
-{
+void deepcopy_VkPhysicalDeviceMemoryProperties2(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryProperties2* from,
+ VkPhysicalDeviceMemoryProperties2* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkPhysicalDeviceMemoryProperties(alloc, rootType, &from->memoryProperties, (VkPhysicalDeviceMemoryProperties*)(&to->memoryProperties));
+ deepcopy_VkPhysicalDeviceMemoryProperties(
+ alloc, rootType, &from->memoryProperties,
+ (VkPhysicalDeviceMemoryProperties*)(&to->memoryProperties));
}
-void deepcopy_VkSparseImageFormatProperties2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSparseImageFormatProperties2* from,
- VkSparseImageFormatProperties2* to)
-{
+void deepcopy_VkSparseImageFormatProperties2(Allocator* alloc, VkStructureType rootType,
+ const VkSparseImageFormatProperties2* from,
+ VkSparseImageFormatProperties2* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkSparseImageFormatProperties(alloc, rootType, &from->properties, (VkSparseImageFormatProperties*)(&to->properties));
+ deepcopy_VkSparseImageFormatProperties(alloc, rootType, &from->properties,
+ (VkSparseImageFormatProperties*)(&to->properties));
}
void deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceSparseImageFormatInfo2* from,
- VkPhysicalDeviceSparseImageFormatInfo2* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceSparseImageFormatInfo2* from,
+ VkPhysicalDeviceSparseImageFormatInfo2* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDevicePointClippingProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDevicePointClippingProperties* from,
- VkPhysicalDevicePointClippingProperties* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDevicePointClippingProperties* from,
+ VkPhysicalDevicePointClippingProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkInputAttachmentAspectReference(
- Allocator* alloc,
- VkStructureType rootType,
- const VkInputAttachmentAspectReference* from,
- VkInputAttachmentAspectReference* to)
-{
+void deepcopy_VkInputAttachmentAspectReference(Allocator* alloc, VkStructureType rootType,
+ const VkInputAttachmentAspectReference* from,
+ VkInputAttachmentAspectReference* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
void deepcopy_VkRenderPassInputAttachmentAspectCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkRenderPassInputAttachmentAspectCreateInfo* from,
- VkRenderPassInputAttachmentAspectCreateInfo* to)
-{
+ VkRenderPassInputAttachmentAspectCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pAspectReferences = nullptr;
- if (from->pAspectReferences)
- {
- to->pAspectReferences = (VkInputAttachmentAspectReference*)alloc->alloc(from->aspectReferenceCount * sizeof(const VkInputAttachmentAspectReference));
+ if (from->pAspectReferences) {
+ to->pAspectReferences = (VkInputAttachmentAspectReference*)alloc->alloc(
+ from->aspectReferenceCount * sizeof(const VkInputAttachmentAspectReference));
to->aspectReferenceCount = from->aspectReferenceCount;
- for (uint32_t i = 0; i < (uint32_t)from->aspectReferenceCount; ++i)
- {
- deepcopy_VkInputAttachmentAspectReference(alloc, rootType, from->pAspectReferences + i, (VkInputAttachmentAspectReference*)(to->pAspectReferences + i));
+ for (uint32_t i = 0; i < (uint32_t)from->aspectReferenceCount; ++i) {
+ deepcopy_VkInputAttachmentAspectReference(
+ alloc, rootType, from->pAspectReferences + i,
+ (VkInputAttachmentAspectReference*)(to->pAspectReferences + i));
}
}
}
}
-void deepcopy_VkImageViewUsageCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageViewUsageCreateInfo* from,
- VkImageViewUsageCreateInfo* to)
-{
+void deepcopy_VkImageViewUsageCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkImageViewUsageCreateInfo* from,
+ VkImageViewUsageCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineTessellationDomainOriginStateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineTessellationDomainOriginStateCreateInfo* from,
- VkPipelineTessellationDomainOriginStateCreateInfo* to)
-{
+ VkPipelineTessellationDomainOriginStateCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkRenderPassMultiviewCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRenderPassMultiviewCreateInfo* from,
- VkRenderPassMultiviewCreateInfo* to)
-{
+void deepcopy_VkRenderPassMultiviewCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkRenderPassMultiviewCreateInfo* from,
+ VkRenderPassMultiviewCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pViewMasks = nullptr;
- if (from->pViewMasks)
- {
- to->pViewMasks = (uint32_t*)alloc->dupArray(from->pViewMasks, from->subpassCount * sizeof(const uint32_t));
+ if (from->pViewMasks) {
+ to->pViewMasks = (uint32_t*)alloc->dupArray(from->pViewMasks,
+ from->subpassCount * sizeof(const uint32_t));
}
to->pViewOffsets = nullptr;
- if (from->pViewOffsets)
- {
- to->pViewOffsets = (int32_t*)alloc->dupArray(from->pViewOffsets, from->dependencyCount * sizeof(const int32_t));
+ if (from->pViewOffsets) {
+ to->pViewOffsets = (int32_t*)alloc->dupArray(from->pViewOffsets,
+ from->dependencyCount * sizeof(const int32_t));
}
to->pCorrelationMasks = nullptr;
- if (from->pCorrelationMasks)
- {
- to->pCorrelationMasks = (uint32_t*)alloc->dupArray(from->pCorrelationMasks, from->correlationMaskCount * sizeof(const uint32_t));
+ if (from->pCorrelationMasks) {
+ to->pCorrelationMasks = (uint32_t*)alloc->dupArray(
+ from->pCorrelationMasks, from->correlationMaskCount * sizeof(const uint32_t));
}
}
-void deepcopy_VkPhysicalDeviceMultiviewFeatures(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiviewFeatures* from,
- VkPhysicalDeviceMultiviewFeatures* to)
-{
+void deepcopy_VkPhysicalDeviceMultiviewFeatures(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceMultiviewFeatures* from,
+ VkPhysicalDeviceMultiviewFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkPhysicalDeviceMultiviewProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiviewProperties* from,
- VkPhysicalDeviceMultiviewProperties* to)
-{
+void deepcopy_VkPhysicalDeviceMultiviewProperties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceMultiviewProperties* from,
+ VkPhysicalDeviceMultiviewProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceVariablePointersFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceVariablePointersFeatures* from,
- VkPhysicalDeviceVariablePointersFeatures* to)
-{
+ VkPhysicalDeviceVariablePointersFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceProtectedMemoryFeatures(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceProtectedMemoryFeatures* from,
- VkPhysicalDeviceProtectedMemoryFeatures* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceProtectedMemoryFeatures* from,
+ VkPhysicalDeviceProtectedMemoryFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceProtectedMemoryProperties(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceProtectedMemoryProperties* from,
- VkPhysicalDeviceProtectedMemoryProperties* to)
-{
+ VkPhysicalDeviceProtectedMemoryProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkDeviceQueueInfo2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceQueueInfo2* from,
- VkDeviceQueueInfo2* to)
-{
+void deepcopy_VkDeviceQueueInfo2(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceQueueInfo2* from, VkDeviceQueueInfo2* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkProtectedSubmitInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkProtectedSubmitInfo* from,
- VkProtectedSubmitInfo* to)
-{
+void deepcopy_VkProtectedSubmitInfo(Allocator* alloc, VkStructureType rootType,
+ const VkProtectedSubmitInfo* from, VkProtectedSubmitInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkSamplerYcbcrConversionCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSamplerYcbcrConversionCreateInfo* from,
- VkSamplerYcbcrConversionCreateInfo* to)
-{
+void deepcopy_VkSamplerYcbcrConversionCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSamplerYcbcrConversionCreateInfo* from,
+ VkSamplerYcbcrConversionCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkComponentMapping(alloc, rootType, &from->components, (VkComponentMapping*)(&to->components));
+ deepcopy_VkComponentMapping(alloc, rootType, &from->components,
+ (VkComponentMapping*)(&to->components));
}
-void deepcopy_VkSamplerYcbcrConversionInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSamplerYcbcrConversionInfo* from,
- VkSamplerYcbcrConversionInfo* to)
-{
+void deepcopy_VkSamplerYcbcrConversionInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSamplerYcbcrConversionInfo* from,
+ VkSamplerYcbcrConversionInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkBindImagePlaneMemoryInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindImagePlaneMemoryInfo* from,
- VkBindImagePlaneMemoryInfo* to)
-{
+void deepcopy_VkBindImagePlaneMemoryInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBindImagePlaneMemoryInfo* from,
+ VkBindImagePlaneMemoryInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkImagePlaneMemoryRequirementsInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImagePlaneMemoryRequirementsInfo* from,
- VkImagePlaneMemoryRequirementsInfo* to)
-{
+void deepcopy_VkImagePlaneMemoryRequirementsInfo(Allocator* alloc, VkStructureType rootType,
+ const VkImagePlaneMemoryRequirementsInfo* from,
+ VkImagePlaneMemoryRequirementsInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceSamplerYcbcrConversionFeatures* from,
- VkPhysicalDeviceSamplerYcbcrConversionFeatures* to)
-{
+ VkPhysicalDeviceSamplerYcbcrConversionFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSamplerYcbcrConversionImageFormatProperties(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkSamplerYcbcrConversionImageFormatProperties* from,
- VkSamplerYcbcrConversionImageFormatProperties* to)
-{
+ VkSamplerYcbcrConversionImageFormatProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkDescriptorUpdateTemplateEntry(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDescriptorUpdateTemplateEntry* from,
- VkDescriptorUpdateTemplateEntry* to)
-{
+void deepcopy_VkDescriptorUpdateTemplateEntry(Allocator* alloc, VkStructureType rootType,
+ const VkDescriptorUpdateTemplateEntry* from,
+ VkDescriptorUpdateTemplateEntry* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkDescriptorUpdateTemplateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDescriptorUpdateTemplateCreateInfo* from,
- VkDescriptorUpdateTemplateCreateInfo* to)
-{
+void deepcopy_VkDescriptorUpdateTemplateCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDescriptorUpdateTemplateCreateInfo* from,
+ VkDescriptorUpdateTemplateCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pDescriptorUpdateEntries = nullptr;
- if (from->pDescriptorUpdateEntries)
- {
- to->pDescriptorUpdateEntries = (VkDescriptorUpdateTemplateEntry*)alloc->alloc(from->descriptorUpdateEntryCount * sizeof(const VkDescriptorUpdateTemplateEntry));
+ if (from->pDescriptorUpdateEntries) {
+ to->pDescriptorUpdateEntries = (VkDescriptorUpdateTemplateEntry*)alloc->alloc(
+ from->descriptorUpdateEntryCount * sizeof(const VkDescriptorUpdateTemplateEntry));
to->descriptorUpdateEntryCount = from->descriptorUpdateEntryCount;
- for (uint32_t i = 0; i < (uint32_t)from->descriptorUpdateEntryCount; ++i)
- {
- deepcopy_VkDescriptorUpdateTemplateEntry(alloc, rootType, from->pDescriptorUpdateEntries + i, (VkDescriptorUpdateTemplateEntry*)(to->pDescriptorUpdateEntries + i));
+ for (uint32_t i = 0; i < (uint32_t)from->descriptorUpdateEntryCount; ++i) {
+ deepcopy_VkDescriptorUpdateTemplateEntry(
+ alloc, rootType, from->pDescriptorUpdateEntries + i,
+ (VkDescriptorUpdateTemplateEntry*)(to->pDescriptorUpdateEntries + i));
}
}
}
}
-void deepcopy_VkExternalMemoryProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExternalMemoryProperties* from,
- VkExternalMemoryProperties* to)
-{
+void deepcopy_VkExternalMemoryProperties(Allocator* alloc, VkStructureType rootType,
+ const VkExternalMemoryProperties* from,
+ VkExternalMemoryProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
void deepcopy_VkPhysicalDeviceExternalImageFormatInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalImageFormatInfo* from,
- VkPhysicalDeviceExternalImageFormatInfo* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceExternalImageFormatInfo* from,
+ VkPhysicalDeviceExternalImageFormatInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkExternalImageFormatProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExternalImageFormatProperties* from,
- VkExternalImageFormatProperties* to)
-{
+void deepcopy_VkExternalImageFormatProperties(Allocator* alloc, VkStructureType rootType,
+ const VkExternalImageFormatProperties* from,
+ VkExternalImageFormatProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExternalMemoryProperties(alloc, rootType, &from->externalMemoryProperties, (VkExternalMemoryProperties*)(&to->externalMemoryProperties));
+ deepcopy_VkExternalMemoryProperties(
+ alloc, rootType, &from->externalMemoryProperties,
+ (VkExternalMemoryProperties*)(&to->externalMemoryProperties));
}
-void deepcopy_VkPhysicalDeviceExternalBufferInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalBufferInfo* from,
- VkPhysicalDeviceExternalBufferInfo* to)
-{
+void deepcopy_VkPhysicalDeviceExternalBufferInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceExternalBufferInfo* from,
+ VkPhysicalDeviceExternalBufferInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkExternalBufferProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExternalBufferProperties* from,
- VkExternalBufferProperties* to)
-{
+void deepcopy_VkExternalBufferProperties(Allocator* alloc, VkStructureType rootType,
+ const VkExternalBufferProperties* from,
+ VkExternalBufferProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExternalMemoryProperties(alloc, rootType, &from->externalMemoryProperties, (VkExternalMemoryProperties*)(&to->externalMemoryProperties));
+ deepcopy_VkExternalMemoryProperties(
+ alloc, rootType, &from->externalMemoryProperties,
+ (VkExternalMemoryProperties*)(&to->externalMemoryProperties));
}
-void deepcopy_VkPhysicalDeviceIDProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceIDProperties* from,
- VkPhysicalDeviceIDProperties* to)
-{
+void deepcopy_VkPhysicalDeviceIDProperties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceIDProperties* from,
+ VkPhysicalDeviceIDProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -4350,337 +3528,266 @@
memcpy(to->deviceLUID, from->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
}
-void deepcopy_VkExternalMemoryImageCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExternalMemoryImageCreateInfo* from,
- VkExternalMemoryImageCreateInfo* to)
-{
+void deepcopy_VkExternalMemoryImageCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkExternalMemoryImageCreateInfo* from,
+ VkExternalMemoryImageCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkExternalMemoryBufferCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExternalMemoryBufferCreateInfo* from,
- VkExternalMemoryBufferCreateInfo* to)
-{
+void deepcopy_VkExternalMemoryBufferCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkExternalMemoryBufferCreateInfo* from,
+ VkExternalMemoryBufferCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkExportMemoryAllocateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExportMemoryAllocateInfo* from,
- VkExportMemoryAllocateInfo* to)
-{
+void deepcopy_VkExportMemoryAllocateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkExportMemoryAllocateInfo* from,
+ VkExportMemoryAllocateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkPhysicalDeviceExternalFenceInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalFenceInfo* from,
- VkPhysicalDeviceExternalFenceInfo* to)
-{
+void deepcopy_VkPhysicalDeviceExternalFenceInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceExternalFenceInfo* from,
+ VkPhysicalDeviceExternalFenceInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkExternalFenceProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExternalFenceProperties* from,
- VkExternalFenceProperties* to)
-{
+void deepcopy_VkExternalFenceProperties(Allocator* alloc, VkStructureType rootType,
+ const VkExternalFenceProperties* from,
+ VkExternalFenceProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkExportFenceCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExportFenceCreateInfo* from,
- VkExportFenceCreateInfo* to)
-{
+void deepcopy_VkExportFenceCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkExportFenceCreateInfo* from,
+ VkExportFenceCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkExportSemaphoreCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExportSemaphoreCreateInfo* from,
- VkExportSemaphoreCreateInfo* to)
-{
+void deepcopy_VkExportSemaphoreCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkExportSemaphoreCreateInfo* from,
+ VkExportSemaphoreCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalSemaphoreInfo* from,
- VkPhysicalDeviceExternalSemaphoreInfo* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceExternalSemaphoreInfo* from,
+ VkPhysicalDeviceExternalSemaphoreInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkExternalSemaphoreProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExternalSemaphoreProperties* from,
- VkExternalSemaphoreProperties* to)
-{
+void deepcopy_VkExternalSemaphoreProperties(Allocator* alloc, VkStructureType rootType,
+ const VkExternalSemaphoreProperties* from,
+ VkExternalSemaphoreProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceMaintenance3Properties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceMaintenance3Properties* from,
- VkPhysicalDeviceMaintenance3Properties* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMaintenance3Properties* from,
+ VkPhysicalDeviceMaintenance3Properties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkDescriptorSetLayoutSupport(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDescriptorSetLayoutSupport* from,
- VkDescriptorSetLayoutSupport* to)
-{
+void deepcopy_VkDescriptorSetLayoutSupport(Allocator* alloc, VkStructureType rootType,
+ const VkDescriptorSetLayoutSupport* from,
+ VkDescriptorSetLayoutSupport* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceShaderDrawParametersFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderDrawParametersFeatures* from,
- VkPhysicalDeviceShaderDrawParametersFeatures* to)
-{
+ VkPhysicalDeviceShaderDrawParametersFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -4688,57 +3795,45 @@
#endif
#ifdef VK_VERSION_1_2
-void deepcopy_VkPhysicalDeviceVulkan11Features(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan11Features* from,
- VkPhysicalDeviceVulkan11Features* to)
-{
+void deepcopy_VkPhysicalDeviceVulkan11Features(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan11Features* from,
+ VkPhysicalDeviceVulkan11Features* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkPhysicalDeviceVulkan11Properties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan11Properties* from,
- VkPhysicalDeviceVulkan11Properties* to)
-{
+void deepcopy_VkPhysicalDeviceVulkan11Properties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan11Properties* from,
+ VkPhysicalDeviceVulkan11Properties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -4747,1520 +3842,1244 @@
memcpy(to->deviceLUID, from->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t));
}
-void deepcopy_VkPhysicalDeviceVulkan12Features(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan12Features* from,
- VkPhysicalDeviceVulkan12Features* to)
-{
+void deepcopy_VkPhysicalDeviceVulkan12Features(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan12Features* from,
+ VkPhysicalDeviceVulkan12Features* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkConformanceVersion(
- Allocator* alloc,
- VkStructureType rootType,
- const VkConformanceVersion* from,
- VkConformanceVersion* to)
-{
+void deepcopy_VkConformanceVersion(Allocator* alloc, VkStructureType rootType,
+ const VkConformanceVersion* from, VkConformanceVersion* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkPhysicalDeviceVulkan12Properties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan12Properties* from,
- VkPhysicalDeviceVulkan12Properties* to)
-{
+void deepcopy_VkPhysicalDeviceVulkan12Properties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan12Properties* from,
+ VkPhysicalDeviceVulkan12Properties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
memcpy(to->driverName, from->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
memcpy(to->driverInfo, from->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
- deepcopy_VkConformanceVersion(alloc, rootType, &from->conformanceVersion, (VkConformanceVersion*)(&to->conformanceVersion));
+ deepcopy_VkConformanceVersion(alloc, rootType, &from->conformanceVersion,
+ (VkConformanceVersion*)(&to->conformanceVersion));
}
-void deepcopy_VkImageFormatListCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageFormatListCreateInfo* from,
- VkImageFormatListCreateInfo* to)
-{
+void deepcopy_VkImageFormatListCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkImageFormatListCreateInfo* from,
+ VkImageFormatListCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pViewFormats = nullptr;
- if (from->pViewFormats)
- {
- to->pViewFormats = (VkFormat*)alloc->dupArray(from->pViewFormats, from->viewFormatCount * sizeof(const VkFormat));
+ if (from->pViewFormats) {
+ to->pViewFormats = (VkFormat*)alloc->dupArray(
+ from->pViewFormats, from->viewFormatCount * sizeof(const VkFormat));
}
}
-void deepcopy_VkAttachmentDescription2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAttachmentDescription2* from,
- VkAttachmentDescription2* to)
-{
+void deepcopy_VkAttachmentDescription2(Allocator* alloc, VkStructureType rootType,
+ const VkAttachmentDescription2* from,
+ VkAttachmentDescription2* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkAttachmentReference2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAttachmentReference2* from,
- VkAttachmentReference2* to)
-{
+void deepcopy_VkAttachmentReference2(Allocator* alloc, VkStructureType rootType,
+ const VkAttachmentReference2* from,
+ VkAttachmentReference2* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkSubpassDescription2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubpassDescription2* from,
- VkSubpassDescription2* to)
-{
+void deepcopy_VkSubpassDescription2(Allocator* alloc, VkStructureType rootType,
+ const VkSubpassDescription2* from, VkSubpassDescription2* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pInputAttachments = nullptr;
- if (from->pInputAttachments)
- {
- to->pInputAttachments = (VkAttachmentReference2*)alloc->alloc(from->inputAttachmentCount * sizeof(const VkAttachmentReference2));
+ if (from->pInputAttachments) {
+ to->pInputAttachments = (VkAttachmentReference2*)alloc->alloc(
+ from->inputAttachmentCount * sizeof(const VkAttachmentReference2));
to->inputAttachmentCount = from->inputAttachmentCount;
- for (uint32_t i = 0; i < (uint32_t)from->inputAttachmentCount; ++i)
- {
- deepcopy_VkAttachmentReference2(alloc, rootType, from->pInputAttachments + i, (VkAttachmentReference2*)(to->pInputAttachments + i));
+ for (uint32_t i = 0; i < (uint32_t)from->inputAttachmentCount; ++i) {
+ deepcopy_VkAttachmentReference2(
+ alloc, rootType, from->pInputAttachments + i,
+ (VkAttachmentReference2*)(to->pInputAttachments + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pColorAttachments = nullptr;
- if (from->pColorAttachments)
- {
- to->pColorAttachments = (VkAttachmentReference2*)alloc->alloc(from->colorAttachmentCount * sizeof(const VkAttachmentReference2));
+ if (from->pColorAttachments) {
+ to->pColorAttachments = (VkAttachmentReference2*)alloc->alloc(
+ from->colorAttachmentCount * sizeof(const VkAttachmentReference2));
to->colorAttachmentCount = from->colorAttachmentCount;
- for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i)
- {
- deepcopy_VkAttachmentReference2(alloc, rootType, from->pColorAttachments + i, (VkAttachmentReference2*)(to->pColorAttachments + i));
+ for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i) {
+ deepcopy_VkAttachmentReference2(
+ alloc, rootType, from->pColorAttachments + i,
+ (VkAttachmentReference2*)(to->pColorAttachments + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pResolveAttachments = nullptr;
- if (from->pResolveAttachments)
- {
- to->pResolveAttachments = (VkAttachmentReference2*)alloc->alloc(from->colorAttachmentCount * sizeof(const VkAttachmentReference2));
+ if (from->pResolveAttachments) {
+ to->pResolveAttachments = (VkAttachmentReference2*)alloc->alloc(
+ from->colorAttachmentCount * sizeof(const VkAttachmentReference2));
to->colorAttachmentCount = from->colorAttachmentCount;
- for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i)
- {
- deepcopy_VkAttachmentReference2(alloc, rootType, from->pResolveAttachments + i, (VkAttachmentReference2*)(to->pResolveAttachments + i));
+ for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i) {
+ deepcopy_VkAttachmentReference2(
+ alloc, rootType, from->pResolveAttachments + i,
+ (VkAttachmentReference2*)(to->pResolveAttachments + i));
}
}
}
to->pDepthStencilAttachment = nullptr;
- if (from->pDepthStencilAttachment)
- {
- to->pDepthStencilAttachment = (VkAttachmentReference2*)alloc->alloc(sizeof(const VkAttachmentReference2));
- deepcopy_VkAttachmentReference2(alloc, rootType, from->pDepthStencilAttachment, (VkAttachmentReference2*)(to->pDepthStencilAttachment));
+ if (from->pDepthStencilAttachment) {
+ to->pDepthStencilAttachment =
+ (VkAttachmentReference2*)alloc->alloc(sizeof(const VkAttachmentReference2));
+ deepcopy_VkAttachmentReference2(alloc, rootType, from->pDepthStencilAttachment,
+ (VkAttachmentReference2*)(to->pDepthStencilAttachment));
}
to->pPreserveAttachments = nullptr;
- if (from->pPreserveAttachments)
- {
- to->pPreserveAttachments = (uint32_t*)alloc->dupArray(from->pPreserveAttachments, from->preserveAttachmentCount * sizeof(const uint32_t));
+ if (from->pPreserveAttachments) {
+ to->pPreserveAttachments = (uint32_t*)alloc->dupArray(
+ from->pPreserveAttachments, from->preserveAttachmentCount * sizeof(const uint32_t));
}
}
-void deepcopy_VkSubpassDependency2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubpassDependency2* from,
- VkSubpassDependency2* to)
-{
+void deepcopy_VkSubpassDependency2(Allocator* alloc, VkStructureType rootType,
+ const VkSubpassDependency2* from, VkSubpassDependency2* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkRenderPassCreateInfo2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRenderPassCreateInfo2* from,
- VkRenderPassCreateInfo2* to)
-{
+void deepcopy_VkRenderPassCreateInfo2(Allocator* alloc, VkStructureType rootType,
+ const VkRenderPassCreateInfo2* from,
+ VkRenderPassCreateInfo2* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pAttachments = nullptr;
- if (from->pAttachments)
- {
- to->pAttachments = (VkAttachmentDescription2*)alloc->alloc(from->attachmentCount * sizeof(const VkAttachmentDescription2));
+ if (from->pAttachments) {
+ to->pAttachments = (VkAttachmentDescription2*)alloc->alloc(
+ from->attachmentCount * sizeof(const VkAttachmentDescription2));
to->attachmentCount = from->attachmentCount;
- for (uint32_t i = 0; i < (uint32_t)from->attachmentCount; ++i)
- {
- deepcopy_VkAttachmentDescription2(alloc, rootType, from->pAttachments + i, (VkAttachmentDescription2*)(to->pAttachments + i));
+ for (uint32_t i = 0; i < (uint32_t)from->attachmentCount; ++i) {
+ deepcopy_VkAttachmentDescription2(
+ alloc, rootType, from->pAttachments + i,
+ (VkAttachmentDescription2*)(to->pAttachments + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pSubpasses = nullptr;
- if (from->pSubpasses)
- {
- to->pSubpasses = (VkSubpassDescription2*)alloc->alloc(from->subpassCount * sizeof(const VkSubpassDescription2));
+ if (from->pSubpasses) {
+ to->pSubpasses = (VkSubpassDescription2*)alloc->alloc(
+ from->subpassCount * sizeof(const VkSubpassDescription2));
to->subpassCount = from->subpassCount;
- for (uint32_t i = 0; i < (uint32_t)from->subpassCount; ++i)
- {
- deepcopy_VkSubpassDescription2(alloc, rootType, from->pSubpasses + i, (VkSubpassDescription2*)(to->pSubpasses + i));
+ for (uint32_t i = 0; i < (uint32_t)from->subpassCount; ++i) {
+ deepcopy_VkSubpassDescription2(alloc, rootType, from->pSubpasses + i,
+ (VkSubpassDescription2*)(to->pSubpasses + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pDependencies = nullptr;
- if (from->pDependencies)
- {
- to->pDependencies = (VkSubpassDependency2*)alloc->alloc(from->dependencyCount * sizeof(const VkSubpassDependency2));
+ if (from->pDependencies) {
+ to->pDependencies = (VkSubpassDependency2*)alloc->alloc(
+ from->dependencyCount * sizeof(const VkSubpassDependency2));
to->dependencyCount = from->dependencyCount;
- for (uint32_t i = 0; i < (uint32_t)from->dependencyCount; ++i)
- {
- deepcopy_VkSubpassDependency2(alloc, rootType, from->pDependencies + i, (VkSubpassDependency2*)(to->pDependencies + i));
+ for (uint32_t i = 0; i < (uint32_t)from->dependencyCount; ++i) {
+ deepcopy_VkSubpassDependency2(alloc, rootType, from->pDependencies + i,
+ (VkSubpassDependency2*)(to->pDependencies + i));
}
}
}
to->pCorrelatedViewMasks = nullptr;
- if (from->pCorrelatedViewMasks)
- {
- to->pCorrelatedViewMasks = (uint32_t*)alloc->dupArray(from->pCorrelatedViewMasks, from->correlatedViewMaskCount * sizeof(const uint32_t));
+ if (from->pCorrelatedViewMasks) {
+ to->pCorrelatedViewMasks = (uint32_t*)alloc->dupArray(
+ from->pCorrelatedViewMasks, from->correlatedViewMaskCount * sizeof(const uint32_t));
}
}
-void deepcopy_VkSubpassBeginInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubpassBeginInfo* from,
- VkSubpassBeginInfo* to)
-{
+void deepcopy_VkSubpassBeginInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSubpassBeginInfo* from, VkSubpassBeginInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkSubpassEndInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubpassEndInfo* from,
- VkSubpassEndInfo* to)
-{
+void deepcopy_VkSubpassEndInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSubpassEndInfo* from, VkSubpassEndInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkPhysicalDevice8BitStorageFeatures(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDevice8BitStorageFeatures* from,
- VkPhysicalDevice8BitStorageFeatures* to)
-{
+void deepcopy_VkPhysicalDevice8BitStorageFeatures(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDevice8BitStorageFeatures* from,
+ VkPhysicalDevice8BitStorageFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkPhysicalDeviceDriverProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceDriverProperties* from,
- VkPhysicalDeviceDriverProperties* to)
-{
+void deepcopy_VkPhysicalDeviceDriverProperties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceDriverProperties* from,
+ VkPhysicalDeviceDriverProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
memcpy(to->driverName, from->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
memcpy(to->driverInfo, from->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
- deepcopy_VkConformanceVersion(alloc, rootType, &from->conformanceVersion, (VkConformanceVersion*)(&to->conformanceVersion));
+ deepcopy_VkConformanceVersion(alloc, rootType, &from->conformanceVersion,
+ (VkConformanceVersion*)(&to->conformanceVersion));
}
void deepcopy_VkPhysicalDeviceShaderAtomicInt64Features(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicInt64Features* from,
- VkPhysicalDeviceShaderAtomicInt64Features* to)
-{
+ VkPhysicalDeviceShaderAtomicInt64Features* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceShaderFloat16Int8Features(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderFloat16Int8Features* from,
- VkPhysicalDeviceShaderFloat16Int8Features* to)
-{
+ VkPhysicalDeviceShaderFloat16Int8Features* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceFloatControlsProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceFloatControlsProperties* from,
- VkPhysicalDeviceFloatControlsProperties* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceFloatControlsProperties* from,
+ VkPhysicalDeviceFloatControlsProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkDescriptorSetLayoutBindingFlagsCreateInfo* from,
- VkDescriptorSetLayoutBindingFlagsCreateInfo* to)
-{
+ VkDescriptorSetLayoutBindingFlagsCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pBindingFlags = nullptr;
- if (from->pBindingFlags)
- {
- to->pBindingFlags = (VkDescriptorBindingFlags*)alloc->dupArray(from->pBindingFlags, from->bindingCount * sizeof(const VkDescriptorBindingFlags));
+ if (from->pBindingFlags) {
+ to->pBindingFlags = (VkDescriptorBindingFlags*)alloc->dupArray(
+ from->pBindingFlags, from->bindingCount * sizeof(const VkDescriptorBindingFlags));
}
}
void deepcopy_VkPhysicalDeviceDescriptorIndexingFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDescriptorIndexingFeatures* from,
- VkPhysicalDeviceDescriptorIndexingFeatures* to)
-{
+ VkPhysicalDeviceDescriptorIndexingFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceDescriptorIndexingProperties(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDescriptorIndexingProperties* from,
- VkPhysicalDeviceDescriptorIndexingProperties* to)
-{
+ VkPhysicalDeviceDescriptorIndexingProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfo(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkDescriptorSetVariableDescriptorCountAllocateInfo* from,
- VkDescriptorSetVariableDescriptorCountAllocateInfo* to)
-{
+ VkDescriptorSetVariableDescriptorCountAllocateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pDescriptorCounts = nullptr;
- if (from->pDescriptorCounts)
- {
- to->pDescriptorCounts = (uint32_t*)alloc->dupArray(from->pDescriptorCounts, from->descriptorSetCount * sizeof(const uint32_t));
+ if (from->pDescriptorCounts) {
+ to->pDescriptorCounts = (uint32_t*)alloc->dupArray(
+ from->pDescriptorCounts, from->descriptorSetCount * sizeof(const uint32_t));
}
}
void deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupport(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkDescriptorSetVariableDescriptorCountLayoutSupport* from,
- VkDescriptorSetVariableDescriptorCountLayoutSupport* to)
-{
+ VkDescriptorSetVariableDescriptorCountLayoutSupport* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSubpassDescriptionDepthStencilResolve(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubpassDescriptionDepthStencilResolve* from,
- VkSubpassDescriptionDepthStencilResolve* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkSubpassDescriptionDepthStencilResolve* from,
+ VkSubpassDescriptionDepthStencilResolve* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pDepthStencilResolveAttachment = nullptr;
- if (from->pDepthStencilResolveAttachment)
- {
- to->pDepthStencilResolveAttachment = (VkAttachmentReference2*)alloc->alloc(sizeof(const VkAttachmentReference2));
- deepcopy_VkAttachmentReference2(alloc, rootType, from->pDepthStencilResolveAttachment, (VkAttachmentReference2*)(to->pDepthStencilResolveAttachment));
+ if (from->pDepthStencilResolveAttachment) {
+ to->pDepthStencilResolveAttachment =
+ (VkAttachmentReference2*)alloc->alloc(sizeof(const VkAttachmentReference2));
+ deepcopy_VkAttachmentReference2(
+ alloc, rootType, from->pDepthStencilResolveAttachment,
+ (VkAttachmentReference2*)(to->pDepthStencilResolveAttachment));
}
}
void deepcopy_VkPhysicalDeviceDepthStencilResolveProperties(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDepthStencilResolveProperties* from,
- VkPhysicalDeviceDepthStencilResolveProperties* to)
-{
+ VkPhysicalDeviceDepthStencilResolveProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceScalarBlockLayoutFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceScalarBlockLayoutFeatures* from,
- VkPhysicalDeviceScalarBlockLayoutFeatures* to)
-{
+ VkPhysicalDeviceScalarBlockLayoutFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkImageStencilUsageCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageStencilUsageCreateInfo* from,
- VkImageStencilUsageCreateInfo* to)
-{
+void deepcopy_VkImageStencilUsageCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkImageStencilUsageCreateInfo* from,
+ VkImageStencilUsageCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkSamplerReductionModeCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSamplerReductionModeCreateInfo* from,
- VkSamplerReductionModeCreateInfo* to)
-{
+void deepcopy_VkSamplerReductionModeCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSamplerReductionModeCreateInfo* from,
+ VkSamplerReductionModeCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceSamplerFilterMinmaxProperties(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceSamplerFilterMinmaxProperties* from,
- VkPhysicalDeviceSamplerFilterMinmaxProperties* to)
-{
+ VkPhysicalDeviceSamplerFilterMinmaxProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceVulkanMemoryModelFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceVulkanMemoryModelFeatures* from,
- VkPhysicalDeviceVulkanMemoryModelFeatures* to)
-{
+ VkPhysicalDeviceVulkanMemoryModelFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceImagelessFramebufferFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceImagelessFramebufferFeatures* from,
- VkPhysicalDeviceImagelessFramebufferFeatures* to)
-{
+ VkPhysicalDeviceImagelessFramebufferFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkFramebufferAttachmentImageInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFramebufferAttachmentImageInfo* from,
- VkFramebufferAttachmentImageInfo* to)
-{
+void deepcopy_VkFramebufferAttachmentImageInfo(Allocator* alloc, VkStructureType rootType,
+ const VkFramebufferAttachmentImageInfo* from,
+ VkFramebufferAttachmentImageInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pViewFormats = nullptr;
- if (from->pViewFormats)
- {
- to->pViewFormats = (VkFormat*)alloc->dupArray(from->pViewFormats, from->viewFormatCount * sizeof(const VkFormat));
+ if (from->pViewFormats) {
+ to->pViewFormats = (VkFormat*)alloc->dupArray(
+ from->pViewFormats, from->viewFormatCount * sizeof(const VkFormat));
}
}
-void deepcopy_VkFramebufferAttachmentsCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFramebufferAttachmentsCreateInfo* from,
- VkFramebufferAttachmentsCreateInfo* to)
-{
+void deepcopy_VkFramebufferAttachmentsCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkFramebufferAttachmentsCreateInfo* from,
+ VkFramebufferAttachmentsCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pAttachmentImageInfos = nullptr;
- if (from->pAttachmentImageInfos)
- {
- to->pAttachmentImageInfos = (VkFramebufferAttachmentImageInfo*)alloc->alloc(from->attachmentImageInfoCount * sizeof(const VkFramebufferAttachmentImageInfo));
+ if (from->pAttachmentImageInfos) {
+ to->pAttachmentImageInfos = (VkFramebufferAttachmentImageInfo*)alloc->alloc(
+ from->attachmentImageInfoCount * sizeof(const VkFramebufferAttachmentImageInfo));
to->attachmentImageInfoCount = from->attachmentImageInfoCount;
- for (uint32_t i = 0; i < (uint32_t)from->attachmentImageInfoCount; ++i)
- {
- deepcopy_VkFramebufferAttachmentImageInfo(alloc, rootType, from->pAttachmentImageInfos + i, (VkFramebufferAttachmentImageInfo*)(to->pAttachmentImageInfos + i));
+ for (uint32_t i = 0; i < (uint32_t)from->attachmentImageInfoCount; ++i) {
+ deepcopy_VkFramebufferAttachmentImageInfo(
+ alloc, rootType, from->pAttachmentImageInfos + i,
+ (VkFramebufferAttachmentImageInfo*)(to->pAttachmentImageInfos + i));
}
}
}
}
-void deepcopy_VkRenderPassAttachmentBeginInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRenderPassAttachmentBeginInfo* from,
- VkRenderPassAttachmentBeginInfo* to)
-{
+void deepcopy_VkRenderPassAttachmentBeginInfo(Allocator* alloc, VkStructureType rootType,
+ const VkRenderPassAttachmentBeginInfo* from,
+ VkRenderPassAttachmentBeginInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pAttachments = nullptr;
- if (from->pAttachments)
- {
- to->pAttachments = (VkImageView*)alloc->dupArray(from->pAttachments, from->attachmentCount * sizeof(const VkImageView));
+ if (from->pAttachments) {
+ to->pAttachments = (VkImageView*)alloc->dupArray(
+ from->pAttachments, from->attachmentCount * sizeof(const VkImageView));
}
}
void deepcopy_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* from,
- VkPhysicalDeviceUniformBufferStandardLayoutFeatures* to)
-{
+ VkPhysicalDeviceUniformBufferStandardLayoutFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* from,
- VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* to)
-{
+ VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* from,
- VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* to)
-{
+ VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkAttachmentReferenceStencilLayout(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAttachmentReferenceStencilLayout* from,
- VkAttachmentReferenceStencilLayout* to)
-{
+void deepcopy_VkAttachmentReferenceStencilLayout(Allocator* alloc, VkStructureType rootType,
+ const VkAttachmentReferenceStencilLayout* from,
+ VkAttachmentReferenceStencilLayout* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkAttachmentDescriptionStencilLayout(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAttachmentDescriptionStencilLayout* from,
- VkAttachmentDescriptionStencilLayout* to)
-{
+void deepcopy_VkAttachmentDescriptionStencilLayout(Allocator* alloc, VkStructureType rootType,
+ const VkAttachmentDescriptionStencilLayout* from,
+ VkAttachmentDescriptionStencilLayout* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceHostQueryResetFeatures(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceHostQueryResetFeatures* from,
- VkPhysicalDeviceHostQueryResetFeatures* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceHostQueryResetFeatures* from,
+ VkPhysicalDeviceHostQueryResetFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceTimelineSemaphoreFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceTimelineSemaphoreFeatures* from,
- VkPhysicalDeviceTimelineSemaphoreFeatures* to)
-{
+ VkPhysicalDeviceTimelineSemaphoreFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceTimelineSemaphoreProperties(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceTimelineSemaphoreProperties* from,
- VkPhysicalDeviceTimelineSemaphoreProperties* to)
-{
+ VkPhysicalDeviceTimelineSemaphoreProperties* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkSemaphoreTypeCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSemaphoreTypeCreateInfo* from,
- VkSemaphoreTypeCreateInfo* to)
-{
+void deepcopy_VkSemaphoreTypeCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSemaphoreTypeCreateInfo* from,
+ VkSemaphoreTypeCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkTimelineSemaphoreSubmitInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkTimelineSemaphoreSubmitInfo* from,
- VkTimelineSemaphoreSubmitInfo* to)
-{
+void deepcopy_VkTimelineSemaphoreSubmitInfo(Allocator* alloc, VkStructureType rootType,
+ const VkTimelineSemaphoreSubmitInfo* from,
+ VkTimelineSemaphoreSubmitInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pWaitSemaphoreValues = nullptr;
- if (from->pWaitSemaphoreValues)
- {
- to->pWaitSemaphoreValues = (uint64_t*)alloc->dupArray(from->pWaitSemaphoreValues, from->waitSemaphoreValueCount * sizeof(const uint64_t));
+ if (from->pWaitSemaphoreValues) {
+ to->pWaitSemaphoreValues = (uint64_t*)alloc->dupArray(
+ from->pWaitSemaphoreValues, from->waitSemaphoreValueCount * sizeof(const uint64_t));
}
to->pSignalSemaphoreValues = nullptr;
- if (from->pSignalSemaphoreValues)
- {
- to->pSignalSemaphoreValues = (uint64_t*)alloc->dupArray(from->pSignalSemaphoreValues, from->signalSemaphoreValueCount * sizeof(const uint64_t));
+ if (from->pSignalSemaphoreValues) {
+ to->pSignalSemaphoreValues = (uint64_t*)alloc->dupArray(
+ from->pSignalSemaphoreValues, from->signalSemaphoreValueCount * sizeof(const uint64_t));
}
}
-void deepcopy_VkSemaphoreWaitInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSemaphoreWaitInfo* from,
- VkSemaphoreWaitInfo* to)
-{
+void deepcopy_VkSemaphoreWaitInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSemaphoreWaitInfo* from, VkSemaphoreWaitInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pSemaphores = nullptr;
- if (from->pSemaphores)
- {
- to->pSemaphores = (VkSemaphore*)alloc->dupArray(from->pSemaphores, from->semaphoreCount * sizeof(const VkSemaphore));
+ if (from->pSemaphores) {
+ to->pSemaphores = (VkSemaphore*)alloc->dupArray(
+ from->pSemaphores, from->semaphoreCount * sizeof(const VkSemaphore));
}
to->pValues = nullptr;
- if (from->pValues)
- {
- to->pValues = (uint64_t*)alloc->dupArray(from->pValues, from->semaphoreCount * sizeof(const uint64_t));
+ if (from->pValues) {
+ to->pValues = (uint64_t*)alloc->dupArray(from->pValues,
+ from->semaphoreCount * sizeof(const uint64_t));
}
}
-void deepcopy_VkSemaphoreSignalInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSemaphoreSignalInfo* from,
- VkSemaphoreSignalInfo* to)
-{
+void deepcopy_VkSemaphoreSignalInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSemaphoreSignalInfo* from, VkSemaphoreSignalInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceBufferDeviceAddressFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceBufferDeviceAddressFeatures* from,
- VkPhysicalDeviceBufferDeviceAddressFeatures* to)
-{
+ VkPhysicalDeviceBufferDeviceAddressFeatures* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkBufferDeviceAddressInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferDeviceAddressInfo* from,
- VkBufferDeviceAddressInfo* to)
-{
+void deepcopy_VkBufferDeviceAddressInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBufferDeviceAddressInfo* from,
+ VkBufferDeviceAddressInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkBufferOpaqueCaptureAddressCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferOpaqueCaptureAddressCreateInfo* from,
- VkBufferOpaqueCaptureAddressCreateInfo* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkBufferOpaqueCaptureAddressCreateInfo* from,
+ VkBufferOpaqueCaptureAddressCreateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkMemoryOpaqueCaptureAddressAllocateInfo(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkMemoryOpaqueCaptureAddressAllocateInfo* from,
- VkMemoryOpaqueCaptureAddressAllocateInfo* to)
-{
+ VkMemoryOpaqueCaptureAddressAllocateInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceMemoryOpaqueCaptureAddressInfo* from,
- VkDeviceMemoryOpaqueCaptureAddressInfo* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkDeviceMemoryOpaqueCaptureAddressInfo* from,
+ VkDeviceMemoryOpaqueCaptureAddressInfo* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -6268,12 +5087,9 @@
#endif
#ifdef VK_KHR_surface
-void deepcopy_VkSurfaceCapabilitiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSurfaceCapabilitiesKHR* from,
- VkSurfaceCapabilitiesKHR* to)
-{
+void deepcopy_VkSurfaceCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkSurfaceCapabilitiesKHR* from,
+ VkSurfaceCapabilitiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
@@ -6282,12 +5098,8 @@
deepcopy_VkExtent2D(alloc, rootType, &from->maxImageExtent, (VkExtent2D*)(&to->maxImageExtent));
}
-void deepcopy_VkSurfaceFormatKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSurfaceFormatKHR* from,
- VkSurfaceFormatKHR* to)
-{
+void deepcopy_VkSurfaceFormatKHR(Allocator* alloc, VkStructureType rootType,
+ const VkSurfaceFormatKHR* from, VkSurfaceFormatKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
@@ -6295,257 +5107,208 @@
#endif
#ifdef VK_KHR_swapchain
-void deepcopy_VkSwapchainCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSwapchainCreateInfoKHR* from,
- VkSwapchainCreateInfoKHR* to)
-{
+void deepcopy_VkSwapchainCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkSwapchainCreateInfoKHR* from,
+ VkSwapchainCreateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
deepcopy_VkExtent2D(alloc, rootType, &from->imageExtent, (VkExtent2D*)(&to->imageExtent));
to->pQueueFamilyIndices = nullptr;
- if (from->pQueueFamilyIndices)
- {
- to->pQueueFamilyIndices = (uint32_t*)alloc->dupArray(from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
+ if (from->pQueueFamilyIndices) {
+ to->pQueueFamilyIndices = (uint32_t*)alloc->dupArray(
+ from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
}
}
-void deepcopy_VkPresentInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPresentInfoKHR* from,
- VkPresentInfoKHR* to)
-{
+void deepcopy_VkPresentInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPresentInfoKHR* from, VkPresentInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pWaitSemaphores = nullptr;
- if (from->pWaitSemaphores)
- {
- to->pWaitSemaphores = (VkSemaphore*)alloc->dupArray(from->pWaitSemaphores, from->waitSemaphoreCount * sizeof(const VkSemaphore));
+ if (from->pWaitSemaphores) {
+ to->pWaitSemaphores = (VkSemaphore*)alloc->dupArray(
+ from->pWaitSemaphores, from->waitSemaphoreCount * sizeof(const VkSemaphore));
}
to->pSwapchains = nullptr;
- if (from->pSwapchains)
- {
- to->pSwapchains = (VkSwapchainKHR*)alloc->dupArray(from->pSwapchains, from->swapchainCount * sizeof(const VkSwapchainKHR));
+ if (from->pSwapchains) {
+ to->pSwapchains = (VkSwapchainKHR*)alloc->dupArray(
+ from->pSwapchains, from->swapchainCount * sizeof(const VkSwapchainKHR));
}
to->pImageIndices = nullptr;
- if (from->pImageIndices)
- {
- to->pImageIndices = (uint32_t*)alloc->dupArray(from->pImageIndices, from->swapchainCount * sizeof(const uint32_t));
+ if (from->pImageIndices) {
+ to->pImageIndices = (uint32_t*)alloc->dupArray(
+ from->pImageIndices, from->swapchainCount * sizeof(const uint32_t));
}
to->pResults = nullptr;
- if (from->pResults)
- {
- to->pResults = (VkResult*)alloc->dupArray(from->pResults, from->swapchainCount * sizeof(VkResult));
+ if (from->pResults) {
+ to->pResults =
+ (VkResult*)alloc->dupArray(from->pResults, from->swapchainCount * sizeof(VkResult));
}
}
-void deepcopy_VkImageSwapchainCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageSwapchainCreateInfoKHR* from,
- VkImageSwapchainCreateInfoKHR* to)
-{
+void deepcopy_VkImageSwapchainCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkImageSwapchainCreateInfoKHR* from,
+ VkImageSwapchainCreateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkBindImageMemorySwapchainInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindImageMemorySwapchainInfoKHR* from,
- VkBindImageMemorySwapchainInfoKHR* to)
-{
+void deepcopy_VkBindImageMemorySwapchainInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkBindImageMemorySwapchainInfoKHR* from,
+ VkBindImageMemorySwapchainInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkAcquireNextImageInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAcquireNextImageInfoKHR* from,
- VkAcquireNextImageInfoKHR* to)
-{
+void deepcopy_VkAcquireNextImageInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkAcquireNextImageInfoKHR* from,
+ VkAcquireNextImageInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkDeviceGroupPresentCapabilitiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceGroupPresentCapabilitiesKHR* from,
- VkDeviceGroupPresentCapabilitiesKHR* to)
-{
+void deepcopy_VkDeviceGroupPresentCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceGroupPresentCapabilitiesKHR* from,
+ VkDeviceGroupPresentCapabilitiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
memcpy(to->presentMask, from->presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t));
}
-void deepcopy_VkDeviceGroupPresentInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceGroupPresentInfoKHR* from,
- VkDeviceGroupPresentInfoKHR* to)
-{
+void deepcopy_VkDeviceGroupPresentInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceGroupPresentInfoKHR* from,
+ VkDeviceGroupPresentInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pDeviceMasks = nullptr;
- if (from->pDeviceMasks)
- {
- to->pDeviceMasks = (uint32_t*)alloc->dupArray(from->pDeviceMasks, from->swapchainCount * sizeof(const uint32_t));
+ if (from->pDeviceMasks) {
+ to->pDeviceMasks = (uint32_t*)alloc->dupArray(
+ from->pDeviceMasks, from->swapchainCount * sizeof(const uint32_t));
}
}
-void deepcopy_VkDeviceGroupSwapchainCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceGroupSwapchainCreateInfoKHR* from,
- VkDeviceGroupSwapchainCreateInfoKHR* to)
-{
+void deepcopy_VkDeviceGroupSwapchainCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceGroupSwapchainCreateInfoKHR* from,
+ VkDeviceGroupSwapchainCreateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -6553,65 +5316,52 @@
#endif
#ifdef VK_KHR_display
-void deepcopy_VkDisplayModeParametersKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayModeParametersKHR* from,
- VkDisplayModeParametersKHR* to)
-{
+void deepcopy_VkDisplayModeParametersKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayModeParametersKHR* from,
+ VkDisplayModeParametersKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
deepcopy_VkExtent2D(alloc, rootType, &from->visibleRegion, (VkExtent2D*)(&to->visibleRegion));
}
-void deepcopy_VkDisplayModeCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayModeCreateInfoKHR* from,
- VkDisplayModeCreateInfoKHR* to)
-{
+void deepcopy_VkDisplayModeCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayModeCreateInfoKHR* from,
+ VkDisplayModeCreateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDisplayModeParametersKHR(alloc, rootType, &from->parameters, (VkDisplayModeParametersKHR*)(&to->parameters));
+ deepcopy_VkDisplayModeParametersKHR(alloc, rootType, &from->parameters,
+ (VkDisplayModeParametersKHR*)(&to->parameters));
}
-void deepcopy_VkDisplayModePropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayModePropertiesKHR* from,
- VkDisplayModePropertiesKHR* to)
-{
+void deepcopy_VkDisplayModePropertiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayModePropertiesKHR* from,
+ VkDisplayModePropertiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- deepcopy_VkDisplayModeParametersKHR(alloc, rootType, &from->parameters, (VkDisplayModeParametersKHR*)(&to->parameters));
+ deepcopy_VkDisplayModeParametersKHR(alloc, rootType, &from->parameters,
+ (VkDisplayModeParametersKHR*)(&to->parameters));
}
-void deepcopy_VkDisplayPlaneCapabilitiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayPlaneCapabilitiesKHR* from,
- VkDisplayPlaneCapabilitiesKHR* to)
-{
+void deepcopy_VkDisplayPlaneCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayPlaneCapabilitiesKHR* from,
+ VkDisplayPlaneCapabilitiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
@@ -6625,58 +5375,47 @@
deepcopy_VkExtent2D(alloc, rootType, &from->maxDstExtent, (VkExtent2D*)(&to->maxDstExtent));
}
-void deepcopy_VkDisplayPlanePropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayPlanePropertiesKHR* from,
- VkDisplayPlanePropertiesKHR* to)
-{
+void deepcopy_VkDisplayPlanePropertiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayPlanePropertiesKHR* from,
+ VkDisplayPlanePropertiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkDisplayPropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayPropertiesKHR* from,
- VkDisplayPropertiesKHR* to)
-{
+void deepcopy_VkDisplayPropertiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayPropertiesKHR* from,
+ VkDisplayPropertiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
to->displayName = nullptr;
- if (from->displayName)
- {
+ if (from->displayName) {
to->displayName = alloc->strDup(from->displayName);
}
- deepcopy_VkExtent2D(alloc, rootType, &from->physicalDimensions, (VkExtent2D*)(&to->physicalDimensions));
- deepcopy_VkExtent2D(alloc, rootType, &from->physicalResolution, (VkExtent2D*)(&to->physicalResolution));
+ deepcopy_VkExtent2D(alloc, rootType, &from->physicalDimensions,
+ (VkExtent2D*)(&to->physicalDimensions));
+ deepcopy_VkExtent2D(alloc, rootType, &from->physicalResolution,
+ (VkExtent2D*)(&to->physicalResolution));
}
-void deepcopy_VkDisplaySurfaceCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplaySurfaceCreateInfoKHR* from,
- VkDisplaySurfaceCreateInfoKHR* to)
-{
+void deepcopy_VkDisplaySurfaceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplaySurfaceCreateInfoKHR* from,
+ VkDisplaySurfaceCreateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -6685,29 +5424,23 @@
#endif
#ifdef VK_KHR_display_swapchain
-void deepcopy_VkDisplayPresentInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayPresentInfoKHR* from,
- VkDisplayPresentInfoKHR* to)
-{
+void deepcopy_VkDisplayPresentInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayPresentInfoKHR* from,
+ VkDisplayPresentInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -6717,174 +5450,140 @@
#endif
#ifdef VK_KHR_xlib_surface
-void deepcopy_VkXlibSurfaceCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkXlibSurfaceCreateInfoKHR* from,
- VkXlibSurfaceCreateInfoKHR* to)
-{
+void deepcopy_VkXlibSurfaceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkXlibSurfaceCreateInfoKHR* from,
+ VkXlibSurfaceCreateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->dpy = nullptr;
- if (from->dpy)
- {
+ if (from->dpy) {
to->dpy = (Display*)alloc->dupArray(from->dpy, sizeof(Display));
}
}
#endif
#ifdef VK_KHR_xcb_surface
-void deepcopy_VkXcbSurfaceCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkXcbSurfaceCreateInfoKHR* from,
- VkXcbSurfaceCreateInfoKHR* to)
-{
+void deepcopy_VkXcbSurfaceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkXcbSurfaceCreateInfoKHR* from,
+ VkXcbSurfaceCreateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->connection = nullptr;
- if (from->connection)
- {
- to->connection = (xcb_connection_t*)alloc->dupArray(from->connection, sizeof(xcb_connection_t));
+ if (from->connection) {
+ to->connection =
+ (xcb_connection_t*)alloc->dupArray(from->connection, sizeof(xcb_connection_t));
}
}
#endif
#ifdef VK_KHR_wayland_surface
-void deepcopy_VkWaylandSurfaceCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkWaylandSurfaceCreateInfoKHR* from,
- VkWaylandSurfaceCreateInfoKHR* to)
-{
+void deepcopy_VkWaylandSurfaceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkWaylandSurfaceCreateInfoKHR* from,
+ VkWaylandSurfaceCreateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->display = nullptr;
- if (from->display)
- {
+ if (from->display) {
to->display = (wl_display*)alloc->dupArray(from->display, sizeof(wl_display));
}
to->surface = nullptr;
- if (from->surface)
- {
+ if (from->surface) {
to->surface = (wl_surface*)alloc->dupArray(from->surface, sizeof(wl_surface));
}
}
#endif
#ifdef VK_KHR_android_surface
-void deepcopy_VkAndroidSurfaceCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAndroidSurfaceCreateInfoKHR* from,
- VkAndroidSurfaceCreateInfoKHR* to)
-{
+void deepcopy_VkAndroidSurfaceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkAndroidSurfaceCreateInfoKHR* from,
+ VkAndroidSurfaceCreateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->window = nullptr;
- if (from->window)
- {
+ if (from->window) {
to->window = (ANativeWindow*)alloc->dupArray(from->window, sizeof(ANativeWindow));
}
}
#endif
#ifdef VK_KHR_win32_surface
-void deepcopy_VkWin32SurfaceCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkWin32SurfaceCreateInfoKHR* from,
- VkWin32SurfaceCreateInfoKHR* to)
-{
+void deepcopy_VkWin32SurfaceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkWin32SurfaceCreateInfoKHR* from,
+ VkWin32SurfaceCreateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -6894,212 +5593,169 @@
#ifdef VK_KHR_sampler_mirror_clamp_to_edge
#endif
#ifdef VK_KHR_video_queue
-void deepcopy_VkVideoQueueFamilyProperties2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoQueueFamilyProperties2KHR* from,
- VkVideoQueueFamilyProperties2KHR* to)
-{
+void deepcopy_VkVideoQueueFamilyProperties2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoQueueFamilyProperties2KHR* from,
+ VkVideoQueueFamilyProperties2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkVideoProfileKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoProfileKHR* from,
- VkVideoProfileKHR* to)
-{
+void deepcopy_VkVideoProfileKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoProfileKHR* from, VkVideoProfileKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkVideoProfilesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoProfilesKHR* from,
- VkVideoProfilesKHR* to)
-{
+void deepcopy_VkVideoProfilesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoProfilesKHR* from, VkVideoProfilesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pProfiles = nullptr;
- if (from->pProfiles)
- {
+ if (from->pProfiles) {
to->pProfiles = (VkVideoProfileKHR*)alloc->alloc(sizeof(const VkVideoProfileKHR));
- deepcopy_VkVideoProfileKHR(alloc, rootType, from->pProfiles, (VkVideoProfileKHR*)(to->pProfiles));
+ deepcopy_VkVideoProfileKHR(alloc, rootType, from->pProfiles,
+ (VkVideoProfileKHR*)(to->pProfiles));
}
}
-void deepcopy_VkVideoCapabilitiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoCapabilitiesKHR* from,
- VkVideoCapabilitiesKHR* to)
-{
+void deepcopy_VkVideoCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoCapabilitiesKHR* from,
+ VkVideoCapabilitiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(alloc, rootType, &from->videoPictureExtentGranularity, (VkExtent2D*)(&to->videoPictureExtentGranularity));
+ deepcopy_VkExtent2D(alloc, rootType, &from->videoPictureExtentGranularity,
+ (VkExtent2D*)(&to->videoPictureExtentGranularity));
deepcopy_VkExtent2D(alloc, rootType, &from->minExtent, (VkExtent2D*)(&to->minExtent));
deepcopy_VkExtent2D(alloc, rootType, &from->maxExtent, (VkExtent2D*)(&to->maxExtent));
}
-void deepcopy_VkPhysicalDeviceVideoFormatInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceVideoFormatInfoKHR* from,
- VkPhysicalDeviceVideoFormatInfoKHR* to)
-{
+void deepcopy_VkPhysicalDeviceVideoFormatInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceVideoFormatInfoKHR* from,
+ VkPhysicalDeviceVideoFormatInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pVideoProfiles = nullptr;
- if (from->pVideoProfiles)
- {
+ if (from->pVideoProfiles) {
to->pVideoProfiles = (VkVideoProfilesKHR*)alloc->alloc(sizeof(const VkVideoProfilesKHR));
- deepcopy_VkVideoProfilesKHR(alloc, rootType, from->pVideoProfiles, (VkVideoProfilesKHR*)(to->pVideoProfiles));
+ deepcopy_VkVideoProfilesKHR(alloc, rootType, from->pVideoProfiles,
+ (VkVideoProfilesKHR*)(to->pVideoProfiles));
}
}
-void deepcopy_VkVideoFormatPropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoFormatPropertiesKHR* from,
- VkVideoFormatPropertiesKHR* to)
-{
+void deepcopy_VkVideoFormatPropertiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoFormatPropertiesKHR* from,
+ VkVideoFormatPropertiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkVideoPictureResourceKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoPictureResourceKHR* from,
- VkVideoPictureResourceKHR* to)
-{
+void deepcopy_VkVideoPictureResourceKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoPictureResourceKHR* from,
+ VkVideoPictureResourceKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -7107,285 +5763,232 @@
deepcopy_VkExtent2D(alloc, rootType, &from->codedExtent, (VkExtent2D*)(&to->codedExtent));
}
-void deepcopy_VkVideoReferenceSlotKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoReferenceSlotKHR* from,
- VkVideoReferenceSlotKHR* to)
-{
+void deepcopy_VkVideoReferenceSlotKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoReferenceSlotKHR* from,
+ VkVideoReferenceSlotKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pPictureResource = nullptr;
- if (from->pPictureResource)
- {
- to->pPictureResource = (VkVideoPictureResourceKHR*)alloc->alloc(sizeof(const VkVideoPictureResourceKHR));
- deepcopy_VkVideoPictureResourceKHR(alloc, rootType, from->pPictureResource, (VkVideoPictureResourceKHR*)(to->pPictureResource));
+ if (from->pPictureResource) {
+ to->pPictureResource =
+ (VkVideoPictureResourceKHR*)alloc->alloc(sizeof(const VkVideoPictureResourceKHR));
+ deepcopy_VkVideoPictureResourceKHR(alloc, rootType, from->pPictureResource,
+ (VkVideoPictureResourceKHR*)(to->pPictureResource));
}
}
-void deepcopy_VkVideoGetMemoryPropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoGetMemoryPropertiesKHR* from,
- VkVideoGetMemoryPropertiesKHR* to)
-{
+void deepcopy_VkVideoGetMemoryPropertiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoGetMemoryPropertiesKHR* from,
+ VkVideoGetMemoryPropertiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pMemoryRequirements = nullptr;
- if (from->pMemoryRequirements)
- {
- to->pMemoryRequirements = (VkMemoryRequirements2*)alloc->alloc(sizeof(VkMemoryRequirements2));
- deepcopy_VkMemoryRequirements2(alloc, rootType, from->pMemoryRequirements, (VkMemoryRequirements2*)(to->pMemoryRequirements));
+ if (from->pMemoryRequirements) {
+ to->pMemoryRequirements =
+ (VkMemoryRequirements2*)alloc->alloc(sizeof(VkMemoryRequirements2));
+ deepcopy_VkMemoryRequirements2(alloc, rootType, from->pMemoryRequirements,
+ (VkMemoryRequirements2*)(to->pMemoryRequirements));
}
}
-void deepcopy_VkVideoBindMemoryKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoBindMemoryKHR* from,
- VkVideoBindMemoryKHR* to)
-{
+void deepcopy_VkVideoBindMemoryKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoBindMemoryKHR* from, VkVideoBindMemoryKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkVideoSessionCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoSessionCreateInfoKHR* from,
- VkVideoSessionCreateInfoKHR* to)
-{
+void deepcopy_VkVideoSessionCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoSessionCreateInfoKHR* from,
+ VkVideoSessionCreateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pVideoProfile = nullptr;
- if (from->pVideoProfile)
- {
+ if (from->pVideoProfile) {
to->pVideoProfile = (VkVideoProfileKHR*)alloc->alloc(sizeof(const VkVideoProfileKHR));
- deepcopy_VkVideoProfileKHR(alloc, rootType, from->pVideoProfile, (VkVideoProfileKHR*)(to->pVideoProfile));
+ deepcopy_VkVideoProfileKHR(alloc, rootType, from->pVideoProfile,
+ (VkVideoProfileKHR*)(to->pVideoProfile));
}
deepcopy_VkExtent2D(alloc, rootType, &from->maxCodedExtent, (VkExtent2D*)(&to->maxCodedExtent));
}
void deepcopy_VkVideoSessionParametersCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoSessionParametersCreateInfoKHR* from,
- VkVideoSessionParametersCreateInfoKHR* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkVideoSessionParametersCreateInfoKHR* from,
+ VkVideoSessionParametersCreateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkVideoSessionParametersUpdateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoSessionParametersUpdateInfoKHR* from,
- VkVideoSessionParametersUpdateInfoKHR* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkVideoSessionParametersUpdateInfoKHR* from,
+ VkVideoSessionParametersUpdateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkVideoBeginCodingInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoBeginCodingInfoKHR* from,
- VkVideoBeginCodingInfoKHR* to)
-{
+void deepcopy_VkVideoBeginCodingInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoBeginCodingInfoKHR* from,
+ VkVideoBeginCodingInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pReferenceSlots = nullptr;
- if (from->pReferenceSlots)
- {
- to->pReferenceSlots = (VkVideoReferenceSlotKHR*)alloc->alloc(from->referenceSlotCount * sizeof(const VkVideoReferenceSlotKHR));
+ if (from->pReferenceSlots) {
+ to->pReferenceSlots = (VkVideoReferenceSlotKHR*)alloc->alloc(
+ from->referenceSlotCount * sizeof(const VkVideoReferenceSlotKHR));
to->referenceSlotCount = from->referenceSlotCount;
- for (uint32_t i = 0; i < (uint32_t)from->referenceSlotCount; ++i)
- {
- deepcopy_VkVideoReferenceSlotKHR(alloc, rootType, from->pReferenceSlots + i, (VkVideoReferenceSlotKHR*)(to->pReferenceSlots + i));
+ for (uint32_t i = 0; i < (uint32_t)from->referenceSlotCount; ++i) {
+ deepcopy_VkVideoReferenceSlotKHR(
+ alloc, rootType, from->pReferenceSlots + i,
+ (VkVideoReferenceSlotKHR*)(to->pReferenceSlots + i));
}
}
}
}
-void deepcopy_VkVideoEndCodingInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEndCodingInfoKHR* from,
- VkVideoEndCodingInfoKHR* to)
-{
+void deepcopy_VkVideoEndCodingInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEndCodingInfoKHR* from,
+ VkVideoEndCodingInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkVideoCodingControlInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoCodingControlInfoKHR* from,
- VkVideoCodingControlInfoKHR* to)
-{
+void deepcopy_VkVideoCodingControlInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoCodingControlInfoKHR* from,
+ VkVideoCodingControlInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -7393,51 +5996,46 @@
#endif
#ifdef VK_KHR_video_decode_queue
-void deepcopy_VkVideoDecodeInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeInfoKHR* from,
- VkVideoDecodeInfoKHR* to)
-{
+void deepcopy_VkVideoDecodeInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoDecodeInfoKHR* from, VkVideoDecodeInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
deepcopy_VkOffset2D(alloc, rootType, &from->codedOffset, (VkOffset2D*)(&to->codedOffset));
deepcopy_VkExtent2D(alloc, rootType, &from->codedExtent, (VkExtent2D*)(&to->codedExtent));
- deepcopy_VkVideoPictureResourceKHR(alloc, rootType, &from->dstPictureResource, (VkVideoPictureResourceKHR*)(&to->dstPictureResource));
+ deepcopy_VkVideoPictureResourceKHR(alloc, rootType, &from->dstPictureResource,
+ (VkVideoPictureResourceKHR*)(&to->dstPictureResource));
to->pSetupReferenceSlot = nullptr;
- if (from->pSetupReferenceSlot)
- {
- to->pSetupReferenceSlot = (VkVideoReferenceSlotKHR*)alloc->alloc(sizeof(const VkVideoReferenceSlotKHR));
- deepcopy_VkVideoReferenceSlotKHR(alloc, rootType, from->pSetupReferenceSlot, (VkVideoReferenceSlotKHR*)(to->pSetupReferenceSlot));
+ if (from->pSetupReferenceSlot) {
+ to->pSetupReferenceSlot =
+ (VkVideoReferenceSlotKHR*)alloc->alloc(sizeof(const VkVideoReferenceSlotKHR));
+ deepcopy_VkVideoReferenceSlotKHR(alloc, rootType, from->pSetupReferenceSlot,
+ (VkVideoReferenceSlotKHR*)(to->pSetupReferenceSlot));
}
- if (from)
- {
+ if (from) {
to->pReferenceSlots = nullptr;
- if (from->pReferenceSlots)
- {
- to->pReferenceSlots = (VkVideoReferenceSlotKHR*)alloc->alloc(from->referenceSlotCount * sizeof(const VkVideoReferenceSlotKHR));
+ if (from->pReferenceSlots) {
+ to->pReferenceSlots = (VkVideoReferenceSlotKHR*)alloc->alloc(
+ from->referenceSlotCount * sizeof(const VkVideoReferenceSlotKHR));
to->referenceSlotCount = from->referenceSlotCount;
- for (uint32_t i = 0; i < (uint32_t)from->referenceSlotCount; ++i)
- {
- deepcopy_VkVideoReferenceSlotKHR(alloc, rootType, from->pReferenceSlots + i, (VkVideoReferenceSlotKHR*)(to->pReferenceSlots + i));
+ for (uint32_t i = 0; i < (uint32_t)from->referenceSlotCount; ++i) {
+ deepcopy_VkVideoReferenceSlotKHR(
+ alloc, rootType, from->pReferenceSlots + i,
+ (VkVideoReferenceSlotKHR*)(to->pReferenceSlots + i));
}
}
}
@@ -7445,296 +6043,251 @@
#endif
#ifdef VK_KHR_dynamic_rendering
-void deepcopy_VkRenderingAttachmentInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRenderingAttachmentInfoKHR* from,
- VkRenderingAttachmentInfoKHR* to)
-{
+void deepcopy_VkRenderingAttachmentInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkRenderingAttachmentInfoKHR* from,
+ VkRenderingAttachmentInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
deepcopy_VkClearValue(alloc, rootType, &from->clearValue, (VkClearValue*)(&to->clearValue));
}
-void deepcopy_VkRenderingInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRenderingInfoKHR* from,
- VkRenderingInfoKHR* to)
-{
+void deepcopy_VkRenderingInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkRenderingInfoKHR* from, VkRenderingInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
deepcopy_VkRect2D(alloc, rootType, &from->renderArea, (VkRect2D*)(&to->renderArea));
- if (from)
- {
+ if (from) {
to->pColorAttachments = nullptr;
- if (from->pColorAttachments)
- {
- to->pColorAttachments = (VkRenderingAttachmentInfoKHR*)alloc->alloc(from->colorAttachmentCount * sizeof(const VkRenderingAttachmentInfoKHR));
+ if (from->pColorAttachments) {
+ to->pColorAttachments = (VkRenderingAttachmentInfoKHR*)alloc->alloc(
+ from->colorAttachmentCount * sizeof(const VkRenderingAttachmentInfoKHR));
to->colorAttachmentCount = from->colorAttachmentCount;
- for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i)
- {
- deepcopy_VkRenderingAttachmentInfoKHR(alloc, rootType, from->pColorAttachments + i, (VkRenderingAttachmentInfoKHR*)(to->pColorAttachments + i));
+ for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i) {
+ deepcopy_VkRenderingAttachmentInfoKHR(
+ alloc, rootType, from->pColorAttachments + i,
+ (VkRenderingAttachmentInfoKHR*)(to->pColorAttachments + i));
}
}
}
to->pDepthAttachment = nullptr;
- if (from->pDepthAttachment)
- {
- to->pDepthAttachment = (VkRenderingAttachmentInfoKHR*)alloc->alloc(sizeof(const VkRenderingAttachmentInfoKHR));
- deepcopy_VkRenderingAttachmentInfoKHR(alloc, rootType, from->pDepthAttachment, (VkRenderingAttachmentInfoKHR*)(to->pDepthAttachment));
+ if (from->pDepthAttachment) {
+ to->pDepthAttachment =
+ (VkRenderingAttachmentInfoKHR*)alloc->alloc(sizeof(const VkRenderingAttachmentInfoKHR));
+ deepcopy_VkRenderingAttachmentInfoKHR(
+ alloc, rootType, from->pDepthAttachment,
+ (VkRenderingAttachmentInfoKHR*)(to->pDepthAttachment));
}
to->pStencilAttachment = nullptr;
- if (from->pStencilAttachment)
- {
- to->pStencilAttachment = (VkRenderingAttachmentInfoKHR*)alloc->alloc(sizeof(const VkRenderingAttachmentInfoKHR));
- deepcopy_VkRenderingAttachmentInfoKHR(alloc, rootType, from->pStencilAttachment, (VkRenderingAttachmentInfoKHR*)(to->pStencilAttachment));
+ if (from->pStencilAttachment) {
+ to->pStencilAttachment =
+ (VkRenderingAttachmentInfoKHR*)alloc->alloc(sizeof(const VkRenderingAttachmentInfoKHR));
+ deepcopy_VkRenderingAttachmentInfoKHR(
+ alloc, rootType, from->pStencilAttachment,
+ (VkRenderingAttachmentInfoKHR*)(to->pStencilAttachment));
}
}
-void deepcopy_VkPipelineRenderingCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineRenderingCreateInfoKHR* from,
- VkPipelineRenderingCreateInfoKHR* to)
-{
+void deepcopy_VkPipelineRenderingCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineRenderingCreateInfoKHR* from,
+ VkPipelineRenderingCreateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pColorAttachmentFormats = nullptr;
- if (from->pColorAttachmentFormats)
- {
- to->pColorAttachmentFormats = (VkFormat*)alloc->dupArray(from->pColorAttachmentFormats, from->colorAttachmentCount * sizeof(const VkFormat));
+ if (from->pColorAttachmentFormats) {
+ to->pColorAttachmentFormats = (VkFormat*)alloc->dupArray(
+ from->pColorAttachmentFormats, from->colorAttachmentCount * sizeof(const VkFormat));
}
}
void deepcopy_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDynamicRenderingFeaturesKHR* from,
- VkPhysicalDeviceDynamicRenderingFeaturesKHR* to)
-{
+ VkPhysicalDeviceDynamicRenderingFeaturesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkCommandBufferInheritanceRenderingInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkCommandBufferInheritanceRenderingInfoKHR* from,
- VkCommandBufferInheritanceRenderingInfoKHR* to)
-{
+ VkCommandBufferInheritanceRenderingInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pColorAttachmentFormats = nullptr;
- if (from->pColorAttachmentFormats)
- {
- to->pColorAttachmentFormats = (VkFormat*)alloc->dupArray(from->pColorAttachmentFormats, from->colorAttachmentCount * sizeof(const VkFormat));
+ if (from->pColorAttachmentFormats) {
+ to->pColorAttachmentFormats = (VkFormat*)alloc->dupArray(
+ from->pColorAttachmentFormats, from->colorAttachmentCount * sizeof(const VkFormat));
}
}
void deepcopy_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkRenderingFragmentShadingRateAttachmentInfoKHR* from,
- VkRenderingFragmentShadingRateAttachmentInfoKHR* to)
-{
+ VkRenderingFragmentShadingRateAttachmentInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(alloc, rootType, &from->shadingRateAttachmentTexelSize, (VkExtent2D*)(&to->shadingRateAttachmentTexelSize));
+ deepcopy_VkExtent2D(alloc, rootType, &from->shadingRateAttachmentTexelSize,
+ (VkExtent2D*)(&to->shadingRateAttachmentTexelSize));
}
void deepcopy_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkRenderingFragmentDensityMapAttachmentInfoEXT* from,
- VkRenderingFragmentDensityMapAttachmentInfoEXT* to)
-{
+ VkRenderingFragmentDensityMapAttachmentInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkAttachmentSampleCountInfoAMD(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAttachmentSampleCountInfoAMD* from,
- VkAttachmentSampleCountInfoAMD* to)
-{
+void deepcopy_VkAttachmentSampleCountInfoAMD(Allocator* alloc, VkStructureType rootType,
+ const VkAttachmentSampleCountInfoAMD* from,
+ VkAttachmentSampleCountInfoAMD* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pColorAttachmentSamples = nullptr;
- if (from->pColorAttachmentSamples)
- {
- to->pColorAttachmentSamples = (VkSampleCountFlagBits*)alloc->dupArray(from->pColorAttachmentSamples, from->colorAttachmentCount * sizeof(const VkSampleCountFlagBits));
+ if (from->pColorAttachmentSamples) {
+ to->pColorAttachmentSamples = (VkSampleCountFlagBits*)alloc->dupArray(
+ from->pColorAttachmentSamples,
+ from->colorAttachmentCount * sizeof(const VkSampleCountFlagBits));
}
}
-void deepcopy_VkMultiviewPerViewAttributesInfoNVX(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMultiviewPerViewAttributesInfoNVX* from,
- VkMultiviewPerViewAttributesInfoNVX* to)
-{
+void deepcopy_VkMultiviewPerViewAttributesInfoNVX(Allocator* alloc, VkStructureType rootType,
+ const VkMultiviewPerViewAttributesInfoNVX* from,
+ VkMultiviewPerViewAttributesInfoNVX* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -7758,118 +6311,94 @@
#ifdef VK_KHR_external_memory
#endif
#ifdef VK_KHR_external_memory_win32
-void deepcopy_VkImportMemoryWin32HandleInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportMemoryWin32HandleInfoKHR* from,
- VkImportMemoryWin32HandleInfoKHR* to)
-{
+void deepcopy_VkImportMemoryWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkImportMemoryWin32HandleInfoKHR* from,
+ VkImportMemoryWin32HandleInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkExportMemoryWin32HandleInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExportMemoryWin32HandleInfoKHR* from,
- VkExportMemoryWin32HandleInfoKHR* to)
-{
+void deepcopy_VkExportMemoryWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkExportMemoryWin32HandleInfoKHR* from,
+ VkExportMemoryWin32HandleInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pAttributes = nullptr;
- if (from->pAttributes)
- {
- to->pAttributes = (SECURITY_ATTRIBUTES*)alloc->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ if (from->pAttributes) {
+ to->pAttributes = (SECURITY_ATTRIBUTES*)alloc->dupArray(from->pAttributes,
+ sizeof(const SECURITY_ATTRIBUTES));
}
}
-void deepcopy_VkMemoryWin32HandlePropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryWin32HandlePropertiesKHR* from,
- VkMemoryWin32HandlePropertiesKHR* to)
-{
+void deepcopy_VkMemoryWin32HandlePropertiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryWin32HandlePropertiesKHR* from,
+ VkMemoryWin32HandlePropertiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkMemoryGetWin32HandleInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryGetWin32HandleInfoKHR* from,
- VkMemoryGetWin32HandleInfoKHR* to)
-{
+void deepcopy_VkMemoryGetWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryGetWin32HandleInfoKHR* from,
+ VkMemoryGetWin32HandleInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -7877,85 +6406,66 @@
#endif
#ifdef VK_KHR_external_memory_fd
-void deepcopy_VkImportMemoryFdInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportMemoryFdInfoKHR* from,
- VkImportMemoryFdInfoKHR* to)
-{
+void deepcopy_VkImportMemoryFdInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkImportMemoryFdInfoKHR* from,
+ VkImportMemoryFdInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkMemoryFdPropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryFdPropertiesKHR* from,
- VkMemoryFdPropertiesKHR* to)
-{
+void deepcopy_VkMemoryFdPropertiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryFdPropertiesKHR* from,
+ VkMemoryFdPropertiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkMemoryGetFdInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryGetFdInfoKHR* from,
- VkMemoryGetFdInfoKHR* to)
-{
+void deepcopy_VkMemoryGetFdInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryGetFdInfoKHR* from, VkMemoryGetFdInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -7964,55 +6474,49 @@
#endif
#ifdef VK_KHR_win32_keyed_mutex
void deepcopy_VkWin32KeyedMutexAcquireReleaseInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkWin32KeyedMutexAcquireReleaseInfoKHR* from,
- VkWin32KeyedMutexAcquireReleaseInfoKHR* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkWin32KeyedMutexAcquireReleaseInfoKHR* from,
+ VkWin32KeyedMutexAcquireReleaseInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pAcquireSyncs = nullptr;
- if (from->pAcquireSyncs)
- {
- to->pAcquireSyncs = (VkDeviceMemory*)alloc->dupArray(from->pAcquireSyncs, from->acquireCount * sizeof(const VkDeviceMemory));
+ if (from->pAcquireSyncs) {
+ to->pAcquireSyncs = (VkDeviceMemory*)alloc->dupArray(
+ from->pAcquireSyncs, from->acquireCount * sizeof(const VkDeviceMemory));
}
to->pAcquireKeys = nullptr;
- if (from->pAcquireKeys)
- {
- to->pAcquireKeys = (uint64_t*)alloc->dupArray(from->pAcquireKeys, from->acquireCount * sizeof(const uint64_t));
+ if (from->pAcquireKeys) {
+ to->pAcquireKeys = (uint64_t*)alloc->dupArray(from->pAcquireKeys,
+ from->acquireCount * sizeof(const uint64_t));
}
to->pAcquireTimeouts = nullptr;
- if (from->pAcquireTimeouts)
- {
- to->pAcquireTimeouts = (uint32_t*)alloc->dupArray(from->pAcquireTimeouts, from->acquireCount * sizeof(const uint32_t));
+ if (from->pAcquireTimeouts) {
+ to->pAcquireTimeouts = (uint32_t*)alloc->dupArray(
+ from->pAcquireTimeouts, from->acquireCount * sizeof(const uint32_t));
}
to->pReleaseSyncs = nullptr;
- if (from->pReleaseSyncs)
- {
- to->pReleaseSyncs = (VkDeviceMemory*)alloc->dupArray(from->pReleaseSyncs, from->releaseCount * sizeof(const VkDeviceMemory));
+ if (from->pReleaseSyncs) {
+ to->pReleaseSyncs = (VkDeviceMemory*)alloc->dupArray(
+ from->pReleaseSyncs, from->releaseCount * sizeof(const VkDeviceMemory));
}
to->pReleaseKeys = nullptr;
- if (from->pReleaseKeys)
- {
- to->pReleaseKeys = (uint64_t*)alloc->dupArray(from->pReleaseKeys, from->releaseCount * sizeof(const uint64_t));
+ if (from->pReleaseKeys) {
+ to->pReleaseKeys = (uint64_t*)alloc->dupArray(from->pReleaseKeys,
+ from->releaseCount * sizeof(const uint64_t));
}
}
@@ -8022,128 +6526,105 @@
#ifdef VK_KHR_external_semaphore
#endif
#ifdef VK_KHR_external_semaphore_win32
-void deepcopy_VkImportSemaphoreWin32HandleInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportSemaphoreWin32HandleInfoKHR* from,
- VkImportSemaphoreWin32HandleInfoKHR* to)
-{
+void deepcopy_VkImportSemaphoreWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkImportSemaphoreWin32HandleInfoKHR* from,
+ VkImportSemaphoreWin32HandleInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkExportSemaphoreWin32HandleInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExportSemaphoreWin32HandleInfoKHR* from,
- VkExportSemaphoreWin32HandleInfoKHR* to)
-{
+void deepcopy_VkExportSemaphoreWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkExportSemaphoreWin32HandleInfoKHR* from,
+ VkExportSemaphoreWin32HandleInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pAttributes = nullptr;
- if (from->pAttributes)
- {
- to->pAttributes = (SECURITY_ATTRIBUTES*)alloc->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ if (from->pAttributes) {
+ to->pAttributes = (SECURITY_ATTRIBUTES*)alloc->dupArray(from->pAttributes,
+ sizeof(const SECURITY_ATTRIBUTES));
}
}
-void deepcopy_VkD3D12FenceSubmitInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkD3D12FenceSubmitInfoKHR* from,
- VkD3D12FenceSubmitInfoKHR* to)
-{
+void deepcopy_VkD3D12FenceSubmitInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkD3D12FenceSubmitInfoKHR* from,
+ VkD3D12FenceSubmitInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pWaitSemaphoreValues = nullptr;
- if (from->pWaitSemaphoreValues)
- {
- to->pWaitSemaphoreValues = (uint64_t*)alloc->dupArray(from->pWaitSemaphoreValues, from->waitSemaphoreValuesCount * sizeof(const uint64_t));
+ if (from->pWaitSemaphoreValues) {
+ to->pWaitSemaphoreValues = (uint64_t*)alloc->dupArray(
+ from->pWaitSemaphoreValues, from->waitSemaphoreValuesCount * sizeof(const uint64_t));
}
to->pSignalSemaphoreValues = nullptr;
- if (from->pSignalSemaphoreValues)
- {
- to->pSignalSemaphoreValues = (uint64_t*)alloc->dupArray(from->pSignalSemaphoreValues, from->signalSemaphoreValuesCount * sizeof(const uint64_t));
+ if (from->pSignalSemaphoreValues) {
+ to->pSignalSemaphoreValues =
+ (uint64_t*)alloc->dupArray(from->pSignalSemaphoreValues,
+ from->signalSemaphoreValuesCount * sizeof(const uint64_t));
}
}
-void deepcopy_VkSemaphoreGetWin32HandleInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSemaphoreGetWin32HandleInfoKHR* from,
- VkSemaphoreGetWin32HandleInfoKHR* to)
-{
+void deepcopy_VkSemaphoreGetWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkSemaphoreGetWin32HandleInfoKHR* from,
+ VkSemaphoreGetWin32HandleInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -8151,57 +6632,45 @@
#endif
#ifdef VK_KHR_external_semaphore_fd
-void deepcopy_VkImportSemaphoreFdInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportSemaphoreFdInfoKHR* from,
- VkImportSemaphoreFdInfoKHR* to)
-{
+void deepcopy_VkImportSemaphoreFdInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkImportSemaphoreFdInfoKHR* from,
+ VkImportSemaphoreFdInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkSemaphoreGetFdInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSemaphoreGetFdInfoKHR* from,
- VkSemaphoreGetFdInfoKHR* to)
-{
+void deepcopy_VkSemaphoreGetFdInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkSemaphoreGetFdInfoKHR* from,
+ VkSemaphoreGetFdInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -8210,28 +6679,23 @@
#endif
#ifdef VK_KHR_push_descriptor
void deepcopy_VkPhysicalDevicePushDescriptorPropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDevicePushDescriptorPropertiesKHR* from,
- VkPhysicalDevicePushDescriptorPropertiesKHR* to)
-{
+ VkPhysicalDevicePushDescriptorPropertiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -8243,12 +6707,8 @@
#ifdef VK_KHR_16bit_storage
#endif
#ifdef VK_KHR_incremental_present
-void deepcopy_VkRectLayerKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRectLayerKHR* from,
- VkRectLayerKHR* to)
-{
+void deepcopy_VkRectLayerKHR(Allocator* alloc, VkStructureType rootType, const VkRectLayerKHR* from,
+ VkRectLayerKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
@@ -8256,66 +6716,53 @@
deepcopy_VkExtent2D(alloc, rootType, &from->extent, (VkExtent2D*)(&to->extent));
}
-void deepcopy_VkPresentRegionKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPresentRegionKHR* from,
- VkPresentRegionKHR* to)
-{
+void deepcopy_VkPresentRegionKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPresentRegionKHR* from, VkPresentRegionKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (from)
- {
+ if (from) {
to->pRectangles = nullptr;
- if (from->pRectangles)
- {
- to->pRectangles = (VkRectLayerKHR*)alloc->alloc(from->rectangleCount * sizeof(const VkRectLayerKHR));
+ if (from->pRectangles) {
+ to->pRectangles =
+ (VkRectLayerKHR*)alloc->alloc(from->rectangleCount * sizeof(const VkRectLayerKHR));
to->rectangleCount = from->rectangleCount;
- for (uint32_t i = 0; i < (uint32_t)from->rectangleCount; ++i)
- {
- deepcopy_VkRectLayerKHR(alloc, rootType, from->pRectangles + i, (VkRectLayerKHR*)(to->pRectangles + i));
+ for (uint32_t i = 0; i < (uint32_t)from->rectangleCount; ++i) {
+ deepcopy_VkRectLayerKHR(alloc, rootType, from->pRectangles + i,
+ (VkRectLayerKHR*)(to->pRectangles + i));
}
}
}
}
-void deepcopy_VkPresentRegionsKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPresentRegionsKHR* from,
- VkPresentRegionsKHR* to)
-{
+void deepcopy_VkPresentRegionsKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPresentRegionsKHR* from, VkPresentRegionsKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pRegions = nullptr;
- if (from->pRegions)
- {
- to->pRegions = (VkPresentRegionKHR*)alloc->alloc(from->swapchainCount * sizeof(const VkPresentRegionKHR));
+ if (from->pRegions) {
+ to->pRegions = (VkPresentRegionKHR*)alloc->alloc(from->swapchainCount *
+ sizeof(const VkPresentRegionKHR));
to->swapchainCount = from->swapchainCount;
- for (uint32_t i = 0; i < (uint32_t)from->swapchainCount; ++i)
- {
- deepcopy_VkPresentRegionKHR(alloc, rootType, from->pRegions + i, (VkPresentRegionKHR*)(to->pRegions + i));
+ for (uint32_t i = 0; i < (uint32_t)from->swapchainCount; ++i) {
+ deepcopy_VkPresentRegionKHR(alloc, rootType, from->pRegions + i,
+ (VkPresentRegionKHR*)(to->pRegions + i));
}
}
}
@@ -8330,28 +6777,22 @@
#endif
#ifdef VK_KHR_shared_presentable_image
void deepcopy_VkSharedPresentSurfaceCapabilitiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSharedPresentSurfaceCapabilitiesKHR* from,
- VkSharedPresentSurfaceCapabilitiesKHR* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkSharedPresentSurfaceCapabilitiesKHR* from,
+ VkSharedPresentSurfaceCapabilitiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -8363,90 +6804,72 @@
#ifdef VK_KHR_external_fence
#endif
#ifdef VK_KHR_external_fence_win32
-void deepcopy_VkImportFenceWin32HandleInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportFenceWin32HandleInfoKHR* from,
- VkImportFenceWin32HandleInfoKHR* to)
-{
+void deepcopy_VkImportFenceWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkImportFenceWin32HandleInfoKHR* from,
+ VkImportFenceWin32HandleInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkExportFenceWin32HandleInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExportFenceWin32HandleInfoKHR* from,
- VkExportFenceWin32HandleInfoKHR* to)
-{
+void deepcopy_VkExportFenceWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkExportFenceWin32HandleInfoKHR* from,
+ VkExportFenceWin32HandleInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pAttributes = nullptr;
- if (from->pAttributes)
- {
- to->pAttributes = (SECURITY_ATTRIBUTES*)alloc->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ if (from->pAttributes) {
+ to->pAttributes = (SECURITY_ATTRIBUTES*)alloc->dupArray(from->pAttributes,
+ sizeof(const SECURITY_ATTRIBUTES));
}
}
-void deepcopy_VkFenceGetWin32HandleInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFenceGetWin32HandleInfoKHR* from,
- VkFenceGetWin32HandleInfoKHR* to)
-{
+void deepcopy_VkFenceGetWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkFenceGetWin32HandleInfoKHR* from,
+ VkFenceGetWin32HandleInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -8454,57 +6877,44 @@
#endif
#ifdef VK_KHR_external_fence_fd
-void deepcopy_VkImportFenceFdInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportFenceFdInfoKHR* from,
- VkImportFenceFdInfoKHR* to)
-{
+void deepcopy_VkImportFenceFdInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkImportFenceFdInfoKHR* from,
+ VkImportFenceFdInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkFenceGetFdInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFenceGetFdInfoKHR* from,
- VkFenceGetFdInfoKHR* to)
-{
+void deepcopy_VkFenceGetFdInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkFenceGetFdInfoKHR* from, VkFenceGetFdInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -8513,113 +6923,91 @@
#endif
#ifdef VK_KHR_performance_query
void deepcopy_VkPhysicalDevicePerformanceQueryFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDevicePerformanceQueryFeaturesKHR* from,
- VkPhysicalDevicePerformanceQueryFeaturesKHR* to)
-{
+ VkPhysicalDevicePerformanceQueryFeaturesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDevicePerformanceQueryPropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDevicePerformanceQueryPropertiesKHR* from,
- VkPhysicalDevicePerformanceQueryPropertiesKHR* to)
-{
+ VkPhysicalDevicePerformanceQueryPropertiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkPerformanceCounterKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPerformanceCounterKHR* from,
- VkPerformanceCounterKHR* to)
-{
+void deepcopy_VkPerformanceCounterKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPerformanceCounterKHR* from,
+ VkPerformanceCounterKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
memcpy(to->uuid, from->uuid, VK_UUID_SIZE * sizeof(uint8_t));
}
-void deepcopy_VkPerformanceCounterDescriptionKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPerformanceCounterDescriptionKHR* from,
- VkPerformanceCounterDescriptionKHR* to)
-{
+void deepcopy_VkPerformanceCounterDescriptionKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPerformanceCounterDescriptionKHR* from,
+ VkPerformanceCounterDescriptionKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -8628,101 +7016,80 @@
memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
}
-void deepcopy_VkQueryPoolPerformanceCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkQueryPoolPerformanceCreateInfoKHR* from,
- VkQueryPoolPerformanceCreateInfoKHR* to)
-{
+void deepcopy_VkQueryPoolPerformanceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkQueryPoolPerformanceCreateInfoKHR* from,
+ VkQueryPoolPerformanceCreateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pCounterIndices = nullptr;
- if (from->pCounterIndices)
- {
- to->pCounterIndices = (uint32_t*)alloc->dupArray(from->pCounterIndices, from->counterIndexCount * sizeof(const uint32_t));
+ if (from->pCounterIndices) {
+ to->pCounterIndices = (uint32_t*)alloc->dupArray(
+ from->pCounterIndices, from->counterIndexCount * sizeof(const uint32_t));
}
}
-void deepcopy_VkPerformanceCounterResultKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPerformanceCounterResultKHR* from,
- VkPerformanceCounterResultKHR* to)
-{
+void deepcopy_VkPerformanceCounterResultKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPerformanceCounterResultKHR* from,
+ VkPerformanceCounterResultKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkAcquireProfilingLockInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAcquireProfilingLockInfoKHR* from,
- VkAcquireProfilingLockInfoKHR* to)
-{
+void deepcopy_VkAcquireProfilingLockInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkAcquireProfilingLockInfoKHR* from,
+ VkAcquireProfilingLockInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkPerformanceQuerySubmitInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPerformanceQuerySubmitInfoKHR* from,
- VkPerformanceQuerySubmitInfoKHR* to)
-{
+void deepcopy_VkPerformanceQuerySubmitInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPerformanceQuerySubmitInfoKHR* from,
+ VkPerformanceQuerySubmitInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -8732,238 +7099,196 @@
#ifdef VK_KHR_maintenance2
#endif
#ifdef VK_KHR_get_surface_capabilities2
-void deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceSurfaceInfo2KHR* from,
- VkPhysicalDeviceSurfaceInfo2KHR* to)
-{
+void deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceSurfaceInfo2KHR* from,
+ VkPhysicalDeviceSurfaceInfo2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkSurfaceCapabilities2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSurfaceCapabilities2KHR* from,
- VkSurfaceCapabilities2KHR* to)
-{
+void deepcopy_VkSurfaceCapabilities2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkSurfaceCapabilities2KHR* from,
+ VkSurfaceCapabilities2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkSurfaceCapabilitiesKHR(alloc, rootType, &from->surfaceCapabilities, (VkSurfaceCapabilitiesKHR*)(&to->surfaceCapabilities));
+ deepcopy_VkSurfaceCapabilitiesKHR(alloc, rootType, &from->surfaceCapabilities,
+ (VkSurfaceCapabilitiesKHR*)(&to->surfaceCapabilities));
}
-void deepcopy_VkSurfaceFormat2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSurfaceFormat2KHR* from,
- VkSurfaceFormat2KHR* to)
-{
+void deepcopy_VkSurfaceFormat2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkSurfaceFormat2KHR* from, VkSurfaceFormat2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkSurfaceFormatKHR(alloc, rootType, &from->surfaceFormat, (VkSurfaceFormatKHR*)(&to->surfaceFormat));
+ deepcopy_VkSurfaceFormatKHR(alloc, rootType, &from->surfaceFormat,
+ (VkSurfaceFormatKHR*)(&to->surfaceFormat));
}
#endif
#ifdef VK_KHR_variable_pointers
#endif
#ifdef VK_KHR_get_display_properties2
-void deepcopy_VkDisplayProperties2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayProperties2KHR* from,
- VkDisplayProperties2KHR* to)
-{
+void deepcopy_VkDisplayProperties2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayProperties2KHR* from,
+ VkDisplayProperties2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDisplayPropertiesKHR(alloc, rootType, &from->displayProperties, (VkDisplayPropertiesKHR*)(&to->displayProperties));
+ deepcopy_VkDisplayPropertiesKHR(alloc, rootType, &from->displayProperties,
+ (VkDisplayPropertiesKHR*)(&to->displayProperties));
}
-void deepcopy_VkDisplayPlaneProperties2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayPlaneProperties2KHR* from,
- VkDisplayPlaneProperties2KHR* to)
-{
+void deepcopy_VkDisplayPlaneProperties2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayPlaneProperties2KHR* from,
+ VkDisplayPlaneProperties2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDisplayPlanePropertiesKHR(alloc, rootType, &from->displayPlaneProperties, (VkDisplayPlanePropertiesKHR*)(&to->displayPlaneProperties));
+ deepcopy_VkDisplayPlanePropertiesKHR(
+ alloc, rootType, &from->displayPlaneProperties,
+ (VkDisplayPlanePropertiesKHR*)(&to->displayPlaneProperties));
}
-void deepcopy_VkDisplayModeProperties2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayModeProperties2KHR* from,
- VkDisplayModeProperties2KHR* to)
-{
+void deepcopy_VkDisplayModeProperties2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayModeProperties2KHR* from,
+ VkDisplayModeProperties2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDisplayModePropertiesKHR(alloc, rootType, &from->displayModeProperties, (VkDisplayModePropertiesKHR*)(&to->displayModeProperties));
+ deepcopy_VkDisplayModePropertiesKHR(alloc, rootType, &from->displayModeProperties,
+ (VkDisplayModePropertiesKHR*)(&to->displayModeProperties));
}
-void deepcopy_VkDisplayPlaneInfo2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayPlaneInfo2KHR* from,
- VkDisplayPlaneInfo2KHR* to)
-{
+void deepcopy_VkDisplayPlaneInfo2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayPlaneInfo2KHR* from,
+ VkDisplayPlaneInfo2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkDisplayPlaneCapabilities2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayPlaneCapabilities2KHR* from,
- VkDisplayPlaneCapabilities2KHR* to)
-{
+void deepcopy_VkDisplayPlaneCapabilities2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayPlaneCapabilities2KHR* from,
+ VkDisplayPlaneCapabilities2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDisplayPlaneCapabilitiesKHR(alloc, rootType, &from->capabilities, (VkDisplayPlaneCapabilitiesKHR*)(&to->capabilities));
+ deepcopy_VkDisplayPlaneCapabilitiesKHR(alloc, rootType, &from->capabilities,
+ (VkDisplayPlaneCapabilitiesKHR*)(&to->capabilities));
}
#endif
@@ -8983,56 +7308,46 @@
#endif
#ifdef VK_KHR_portability_subset
void deepcopy_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDevicePortabilitySubsetFeaturesKHR* from,
- VkPhysicalDevicePortabilitySubsetFeaturesKHR* to)
-{
+ VkPhysicalDevicePortabilitySubsetFeaturesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDevicePortabilitySubsetPropertiesKHR* from,
- VkPhysicalDevicePortabilitySubsetPropertiesKHR* to)
-{
+ VkPhysicalDevicePortabilitySubsetPropertiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -9051,28 +7366,22 @@
#endif
#ifdef VK_KHR_shader_clock
void deepcopy_VkPhysicalDeviceShaderClockFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderClockFeaturesKHR* from,
- VkPhysicalDeviceShaderClockFeaturesKHR* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceShaderClockFeaturesKHR* from,
+ VkPhysicalDeviceShaderClockFeaturesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -9093,28 +7402,23 @@
#endif
#ifdef VK_KHR_shader_terminate_invocation
void deepcopy_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* from,
- VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* to)
-{
+ VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -9123,63 +7427,55 @@
#endif
#ifdef VK_KHR_fragment_shading_rate
void deepcopy_VkFragmentShadingRateAttachmentInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFragmentShadingRateAttachmentInfoKHR* from,
- VkFragmentShadingRateAttachmentInfoKHR* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkFragmentShadingRateAttachmentInfoKHR* from,
+ VkFragmentShadingRateAttachmentInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pFragmentShadingRateAttachment = nullptr;
- if (from->pFragmentShadingRateAttachment)
- {
- to->pFragmentShadingRateAttachment = (VkAttachmentReference2*)alloc->alloc(sizeof(const VkAttachmentReference2));
- deepcopy_VkAttachmentReference2(alloc, rootType, from->pFragmentShadingRateAttachment, (VkAttachmentReference2*)(to->pFragmentShadingRateAttachment));
+ if (from->pFragmentShadingRateAttachment) {
+ to->pFragmentShadingRateAttachment =
+ (VkAttachmentReference2*)alloc->alloc(sizeof(const VkAttachmentReference2));
+ deepcopy_VkAttachmentReference2(
+ alloc, rootType, from->pFragmentShadingRateAttachment,
+ (VkAttachmentReference2*)(to->pFragmentShadingRateAttachment));
}
- deepcopy_VkExtent2D(alloc, rootType, &from->shadingRateAttachmentTexelSize, (VkExtent2D*)(&to->shadingRateAttachmentTexelSize));
+ deepcopy_VkExtent2D(alloc, rootType, &from->shadingRateAttachmentTexelSize,
+ (VkExtent2D*)(&to->shadingRateAttachmentTexelSize));
}
void deepcopy_VkPipelineFragmentShadingRateStateCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineFragmentShadingRateStateCreateInfoKHR* from,
- VkPipelineFragmentShadingRateStateCreateInfoKHR* to)
-{
+ VkPipelineFragmentShadingRateStateCreateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -9188,87 +7484,74 @@
}
void deepcopy_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* from,
- VkPhysicalDeviceFragmentShadingRateFeaturesKHR* to)
-{
+ VkPhysicalDeviceFragmentShadingRateFeaturesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* from,
- VkPhysicalDeviceFragmentShadingRatePropertiesKHR* to)
-{
+ VkPhysicalDeviceFragmentShadingRatePropertiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(alloc, rootType, &from->minFragmentShadingRateAttachmentTexelSize, (VkExtent2D*)(&to->minFragmentShadingRateAttachmentTexelSize));
- deepcopy_VkExtent2D(alloc, rootType, &from->maxFragmentShadingRateAttachmentTexelSize, (VkExtent2D*)(&to->maxFragmentShadingRateAttachmentTexelSize));
- deepcopy_VkExtent2D(alloc, rootType, &from->maxFragmentSize, (VkExtent2D*)(&to->maxFragmentSize));
+ deepcopy_VkExtent2D(alloc, rootType, &from->minFragmentShadingRateAttachmentTexelSize,
+ (VkExtent2D*)(&to->minFragmentShadingRateAttachmentTexelSize));
+ deepcopy_VkExtent2D(alloc, rootType, &from->maxFragmentShadingRateAttachmentTexelSize,
+ (VkExtent2D*)(&to->maxFragmentShadingRateAttachmentTexelSize));
+ deepcopy_VkExtent2D(alloc, rootType, &from->maxFragmentSize,
+ (VkExtent2D*)(&to->maxFragmentSize));
}
void deepcopy_VkPhysicalDeviceFragmentShadingRateKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateKHR* from,
- VkPhysicalDeviceFragmentShadingRateKHR* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceFragmentShadingRateKHR* from,
+ VkPhysicalDeviceFragmentShadingRateKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -9279,29 +7562,23 @@
#ifdef VK_KHR_spirv_1_4
#endif
#ifdef VK_KHR_surface_protected_capabilities
-void deepcopy_VkSurfaceProtectedCapabilitiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSurfaceProtectedCapabilitiesKHR* from,
- VkSurfaceProtectedCapabilitiesKHR* to)
-{
+void deepcopy_VkSurfaceProtectedCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkSurfaceProtectedCapabilitiesKHR* from,
+ VkSurfaceProtectedCapabilitiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -9312,28 +7589,22 @@
#endif
#ifdef VK_KHR_present_wait
void deepcopy_VkPhysicalDevicePresentWaitFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDevicePresentWaitFeaturesKHR* from,
- VkPhysicalDevicePresentWaitFeaturesKHR* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDevicePresentWaitFeaturesKHR* from,
+ VkPhysicalDevicePresentWaitFeaturesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -9348,84 +7619,66 @@
#endif
#ifdef VK_KHR_pipeline_executable_properties
void deepcopy_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* from,
- VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* to)
-{
+ VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkPipelineInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineInfoKHR* from,
- VkPipelineInfoKHR* to)
-{
+void deepcopy_VkPipelineInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineInfoKHR* from, VkPipelineInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkPipelineExecutablePropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineExecutablePropertiesKHR* from,
- VkPipelineExecutablePropertiesKHR* to)
-{
+void deepcopy_VkPipelineExecutablePropertiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineExecutablePropertiesKHR* from,
+ VkPipelineExecutablePropertiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -9433,107 +7686,87 @@
memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
}
-void deepcopy_VkPipelineExecutableInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineExecutableInfoKHR* from,
- VkPipelineExecutableInfoKHR* to)
-{
+void deepcopy_VkPipelineExecutableInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineExecutableInfoKHR* from,
+ VkPipelineExecutableInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineExecutableStatisticValueKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineExecutableStatisticValueKHR* from,
- VkPipelineExecutableStatisticValueKHR* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPipelineExecutableStatisticValueKHR* from,
+ VkPipelineExecutableStatisticValueKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkPipelineExecutableStatisticKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineExecutableStatisticKHR* from,
- VkPipelineExecutableStatisticKHR* to)
-{
+void deepcopy_VkPipelineExecutableStatisticKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineExecutableStatisticKHR* from,
+ VkPipelineExecutableStatisticKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
memcpy(to->name, from->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
- deepcopy_VkPipelineExecutableStatisticValueKHR(alloc, rootType, &from->value, (VkPipelineExecutableStatisticValueKHR*)(&to->value));
+ deepcopy_VkPipelineExecutableStatisticValueKHR(
+ alloc, rootType, &from->value, (VkPipelineExecutableStatisticValueKHR*)(&to->value));
}
void deepcopy_VkPipelineExecutableInternalRepresentationKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineExecutableInternalRepresentationKHR* from,
- VkPipelineExecutableInternalRepresentationKHR* to)
-{
+ VkPipelineExecutableInternalRepresentationKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
memcpy(to->name, from->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
to->pData = nullptr;
- if (from->pData)
- {
+ if (from->pData) {
to->pData = (void*)alloc->dupArray(from->pData, from->dataSize * sizeof(uint8_t));
}
}
@@ -9541,56 +7774,46 @@
#endif
#ifdef VK_KHR_shader_integer_dot_product
void deepcopy_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* from,
- VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* to)
-{
+ VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* from,
- VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* to)
-{
+ VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -9598,36 +7821,30 @@
#endif
#ifdef VK_KHR_pipeline_library
-void deepcopy_VkPipelineLibraryCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineLibraryCreateInfoKHR* from,
- VkPipelineLibraryCreateInfoKHR* to)
-{
+void deepcopy_VkPipelineLibraryCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineLibraryCreateInfoKHR* from,
+ VkPipelineLibraryCreateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pLibraries = nullptr;
- if (from->pLibraries)
- {
- to->pLibraries = (VkPipeline*)alloc->dupArray(from->pLibraries, from->libraryCount * sizeof(const VkPipeline));
+ if (from->pLibraries) {
+ to->pLibraries = (VkPipeline*)alloc->dupArray(
+ from->pLibraries, from->libraryCount * sizeof(const VkPipeline));
}
}
@@ -9635,62 +7852,49 @@
#ifdef VK_KHR_shader_non_semantic_info
#endif
#ifdef VK_KHR_present_id
-void deepcopy_VkPresentIdKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPresentIdKHR* from,
- VkPresentIdKHR* to)
-{
+void deepcopy_VkPresentIdKHR(Allocator* alloc, VkStructureType rootType, const VkPresentIdKHR* from,
+ VkPresentIdKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pPresentIds = nullptr;
- if (from->pPresentIds)
- {
- to->pPresentIds = (uint64_t*)alloc->dupArray(from->pPresentIds, from->swapchainCount * sizeof(const uint64_t));
+ if (from->pPresentIds) {
+ to->pPresentIds = (uint64_t*)alloc->dupArray(from->pPresentIds,
+ from->swapchainCount * sizeof(const uint64_t));
}
}
-void deepcopy_VkPhysicalDevicePresentIdFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDevicePresentIdFeaturesKHR* from,
- VkPhysicalDevicePresentIdFeaturesKHR* to)
-{
+void deepcopy_VkPhysicalDevicePresentIdFeaturesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDevicePresentIdFeaturesKHR* from,
+ VkPhysicalDevicePresentIdFeaturesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -9698,78 +7902,67 @@
#endif
#ifdef VK_KHR_video_encode_queue
-void deepcopy_VkVideoEncodeInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeInfoKHR* from,
- VkVideoEncodeInfoKHR* to)
-{
+void deepcopy_VkVideoEncodeInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeInfoKHR* from, VkVideoEncodeInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
deepcopy_VkExtent2D(alloc, rootType, &from->codedExtent, (VkExtent2D*)(&to->codedExtent));
- deepcopy_VkVideoPictureResourceKHR(alloc, rootType, &from->srcPictureResource, (VkVideoPictureResourceKHR*)(&to->srcPictureResource));
+ deepcopy_VkVideoPictureResourceKHR(alloc, rootType, &from->srcPictureResource,
+ (VkVideoPictureResourceKHR*)(&to->srcPictureResource));
to->pSetupReferenceSlot = nullptr;
- if (from->pSetupReferenceSlot)
- {
- to->pSetupReferenceSlot = (VkVideoReferenceSlotKHR*)alloc->alloc(sizeof(const VkVideoReferenceSlotKHR));
- deepcopy_VkVideoReferenceSlotKHR(alloc, rootType, from->pSetupReferenceSlot, (VkVideoReferenceSlotKHR*)(to->pSetupReferenceSlot));
+ if (from->pSetupReferenceSlot) {
+ to->pSetupReferenceSlot =
+ (VkVideoReferenceSlotKHR*)alloc->alloc(sizeof(const VkVideoReferenceSlotKHR));
+ deepcopy_VkVideoReferenceSlotKHR(alloc, rootType, from->pSetupReferenceSlot,
+ (VkVideoReferenceSlotKHR*)(to->pSetupReferenceSlot));
}
- if (from)
- {
+ if (from) {
to->pReferenceSlots = nullptr;
- if (from->pReferenceSlots)
- {
- to->pReferenceSlots = (VkVideoReferenceSlotKHR*)alloc->alloc(from->referenceSlotCount * sizeof(const VkVideoReferenceSlotKHR));
+ if (from->pReferenceSlots) {
+ to->pReferenceSlots = (VkVideoReferenceSlotKHR*)alloc->alloc(
+ from->referenceSlotCount * sizeof(const VkVideoReferenceSlotKHR));
to->referenceSlotCount = from->referenceSlotCount;
- for (uint32_t i = 0; i < (uint32_t)from->referenceSlotCount; ++i)
- {
- deepcopy_VkVideoReferenceSlotKHR(alloc, rootType, from->pReferenceSlots + i, (VkVideoReferenceSlotKHR*)(to->pReferenceSlots + i));
+ for (uint32_t i = 0; i < (uint32_t)from->referenceSlotCount; ++i) {
+ deepcopy_VkVideoReferenceSlotKHR(
+ alloc, rootType, from->pReferenceSlots + i,
+ (VkVideoReferenceSlotKHR*)(to->pReferenceSlots + i));
}
}
}
}
-void deepcopy_VkVideoEncodeRateControlInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeRateControlInfoKHR* from,
- VkVideoEncodeRateControlInfoKHR* to)
-{
+void deepcopy_VkVideoEncodeRateControlInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeRateControlInfoKHR* from,
+ VkVideoEncodeRateControlInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -9777,366 +7970,302 @@
#endif
#ifdef VK_KHR_synchronization2
-void deepcopy_VkMemoryBarrier2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryBarrier2KHR* from,
- VkMemoryBarrier2KHR* to)
-{
+void deepcopy_VkMemoryBarrier2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryBarrier2KHR* from, VkMemoryBarrier2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkBufferMemoryBarrier2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferMemoryBarrier2KHR* from,
- VkBufferMemoryBarrier2KHR* to)
-{
+void deepcopy_VkBufferMemoryBarrier2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkBufferMemoryBarrier2KHR* from,
+ VkBufferMemoryBarrier2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkImageMemoryBarrier2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageMemoryBarrier2KHR* from,
- VkImageMemoryBarrier2KHR* to)
-{
+void deepcopy_VkImageMemoryBarrier2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkImageMemoryBarrier2KHR* from,
+ VkImageMemoryBarrier2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkImageSubresourceRange(alloc, rootType, &from->subresourceRange, (VkImageSubresourceRange*)(&to->subresourceRange));
+ deepcopy_VkImageSubresourceRange(alloc, rootType, &from->subresourceRange,
+ (VkImageSubresourceRange*)(&to->subresourceRange));
}
-void deepcopy_VkDependencyInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDependencyInfoKHR* from,
- VkDependencyInfoKHR* to)
-{
+void deepcopy_VkDependencyInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDependencyInfoKHR* from, VkDependencyInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pMemoryBarriers = nullptr;
- if (from->pMemoryBarriers)
- {
- to->pMemoryBarriers = (VkMemoryBarrier2KHR*)alloc->alloc(from->memoryBarrierCount * sizeof(const VkMemoryBarrier2KHR));
+ if (from->pMemoryBarriers) {
+ to->pMemoryBarriers = (VkMemoryBarrier2KHR*)alloc->alloc(
+ from->memoryBarrierCount * sizeof(const VkMemoryBarrier2KHR));
to->memoryBarrierCount = from->memoryBarrierCount;
- for (uint32_t i = 0; i < (uint32_t)from->memoryBarrierCount; ++i)
- {
- deepcopy_VkMemoryBarrier2KHR(alloc, rootType, from->pMemoryBarriers + i, (VkMemoryBarrier2KHR*)(to->pMemoryBarriers + i));
+ for (uint32_t i = 0; i < (uint32_t)from->memoryBarrierCount; ++i) {
+ deepcopy_VkMemoryBarrier2KHR(alloc, rootType, from->pMemoryBarriers + i,
+ (VkMemoryBarrier2KHR*)(to->pMemoryBarriers + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pBufferMemoryBarriers = nullptr;
- if (from->pBufferMemoryBarriers)
- {
- to->pBufferMemoryBarriers = (VkBufferMemoryBarrier2KHR*)alloc->alloc(from->bufferMemoryBarrierCount * sizeof(const VkBufferMemoryBarrier2KHR));
+ if (from->pBufferMemoryBarriers) {
+ to->pBufferMemoryBarriers = (VkBufferMemoryBarrier2KHR*)alloc->alloc(
+ from->bufferMemoryBarrierCount * sizeof(const VkBufferMemoryBarrier2KHR));
to->bufferMemoryBarrierCount = from->bufferMemoryBarrierCount;
- for (uint32_t i = 0; i < (uint32_t)from->bufferMemoryBarrierCount; ++i)
- {
- deepcopy_VkBufferMemoryBarrier2KHR(alloc, rootType, from->pBufferMemoryBarriers + i, (VkBufferMemoryBarrier2KHR*)(to->pBufferMemoryBarriers + i));
+ for (uint32_t i = 0; i < (uint32_t)from->bufferMemoryBarrierCount; ++i) {
+ deepcopy_VkBufferMemoryBarrier2KHR(
+ alloc, rootType, from->pBufferMemoryBarriers + i,
+ (VkBufferMemoryBarrier2KHR*)(to->pBufferMemoryBarriers + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pImageMemoryBarriers = nullptr;
- if (from->pImageMemoryBarriers)
- {
- to->pImageMemoryBarriers = (VkImageMemoryBarrier2KHR*)alloc->alloc(from->imageMemoryBarrierCount * sizeof(const VkImageMemoryBarrier2KHR));
+ if (from->pImageMemoryBarriers) {
+ to->pImageMemoryBarriers = (VkImageMemoryBarrier2KHR*)alloc->alloc(
+ from->imageMemoryBarrierCount * sizeof(const VkImageMemoryBarrier2KHR));
to->imageMemoryBarrierCount = from->imageMemoryBarrierCount;
- for (uint32_t i = 0; i < (uint32_t)from->imageMemoryBarrierCount; ++i)
- {
- deepcopy_VkImageMemoryBarrier2KHR(alloc, rootType, from->pImageMemoryBarriers + i, (VkImageMemoryBarrier2KHR*)(to->pImageMemoryBarriers + i));
+ for (uint32_t i = 0; i < (uint32_t)from->imageMemoryBarrierCount; ++i) {
+ deepcopy_VkImageMemoryBarrier2KHR(
+ alloc, rootType, from->pImageMemoryBarriers + i,
+ (VkImageMemoryBarrier2KHR*)(to->pImageMemoryBarriers + i));
}
}
}
}
-void deepcopy_VkSemaphoreSubmitInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSemaphoreSubmitInfoKHR* from,
- VkSemaphoreSubmitInfoKHR* to)
-{
+void deepcopy_VkSemaphoreSubmitInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkSemaphoreSubmitInfoKHR* from,
+ VkSemaphoreSubmitInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkCommandBufferSubmitInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCommandBufferSubmitInfoKHR* from,
- VkCommandBufferSubmitInfoKHR* to)
-{
+void deepcopy_VkCommandBufferSubmitInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkCommandBufferSubmitInfoKHR* from,
+ VkCommandBufferSubmitInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkSubmitInfo2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubmitInfo2KHR* from,
- VkSubmitInfo2KHR* to)
-{
+void deepcopy_VkSubmitInfo2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkSubmitInfo2KHR* from, VkSubmitInfo2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pWaitSemaphoreInfos = nullptr;
- if (from->pWaitSemaphoreInfos)
- {
- to->pWaitSemaphoreInfos = (VkSemaphoreSubmitInfoKHR*)alloc->alloc(from->waitSemaphoreInfoCount * sizeof(const VkSemaphoreSubmitInfoKHR));
+ if (from->pWaitSemaphoreInfos) {
+ to->pWaitSemaphoreInfos = (VkSemaphoreSubmitInfoKHR*)alloc->alloc(
+ from->waitSemaphoreInfoCount * sizeof(const VkSemaphoreSubmitInfoKHR));
to->waitSemaphoreInfoCount = from->waitSemaphoreInfoCount;
- for (uint32_t i = 0; i < (uint32_t)from->waitSemaphoreInfoCount; ++i)
- {
- deepcopy_VkSemaphoreSubmitInfoKHR(alloc, rootType, from->pWaitSemaphoreInfos + i, (VkSemaphoreSubmitInfoKHR*)(to->pWaitSemaphoreInfos + i));
+ for (uint32_t i = 0; i < (uint32_t)from->waitSemaphoreInfoCount; ++i) {
+ deepcopy_VkSemaphoreSubmitInfoKHR(
+ alloc, rootType, from->pWaitSemaphoreInfos + i,
+ (VkSemaphoreSubmitInfoKHR*)(to->pWaitSemaphoreInfos + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pCommandBufferInfos = nullptr;
- if (from->pCommandBufferInfos)
- {
- to->pCommandBufferInfos = (VkCommandBufferSubmitInfoKHR*)alloc->alloc(from->commandBufferInfoCount * sizeof(const VkCommandBufferSubmitInfoKHR));
+ if (from->pCommandBufferInfos) {
+ to->pCommandBufferInfos = (VkCommandBufferSubmitInfoKHR*)alloc->alloc(
+ from->commandBufferInfoCount * sizeof(const VkCommandBufferSubmitInfoKHR));
to->commandBufferInfoCount = from->commandBufferInfoCount;
- for (uint32_t i = 0; i < (uint32_t)from->commandBufferInfoCount; ++i)
- {
- deepcopy_VkCommandBufferSubmitInfoKHR(alloc, rootType, from->pCommandBufferInfos + i, (VkCommandBufferSubmitInfoKHR*)(to->pCommandBufferInfos + i));
+ for (uint32_t i = 0; i < (uint32_t)from->commandBufferInfoCount; ++i) {
+ deepcopy_VkCommandBufferSubmitInfoKHR(
+ alloc, rootType, from->pCommandBufferInfos + i,
+ (VkCommandBufferSubmitInfoKHR*)(to->pCommandBufferInfos + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pSignalSemaphoreInfos = nullptr;
- if (from->pSignalSemaphoreInfos)
- {
- to->pSignalSemaphoreInfos = (VkSemaphoreSubmitInfoKHR*)alloc->alloc(from->signalSemaphoreInfoCount * sizeof(const VkSemaphoreSubmitInfoKHR));
+ if (from->pSignalSemaphoreInfos) {
+ to->pSignalSemaphoreInfos = (VkSemaphoreSubmitInfoKHR*)alloc->alloc(
+ from->signalSemaphoreInfoCount * sizeof(const VkSemaphoreSubmitInfoKHR));
to->signalSemaphoreInfoCount = from->signalSemaphoreInfoCount;
- for (uint32_t i = 0; i < (uint32_t)from->signalSemaphoreInfoCount; ++i)
- {
- deepcopy_VkSemaphoreSubmitInfoKHR(alloc, rootType, from->pSignalSemaphoreInfos + i, (VkSemaphoreSubmitInfoKHR*)(to->pSignalSemaphoreInfos + i));
+ for (uint32_t i = 0; i < (uint32_t)from->signalSemaphoreInfoCount; ++i) {
+ deepcopy_VkSemaphoreSubmitInfoKHR(
+ alloc, rootType, from->pSignalSemaphoreInfos + i,
+ (VkSemaphoreSubmitInfoKHR*)(to->pSignalSemaphoreInfos + i));
}
}
}
}
void deepcopy_VkPhysicalDeviceSynchronization2FeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceSynchronization2FeaturesKHR* from,
- VkPhysicalDeviceSynchronization2FeaturesKHR* to)
-{
+ VkPhysicalDeviceSynchronization2FeaturesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkQueueFamilyCheckpointProperties2NV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkQueueFamilyCheckpointProperties2NV* from,
- VkQueueFamilyCheckpointProperties2NV* to)
-{
+void deepcopy_VkQueueFamilyCheckpointProperties2NV(Allocator* alloc, VkStructureType rootType,
+ const VkQueueFamilyCheckpointProperties2NV* from,
+ VkQueueFamilyCheckpointProperties2NV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkCheckpointData2NV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCheckpointData2NV* from,
- VkCheckpointData2NV* to)
-{
+void deepcopy_VkCheckpointData2NV(Allocator* alloc, VkStructureType rootType,
+ const VkCheckpointData2NV* from, VkCheckpointData2NV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pCheckpointMarker = nullptr;
- if (from->pCheckpointMarker)
- {
+ if (from->pCheckpointMarker) {
to->pCheckpointMarker = (void*)alloc->dupArray(from->pCheckpointMarker, sizeof(uint8_t));
}
}
@@ -10144,28 +8273,23 @@
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
void deepcopy_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* from,
- VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* to)
-{
+ VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -10174,28 +8298,23 @@
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
void deepcopy_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* from,
- VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* to)
-{
+ VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -10204,28 +8323,23 @@
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
void deepcopy_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* from,
- VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* to)
-{
+ VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -10233,410 +8347,337 @@
#endif
#ifdef VK_KHR_copy_commands2
-void deepcopy_VkBufferCopy2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferCopy2KHR* from,
- VkBufferCopy2KHR* to)
-{
+void deepcopy_VkBufferCopy2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkBufferCopy2KHR* from, VkBufferCopy2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkCopyBufferInfo2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCopyBufferInfo2KHR* from,
- VkCopyBufferInfo2KHR* to)
-{
+void deepcopy_VkCopyBufferInfo2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkCopyBufferInfo2KHR* from, VkCopyBufferInfo2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pRegions = nullptr;
- if (from->pRegions)
- {
- to->pRegions = (VkBufferCopy2KHR*)alloc->alloc(from->regionCount * sizeof(const VkBufferCopy2KHR));
+ if (from->pRegions) {
+ to->pRegions =
+ (VkBufferCopy2KHR*)alloc->alloc(from->regionCount * sizeof(const VkBufferCopy2KHR));
to->regionCount = from->regionCount;
- for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i)
- {
- deepcopy_VkBufferCopy2KHR(alloc, rootType, from->pRegions + i, (VkBufferCopy2KHR*)(to->pRegions + i));
+ for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
+ deepcopy_VkBufferCopy2KHR(alloc, rootType, from->pRegions + i,
+ (VkBufferCopy2KHR*)(to->pRegions + i));
}
}
}
}
-void deepcopy_VkImageCopy2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageCopy2KHR* from,
- VkImageCopy2KHR* to)
-{
+void deepcopy_VkImageCopy2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkImageCopy2KHR* from, VkImageCopy2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
+ deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->srcSubresource,
+ (VkImageSubresourceLayers*)(&to->srcSubresource));
deepcopy_VkOffset3D(alloc, rootType, &from->srcOffset, (VkOffset3D*)(&to->srcOffset));
- deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
+ deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->dstSubresource,
+ (VkImageSubresourceLayers*)(&to->dstSubresource));
deepcopy_VkOffset3D(alloc, rootType, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
deepcopy_VkExtent3D(alloc, rootType, &from->extent, (VkExtent3D*)(&to->extent));
}
-void deepcopy_VkCopyImageInfo2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCopyImageInfo2KHR* from,
- VkCopyImageInfo2KHR* to)
-{
+void deepcopy_VkCopyImageInfo2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkCopyImageInfo2KHR* from, VkCopyImageInfo2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pRegions = nullptr;
- if (from->pRegions)
- {
- to->pRegions = (VkImageCopy2KHR*)alloc->alloc(from->regionCount * sizeof(const VkImageCopy2KHR));
+ if (from->pRegions) {
+ to->pRegions =
+ (VkImageCopy2KHR*)alloc->alloc(from->regionCount * sizeof(const VkImageCopy2KHR));
to->regionCount = from->regionCount;
- for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i)
- {
- deepcopy_VkImageCopy2KHR(alloc, rootType, from->pRegions + i, (VkImageCopy2KHR*)(to->pRegions + i));
+ for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
+ deepcopy_VkImageCopy2KHR(alloc, rootType, from->pRegions + i,
+ (VkImageCopy2KHR*)(to->pRegions + i));
}
}
}
}
-void deepcopy_VkBufferImageCopy2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferImageCopy2KHR* from,
- VkBufferImageCopy2KHR* to)
-{
+void deepcopy_VkBufferImageCopy2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkBufferImageCopy2KHR* from, VkBufferImageCopy2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->imageSubresource, (VkImageSubresourceLayers*)(&to->imageSubresource));
+ deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->imageSubresource,
+ (VkImageSubresourceLayers*)(&to->imageSubresource));
deepcopy_VkOffset3D(alloc, rootType, &from->imageOffset, (VkOffset3D*)(&to->imageOffset));
deepcopy_VkExtent3D(alloc, rootType, &from->imageExtent, (VkExtent3D*)(&to->imageExtent));
}
-void deepcopy_VkCopyBufferToImageInfo2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCopyBufferToImageInfo2KHR* from,
- VkCopyBufferToImageInfo2KHR* to)
-{
+void deepcopy_VkCopyBufferToImageInfo2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkCopyBufferToImageInfo2KHR* from,
+ VkCopyBufferToImageInfo2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pRegions = nullptr;
- if (from->pRegions)
- {
- to->pRegions = (VkBufferImageCopy2KHR*)alloc->alloc(from->regionCount * sizeof(const VkBufferImageCopy2KHR));
+ if (from->pRegions) {
+ to->pRegions = (VkBufferImageCopy2KHR*)alloc->alloc(
+ from->regionCount * sizeof(const VkBufferImageCopy2KHR));
to->regionCount = from->regionCount;
- for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i)
- {
- deepcopy_VkBufferImageCopy2KHR(alloc, rootType, from->pRegions + i, (VkBufferImageCopy2KHR*)(to->pRegions + i));
+ for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
+ deepcopy_VkBufferImageCopy2KHR(alloc, rootType, from->pRegions + i,
+ (VkBufferImageCopy2KHR*)(to->pRegions + i));
}
}
}
}
-void deepcopy_VkCopyImageToBufferInfo2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCopyImageToBufferInfo2KHR* from,
- VkCopyImageToBufferInfo2KHR* to)
-{
+void deepcopy_VkCopyImageToBufferInfo2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkCopyImageToBufferInfo2KHR* from,
+ VkCopyImageToBufferInfo2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pRegions = nullptr;
- if (from->pRegions)
- {
- to->pRegions = (VkBufferImageCopy2KHR*)alloc->alloc(from->regionCount * sizeof(const VkBufferImageCopy2KHR));
+ if (from->pRegions) {
+ to->pRegions = (VkBufferImageCopy2KHR*)alloc->alloc(
+ from->regionCount * sizeof(const VkBufferImageCopy2KHR));
to->regionCount = from->regionCount;
- for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i)
- {
- deepcopy_VkBufferImageCopy2KHR(alloc, rootType, from->pRegions + i, (VkBufferImageCopy2KHR*)(to->pRegions + i));
+ for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
+ deepcopy_VkBufferImageCopy2KHR(alloc, rootType, from->pRegions + i,
+ (VkBufferImageCopy2KHR*)(to->pRegions + i));
}
}
}
}
-void deepcopy_VkImageBlit2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageBlit2KHR* from,
- VkImageBlit2KHR* to)
-{
+void deepcopy_VkImageBlit2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkImageBlit2KHR* from, VkImageBlit2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
- deepcopy_VkOffset3D(alloc, rootType, from->srcOffsets + i, (VkOffset3D*)(to->srcOffsets + i));
+ deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->srcSubresource,
+ (VkImageSubresourceLayers*)(&to->srcSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+ deepcopy_VkOffset3D(alloc, rootType, from->srcOffsets + i,
+ (VkOffset3D*)(to->srcOffsets + i));
}
- deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
- deepcopy_VkOffset3D(alloc, rootType, from->dstOffsets + i, (VkOffset3D*)(to->dstOffsets + i));
+ deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->dstSubresource,
+ (VkImageSubresourceLayers*)(&to->dstSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+ deepcopy_VkOffset3D(alloc, rootType, from->dstOffsets + i,
+ (VkOffset3D*)(to->dstOffsets + i));
}
}
-void deepcopy_VkBlitImageInfo2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBlitImageInfo2KHR* from,
- VkBlitImageInfo2KHR* to)
-{
+void deepcopy_VkBlitImageInfo2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkBlitImageInfo2KHR* from, VkBlitImageInfo2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pRegions = nullptr;
- if (from->pRegions)
- {
- to->pRegions = (VkImageBlit2KHR*)alloc->alloc(from->regionCount * sizeof(const VkImageBlit2KHR));
+ if (from->pRegions) {
+ to->pRegions =
+ (VkImageBlit2KHR*)alloc->alloc(from->regionCount * sizeof(const VkImageBlit2KHR));
to->regionCount = from->regionCount;
- for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i)
- {
- deepcopy_VkImageBlit2KHR(alloc, rootType, from->pRegions + i, (VkImageBlit2KHR*)(to->pRegions + i));
+ for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
+ deepcopy_VkImageBlit2KHR(alloc, rootType, from->pRegions + i,
+ (VkImageBlit2KHR*)(to->pRegions + i));
}
}
}
}
-void deepcopy_VkImageResolve2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageResolve2KHR* from,
- VkImageResolve2KHR* to)
-{
+void deepcopy_VkImageResolve2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkImageResolve2KHR* from, VkImageResolve2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->srcSubresource, (VkImageSubresourceLayers*)(&to->srcSubresource));
+ deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->srcSubresource,
+ (VkImageSubresourceLayers*)(&to->srcSubresource));
deepcopy_VkOffset3D(alloc, rootType, &from->srcOffset, (VkOffset3D*)(&to->srcOffset));
- deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->dstSubresource, (VkImageSubresourceLayers*)(&to->dstSubresource));
+ deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->dstSubresource,
+ (VkImageSubresourceLayers*)(&to->dstSubresource));
deepcopy_VkOffset3D(alloc, rootType, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
deepcopy_VkExtent3D(alloc, rootType, &from->extent, (VkExtent3D*)(&to->extent));
}
-void deepcopy_VkResolveImageInfo2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkResolveImageInfo2KHR* from,
- VkResolveImageInfo2KHR* to)
-{
+void deepcopy_VkResolveImageInfo2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkResolveImageInfo2KHR* from,
+ VkResolveImageInfo2KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pRegions = nullptr;
- if (from->pRegions)
- {
- to->pRegions = (VkImageResolve2KHR*)alloc->alloc(from->regionCount * sizeof(const VkImageResolve2KHR));
+ if (from->pRegions) {
+ to->pRegions = (VkImageResolve2KHR*)alloc->alloc(from->regionCount *
+ sizeof(const VkImageResolve2KHR));
to->regionCount = from->regionCount;
- for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i)
- {
- deepcopy_VkImageResolve2KHR(alloc, rootType, from->pRegions + i, (VkImageResolve2KHR*)(to->pRegions + i));
+ for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
+ deepcopy_VkImageResolve2KHR(alloc, rootType, from->pRegions + i,
+ (VkImageResolve2KHR*)(to->pRegions + i));
}
}
}
@@ -10644,29 +8685,23 @@
#endif
#ifdef VK_KHR_format_feature_flags2
-void deepcopy_VkFormatProperties3KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFormatProperties3KHR* from,
- VkFormatProperties3KHR* to)
-{
+void deepcopy_VkFormatProperties3KHR(Allocator* alloc, VkStructureType rootType,
+ const VkFormatProperties3KHR* from,
+ VkFormatProperties3KHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -10675,195 +8710,157 @@
#endif
#ifdef VK_KHR_maintenance4
void deepcopy_VkPhysicalDeviceMaintenance4FeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceMaintenance4FeaturesKHR* from,
- VkPhysicalDeviceMaintenance4FeaturesKHR* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMaintenance4FeaturesKHR* from,
+ VkPhysicalDeviceMaintenance4FeaturesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceMaintenance4PropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceMaintenance4PropertiesKHR* from,
- VkPhysicalDeviceMaintenance4PropertiesKHR* to)
-{
+ VkPhysicalDeviceMaintenance4PropertiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkDeviceBufferMemoryRequirementsKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceBufferMemoryRequirementsKHR* from,
- VkDeviceBufferMemoryRequirementsKHR* to)
-{
+void deepcopy_VkDeviceBufferMemoryRequirementsKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceBufferMemoryRequirementsKHR* from,
+ VkDeviceBufferMemoryRequirementsKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pCreateInfo = nullptr;
- if (from->pCreateInfo)
- {
+ if (from->pCreateInfo) {
to->pCreateInfo = (VkBufferCreateInfo*)alloc->alloc(sizeof(const VkBufferCreateInfo));
- deepcopy_VkBufferCreateInfo(alloc, rootType, from->pCreateInfo, (VkBufferCreateInfo*)(to->pCreateInfo));
+ deepcopy_VkBufferCreateInfo(alloc, rootType, from->pCreateInfo,
+ (VkBufferCreateInfo*)(to->pCreateInfo));
}
}
-void deepcopy_VkDeviceImageMemoryRequirementsKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceImageMemoryRequirementsKHR* from,
- VkDeviceImageMemoryRequirementsKHR* to)
-{
+void deepcopy_VkDeviceImageMemoryRequirementsKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceImageMemoryRequirementsKHR* from,
+ VkDeviceImageMemoryRequirementsKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pCreateInfo = nullptr;
- if (from->pCreateInfo)
- {
+ if (from->pCreateInfo) {
to->pCreateInfo = (VkImageCreateInfo*)alloc->alloc(sizeof(const VkImageCreateInfo));
- deepcopy_VkImageCreateInfo(alloc, rootType, from->pCreateInfo, (VkImageCreateInfo*)(to->pCreateInfo));
+ deepcopy_VkImageCreateInfo(alloc, rootType, from->pCreateInfo,
+ (VkImageCreateInfo*)(to->pCreateInfo));
}
}
#endif
#ifdef VK_ANDROID_native_buffer
-void deepcopy_VkNativeBufferANDROID(
- Allocator* alloc,
- VkStructureType rootType,
- const VkNativeBufferANDROID* from,
- VkNativeBufferANDROID* to)
-{
+void deepcopy_VkNativeBufferANDROID(Allocator* alloc, VkStructureType rootType,
+ const VkNativeBufferANDROID* from, VkNativeBufferANDROID* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->handle = nullptr;
- if (from->handle)
- {
+ if (from->handle) {
to->handle = (uint32_t*)alloc->dupArray(from->handle, sizeof(const uint32_t));
}
}
#endif
#ifdef VK_EXT_debug_report
-void deepcopy_VkDebugReportCallbackCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDebugReportCallbackCreateInfoEXT* from,
- VkDebugReportCallbackCreateInfoEXT* to)
-{
+void deepcopy_VkDebugReportCallbackCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugReportCallbackCreateInfoEXT* from,
+ VkDebugReportCallbackCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pUserData = nullptr;
- if (from->pUserData)
- {
+ if (from->pUserData) {
to->pUserData = (void*)alloc->dupArray(from->pUserData, sizeof(uint8_t));
}
}
@@ -10877,28 +8874,23 @@
#endif
#ifdef VK_AMD_rasterization_order
void deepcopy_VkPipelineRasterizationStateRasterizationOrderAMD(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineRasterizationStateRasterizationOrderAMD* from,
- VkPipelineRasterizationStateRasterizationOrderAMD* to)
-{
+ VkPipelineRasterizationStateRasterizationOrderAMD* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -10910,101 +8902,80 @@
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
-void deepcopy_VkDebugMarkerObjectNameInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDebugMarkerObjectNameInfoEXT* from,
- VkDebugMarkerObjectNameInfoEXT* to)
-{
+void deepcopy_VkDebugMarkerObjectNameInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugMarkerObjectNameInfoEXT* from,
+ VkDebugMarkerObjectNameInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pObjectName = nullptr;
- if (from->pObjectName)
- {
+ if (from->pObjectName) {
to->pObjectName = alloc->strDup(from->pObjectName);
}
}
-void deepcopy_VkDebugMarkerObjectTagInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDebugMarkerObjectTagInfoEXT* from,
- VkDebugMarkerObjectTagInfoEXT* to)
-{
+void deepcopy_VkDebugMarkerObjectTagInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugMarkerObjectTagInfoEXT* from,
+ VkDebugMarkerObjectTagInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pTag = nullptr;
- if (from->pTag)
- {
+ if (from->pTag) {
to->pTag = (void*)alloc->dupArray(from->pTag, from->tagSize * sizeof(const uint8_t));
}
}
-void deepcopy_VkDebugMarkerMarkerInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDebugMarkerMarkerInfoEXT* from,
- VkDebugMarkerMarkerInfoEXT* to)
-{
+void deepcopy_VkDebugMarkerMarkerInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugMarkerMarkerInfoEXT* from,
+ VkDebugMarkerMarkerInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pMarkerName = nullptr;
- if (from->pMarkerName)
- {
+ if (from->pMarkerName) {
to->pMarkerName = alloc->strDup(from->pMarkerName);
}
memcpy(to->color, from->color, 4 * sizeof(float));
@@ -11015,84 +8986,67 @@
#endif
#ifdef VK_NV_dedicated_allocation
void deepcopy_VkDedicatedAllocationImageCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDedicatedAllocationImageCreateInfoNV* from,
- VkDedicatedAllocationImageCreateInfoNV* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkDedicatedAllocationImageCreateInfoNV* from,
+ VkDedicatedAllocationImageCreateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDedicatedAllocationBufferCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDedicatedAllocationBufferCreateInfoNV* from,
- VkDedicatedAllocationBufferCreateInfoNV* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkDedicatedAllocationBufferCreateInfoNV* from,
+ VkDedicatedAllocationBufferCreateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDedicatedAllocationMemoryAllocateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkDedicatedAllocationMemoryAllocateInfoNV* from,
- VkDedicatedAllocationMemoryAllocateInfoNV* to)
-{
+ VkDedicatedAllocationMemoryAllocateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -11101,84 +9055,69 @@
#endif
#ifdef VK_EXT_transform_feedback
void deepcopy_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceTransformFeedbackFeaturesEXT* from,
- VkPhysicalDeviceTransformFeedbackFeaturesEXT* to)
-{
+ VkPhysicalDeviceTransformFeedbackFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceTransformFeedbackPropertiesEXT* from,
- VkPhysicalDeviceTransformFeedbackPropertiesEXT* to)
-{
+ VkPhysicalDeviceTransformFeedbackPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineRasterizationStateStreamCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineRasterizationStateStreamCreateInfoEXT* from,
- VkPipelineRasterizationStateStreamCreateInfoEXT* to)
-{
+ VkPipelineRasterizationStateStreamCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -11186,95 +9125,74 @@
#endif
#ifdef VK_NVX_binary_import
-void deepcopy_VkCuModuleCreateInfoNVX(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCuModuleCreateInfoNVX* from,
- VkCuModuleCreateInfoNVX* to)
-{
+void deepcopy_VkCuModuleCreateInfoNVX(Allocator* alloc, VkStructureType rootType,
+ const VkCuModuleCreateInfoNVX* from,
+ VkCuModuleCreateInfoNVX* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pData = nullptr;
- if (from->pData)
- {
+ if (from->pData) {
to->pData = (void*)alloc->dupArray(from->pData, from->dataSize * sizeof(const uint8_t));
}
}
-void deepcopy_VkCuFunctionCreateInfoNVX(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCuFunctionCreateInfoNVX* from,
- VkCuFunctionCreateInfoNVX* to)
-{
+void deepcopy_VkCuFunctionCreateInfoNVX(Allocator* alloc, VkStructureType rootType,
+ const VkCuFunctionCreateInfoNVX* from,
+ VkCuFunctionCreateInfoNVX* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pName = nullptr;
- if (from->pName)
- {
+ if (from->pName) {
to->pName = alloc->strDup(from->pName);
}
}
-void deepcopy_VkCuLaunchInfoNVX(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCuLaunchInfoNVX* from,
- VkCuLaunchInfoNVX* to)
-{
+void deepcopy_VkCuLaunchInfoNVX(Allocator* alloc, VkStructureType rootType,
+ const VkCuLaunchInfoNVX* from, VkCuLaunchInfoNVX* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -11282,57 +9200,45 @@
#endif
#ifdef VK_NVX_image_view_handle
-void deepcopy_VkImageViewHandleInfoNVX(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageViewHandleInfoNVX* from,
- VkImageViewHandleInfoNVX* to)
-{
+void deepcopy_VkImageViewHandleInfoNVX(Allocator* alloc, VkStructureType rootType,
+ const VkImageViewHandleInfoNVX* from,
+ VkImageViewHandleInfoNVX* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkImageViewAddressPropertiesNVX(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageViewAddressPropertiesNVX* from,
- VkImageViewAddressPropertiesNVX* to)
-{
+void deepcopy_VkImageViewAddressPropertiesNVX(Allocator* alloc, VkStructureType rootType,
+ const VkImageViewAddressPropertiesNVX* from,
+ VkImageViewAddressPropertiesNVX* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -11348,366 +9254,327 @@
#ifdef VK_AMD_shader_ballot
#endif
#ifdef VK_EXT_video_encode_h264
-void deepcopy_VkVideoEncodeH264CapabilitiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH264CapabilitiesEXT* from,
- VkVideoEncodeH264CapabilitiesEXT* to)
-{
+void deepcopy_VkVideoEncodeH264CapabilitiesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH264CapabilitiesEXT* from,
+ VkVideoEncodeH264CapabilitiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(alloc, rootType, &from->minPictureSizeInMbs, (VkExtent2D*)(&to->minPictureSizeInMbs));
- deepcopy_VkExtent2D(alloc, rootType, &from->maxPictureSizeInMbs, (VkExtent2D*)(&to->maxPictureSizeInMbs));
- deepcopy_VkExtent2D(alloc, rootType, &from->inputImageDataAlignment, (VkExtent2D*)(&to->inputImageDataAlignment));
- deepcopy_VkExtensionProperties(alloc, rootType, &from->stdExtensionVersion, (VkExtensionProperties*)(&to->stdExtensionVersion));
+ deepcopy_VkExtent2D(alloc, rootType, &from->minPictureSizeInMbs,
+ (VkExtent2D*)(&to->minPictureSizeInMbs));
+ deepcopy_VkExtent2D(alloc, rootType, &from->maxPictureSizeInMbs,
+ (VkExtent2D*)(&to->maxPictureSizeInMbs));
+ deepcopy_VkExtent2D(alloc, rootType, &from->inputImageDataAlignment,
+ (VkExtent2D*)(&to->inputImageDataAlignment));
+ deepcopy_VkExtensionProperties(alloc, rootType, &from->stdExtensionVersion,
+ (VkExtensionProperties*)(&to->stdExtensionVersion));
}
void deepcopy_VkVideoEncodeH264SessionCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH264SessionCreateInfoEXT* from,
- VkVideoEncodeH264SessionCreateInfoEXT* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkVideoEncodeH264SessionCreateInfoEXT* from,
+ VkVideoEncodeH264SessionCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(alloc, rootType, &from->maxPictureSizeInMbs, (VkExtent2D*)(&to->maxPictureSizeInMbs));
+ deepcopy_VkExtent2D(alloc, rootType, &from->maxPictureSizeInMbs,
+ (VkExtent2D*)(&to->maxPictureSizeInMbs));
to->pStdExtensionVersion = nullptr;
- if (from->pStdExtensionVersion)
- {
- to->pStdExtensionVersion = (VkExtensionProperties*)alloc->alloc(sizeof(const VkExtensionProperties));
- deepcopy_VkExtensionProperties(alloc, rootType, from->pStdExtensionVersion, (VkExtensionProperties*)(to->pStdExtensionVersion));
+ if (from->pStdExtensionVersion) {
+ to->pStdExtensionVersion =
+ (VkExtensionProperties*)alloc->alloc(sizeof(const VkExtensionProperties));
+ deepcopy_VkExtensionProperties(alloc, rootType, from->pStdExtensionVersion,
+ (VkExtensionProperties*)(to->pStdExtensionVersion));
}
}
void deepcopy_VkVideoEncodeH264SessionParametersAddInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVideoEncodeH264SessionParametersAddInfoEXT* from,
- VkVideoEncodeH264SessionParametersAddInfoEXT* to)
-{
+ VkVideoEncodeH264SessionParametersAddInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pSpsStd = nullptr;
- if (from->pSpsStd)
- {
- to->pSpsStd = (StdVideoH264SequenceParameterSet*)alloc->dupArray(from->pSpsStd, from->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
+ if (from->pSpsStd) {
+ to->pSpsStd = (StdVideoH264SequenceParameterSet*)alloc->dupArray(
+ from->pSpsStd, from->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
}
to->pPpsStd = nullptr;
- if (from->pPpsStd)
- {
- to->pPpsStd = (StdVideoH264PictureParameterSet*)alloc->dupArray(from->pPpsStd, from->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
+ if (from->pPpsStd) {
+ to->pPpsStd = (StdVideoH264PictureParameterSet*)alloc->dupArray(
+ from->pPpsStd, from->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
}
}
void deepcopy_VkVideoEncodeH264SessionParametersCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVideoEncodeH264SessionParametersCreateInfoEXT* from,
- VkVideoEncodeH264SessionParametersCreateInfoEXT* to)
-{
+ VkVideoEncodeH264SessionParametersCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pParametersAddInfo = nullptr;
- if (from->pParametersAddInfo)
- {
- to->pParametersAddInfo = (VkVideoEncodeH264SessionParametersAddInfoEXT*)alloc->alloc(sizeof(const VkVideoEncodeH264SessionParametersAddInfoEXT));
- deepcopy_VkVideoEncodeH264SessionParametersAddInfoEXT(alloc, rootType, from->pParametersAddInfo, (VkVideoEncodeH264SessionParametersAddInfoEXT*)(to->pParametersAddInfo));
+ if (from->pParametersAddInfo) {
+ to->pParametersAddInfo = (VkVideoEncodeH264SessionParametersAddInfoEXT*)alloc->alloc(
+ sizeof(const VkVideoEncodeH264SessionParametersAddInfoEXT));
+ deepcopy_VkVideoEncodeH264SessionParametersAddInfoEXT(
+ alloc, rootType, from->pParametersAddInfo,
+ (VkVideoEncodeH264SessionParametersAddInfoEXT*)(to->pParametersAddInfo));
}
}
-void deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH264DpbSlotInfoEXT* from,
- VkVideoEncodeH264DpbSlotInfoEXT* to)
-{
+void deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH264DpbSlotInfoEXT* from,
+ VkVideoEncodeH264DpbSlotInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pStdPictureInfo = nullptr;
- if (from->pStdPictureInfo)
- {
- to->pStdPictureInfo = (StdVideoEncodeH264PictureInfo*)alloc->dupArray(from->pStdPictureInfo, sizeof(const StdVideoEncodeH264PictureInfo));
+ if (from->pStdPictureInfo) {
+ to->pStdPictureInfo = (StdVideoEncodeH264PictureInfo*)alloc->dupArray(
+ from->pStdPictureInfo, sizeof(const StdVideoEncodeH264PictureInfo));
}
}
-void deepcopy_VkVideoEncodeH264NaluSliceEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH264NaluSliceEXT* from,
- VkVideoEncodeH264NaluSliceEXT* to)
-{
+void deepcopy_VkVideoEncodeH264NaluSliceEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH264NaluSliceEXT* from,
+ VkVideoEncodeH264NaluSliceEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pSliceHeaderStd = nullptr;
- if (from->pSliceHeaderStd)
- {
- to->pSliceHeaderStd = (StdVideoEncodeH264SliceHeader*)alloc->dupArray(from->pSliceHeaderStd, sizeof(const StdVideoEncodeH264SliceHeader));
+ if (from->pSliceHeaderStd) {
+ to->pSliceHeaderStd = (StdVideoEncodeH264SliceHeader*)alloc->dupArray(
+ from->pSliceHeaderStd, sizeof(const StdVideoEncodeH264SliceHeader));
}
- if (from)
- {
+ if (from) {
to->pRefFinalList0Entries = nullptr;
- if (from->pRefFinalList0Entries)
- {
- to->pRefFinalList0Entries = (VkVideoEncodeH264DpbSlotInfoEXT*)alloc->alloc(from->refFinalList0EntryCount * sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
+ if (from->pRefFinalList0Entries) {
+ to->pRefFinalList0Entries = (VkVideoEncodeH264DpbSlotInfoEXT*)alloc->alloc(
+ from->refFinalList0EntryCount * sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
to->refFinalList0EntryCount = from->refFinalList0EntryCount;
- for (uint32_t i = 0; i < (uint32_t)from->refFinalList0EntryCount; ++i)
- {
- deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(alloc, rootType, from->pRefFinalList0Entries + i, (VkVideoEncodeH264DpbSlotInfoEXT*)(to->pRefFinalList0Entries + i));
+ for (uint32_t i = 0; i < (uint32_t)from->refFinalList0EntryCount; ++i) {
+ deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(
+ alloc, rootType, from->pRefFinalList0Entries + i,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(to->pRefFinalList0Entries + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pRefFinalList1Entries = nullptr;
- if (from->pRefFinalList1Entries)
- {
- to->pRefFinalList1Entries = (VkVideoEncodeH264DpbSlotInfoEXT*)alloc->alloc(from->refFinalList1EntryCount * sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
+ if (from->pRefFinalList1Entries) {
+ to->pRefFinalList1Entries = (VkVideoEncodeH264DpbSlotInfoEXT*)alloc->alloc(
+ from->refFinalList1EntryCount * sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
to->refFinalList1EntryCount = from->refFinalList1EntryCount;
- for (uint32_t i = 0; i < (uint32_t)from->refFinalList1EntryCount; ++i)
- {
- deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(alloc, rootType, from->pRefFinalList1Entries + i, (VkVideoEncodeH264DpbSlotInfoEXT*)(to->pRefFinalList1Entries + i));
+ for (uint32_t i = 0; i < (uint32_t)from->refFinalList1EntryCount; ++i) {
+ deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(
+ alloc, rootType, from->pRefFinalList1Entries + i,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(to->pRefFinalList1Entries + i));
}
}
}
}
-void deepcopy_VkVideoEncodeH264VclFrameInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH264VclFrameInfoEXT* from,
- VkVideoEncodeH264VclFrameInfoEXT* to)
-{
+void deepcopy_VkVideoEncodeH264VclFrameInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH264VclFrameInfoEXT* from,
+ VkVideoEncodeH264VclFrameInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pRefDefaultFinalList0Entries = nullptr;
- if (from->pRefDefaultFinalList0Entries)
- {
- to->pRefDefaultFinalList0Entries = (VkVideoEncodeH264DpbSlotInfoEXT*)alloc->alloc(from->refDefaultFinalList0EntryCount * sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
+ if (from->pRefDefaultFinalList0Entries) {
+ to->pRefDefaultFinalList0Entries = (VkVideoEncodeH264DpbSlotInfoEXT*)alloc->alloc(
+ from->refDefaultFinalList0EntryCount *
+ sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
to->refDefaultFinalList0EntryCount = from->refDefaultFinalList0EntryCount;
- for (uint32_t i = 0; i < (uint32_t)from->refDefaultFinalList0EntryCount; ++i)
- {
- deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(alloc, rootType, from->pRefDefaultFinalList0Entries + i, (VkVideoEncodeH264DpbSlotInfoEXT*)(to->pRefDefaultFinalList0Entries + i));
+ for (uint32_t i = 0; i < (uint32_t)from->refDefaultFinalList0EntryCount; ++i) {
+ deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(
+ alloc, rootType, from->pRefDefaultFinalList0Entries + i,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(to->pRefDefaultFinalList0Entries + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pRefDefaultFinalList1Entries = nullptr;
- if (from->pRefDefaultFinalList1Entries)
- {
- to->pRefDefaultFinalList1Entries = (VkVideoEncodeH264DpbSlotInfoEXT*)alloc->alloc(from->refDefaultFinalList1EntryCount * sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
+ if (from->pRefDefaultFinalList1Entries) {
+ to->pRefDefaultFinalList1Entries = (VkVideoEncodeH264DpbSlotInfoEXT*)alloc->alloc(
+ from->refDefaultFinalList1EntryCount *
+ sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
to->refDefaultFinalList1EntryCount = from->refDefaultFinalList1EntryCount;
- for (uint32_t i = 0; i < (uint32_t)from->refDefaultFinalList1EntryCount; ++i)
- {
- deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(alloc, rootType, from->pRefDefaultFinalList1Entries + i, (VkVideoEncodeH264DpbSlotInfoEXT*)(to->pRefDefaultFinalList1Entries + i));
+ for (uint32_t i = 0; i < (uint32_t)from->refDefaultFinalList1EntryCount; ++i) {
+ deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(
+ alloc, rootType, from->pRefDefaultFinalList1Entries + i,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(to->pRefDefaultFinalList1Entries + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pNaluSliceEntries = nullptr;
- if (from->pNaluSliceEntries)
- {
- to->pNaluSliceEntries = (VkVideoEncodeH264NaluSliceEXT*)alloc->alloc(from->naluSliceEntryCount * sizeof(const VkVideoEncodeH264NaluSliceEXT));
+ if (from->pNaluSliceEntries) {
+ to->pNaluSliceEntries = (VkVideoEncodeH264NaluSliceEXT*)alloc->alloc(
+ from->naluSliceEntryCount * sizeof(const VkVideoEncodeH264NaluSliceEXT));
to->naluSliceEntryCount = from->naluSliceEntryCount;
- for (uint32_t i = 0; i < (uint32_t)from->naluSliceEntryCount; ++i)
- {
- deepcopy_VkVideoEncodeH264NaluSliceEXT(alloc, rootType, from->pNaluSliceEntries + i, (VkVideoEncodeH264NaluSliceEXT*)(to->pNaluSliceEntries + i));
+ for (uint32_t i = 0; i < (uint32_t)from->naluSliceEntryCount; ++i) {
+ deepcopy_VkVideoEncodeH264NaluSliceEXT(
+ alloc, rootType, from->pNaluSliceEntries + i,
+ (VkVideoEncodeH264NaluSliceEXT*)(to->pNaluSliceEntries + i));
}
}
}
to->pCurrentPictureInfo = nullptr;
- if (from->pCurrentPictureInfo)
- {
- to->pCurrentPictureInfo = (VkVideoEncodeH264DpbSlotInfoEXT*)alloc->alloc(sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
- deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(alloc, rootType, from->pCurrentPictureInfo, (VkVideoEncodeH264DpbSlotInfoEXT*)(to->pCurrentPictureInfo));
+ if (from->pCurrentPictureInfo) {
+ to->pCurrentPictureInfo = (VkVideoEncodeH264DpbSlotInfoEXT*)alloc->alloc(
+ sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
+ deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(
+ alloc, rootType, from->pCurrentPictureInfo,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(to->pCurrentPictureInfo));
}
}
void deepcopy_VkVideoEncodeH264EmitPictureParametersEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVideoEncodeH264EmitPictureParametersEXT* from,
- VkVideoEncodeH264EmitPictureParametersEXT* to)
-{
+ VkVideoEncodeH264EmitPictureParametersEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->ppsIdEntries = nullptr;
- if (from->ppsIdEntries)
- {
- to->ppsIdEntries = (uint8_t*)alloc->dupArray(from->ppsIdEntries, from->ppsIdEntryCount * sizeof(const uint8_t));
+ if (from->ppsIdEntries) {
+ to->ppsIdEntries = (uint8_t*)alloc->dupArray(from->ppsIdEntries,
+ from->ppsIdEntryCount * sizeof(const uint8_t));
}
}
-void deepcopy_VkVideoEncodeH264ProfileEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH264ProfileEXT* from,
- VkVideoEncodeH264ProfileEXT* to)
-{
+void deepcopy_VkVideoEncodeH264ProfileEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH264ProfileEXT* from,
+ VkVideoEncodeH264ProfileEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -11715,386 +9582,338 @@
#endif
#ifdef VK_EXT_video_encode_h265
-void deepcopy_VkVideoEncodeH265CapabilitiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH265CapabilitiesEXT* from,
- VkVideoEncodeH265CapabilitiesEXT* to)
-{
+void deepcopy_VkVideoEncodeH265CapabilitiesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH265CapabilitiesEXT* from,
+ VkVideoEncodeH265CapabilitiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(alloc, rootType, &from->inputImageDataAlignment, (VkExtent2D*)(&to->inputImageDataAlignment));
- deepcopy_VkExtensionProperties(alloc, rootType, &from->stdExtensionVersion, (VkExtensionProperties*)(&to->stdExtensionVersion));
+ deepcopy_VkExtent2D(alloc, rootType, &from->inputImageDataAlignment,
+ (VkExtent2D*)(&to->inputImageDataAlignment));
+ deepcopy_VkExtensionProperties(alloc, rootType, &from->stdExtensionVersion,
+ (VkExtensionProperties*)(&to->stdExtensionVersion));
}
void deepcopy_VkVideoEncodeH265SessionCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH265SessionCreateInfoEXT* from,
- VkVideoEncodeH265SessionCreateInfoEXT* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkVideoEncodeH265SessionCreateInfoEXT* from,
+ VkVideoEncodeH265SessionCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pStdExtensionVersion = nullptr;
- if (from->pStdExtensionVersion)
- {
- to->pStdExtensionVersion = (VkExtensionProperties*)alloc->alloc(sizeof(const VkExtensionProperties));
- deepcopy_VkExtensionProperties(alloc, rootType, from->pStdExtensionVersion, (VkExtensionProperties*)(to->pStdExtensionVersion));
+ if (from->pStdExtensionVersion) {
+ to->pStdExtensionVersion =
+ (VkExtensionProperties*)alloc->alloc(sizeof(const VkExtensionProperties));
+ deepcopy_VkExtensionProperties(alloc, rootType, from->pStdExtensionVersion,
+ (VkExtensionProperties*)(to->pStdExtensionVersion));
}
}
void deepcopy_VkVideoEncodeH265SessionParametersAddInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVideoEncodeH265SessionParametersAddInfoEXT* from,
- VkVideoEncodeH265SessionParametersAddInfoEXT* to)
-{
+ VkVideoEncodeH265SessionParametersAddInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pVpsStd = nullptr;
- if (from->pVpsStd)
- {
- to->pVpsStd = (StdVideoH265VideoParameterSet*)alloc->dupArray(from->pVpsStd, from->vpsStdCount * sizeof(const StdVideoH265VideoParameterSet));
+ if (from->pVpsStd) {
+ to->pVpsStd = (StdVideoH265VideoParameterSet*)alloc->dupArray(
+ from->pVpsStd, from->vpsStdCount * sizeof(const StdVideoH265VideoParameterSet));
}
to->pSpsStd = nullptr;
- if (from->pSpsStd)
- {
- to->pSpsStd = (StdVideoH265SequenceParameterSet*)alloc->dupArray(from->pSpsStd, from->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
+ if (from->pSpsStd) {
+ to->pSpsStd = (StdVideoH265SequenceParameterSet*)alloc->dupArray(
+ from->pSpsStd, from->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
}
to->pPpsStd = nullptr;
- if (from->pPpsStd)
- {
- to->pPpsStd = (StdVideoH265PictureParameterSet*)alloc->dupArray(from->pPpsStd, from->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
+ if (from->pPpsStd) {
+ to->pPpsStd = (StdVideoH265PictureParameterSet*)alloc->dupArray(
+ from->pPpsStd, from->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
}
}
void deepcopy_VkVideoEncodeH265SessionParametersCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVideoEncodeH265SessionParametersCreateInfoEXT* from,
- VkVideoEncodeH265SessionParametersCreateInfoEXT* to)
-{
+ VkVideoEncodeH265SessionParametersCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pParametersAddInfo = nullptr;
- if (from->pParametersAddInfo)
- {
- to->pParametersAddInfo = (VkVideoEncodeH265SessionParametersAddInfoEXT*)alloc->alloc(sizeof(const VkVideoEncodeH265SessionParametersAddInfoEXT));
- deepcopy_VkVideoEncodeH265SessionParametersAddInfoEXT(alloc, rootType, from->pParametersAddInfo, (VkVideoEncodeH265SessionParametersAddInfoEXT*)(to->pParametersAddInfo));
+ if (from->pParametersAddInfo) {
+ to->pParametersAddInfo = (VkVideoEncodeH265SessionParametersAddInfoEXT*)alloc->alloc(
+ sizeof(const VkVideoEncodeH265SessionParametersAddInfoEXT));
+ deepcopy_VkVideoEncodeH265SessionParametersAddInfoEXT(
+ alloc, rootType, from->pParametersAddInfo,
+ (VkVideoEncodeH265SessionParametersAddInfoEXT*)(to->pParametersAddInfo));
}
}
-void deepcopy_VkVideoEncodeH265DpbSlotInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH265DpbSlotInfoEXT* from,
- VkVideoEncodeH265DpbSlotInfoEXT* to)
-{
+void deepcopy_VkVideoEncodeH265DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH265DpbSlotInfoEXT* from,
+ VkVideoEncodeH265DpbSlotInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pStdReferenceInfo = nullptr;
- if (from->pStdReferenceInfo)
- {
- to->pStdReferenceInfo = (StdVideoEncodeH265ReferenceInfo*)alloc->dupArray(from->pStdReferenceInfo, sizeof(const StdVideoEncodeH265ReferenceInfo));
+ if (from->pStdReferenceInfo) {
+ to->pStdReferenceInfo = (StdVideoEncodeH265ReferenceInfo*)alloc->dupArray(
+ from->pStdReferenceInfo, sizeof(const StdVideoEncodeH265ReferenceInfo));
}
}
-void deepcopy_VkVideoEncodeH265ReferenceListsEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH265ReferenceListsEXT* from,
- VkVideoEncodeH265ReferenceListsEXT* to)
-{
+void deepcopy_VkVideoEncodeH265ReferenceListsEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH265ReferenceListsEXT* from,
+ VkVideoEncodeH265ReferenceListsEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pReferenceList0Entries = nullptr;
- if (from->pReferenceList0Entries)
- {
- to->pReferenceList0Entries = (VkVideoEncodeH265DpbSlotInfoEXT*)alloc->alloc(from->referenceList0EntryCount * sizeof(const VkVideoEncodeH265DpbSlotInfoEXT));
+ if (from->pReferenceList0Entries) {
+ to->pReferenceList0Entries = (VkVideoEncodeH265DpbSlotInfoEXT*)alloc->alloc(
+ from->referenceList0EntryCount * sizeof(const VkVideoEncodeH265DpbSlotInfoEXT));
to->referenceList0EntryCount = from->referenceList0EntryCount;
- for (uint32_t i = 0; i < (uint32_t)from->referenceList0EntryCount; ++i)
- {
- deepcopy_VkVideoEncodeH265DpbSlotInfoEXT(alloc, rootType, from->pReferenceList0Entries + i, (VkVideoEncodeH265DpbSlotInfoEXT*)(to->pReferenceList0Entries + i));
+ for (uint32_t i = 0; i < (uint32_t)from->referenceList0EntryCount; ++i) {
+ deepcopy_VkVideoEncodeH265DpbSlotInfoEXT(
+ alloc, rootType, from->pReferenceList0Entries + i,
+ (VkVideoEncodeH265DpbSlotInfoEXT*)(to->pReferenceList0Entries + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pReferenceList1Entries = nullptr;
- if (from->pReferenceList1Entries)
- {
- to->pReferenceList1Entries = (VkVideoEncodeH265DpbSlotInfoEXT*)alloc->alloc(from->referenceList1EntryCount * sizeof(const VkVideoEncodeH265DpbSlotInfoEXT));
+ if (from->pReferenceList1Entries) {
+ to->pReferenceList1Entries = (VkVideoEncodeH265DpbSlotInfoEXT*)alloc->alloc(
+ from->referenceList1EntryCount * sizeof(const VkVideoEncodeH265DpbSlotInfoEXT));
to->referenceList1EntryCount = from->referenceList1EntryCount;
- for (uint32_t i = 0; i < (uint32_t)from->referenceList1EntryCount; ++i)
- {
- deepcopy_VkVideoEncodeH265DpbSlotInfoEXT(alloc, rootType, from->pReferenceList1Entries + i, (VkVideoEncodeH265DpbSlotInfoEXT*)(to->pReferenceList1Entries + i));
+ for (uint32_t i = 0; i < (uint32_t)from->referenceList1EntryCount; ++i) {
+ deepcopy_VkVideoEncodeH265DpbSlotInfoEXT(
+ alloc, rootType, from->pReferenceList1Entries + i,
+ (VkVideoEncodeH265DpbSlotInfoEXT*)(to->pReferenceList1Entries + i));
}
}
}
to->pReferenceModifications = nullptr;
- if (from->pReferenceModifications)
- {
- to->pReferenceModifications = (StdVideoEncodeH265ReferenceModifications*)alloc->dupArray(from->pReferenceModifications, sizeof(const StdVideoEncodeH265ReferenceModifications));
+ if (from->pReferenceModifications) {
+ to->pReferenceModifications = (StdVideoEncodeH265ReferenceModifications*)alloc->dupArray(
+ from->pReferenceModifications, sizeof(const StdVideoEncodeH265ReferenceModifications));
}
}
-void deepcopy_VkVideoEncodeH265NaluSliceEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH265NaluSliceEXT* from,
- VkVideoEncodeH265NaluSliceEXT* to)
-{
+void deepcopy_VkVideoEncodeH265NaluSliceEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH265NaluSliceEXT* from,
+ VkVideoEncodeH265NaluSliceEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pReferenceFinalLists = nullptr;
- if (from->pReferenceFinalLists)
- {
- to->pReferenceFinalLists = (VkVideoEncodeH265ReferenceListsEXT*)alloc->alloc(sizeof(const VkVideoEncodeH265ReferenceListsEXT));
- deepcopy_VkVideoEncodeH265ReferenceListsEXT(alloc, rootType, from->pReferenceFinalLists, (VkVideoEncodeH265ReferenceListsEXT*)(to->pReferenceFinalLists));
+ if (from->pReferenceFinalLists) {
+ to->pReferenceFinalLists = (VkVideoEncodeH265ReferenceListsEXT*)alloc->alloc(
+ sizeof(const VkVideoEncodeH265ReferenceListsEXT));
+ deepcopy_VkVideoEncodeH265ReferenceListsEXT(
+ alloc, rootType, from->pReferenceFinalLists,
+ (VkVideoEncodeH265ReferenceListsEXT*)(to->pReferenceFinalLists));
}
to->pSliceHeaderStd = nullptr;
- if (from->pSliceHeaderStd)
- {
- to->pSliceHeaderStd = (StdVideoEncodeH265SliceHeader*)alloc->dupArray(from->pSliceHeaderStd, sizeof(const StdVideoEncodeH265SliceHeader));
+ if (from->pSliceHeaderStd) {
+ to->pSliceHeaderStd = (StdVideoEncodeH265SliceHeader*)alloc->dupArray(
+ from->pSliceHeaderStd, sizeof(const StdVideoEncodeH265SliceHeader));
}
}
-void deepcopy_VkVideoEncodeH265VclFrameInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH265VclFrameInfoEXT* from,
- VkVideoEncodeH265VclFrameInfoEXT* to)
-{
+void deepcopy_VkVideoEncodeH265VclFrameInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH265VclFrameInfoEXT* from,
+ VkVideoEncodeH265VclFrameInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pReferenceFinalLists = nullptr;
- if (from->pReferenceFinalLists)
- {
- to->pReferenceFinalLists = (VkVideoEncodeH265ReferenceListsEXT*)alloc->alloc(sizeof(const VkVideoEncodeH265ReferenceListsEXT));
- deepcopy_VkVideoEncodeH265ReferenceListsEXT(alloc, rootType, from->pReferenceFinalLists, (VkVideoEncodeH265ReferenceListsEXT*)(to->pReferenceFinalLists));
+ if (from->pReferenceFinalLists) {
+ to->pReferenceFinalLists = (VkVideoEncodeH265ReferenceListsEXT*)alloc->alloc(
+ sizeof(const VkVideoEncodeH265ReferenceListsEXT));
+ deepcopy_VkVideoEncodeH265ReferenceListsEXT(
+ alloc, rootType, from->pReferenceFinalLists,
+ (VkVideoEncodeH265ReferenceListsEXT*)(to->pReferenceFinalLists));
}
- if (from)
- {
+ if (from) {
to->pNaluSliceEntries = nullptr;
- if (from->pNaluSliceEntries)
- {
- to->pNaluSliceEntries = (VkVideoEncodeH265NaluSliceEXT*)alloc->alloc(from->naluSliceEntryCount * sizeof(const VkVideoEncodeH265NaluSliceEXT));
+ if (from->pNaluSliceEntries) {
+ to->pNaluSliceEntries = (VkVideoEncodeH265NaluSliceEXT*)alloc->alloc(
+ from->naluSliceEntryCount * sizeof(const VkVideoEncodeH265NaluSliceEXT));
to->naluSliceEntryCount = from->naluSliceEntryCount;
- for (uint32_t i = 0; i < (uint32_t)from->naluSliceEntryCount; ++i)
- {
- deepcopy_VkVideoEncodeH265NaluSliceEXT(alloc, rootType, from->pNaluSliceEntries + i, (VkVideoEncodeH265NaluSliceEXT*)(to->pNaluSliceEntries + i));
+ for (uint32_t i = 0; i < (uint32_t)from->naluSliceEntryCount; ++i) {
+ deepcopy_VkVideoEncodeH265NaluSliceEXT(
+ alloc, rootType, from->pNaluSliceEntries + i,
+ (VkVideoEncodeH265NaluSliceEXT*)(to->pNaluSliceEntries + i));
}
}
}
to->pCurrentPictureInfo = nullptr;
- if (from->pCurrentPictureInfo)
- {
- to->pCurrentPictureInfo = (StdVideoEncodeH265PictureInfo*)alloc->dupArray(from->pCurrentPictureInfo, sizeof(const StdVideoEncodeH265PictureInfo));
+ if (from->pCurrentPictureInfo) {
+ to->pCurrentPictureInfo = (StdVideoEncodeH265PictureInfo*)alloc->dupArray(
+ from->pCurrentPictureInfo, sizeof(const StdVideoEncodeH265PictureInfo));
}
}
void deepcopy_VkVideoEncodeH265EmitPictureParametersEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVideoEncodeH265EmitPictureParametersEXT* from,
- VkVideoEncodeH265EmitPictureParametersEXT* to)
-{
+ VkVideoEncodeH265EmitPictureParametersEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->ppsIdEntries = nullptr;
- if (from->ppsIdEntries)
- {
- to->ppsIdEntries = (uint8_t*)alloc->dupArray(from->ppsIdEntries, from->ppsIdEntryCount * sizeof(const uint8_t));
+ if (from->ppsIdEntries) {
+ to->ppsIdEntries = (uint8_t*)alloc->dupArray(from->ppsIdEntries,
+ from->ppsIdEntryCount * sizeof(const uint8_t));
}
}
-void deepcopy_VkVideoEncodeH265ProfileEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH265ProfileEXT* from,
- VkVideoEncodeH265ProfileEXT* to)
-{
+void deepcopy_VkVideoEncodeH265ProfileEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH265ProfileEXT* from,
+ VkVideoEncodeH265ProfileEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -12102,299 +9921,252 @@
#endif
#ifdef VK_EXT_video_decode_h264
-void deepcopy_VkVideoDecodeH264ProfileEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH264ProfileEXT* from,
- VkVideoDecodeH264ProfileEXT* to)
-{
+void deepcopy_VkVideoDecodeH264ProfileEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoDecodeH264ProfileEXT* from,
+ VkVideoDecodeH264ProfileEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkVideoDecodeH264CapabilitiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH264CapabilitiesEXT* from,
- VkVideoDecodeH264CapabilitiesEXT* to)
-{
+void deepcopy_VkVideoDecodeH264CapabilitiesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoDecodeH264CapabilitiesEXT* from,
+ VkVideoDecodeH264CapabilitiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkOffset2D(alloc, rootType, &from->fieldOffsetGranularity, (VkOffset2D*)(&to->fieldOffsetGranularity));
- deepcopy_VkExtensionProperties(alloc, rootType, &from->stdExtensionVersion, (VkExtensionProperties*)(&to->stdExtensionVersion));
+ deepcopy_VkOffset2D(alloc, rootType, &from->fieldOffsetGranularity,
+ (VkOffset2D*)(&to->fieldOffsetGranularity));
+ deepcopy_VkExtensionProperties(alloc, rootType, &from->stdExtensionVersion,
+ (VkExtensionProperties*)(&to->stdExtensionVersion));
}
void deepcopy_VkVideoDecodeH264SessionCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH264SessionCreateInfoEXT* from,
- VkVideoDecodeH264SessionCreateInfoEXT* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkVideoDecodeH264SessionCreateInfoEXT* from,
+ VkVideoDecodeH264SessionCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pStdExtensionVersion = nullptr;
- if (from->pStdExtensionVersion)
- {
- to->pStdExtensionVersion = (VkExtensionProperties*)alloc->alloc(sizeof(const VkExtensionProperties));
- deepcopy_VkExtensionProperties(alloc, rootType, from->pStdExtensionVersion, (VkExtensionProperties*)(to->pStdExtensionVersion));
+ if (from->pStdExtensionVersion) {
+ to->pStdExtensionVersion =
+ (VkExtensionProperties*)alloc->alloc(sizeof(const VkExtensionProperties));
+ deepcopy_VkExtensionProperties(alloc, rootType, from->pStdExtensionVersion,
+ (VkExtensionProperties*)(to->pStdExtensionVersion));
}
}
void deepcopy_VkVideoDecodeH264SessionParametersAddInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVideoDecodeH264SessionParametersAddInfoEXT* from,
- VkVideoDecodeH264SessionParametersAddInfoEXT* to)
-{
+ VkVideoDecodeH264SessionParametersAddInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pSpsStd = nullptr;
- if (from->pSpsStd)
- {
- to->pSpsStd = (StdVideoH264SequenceParameterSet*)alloc->dupArray(from->pSpsStd, from->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
+ if (from->pSpsStd) {
+ to->pSpsStd = (StdVideoH264SequenceParameterSet*)alloc->dupArray(
+ from->pSpsStd, from->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
}
to->pPpsStd = nullptr;
- if (from->pPpsStd)
- {
- to->pPpsStd = (StdVideoH264PictureParameterSet*)alloc->dupArray(from->pPpsStd, from->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
+ if (from->pPpsStd) {
+ to->pPpsStd = (StdVideoH264PictureParameterSet*)alloc->dupArray(
+ from->pPpsStd, from->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
}
}
void deepcopy_VkVideoDecodeH264SessionParametersCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVideoDecodeH264SessionParametersCreateInfoEXT* from,
- VkVideoDecodeH264SessionParametersCreateInfoEXT* to)
-{
+ VkVideoDecodeH264SessionParametersCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pParametersAddInfo = nullptr;
- if (from->pParametersAddInfo)
- {
- to->pParametersAddInfo = (VkVideoDecodeH264SessionParametersAddInfoEXT*)alloc->alloc(sizeof(const VkVideoDecodeH264SessionParametersAddInfoEXT));
- deepcopy_VkVideoDecodeH264SessionParametersAddInfoEXT(alloc, rootType, from->pParametersAddInfo, (VkVideoDecodeH264SessionParametersAddInfoEXT*)(to->pParametersAddInfo));
+ if (from->pParametersAddInfo) {
+ to->pParametersAddInfo = (VkVideoDecodeH264SessionParametersAddInfoEXT*)alloc->alloc(
+ sizeof(const VkVideoDecodeH264SessionParametersAddInfoEXT));
+ deepcopy_VkVideoDecodeH264SessionParametersAddInfoEXT(
+ alloc, rootType, from->pParametersAddInfo,
+ (VkVideoDecodeH264SessionParametersAddInfoEXT*)(to->pParametersAddInfo));
}
}
-void deepcopy_VkVideoDecodeH264PictureInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH264PictureInfoEXT* from,
- VkVideoDecodeH264PictureInfoEXT* to)
-{
+void deepcopy_VkVideoDecodeH264PictureInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoDecodeH264PictureInfoEXT* from,
+ VkVideoDecodeH264PictureInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pStdPictureInfo = nullptr;
- if (from->pStdPictureInfo)
- {
- to->pStdPictureInfo = (StdVideoDecodeH264PictureInfo*)alloc->dupArray(from->pStdPictureInfo, sizeof(const StdVideoDecodeH264PictureInfo));
+ if (from->pStdPictureInfo) {
+ to->pStdPictureInfo = (StdVideoDecodeH264PictureInfo*)alloc->dupArray(
+ from->pStdPictureInfo, sizeof(const StdVideoDecodeH264PictureInfo));
}
to->pSlicesDataOffsets = nullptr;
- if (from->pSlicesDataOffsets)
- {
- to->pSlicesDataOffsets = (uint32_t*)alloc->dupArray(from->pSlicesDataOffsets, from->slicesCount * sizeof(const uint32_t));
+ if (from->pSlicesDataOffsets) {
+ to->pSlicesDataOffsets = (uint32_t*)alloc->dupArray(
+ from->pSlicesDataOffsets, from->slicesCount * sizeof(const uint32_t));
}
}
-void deepcopy_VkVideoDecodeH264MvcEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH264MvcEXT* from,
- VkVideoDecodeH264MvcEXT* to)
-{
+void deepcopy_VkVideoDecodeH264MvcEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoDecodeH264MvcEXT* from,
+ VkVideoDecodeH264MvcEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pStdMvc = nullptr;
- if (from->pStdMvc)
- {
- to->pStdMvc = (StdVideoDecodeH264Mvc*)alloc->dupArray(from->pStdMvc, sizeof(const StdVideoDecodeH264Mvc));
+ if (from->pStdMvc) {
+ to->pStdMvc = (StdVideoDecodeH264Mvc*)alloc->dupArray(from->pStdMvc,
+ sizeof(const StdVideoDecodeH264Mvc));
}
}
-void deepcopy_VkVideoDecodeH264DpbSlotInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH264DpbSlotInfoEXT* from,
- VkVideoDecodeH264DpbSlotInfoEXT* to)
-{
+void deepcopy_VkVideoDecodeH264DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoDecodeH264DpbSlotInfoEXT* from,
+ VkVideoDecodeH264DpbSlotInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pStdReferenceInfo = nullptr;
- if (from->pStdReferenceInfo)
- {
- to->pStdReferenceInfo = (StdVideoDecodeH264ReferenceInfo*)alloc->dupArray(from->pStdReferenceInfo, sizeof(const StdVideoDecodeH264ReferenceInfo));
+ if (from->pStdReferenceInfo) {
+ to->pStdReferenceInfo = (StdVideoDecodeH264ReferenceInfo*)alloc->dupArray(
+ from->pStdReferenceInfo, sizeof(const StdVideoDecodeH264ReferenceInfo));
}
}
#endif
#ifdef VK_AMD_texture_gather_bias_lod
void deepcopy_VkTextureLODGatherFormatPropertiesAMD(
- Allocator* alloc,
- VkStructureType rootType,
- const VkTextureLODGatherFormatPropertiesAMD* from,
- VkTextureLODGatherFormatPropertiesAMD* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkTextureLODGatherFormatPropertiesAMD* from,
+ VkTextureLODGatherFormatPropertiesAMD* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -12402,27 +10174,22 @@
#endif
#ifdef VK_AMD_shader_info
-void deepcopy_VkShaderResourceUsageAMD(
- Allocator* alloc,
- VkStructureType rootType,
- const VkShaderResourceUsageAMD* from,
- VkShaderResourceUsageAMD* to)
-{
+void deepcopy_VkShaderResourceUsageAMD(Allocator* alloc, VkStructureType rootType,
+ const VkShaderResourceUsageAMD* from,
+ VkShaderResourceUsageAMD* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkShaderStatisticsInfoAMD(
- Allocator* alloc,
- VkStructureType rootType,
- const VkShaderStatisticsInfoAMD* from,
- VkShaderStatisticsInfoAMD* to)
-{
+void deepcopy_VkShaderStatisticsInfoAMD(Allocator* alloc, VkStructureType rootType,
+ const VkShaderStatisticsInfoAMD* from,
+ VkShaderStatisticsInfoAMD* to) {
(void)alloc;
(void)rootType;
*to = *from;
- deepcopy_VkShaderResourceUsageAMD(alloc, rootType, &from->resourceUsage, (VkShaderResourceUsageAMD*)(&to->resourceUsage));
+ deepcopy_VkShaderResourceUsageAMD(alloc, rootType, &from->resourceUsage,
+ (VkShaderResourceUsageAMD*)(&to->resourceUsage));
memcpy(to->computeWorkGroupSize, from->computeWorkGroupSize, 3 * sizeof(uint32_t));
}
@@ -12431,28 +10198,22 @@
#endif
#ifdef VK_GGP_stream_descriptor_surface
void deepcopy_VkStreamDescriptorSurfaceCreateInfoGGP(
- Allocator* alloc,
- VkStructureType rootType,
- const VkStreamDescriptorSurfaceCreateInfoGGP* from,
- VkStreamDescriptorSurfaceCreateInfoGGP* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkStreamDescriptorSurfaceCreateInfoGGP* from,
+ VkStreamDescriptorSurfaceCreateInfoGGP* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -12461,28 +10222,23 @@
#endif
#ifdef VK_NV_corner_sampled_image
void deepcopy_VkPhysicalDeviceCornerSampledImageFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceCornerSampledImageFeaturesNV* from,
- VkPhysicalDeviceCornerSampledImageFeaturesNV* to)
-{
+ VkPhysicalDeviceCornerSampledImageFeaturesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -12492,71 +10248,57 @@
#ifdef VK_IMG_format_pvrtc
#endif
#ifdef VK_NV_external_memory_capabilities
-void deepcopy_VkExternalImageFormatPropertiesNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExternalImageFormatPropertiesNV* from,
- VkExternalImageFormatPropertiesNV* to)
-{
+void deepcopy_VkExternalImageFormatPropertiesNV(Allocator* alloc, VkStructureType rootType,
+ const VkExternalImageFormatPropertiesNV* from,
+ VkExternalImageFormatPropertiesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- deepcopy_VkImageFormatProperties(alloc, rootType, &from->imageFormatProperties, (VkImageFormatProperties*)(&to->imageFormatProperties));
+ deepcopy_VkImageFormatProperties(alloc, rootType, &from->imageFormatProperties,
+ (VkImageFormatProperties*)(&to->imageFormatProperties));
}
#endif
#ifdef VK_NV_external_memory
-void deepcopy_VkExternalMemoryImageCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExternalMemoryImageCreateInfoNV* from,
- VkExternalMemoryImageCreateInfoNV* to)
-{
+void deepcopy_VkExternalMemoryImageCreateInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkExternalMemoryImageCreateInfoNV* from,
+ VkExternalMemoryImageCreateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkExportMemoryAllocateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExportMemoryAllocateInfoNV* from,
- VkExportMemoryAllocateInfoNV* to)
-{
+void deepcopy_VkExportMemoryAllocateInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkExportMemoryAllocateInfoNV* from,
+ VkExportMemoryAllocateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -12564,188 +10306,157 @@
#endif
#ifdef VK_NV_external_memory_win32
-void deepcopy_VkImportMemoryWin32HandleInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportMemoryWin32HandleInfoNV* from,
- VkImportMemoryWin32HandleInfoNV* to)
-{
+void deepcopy_VkImportMemoryWin32HandleInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkImportMemoryWin32HandleInfoNV* from,
+ VkImportMemoryWin32HandleInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkExportMemoryWin32HandleInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExportMemoryWin32HandleInfoNV* from,
- VkExportMemoryWin32HandleInfoNV* to)
-{
+void deepcopy_VkExportMemoryWin32HandleInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkExportMemoryWin32HandleInfoNV* from,
+ VkExportMemoryWin32HandleInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pAttributes = nullptr;
- if (from->pAttributes)
- {
- to->pAttributes = (SECURITY_ATTRIBUTES*)alloc->dupArray(from->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ if (from->pAttributes) {
+ to->pAttributes = (SECURITY_ATTRIBUTES*)alloc->dupArray(from->pAttributes,
+ sizeof(const SECURITY_ATTRIBUTES));
}
}
#endif
#ifdef VK_NV_win32_keyed_mutex
void deepcopy_VkWin32KeyedMutexAcquireReleaseInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkWin32KeyedMutexAcquireReleaseInfoNV* from,
- VkWin32KeyedMutexAcquireReleaseInfoNV* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkWin32KeyedMutexAcquireReleaseInfoNV* from,
+ VkWin32KeyedMutexAcquireReleaseInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pAcquireSyncs = nullptr;
- if (from->pAcquireSyncs)
- {
- to->pAcquireSyncs = (VkDeviceMemory*)alloc->dupArray(from->pAcquireSyncs, from->acquireCount * sizeof(const VkDeviceMemory));
+ if (from->pAcquireSyncs) {
+ to->pAcquireSyncs = (VkDeviceMemory*)alloc->dupArray(
+ from->pAcquireSyncs, from->acquireCount * sizeof(const VkDeviceMemory));
}
to->pAcquireKeys = nullptr;
- if (from->pAcquireKeys)
- {
- to->pAcquireKeys = (uint64_t*)alloc->dupArray(from->pAcquireKeys, from->acquireCount * sizeof(const uint64_t));
+ if (from->pAcquireKeys) {
+ to->pAcquireKeys = (uint64_t*)alloc->dupArray(from->pAcquireKeys,
+ from->acquireCount * sizeof(const uint64_t));
}
to->pAcquireTimeoutMilliseconds = nullptr;
- if (from->pAcquireTimeoutMilliseconds)
- {
- to->pAcquireTimeoutMilliseconds = (uint32_t*)alloc->dupArray(from->pAcquireTimeoutMilliseconds, from->acquireCount * sizeof(const uint32_t));
+ if (from->pAcquireTimeoutMilliseconds) {
+ to->pAcquireTimeoutMilliseconds = (uint32_t*)alloc->dupArray(
+ from->pAcquireTimeoutMilliseconds, from->acquireCount * sizeof(const uint32_t));
}
to->pReleaseSyncs = nullptr;
- if (from->pReleaseSyncs)
- {
- to->pReleaseSyncs = (VkDeviceMemory*)alloc->dupArray(from->pReleaseSyncs, from->releaseCount * sizeof(const VkDeviceMemory));
+ if (from->pReleaseSyncs) {
+ to->pReleaseSyncs = (VkDeviceMemory*)alloc->dupArray(
+ from->pReleaseSyncs, from->releaseCount * sizeof(const VkDeviceMemory));
}
to->pReleaseKeys = nullptr;
- if (from->pReleaseKeys)
- {
- to->pReleaseKeys = (uint64_t*)alloc->dupArray(from->pReleaseKeys, from->releaseCount * sizeof(const uint64_t));
+ if (from->pReleaseKeys) {
+ to->pReleaseKeys = (uint64_t*)alloc->dupArray(from->pReleaseKeys,
+ from->releaseCount * sizeof(const uint64_t));
}
}
#endif
#ifdef VK_EXT_validation_flags
-void deepcopy_VkValidationFlagsEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkValidationFlagsEXT* from,
- VkValidationFlagsEXT* to)
-{
+void deepcopy_VkValidationFlagsEXT(Allocator* alloc, VkStructureType rootType,
+ const VkValidationFlagsEXT* from, VkValidationFlagsEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pDisabledValidationChecks = nullptr;
- if (from->pDisabledValidationChecks)
- {
- to->pDisabledValidationChecks = (VkValidationCheckEXT*)alloc->dupArray(from->pDisabledValidationChecks, from->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
+ if (from->pDisabledValidationChecks) {
+ to->pDisabledValidationChecks = (VkValidationCheckEXT*)alloc->dupArray(
+ from->pDisabledValidationChecks,
+ from->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
}
}
#endif
#ifdef VK_NN_vi_surface
-void deepcopy_VkViSurfaceCreateInfoNN(
- Allocator* alloc,
- VkStructureType rootType,
- const VkViSurfaceCreateInfoNN* from,
- VkViSurfaceCreateInfoNN* to)
-{
+void deepcopy_VkViSurfaceCreateInfoNN(Allocator* alloc, VkStructureType rootType,
+ const VkViSurfaceCreateInfoNN* from,
+ VkViSurfaceCreateInfoNN* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->window = nullptr;
- if (from->window)
- {
+ if (from->window) {
to->window = (void*)alloc->dupArray(from->window, sizeof(uint8_t));
}
}
@@ -12757,28 +10468,23 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
void deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* from,
- VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* to)
-{
+ VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -12786,57 +10492,45 @@
#endif
#ifdef VK_EXT_astc_decode_mode
-void deepcopy_VkImageViewASTCDecodeModeEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageViewASTCDecodeModeEXT* from,
- VkImageViewASTCDecodeModeEXT* to)
-{
+void deepcopy_VkImageViewASTCDecodeModeEXT(Allocator* alloc, VkStructureType rootType,
+ const VkImageViewASTCDecodeModeEXT* from,
+ VkImageViewASTCDecodeModeEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceASTCDecodeFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceASTCDecodeFeaturesEXT* from,
- VkPhysicalDeviceASTCDecodeFeaturesEXT* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceASTCDecodeFeaturesEXT* from,
+ VkPhysicalDeviceASTCDecodeFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -12844,85 +10538,69 @@
#endif
#ifdef VK_EXT_conditional_rendering
-void deepcopy_VkConditionalRenderingBeginInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkConditionalRenderingBeginInfoEXT* from,
- VkConditionalRenderingBeginInfoEXT* to)
-{
+void deepcopy_VkConditionalRenderingBeginInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkConditionalRenderingBeginInfoEXT* from,
+ VkConditionalRenderingBeginInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceConditionalRenderingFeaturesEXT* from,
- VkPhysicalDeviceConditionalRenderingFeaturesEXT* to)
-{
+ VkPhysicalDeviceConditionalRenderingFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkCommandBufferInheritanceConditionalRenderingInfoEXT* from,
- VkCommandBufferInheritanceConditionalRenderingInfoEXT* to)
-{
+ VkCommandBufferInheritanceConditionalRenderingInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -12930,53 +10608,43 @@
#endif
#ifdef VK_NV_clip_space_w_scaling
-void deepcopy_VkViewportWScalingNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkViewportWScalingNV* from,
- VkViewportWScalingNV* to)
-{
+void deepcopy_VkViewportWScalingNV(Allocator* alloc, VkStructureType rootType,
+ const VkViewportWScalingNV* from, VkViewportWScalingNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
void deepcopy_VkPipelineViewportWScalingStateCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineViewportWScalingStateCreateInfoNV* from,
- VkPipelineViewportWScalingStateCreateInfoNV* to)
-{
+ VkPipelineViewportWScalingStateCreateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pViewportWScalings = nullptr;
- if (from->pViewportWScalings)
- {
- to->pViewportWScalings = (VkViewportWScalingNV*)alloc->alloc(from->viewportCount * sizeof(const VkViewportWScalingNV));
+ if (from->pViewportWScalings) {
+ to->pViewportWScalings = (VkViewportWScalingNV*)alloc->alloc(
+ from->viewportCount * sizeof(const VkViewportWScalingNV));
to->viewportCount = from->viewportCount;
- for (uint32_t i = 0; i < (uint32_t)from->viewportCount; ++i)
- {
- deepcopy_VkViewportWScalingNV(alloc, rootType, from->pViewportWScalings + i, (VkViewportWScalingNV*)(to->pViewportWScalings + i));
+ for (uint32_t i = 0; i < (uint32_t)from->viewportCount; ++i) {
+ deepcopy_VkViewportWScalingNV(alloc, rootType, from->pViewportWScalings + i,
+ (VkViewportWScalingNV*)(to->pViewportWScalings + i));
}
}
}
@@ -12988,29 +10656,23 @@
#ifdef VK_EXT_acquire_xlib_display
#endif
#ifdef VK_EXT_display_surface_counter
-void deepcopy_VkSurfaceCapabilities2EXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSurfaceCapabilities2EXT* from,
- VkSurfaceCapabilities2EXT* to)
-{
+void deepcopy_VkSurfaceCapabilities2EXT(Allocator* alloc, VkStructureType rootType,
+ const VkSurfaceCapabilities2EXT* from,
+ VkSurfaceCapabilities2EXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -13021,113 +10683,86 @@
#endif
#ifdef VK_EXT_display_control
-void deepcopy_VkDisplayPowerInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayPowerInfoEXT* from,
- VkDisplayPowerInfoEXT* to)
-{
+void deepcopy_VkDisplayPowerInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayPowerInfoEXT* from, VkDisplayPowerInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkDeviceEventInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceEventInfoEXT* from,
- VkDeviceEventInfoEXT* to)
-{
+void deepcopy_VkDeviceEventInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceEventInfoEXT* from, VkDeviceEventInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkDisplayEventInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayEventInfoEXT* from,
- VkDisplayEventInfoEXT* to)
-{
+void deepcopy_VkDisplayEventInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayEventInfoEXT* from, VkDisplayEventInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkSwapchainCounterCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSwapchainCounterCreateInfoEXT* from,
- VkSwapchainCounterCreateInfoEXT* to)
-{
+void deepcopy_VkSwapchainCounterCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkSwapchainCounterCreateInfoEXT* from,
+ VkSwapchainCounterCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -13135,75 +10770,58 @@
#endif
#ifdef VK_GOOGLE_display_timing
-void deepcopy_VkRefreshCycleDurationGOOGLE(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRefreshCycleDurationGOOGLE* from,
- VkRefreshCycleDurationGOOGLE* to)
-{
+void deepcopy_VkRefreshCycleDurationGOOGLE(Allocator* alloc, VkStructureType rootType,
+ const VkRefreshCycleDurationGOOGLE* from,
+ VkRefreshCycleDurationGOOGLE* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkPastPresentationTimingGOOGLE(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPastPresentationTimingGOOGLE* from,
- VkPastPresentationTimingGOOGLE* to)
-{
+void deepcopy_VkPastPresentationTimingGOOGLE(Allocator* alloc, VkStructureType rootType,
+ const VkPastPresentationTimingGOOGLE* from,
+ VkPastPresentationTimingGOOGLE* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkPresentTimeGOOGLE(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPresentTimeGOOGLE* from,
- VkPresentTimeGOOGLE* to)
-{
+void deepcopy_VkPresentTimeGOOGLE(Allocator* alloc, VkStructureType rootType,
+ const VkPresentTimeGOOGLE* from, VkPresentTimeGOOGLE* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkPresentTimesInfoGOOGLE(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPresentTimesInfoGOOGLE* from,
- VkPresentTimesInfoGOOGLE* to)
-{
+void deepcopy_VkPresentTimesInfoGOOGLE(Allocator* alloc, VkStructureType rootType,
+ const VkPresentTimesInfoGOOGLE* from,
+ VkPresentTimesInfoGOOGLE* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pTimes = nullptr;
- if (from->pTimes)
- {
- to->pTimes = (VkPresentTimeGOOGLE*)alloc->alloc(from->swapchainCount * sizeof(const VkPresentTimeGOOGLE));
+ if (from->pTimes) {
+ to->pTimes = (VkPresentTimeGOOGLE*)alloc->alloc(from->swapchainCount *
+ sizeof(const VkPresentTimeGOOGLE));
to->swapchainCount = from->swapchainCount;
- for (uint32_t i = 0; i < (uint32_t)from->swapchainCount; ++i)
- {
- deepcopy_VkPresentTimeGOOGLE(alloc, rootType, from->pTimes + i, (VkPresentTimeGOOGLE*)(to->pTimes + i));
+ for (uint32_t i = 0; i < (uint32_t)from->swapchainCount; ++i) {
+ deepcopy_VkPresentTimeGOOGLE(alloc, rootType, from->pTimes + i,
+ (VkPresentTimeGOOGLE*)(to->pTimes + i));
}
}
}
@@ -13218,28 +10836,23 @@
#endif
#ifdef VK_NVX_multiview_per_view_attributes
void deepcopy_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* from,
- VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* to)
-{
+ VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -13247,53 +10860,43 @@
#endif
#ifdef VK_NV_viewport_swizzle
-void deepcopy_VkViewportSwizzleNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkViewportSwizzleNV* from,
- VkViewportSwizzleNV* to)
-{
+void deepcopy_VkViewportSwizzleNV(Allocator* alloc, VkStructureType rootType,
+ const VkViewportSwizzleNV* from, VkViewportSwizzleNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
void deepcopy_VkPipelineViewportSwizzleStateCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineViewportSwizzleStateCreateInfoNV* from,
- VkPipelineViewportSwizzleStateCreateInfoNV* to)
-{
+ VkPipelineViewportSwizzleStateCreateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pViewportSwizzles = nullptr;
- if (from->pViewportSwizzles)
- {
- to->pViewportSwizzles = (VkViewportSwizzleNV*)alloc->alloc(from->viewportCount * sizeof(const VkViewportSwizzleNV));
+ if (from->pViewportSwizzles) {
+ to->pViewportSwizzles = (VkViewportSwizzleNV*)alloc->alloc(
+ from->viewportCount * sizeof(const VkViewportSwizzleNV));
to->viewportCount = from->viewportCount;
- for (uint32_t i = 0; i < (uint32_t)from->viewportCount; ++i)
- {
- deepcopy_VkViewportSwizzleNV(alloc, rootType, from->pViewportSwizzles + i, (VkViewportSwizzleNV*)(to->pViewportSwizzles + i));
+ for (uint32_t i = 0; i < (uint32_t)from->viewportCount; ++i) {
+ deepcopy_VkViewportSwizzleNV(alloc, rootType, from->pViewportSwizzles + i,
+ (VkViewportSwizzleNV*)(to->pViewportSwizzles + i));
}
}
}
@@ -13302,69 +10905,58 @@
#endif
#ifdef VK_EXT_discard_rectangles
void deepcopy_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDiscardRectanglePropertiesEXT* from,
- VkPhysicalDeviceDiscardRectanglePropertiesEXT* to)
-{
+ VkPhysicalDeviceDiscardRectanglePropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineDiscardRectangleStateCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineDiscardRectangleStateCreateInfoEXT* from,
- VkPipelineDiscardRectangleStateCreateInfoEXT* to)
-{
+ VkPipelineDiscardRectangleStateCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pDiscardRectangles = nullptr;
- if (from->pDiscardRectangles)
- {
- to->pDiscardRectangles = (VkRect2D*)alloc->alloc(from->discardRectangleCount * sizeof(const VkRect2D));
+ if (from->pDiscardRectangles) {
+ to->pDiscardRectangles =
+ (VkRect2D*)alloc->alloc(from->discardRectangleCount * sizeof(const VkRect2D));
to->discardRectangleCount = from->discardRectangleCount;
- for (uint32_t i = 0; i < (uint32_t)from->discardRectangleCount; ++i)
- {
- deepcopy_VkRect2D(alloc, rootType, from->pDiscardRectangles + i, (VkRect2D*)(to->pDiscardRectangles + i));
+ for (uint32_t i = 0; i < (uint32_t)from->discardRectangleCount; ++i) {
+ deepcopy_VkRect2D(alloc, rootType, from->pDiscardRectangles + i,
+ (VkRect2D*)(to->pDiscardRectangles + i));
}
}
}
@@ -13373,56 +10965,46 @@
#endif
#ifdef VK_EXT_conservative_rasterization
void deepcopy_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* from,
- VkPhysicalDeviceConservativeRasterizationPropertiesEXT* to)
-{
+ VkPhysicalDeviceConservativeRasterizationPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineRasterizationConservativeStateCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineRasterizationConservativeStateCreateInfoEXT* from,
- VkPipelineRasterizationConservativeStateCreateInfoEXT* to)
-{
+ VkPipelineRasterizationConservativeStateCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -13431,56 +11013,46 @@
#endif
#ifdef VK_EXT_depth_clip_enable
void deepcopy_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDepthClipEnableFeaturesEXT* from,
- VkPhysicalDeviceDepthClipEnableFeaturesEXT* to)
-{
+ VkPhysicalDeviceDepthClipEnableFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineRasterizationDepthClipStateCreateInfoEXT* from,
- VkPipelineRasterizationDepthClipStateCreateInfoEXT* to)
-{
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -13490,115 +11062,93 @@
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
-void deepcopy_VkXYColorEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkXYColorEXT* from,
- VkXYColorEXT* to)
-{
+void deepcopy_VkXYColorEXT(Allocator* alloc, VkStructureType rootType, const VkXYColorEXT* from,
+ VkXYColorEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkHdrMetadataEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkHdrMetadataEXT* from,
- VkHdrMetadataEXT* to)
-{
+void deepcopy_VkHdrMetadataEXT(Allocator* alloc, VkStructureType rootType,
+ const VkHdrMetadataEXT* from, VkHdrMetadataEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkXYColorEXT(alloc, rootType, &from->displayPrimaryRed, (VkXYColorEXT*)(&to->displayPrimaryRed));
- deepcopy_VkXYColorEXT(alloc, rootType, &from->displayPrimaryGreen, (VkXYColorEXT*)(&to->displayPrimaryGreen));
- deepcopy_VkXYColorEXT(alloc, rootType, &from->displayPrimaryBlue, (VkXYColorEXT*)(&to->displayPrimaryBlue));
+ deepcopy_VkXYColorEXT(alloc, rootType, &from->displayPrimaryRed,
+ (VkXYColorEXT*)(&to->displayPrimaryRed));
+ deepcopy_VkXYColorEXT(alloc, rootType, &from->displayPrimaryGreen,
+ (VkXYColorEXT*)(&to->displayPrimaryGreen));
+ deepcopy_VkXYColorEXT(alloc, rootType, &from->displayPrimaryBlue,
+ (VkXYColorEXT*)(&to->displayPrimaryBlue));
deepcopy_VkXYColorEXT(alloc, rootType, &from->whitePoint, (VkXYColorEXT*)(&to->whitePoint));
}
#endif
#ifdef VK_MVK_ios_surface
-void deepcopy_VkIOSSurfaceCreateInfoMVK(
- Allocator* alloc,
- VkStructureType rootType,
- const VkIOSSurfaceCreateInfoMVK* from,
- VkIOSSurfaceCreateInfoMVK* to)
-{
+void deepcopy_VkIOSSurfaceCreateInfoMVK(Allocator* alloc, VkStructureType rootType,
+ const VkIOSSurfaceCreateInfoMVK* from,
+ VkIOSSurfaceCreateInfoMVK* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pView = nullptr;
- if (from->pView)
- {
+ if (from->pView) {
to->pView = (void*)alloc->dupArray(from->pView, sizeof(const uint8_t));
}
}
#endif
#ifdef VK_MVK_macos_surface
-void deepcopy_VkMacOSSurfaceCreateInfoMVK(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMacOSSurfaceCreateInfoMVK* from,
- VkMacOSSurfaceCreateInfoMVK* to)
-{
+void deepcopy_VkMacOSSurfaceCreateInfoMVK(Allocator* alloc, VkStructureType rootType,
+ const VkMacOSSurfaceCreateInfoMVK* from,
+ VkMacOSSurfaceCreateInfoMVK* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pView = nullptr;
- if (from->pView)
- {
+ if (from->pView) {
to->pView = (void*)alloc->dupArray(from->pView, sizeof(const uint8_t));
}
}
@@ -13611,419 +11161,344 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
-void deepcopy_VkDebugUtilsLabelEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDebugUtilsLabelEXT* from,
- VkDebugUtilsLabelEXT* to)
-{
+void deepcopy_VkDebugUtilsLabelEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugUtilsLabelEXT* from, VkDebugUtilsLabelEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pLabelName = nullptr;
- if (from->pLabelName)
- {
+ if (from->pLabelName) {
to->pLabelName = alloc->strDup(from->pLabelName);
}
memcpy(to->color, from->color, 4 * sizeof(float));
}
-void deepcopy_VkDebugUtilsObjectNameInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDebugUtilsObjectNameInfoEXT* from,
- VkDebugUtilsObjectNameInfoEXT* to)
-{
+void deepcopy_VkDebugUtilsObjectNameInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugUtilsObjectNameInfoEXT* from,
+ VkDebugUtilsObjectNameInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pObjectName = nullptr;
- if (from->pObjectName)
- {
+ if (from->pObjectName) {
to->pObjectName = alloc->strDup(from->pObjectName);
}
}
-void deepcopy_VkDebugUtilsMessengerCallbackDataEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDebugUtilsMessengerCallbackDataEXT* from,
- VkDebugUtilsMessengerCallbackDataEXT* to)
-{
+void deepcopy_VkDebugUtilsMessengerCallbackDataEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugUtilsMessengerCallbackDataEXT* from,
+ VkDebugUtilsMessengerCallbackDataEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pMessageIdName = nullptr;
- if (from->pMessageIdName)
- {
+ if (from->pMessageIdName) {
to->pMessageIdName = alloc->strDup(from->pMessageIdName);
}
to->pMessage = nullptr;
- if (from->pMessage)
- {
+ if (from->pMessage) {
to->pMessage = alloc->strDup(from->pMessage);
}
- if (from)
- {
+ if (from) {
to->pQueueLabels = nullptr;
- if (from->pQueueLabels)
- {
- to->pQueueLabels = (VkDebugUtilsLabelEXT*)alloc->alloc(from->queueLabelCount * sizeof(VkDebugUtilsLabelEXT));
+ if (from->pQueueLabels) {
+ to->pQueueLabels = (VkDebugUtilsLabelEXT*)alloc->alloc(from->queueLabelCount *
+ sizeof(VkDebugUtilsLabelEXT));
to->queueLabelCount = from->queueLabelCount;
- for (uint32_t i = 0; i < (uint32_t)from->queueLabelCount; ++i)
- {
- deepcopy_VkDebugUtilsLabelEXT(alloc, rootType, from->pQueueLabels + i, (VkDebugUtilsLabelEXT*)(to->pQueueLabels + i));
+ for (uint32_t i = 0; i < (uint32_t)from->queueLabelCount; ++i) {
+ deepcopy_VkDebugUtilsLabelEXT(alloc, rootType, from->pQueueLabels + i,
+ (VkDebugUtilsLabelEXT*)(to->pQueueLabels + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pCmdBufLabels = nullptr;
- if (from->pCmdBufLabels)
- {
- to->pCmdBufLabels = (VkDebugUtilsLabelEXT*)alloc->alloc(from->cmdBufLabelCount * sizeof(VkDebugUtilsLabelEXT));
+ if (from->pCmdBufLabels) {
+ to->pCmdBufLabels = (VkDebugUtilsLabelEXT*)alloc->alloc(from->cmdBufLabelCount *
+ sizeof(VkDebugUtilsLabelEXT));
to->cmdBufLabelCount = from->cmdBufLabelCount;
- for (uint32_t i = 0; i < (uint32_t)from->cmdBufLabelCount; ++i)
- {
- deepcopy_VkDebugUtilsLabelEXT(alloc, rootType, from->pCmdBufLabels + i, (VkDebugUtilsLabelEXT*)(to->pCmdBufLabels + i));
+ for (uint32_t i = 0; i < (uint32_t)from->cmdBufLabelCount; ++i) {
+ deepcopy_VkDebugUtilsLabelEXT(alloc, rootType, from->pCmdBufLabels + i,
+ (VkDebugUtilsLabelEXT*)(to->pCmdBufLabels + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pObjects = nullptr;
- if (from->pObjects)
- {
- to->pObjects = (VkDebugUtilsObjectNameInfoEXT*)alloc->alloc(from->objectCount * sizeof(VkDebugUtilsObjectNameInfoEXT));
+ if (from->pObjects) {
+ to->pObjects = (VkDebugUtilsObjectNameInfoEXT*)alloc->alloc(
+ from->objectCount * sizeof(VkDebugUtilsObjectNameInfoEXT));
to->objectCount = from->objectCount;
- for (uint32_t i = 0; i < (uint32_t)from->objectCount; ++i)
- {
- deepcopy_VkDebugUtilsObjectNameInfoEXT(alloc, rootType, from->pObjects + i, (VkDebugUtilsObjectNameInfoEXT*)(to->pObjects + i));
+ for (uint32_t i = 0; i < (uint32_t)from->objectCount; ++i) {
+ deepcopy_VkDebugUtilsObjectNameInfoEXT(
+ alloc, rootType, from->pObjects + i,
+ (VkDebugUtilsObjectNameInfoEXT*)(to->pObjects + i));
}
}
}
}
-void deepcopy_VkDebugUtilsMessengerCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDebugUtilsMessengerCreateInfoEXT* from,
- VkDebugUtilsMessengerCreateInfoEXT* to)
-{
+void deepcopy_VkDebugUtilsMessengerCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugUtilsMessengerCreateInfoEXT* from,
+ VkDebugUtilsMessengerCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pUserData = nullptr;
- if (from->pUserData)
- {
+ if (from->pUserData) {
to->pUserData = (void*)alloc->dupArray(from->pUserData, sizeof(uint8_t));
}
}
-void deepcopy_VkDebugUtilsObjectTagInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDebugUtilsObjectTagInfoEXT* from,
- VkDebugUtilsObjectTagInfoEXT* to)
-{
+void deepcopy_VkDebugUtilsObjectTagInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugUtilsObjectTagInfoEXT* from,
+ VkDebugUtilsObjectTagInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pTag = nullptr;
- if (from->pTag)
- {
+ if (from->pTag) {
to->pTag = (void*)alloc->dupArray(from->pTag, from->tagSize * sizeof(const uint8_t));
}
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
-void deepcopy_VkAndroidHardwareBufferUsageANDROID(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAndroidHardwareBufferUsageANDROID* from,
- VkAndroidHardwareBufferUsageANDROID* to)
-{
+void deepcopy_VkAndroidHardwareBufferUsageANDROID(Allocator* alloc, VkStructureType rootType,
+ const VkAndroidHardwareBufferUsageANDROID* from,
+ VkAndroidHardwareBufferUsageANDROID* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkAndroidHardwareBufferPropertiesANDROID(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAndroidHardwareBufferPropertiesANDROID* from,
- VkAndroidHardwareBufferPropertiesANDROID* to)
-{
+ VkAndroidHardwareBufferPropertiesANDROID* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkAndroidHardwareBufferFormatPropertiesANDROID(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAndroidHardwareBufferFormatPropertiesANDROID* from,
- VkAndroidHardwareBufferFormatPropertiesANDROID* to)
-{
+ VkAndroidHardwareBufferFormatPropertiesANDROID* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkComponentMapping(alloc, rootType, &from->samplerYcbcrConversionComponents, (VkComponentMapping*)(&to->samplerYcbcrConversionComponents));
+ deepcopy_VkComponentMapping(alloc, rootType, &from->samplerYcbcrConversionComponents,
+ (VkComponentMapping*)(&to->samplerYcbcrConversionComponents));
}
void deepcopy_VkImportAndroidHardwareBufferInfoANDROID(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkImportAndroidHardwareBufferInfoANDROID* from,
- VkImportAndroidHardwareBufferInfoANDROID* to)
-{
+ VkImportAndroidHardwareBufferInfoANDROID* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->buffer = nullptr;
- if (from->buffer)
- {
+ if (from->buffer) {
to->buffer = (AHardwareBuffer*)alloc->dupArray(from->buffer, sizeof(AHardwareBuffer));
}
}
void deepcopy_VkMemoryGetAndroidHardwareBufferInfoANDROID(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkMemoryGetAndroidHardwareBufferInfoANDROID* from,
- VkMemoryGetAndroidHardwareBufferInfoANDROID* to)
-{
+ VkMemoryGetAndroidHardwareBufferInfoANDROID* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkExternalFormatANDROID(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExternalFormatANDROID* from,
- VkExternalFormatANDROID* to)
-{
+void deepcopy_VkExternalFormatANDROID(Allocator* alloc, VkStructureType rootType,
+ const VkExternalFormatANDROID* from,
+ VkExternalFormatANDROID* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkAndroidHardwareBufferFormatProperties2ANDROID(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAndroidHardwareBufferFormatProperties2ANDROID* from,
- VkAndroidHardwareBufferFormatProperties2ANDROID* to)
-{
+ VkAndroidHardwareBufferFormatProperties2ANDROID* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkComponentMapping(alloc, rootType, &from->samplerYcbcrConversionComponents, (VkComponentMapping*)(&to->samplerYcbcrConversionComponents));
+ deepcopy_VkComponentMapping(alloc, rootType, &from->samplerYcbcrConversionComponents,
+ (VkComponentMapping*)(&to->samplerYcbcrConversionComponents));
}
#endif
@@ -14037,117 +11512,96 @@
#endif
#ifdef VK_EXT_inline_uniform_block
void deepcopy_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* from,
- VkPhysicalDeviceInlineUniformBlockFeaturesEXT* to)
-{
+ VkPhysicalDeviceInlineUniformBlockFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* from,
- VkPhysicalDeviceInlineUniformBlockPropertiesEXT* to)
-{
+ VkPhysicalDeviceInlineUniformBlockPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkWriteDescriptorSetInlineUniformBlockEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkWriteDescriptorSetInlineUniformBlockEXT* from,
- VkWriteDescriptorSetInlineUniformBlockEXT* to)
-{
+ VkWriteDescriptorSetInlineUniformBlockEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pData = nullptr;
- if (from->pData)
- {
+ if (from->pData) {
to->pData = (void*)alloc->dupArray(from->pData, from->dataSize * sizeof(const uint8_t));
}
}
void deepcopy_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* from,
- VkDescriptorPoolInlineUniformBlockCreateInfoEXT* to)
-{
+ VkDescriptorPoolInlineUniformBlockCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -14157,306 +11611,260 @@
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
-void deepcopy_VkSampleLocationEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSampleLocationEXT* from,
- VkSampleLocationEXT* to)
-{
+void deepcopy_VkSampleLocationEXT(Allocator* alloc, VkStructureType rootType,
+ const VkSampleLocationEXT* from, VkSampleLocationEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkSampleLocationsInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSampleLocationsInfoEXT* from,
- VkSampleLocationsInfoEXT* to)
-{
+void deepcopy_VkSampleLocationsInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkSampleLocationsInfoEXT* from,
+ VkSampleLocationsInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(alloc, rootType, &from->sampleLocationGridSize, (VkExtent2D*)(&to->sampleLocationGridSize));
- if (from)
- {
+ deepcopy_VkExtent2D(alloc, rootType, &from->sampleLocationGridSize,
+ (VkExtent2D*)(&to->sampleLocationGridSize));
+ if (from) {
to->pSampleLocations = nullptr;
- if (from->pSampleLocations)
- {
- to->pSampleLocations = (VkSampleLocationEXT*)alloc->alloc(from->sampleLocationsCount * sizeof(const VkSampleLocationEXT));
+ if (from->pSampleLocations) {
+ to->pSampleLocations = (VkSampleLocationEXT*)alloc->alloc(
+ from->sampleLocationsCount * sizeof(const VkSampleLocationEXT));
to->sampleLocationsCount = from->sampleLocationsCount;
- for (uint32_t i = 0; i < (uint32_t)from->sampleLocationsCount; ++i)
- {
- deepcopy_VkSampleLocationEXT(alloc, rootType, from->pSampleLocations + i, (VkSampleLocationEXT*)(to->pSampleLocations + i));
+ for (uint32_t i = 0; i < (uint32_t)from->sampleLocationsCount; ++i) {
+ deepcopy_VkSampleLocationEXT(alloc, rootType, from->pSampleLocations + i,
+ (VkSampleLocationEXT*)(to->pSampleLocations + i));
}
}
}
}
-void deepcopy_VkAttachmentSampleLocationsEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAttachmentSampleLocationsEXT* from,
- VkAttachmentSampleLocationsEXT* to)
-{
+void deepcopy_VkAttachmentSampleLocationsEXT(Allocator* alloc, VkStructureType rootType,
+ const VkAttachmentSampleLocationsEXT* from,
+ VkAttachmentSampleLocationsEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- deepcopy_VkSampleLocationsInfoEXT(alloc, rootType, &from->sampleLocationsInfo, (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
+ deepcopy_VkSampleLocationsInfoEXT(alloc, rootType, &from->sampleLocationsInfo,
+ (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
}
-void deepcopy_VkSubpassSampleLocationsEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubpassSampleLocationsEXT* from,
- VkSubpassSampleLocationsEXT* to)
-{
+void deepcopy_VkSubpassSampleLocationsEXT(Allocator* alloc, VkStructureType rootType,
+ const VkSubpassSampleLocationsEXT* from,
+ VkSubpassSampleLocationsEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- deepcopy_VkSampleLocationsInfoEXT(alloc, rootType, &from->sampleLocationsInfo, (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
+ deepcopy_VkSampleLocationsInfoEXT(alloc, rootType, &from->sampleLocationsInfo,
+ (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
}
void deepcopy_VkRenderPassSampleLocationsBeginInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRenderPassSampleLocationsBeginInfoEXT* from,
- VkRenderPassSampleLocationsBeginInfoEXT* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkRenderPassSampleLocationsBeginInfoEXT* from,
+ VkRenderPassSampleLocationsBeginInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pAttachmentInitialSampleLocations = nullptr;
- if (from->pAttachmentInitialSampleLocations)
- {
- to->pAttachmentInitialSampleLocations = (VkAttachmentSampleLocationsEXT*)alloc->alloc(from->attachmentInitialSampleLocationsCount * sizeof(const VkAttachmentSampleLocationsEXT));
+ if (from->pAttachmentInitialSampleLocations) {
+ to->pAttachmentInitialSampleLocations = (VkAttachmentSampleLocationsEXT*)alloc->alloc(
+ from->attachmentInitialSampleLocationsCount *
+ sizeof(const VkAttachmentSampleLocationsEXT));
to->attachmentInitialSampleLocationsCount = from->attachmentInitialSampleLocationsCount;
- for (uint32_t i = 0; i < (uint32_t)from->attachmentInitialSampleLocationsCount; ++i)
- {
- deepcopy_VkAttachmentSampleLocationsEXT(alloc, rootType, from->pAttachmentInitialSampleLocations + i, (VkAttachmentSampleLocationsEXT*)(to->pAttachmentInitialSampleLocations + i));
+ for (uint32_t i = 0; i < (uint32_t)from->attachmentInitialSampleLocationsCount; ++i) {
+ deepcopy_VkAttachmentSampleLocationsEXT(
+ alloc, rootType, from->pAttachmentInitialSampleLocations + i,
+ (VkAttachmentSampleLocationsEXT*)(to->pAttachmentInitialSampleLocations + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pPostSubpassSampleLocations = nullptr;
- if (from->pPostSubpassSampleLocations)
- {
- to->pPostSubpassSampleLocations = (VkSubpassSampleLocationsEXT*)alloc->alloc(from->postSubpassSampleLocationsCount * sizeof(const VkSubpassSampleLocationsEXT));
+ if (from->pPostSubpassSampleLocations) {
+ to->pPostSubpassSampleLocations = (VkSubpassSampleLocationsEXT*)alloc->alloc(
+ from->postSubpassSampleLocationsCount * sizeof(const VkSubpassSampleLocationsEXT));
to->postSubpassSampleLocationsCount = from->postSubpassSampleLocationsCount;
- for (uint32_t i = 0; i < (uint32_t)from->postSubpassSampleLocationsCount; ++i)
- {
- deepcopy_VkSubpassSampleLocationsEXT(alloc, rootType, from->pPostSubpassSampleLocations + i, (VkSubpassSampleLocationsEXT*)(to->pPostSubpassSampleLocations + i));
+ for (uint32_t i = 0; i < (uint32_t)from->postSubpassSampleLocationsCount; ++i) {
+ deepcopy_VkSubpassSampleLocationsEXT(
+ alloc, rootType, from->pPostSubpassSampleLocations + i,
+ (VkSubpassSampleLocationsEXT*)(to->pPostSubpassSampleLocations + i));
}
}
}
}
void deepcopy_VkPipelineSampleLocationsStateCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineSampleLocationsStateCreateInfoEXT* from,
- VkPipelineSampleLocationsStateCreateInfoEXT* to)
-{
+ VkPipelineSampleLocationsStateCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkSampleLocationsInfoEXT(alloc, rootType, &from->sampleLocationsInfo, (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
+ deepcopy_VkSampleLocationsInfoEXT(alloc, rootType, &from->sampleLocationsInfo,
+ (VkSampleLocationsInfoEXT*)(&to->sampleLocationsInfo));
}
void deepcopy_VkPhysicalDeviceSampleLocationsPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceSampleLocationsPropertiesEXT* from,
- VkPhysicalDeviceSampleLocationsPropertiesEXT* to)
-{
+ VkPhysicalDeviceSampleLocationsPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(alloc, rootType, &from->maxSampleLocationGridSize, (VkExtent2D*)(&to->maxSampleLocationGridSize));
- memcpy(to->sampleLocationCoordinateRange, from->sampleLocationCoordinateRange, 2 * sizeof(float));
+ deepcopy_VkExtent2D(alloc, rootType, &from->maxSampleLocationGridSize,
+ (VkExtent2D*)(&to->maxSampleLocationGridSize));
+ memcpy(to->sampleLocationCoordinateRange, from->sampleLocationCoordinateRange,
+ 2 * sizeof(float));
}
-void deepcopy_VkMultisamplePropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMultisamplePropertiesEXT* from,
- VkMultisamplePropertiesEXT* to)
-{
+void deepcopy_VkMultisamplePropertiesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkMultisamplePropertiesEXT* from,
+ VkMultisamplePropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(alloc, rootType, &from->maxSampleLocationGridSize, (VkExtent2D*)(&to->maxSampleLocationGridSize));
+ deepcopy_VkExtent2D(alloc, rootType, &from->maxSampleLocationGridSize,
+ (VkExtent2D*)(&to->maxSampleLocationGridSize));
}
#endif
#ifdef VK_EXT_blend_operation_advanced
void deepcopy_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* from,
- VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* to)
-{
+ VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* from,
- VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* to)
-{
+ VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineColorBlendAdvancedStateCreateInfoEXT* from,
- VkPipelineColorBlendAdvancedStateCreateInfoEXT* to)
-{
+ VkPipelineColorBlendAdvancedStateCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -14465,28 +11873,23 @@
#endif
#ifdef VK_NV_fragment_coverage_to_color
void deepcopy_VkPipelineCoverageToColorStateCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineCoverageToColorStateCreateInfoNV* from,
- VkPipelineCoverageToColorStateCreateInfoNV* to)
-{
+ VkPipelineCoverageToColorStateCreateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -14495,35 +11898,31 @@
#endif
#ifdef VK_NV_framebuffer_mixed_samples
void deepcopy_VkPipelineCoverageModulationStateCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineCoverageModulationStateCreateInfoNV* from,
- VkPipelineCoverageModulationStateCreateInfoNV* to)
-{
+ VkPipelineCoverageModulationStateCreateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pCoverageModulationTable = nullptr;
- if (from->pCoverageModulationTable)
- {
- to->pCoverageModulationTable = (float*)alloc->dupArray(from->pCoverageModulationTable, from->coverageModulationTableCount * sizeof(const float));
+ if (from->pCoverageModulationTable) {
+ to->pCoverageModulationTable =
+ (float*)alloc->dupArray(from->pCoverageModulationTable,
+ from->coverageModulationTableCount * sizeof(const float));
}
}
@@ -14532,56 +11931,46 @@
#endif
#ifdef VK_NV_shader_sm_builtins
void deepcopy_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* from,
- VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* to)
-{
+ VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* from,
- VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* to)
-{
+ VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -14591,240 +11980,200 @@
#ifdef VK_EXT_post_depth_coverage
#endif
#ifdef VK_EXT_image_drm_format_modifier
-void deepcopy_VkDrmFormatModifierPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesEXT* from,
- VkDrmFormatModifierPropertiesEXT* to)
-{
+void deepcopy_VkDrmFormatModifierPropertiesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDrmFormatModifierPropertiesEXT* from,
+ VkDrmFormatModifierPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkDrmFormatModifierPropertiesListEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesListEXT* from,
- VkDrmFormatModifierPropertiesListEXT* to)
-{
+void deepcopy_VkDrmFormatModifierPropertiesListEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDrmFormatModifierPropertiesListEXT* from,
+ VkDrmFormatModifierPropertiesListEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pDrmFormatModifierProperties = nullptr;
- if (from->pDrmFormatModifierProperties)
- {
- to->pDrmFormatModifierProperties = (VkDrmFormatModifierPropertiesEXT*)alloc->alloc(from->drmFormatModifierCount * sizeof(VkDrmFormatModifierPropertiesEXT));
+ if (from->pDrmFormatModifierProperties) {
+ to->pDrmFormatModifierProperties = (VkDrmFormatModifierPropertiesEXT*)alloc->alloc(
+ from->drmFormatModifierCount * sizeof(VkDrmFormatModifierPropertiesEXT));
to->drmFormatModifierCount = from->drmFormatModifierCount;
- for (uint32_t i = 0; i < (uint32_t)from->drmFormatModifierCount; ++i)
- {
- deepcopy_VkDrmFormatModifierPropertiesEXT(alloc, rootType, from->pDrmFormatModifierProperties + i, (VkDrmFormatModifierPropertiesEXT*)(to->pDrmFormatModifierProperties + i));
+ for (uint32_t i = 0; i < (uint32_t)from->drmFormatModifierCount; ++i) {
+ deepcopy_VkDrmFormatModifierPropertiesEXT(
+ alloc, rootType, from->pDrmFormatModifierProperties + i,
+ (VkDrmFormatModifierPropertiesEXT*)(to->pDrmFormatModifierProperties + i));
}
}
}
}
void deepcopy_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* from,
- VkPhysicalDeviceImageDrmFormatModifierInfoEXT* to)
-{
+ VkPhysicalDeviceImageDrmFormatModifierInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pQueueFamilyIndices = nullptr;
- if (from->pQueueFamilyIndices)
- {
- to->pQueueFamilyIndices = (uint32_t*)alloc->dupArray(from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
+ if (from->pQueueFamilyIndices) {
+ to->pQueueFamilyIndices = (uint32_t*)alloc->dupArray(
+ from->pQueueFamilyIndices, from->queueFamilyIndexCount * sizeof(const uint32_t));
}
}
void deepcopy_VkImageDrmFormatModifierListCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkImageDrmFormatModifierListCreateInfoEXT* from,
- VkImageDrmFormatModifierListCreateInfoEXT* to)
-{
+ VkImageDrmFormatModifierListCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pDrmFormatModifiers = nullptr;
- if (from->pDrmFormatModifiers)
- {
- to->pDrmFormatModifiers = (uint64_t*)alloc->dupArray(from->pDrmFormatModifiers, from->drmFormatModifierCount * sizeof(const uint64_t));
+ if (from->pDrmFormatModifiers) {
+ to->pDrmFormatModifiers = (uint64_t*)alloc->dupArray(
+ from->pDrmFormatModifiers, from->drmFormatModifierCount * sizeof(const uint64_t));
}
}
void deepcopy_VkImageDrmFormatModifierExplicitCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkImageDrmFormatModifierExplicitCreateInfoEXT* from,
- VkImageDrmFormatModifierExplicitCreateInfoEXT* to)
-{
+ VkImageDrmFormatModifierExplicitCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pPlaneLayouts = nullptr;
- if (from->pPlaneLayouts)
- {
- to->pPlaneLayouts = (VkSubresourceLayout*)alloc->alloc(from->drmFormatModifierPlaneCount * sizeof(const VkSubresourceLayout));
+ if (from->pPlaneLayouts) {
+ to->pPlaneLayouts = (VkSubresourceLayout*)alloc->alloc(
+ from->drmFormatModifierPlaneCount * sizeof(const VkSubresourceLayout));
to->drmFormatModifierPlaneCount = from->drmFormatModifierPlaneCount;
- for (uint32_t i = 0; i < (uint32_t)from->drmFormatModifierPlaneCount; ++i)
- {
- deepcopy_VkSubresourceLayout(alloc, rootType, from->pPlaneLayouts + i, (VkSubresourceLayout*)(to->pPlaneLayouts + i));
+ for (uint32_t i = 0; i < (uint32_t)from->drmFormatModifierPlaneCount; ++i) {
+ deepcopy_VkSubresourceLayout(alloc, rootType, from->pPlaneLayouts + i,
+ (VkSubresourceLayout*)(to->pPlaneLayouts + i));
}
}
}
}
void deepcopy_VkImageDrmFormatModifierPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageDrmFormatModifierPropertiesEXT* from,
- VkImageDrmFormatModifierPropertiesEXT* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkImageDrmFormatModifierPropertiesEXT* from,
+ VkImageDrmFormatModifierPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkDrmFormatModifierProperties2EXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDrmFormatModifierProperties2EXT* from,
- VkDrmFormatModifierProperties2EXT* to)
-{
+void deepcopy_VkDrmFormatModifierProperties2EXT(Allocator* alloc, VkStructureType rootType,
+ const VkDrmFormatModifierProperties2EXT* from,
+ VkDrmFormatModifierProperties2EXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
void deepcopy_VkDrmFormatModifierPropertiesList2EXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesList2EXT* from,
- VkDrmFormatModifierPropertiesList2EXT* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkDrmFormatModifierPropertiesList2EXT* from,
+ VkDrmFormatModifierPropertiesList2EXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pDrmFormatModifierProperties = nullptr;
- if (from->pDrmFormatModifierProperties)
- {
- to->pDrmFormatModifierProperties = (VkDrmFormatModifierProperties2EXT*)alloc->alloc(from->drmFormatModifierCount * sizeof(VkDrmFormatModifierProperties2EXT));
+ if (from->pDrmFormatModifierProperties) {
+ to->pDrmFormatModifierProperties = (VkDrmFormatModifierProperties2EXT*)alloc->alloc(
+ from->drmFormatModifierCount * sizeof(VkDrmFormatModifierProperties2EXT));
to->drmFormatModifierCount = from->drmFormatModifierCount;
- for (uint32_t i = 0; i < (uint32_t)from->drmFormatModifierCount; ++i)
- {
- deepcopy_VkDrmFormatModifierProperties2EXT(alloc, rootType, from->pDrmFormatModifierProperties + i, (VkDrmFormatModifierProperties2EXT*)(to->pDrmFormatModifierProperties + i));
+ for (uint32_t i = 0; i < (uint32_t)from->drmFormatModifierCount; ++i) {
+ deepcopy_VkDrmFormatModifierProperties2EXT(
+ alloc, rootType, from->pDrmFormatModifierProperties + i,
+ (VkDrmFormatModifierProperties2EXT*)(to->pDrmFormatModifierProperties + i));
}
}
}
@@ -14832,62 +12181,51 @@
#endif
#ifdef VK_EXT_validation_cache
-void deepcopy_VkValidationCacheCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkValidationCacheCreateInfoEXT* from,
- VkValidationCacheCreateInfoEXT* to)
-{
+void deepcopy_VkValidationCacheCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkValidationCacheCreateInfoEXT* from,
+ VkValidationCacheCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pInitialData = nullptr;
- if (from->pInitialData)
- {
- to->pInitialData = (void*)alloc->dupArray(from->pInitialData, from->initialDataSize * sizeof(const uint8_t));
+ if (from->pInitialData) {
+ to->pInitialData = (void*)alloc->dupArray(from->pInitialData,
+ from->initialDataSize * sizeof(const uint8_t));
}
}
void deepcopy_VkShaderModuleValidationCacheCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkShaderModuleValidationCacheCreateInfoEXT* from,
- VkShaderModuleValidationCacheCreateInfoEXT* to)
-{
+ VkShaderModuleValidationCacheCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -14899,191 +12237,164 @@
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_NV_shading_rate_image
-void deepcopy_VkShadingRatePaletteNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkShadingRatePaletteNV* from,
- VkShadingRatePaletteNV* to)
-{
+void deepcopy_VkShadingRatePaletteNV(Allocator* alloc, VkStructureType rootType,
+ const VkShadingRatePaletteNV* from,
+ VkShadingRatePaletteNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
to->pShadingRatePaletteEntries = nullptr;
- if (from->pShadingRatePaletteEntries)
- {
- to->pShadingRatePaletteEntries = (VkShadingRatePaletteEntryNV*)alloc->dupArray(from->pShadingRatePaletteEntries, from->shadingRatePaletteEntryCount * sizeof(const VkShadingRatePaletteEntryNV));
+ if (from->pShadingRatePaletteEntries) {
+ to->pShadingRatePaletteEntries = (VkShadingRatePaletteEntryNV*)alloc->dupArray(
+ from->pShadingRatePaletteEntries,
+ from->shadingRatePaletteEntryCount * sizeof(const VkShadingRatePaletteEntryNV));
}
}
void deepcopy_VkPipelineViewportShadingRateImageStateCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineViewportShadingRateImageStateCreateInfoNV* from,
- VkPipelineViewportShadingRateImageStateCreateInfoNV* to)
-{
+ VkPipelineViewportShadingRateImageStateCreateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pShadingRatePalettes = nullptr;
- if (from->pShadingRatePalettes)
- {
- to->pShadingRatePalettes = (VkShadingRatePaletteNV*)alloc->alloc(from->viewportCount * sizeof(const VkShadingRatePaletteNV));
+ if (from->pShadingRatePalettes) {
+ to->pShadingRatePalettes = (VkShadingRatePaletteNV*)alloc->alloc(
+ from->viewportCount * sizeof(const VkShadingRatePaletteNV));
to->viewportCount = from->viewportCount;
- for (uint32_t i = 0; i < (uint32_t)from->viewportCount; ++i)
- {
- deepcopy_VkShadingRatePaletteNV(alloc, rootType, from->pShadingRatePalettes + i, (VkShadingRatePaletteNV*)(to->pShadingRatePalettes + i));
+ for (uint32_t i = 0; i < (uint32_t)from->viewportCount; ++i) {
+ deepcopy_VkShadingRatePaletteNV(
+ alloc, rootType, from->pShadingRatePalettes + i,
+ (VkShadingRatePaletteNV*)(to->pShadingRatePalettes + i));
}
}
}
}
void deepcopy_VkPhysicalDeviceShadingRateImageFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShadingRateImageFeaturesNV* from,
- VkPhysicalDeviceShadingRateImageFeaturesNV* to)
-{
+ VkPhysicalDeviceShadingRateImageFeaturesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceShadingRateImagePropertiesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShadingRateImagePropertiesNV* from,
- VkPhysicalDeviceShadingRateImagePropertiesNV* to)
-{
+ VkPhysicalDeviceShadingRateImagePropertiesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(alloc, rootType, &from->shadingRateTexelSize, (VkExtent2D*)(&to->shadingRateTexelSize));
+ deepcopy_VkExtent2D(alloc, rootType, &from->shadingRateTexelSize,
+ (VkExtent2D*)(&to->shadingRateTexelSize));
}
-void deepcopy_VkCoarseSampleLocationNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCoarseSampleLocationNV* from,
- VkCoarseSampleLocationNV* to)
-{
+void deepcopy_VkCoarseSampleLocationNV(Allocator* alloc, VkStructureType rootType,
+ const VkCoarseSampleLocationNV* from,
+ VkCoarseSampleLocationNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkCoarseSampleOrderCustomNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCoarseSampleOrderCustomNV* from,
- VkCoarseSampleOrderCustomNV* to)
-{
+void deepcopy_VkCoarseSampleOrderCustomNV(Allocator* alloc, VkStructureType rootType,
+ const VkCoarseSampleOrderCustomNV* from,
+ VkCoarseSampleOrderCustomNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (from)
- {
+ if (from) {
to->pSampleLocations = nullptr;
- if (from->pSampleLocations)
- {
- to->pSampleLocations = (VkCoarseSampleLocationNV*)alloc->alloc(from->sampleLocationCount * sizeof(const VkCoarseSampleLocationNV));
+ if (from->pSampleLocations) {
+ to->pSampleLocations = (VkCoarseSampleLocationNV*)alloc->alloc(
+ from->sampleLocationCount * sizeof(const VkCoarseSampleLocationNV));
to->sampleLocationCount = from->sampleLocationCount;
- for (uint32_t i = 0; i < (uint32_t)from->sampleLocationCount; ++i)
- {
- deepcopy_VkCoarseSampleLocationNV(alloc, rootType, from->pSampleLocations + i, (VkCoarseSampleLocationNV*)(to->pSampleLocations + i));
+ for (uint32_t i = 0; i < (uint32_t)from->sampleLocationCount; ++i) {
+ deepcopy_VkCoarseSampleLocationNV(
+ alloc, rootType, from->pSampleLocations + i,
+ (VkCoarseSampleLocationNV*)(to->pSampleLocations + i));
}
}
}
}
void deepcopy_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* from,
- VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* to)
-{
+ VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pCustomSampleOrders = nullptr;
- if (from->pCustomSampleOrders)
- {
- to->pCustomSampleOrders = (VkCoarseSampleOrderCustomNV*)alloc->alloc(from->customSampleOrderCount * sizeof(const VkCoarseSampleOrderCustomNV));
+ if (from->pCustomSampleOrders) {
+ to->pCustomSampleOrders = (VkCoarseSampleOrderCustomNV*)alloc->alloc(
+ from->customSampleOrderCount * sizeof(const VkCoarseSampleOrderCustomNV));
to->customSampleOrderCount = from->customSampleOrderCount;
- for (uint32_t i = 0; i < (uint32_t)from->customSampleOrderCount; ++i)
- {
- deepcopy_VkCoarseSampleOrderCustomNV(alloc, rootType, from->pCustomSampleOrders + i, (VkCoarseSampleOrderCustomNV*)(to->pCustomSampleOrders + i));
+ for (uint32_t i = 0; i < (uint32_t)from->customSampleOrderCount; ++i) {
+ deepcopy_VkCoarseSampleOrderCustomNV(
+ alloc, rootType, from->pCustomSampleOrders + i,
+ (VkCoarseSampleOrderCustomNV*)(to->pCustomSampleOrders + i));
}
}
}
@@ -15091,466 +12402,377 @@
#endif
#ifdef VK_NV_ray_tracing
-void deepcopy_VkRayTracingShaderGroupCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRayTracingShaderGroupCreateInfoNV* from,
- VkRayTracingShaderGroupCreateInfoNV* to)
-{
+void deepcopy_VkRayTracingShaderGroupCreateInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkRayTracingShaderGroupCreateInfoNV* from,
+ VkRayTracingShaderGroupCreateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkRayTracingPipelineCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRayTracingPipelineCreateInfoNV* from,
- VkRayTracingPipelineCreateInfoNV* to)
-{
+void deepcopy_VkRayTracingPipelineCreateInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkRayTracingPipelineCreateInfoNV* from,
+ VkRayTracingPipelineCreateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pStages = nullptr;
- if (from->pStages)
- {
- to->pStages = (VkPipelineShaderStageCreateInfo*)alloc->alloc(from->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
+ if (from->pStages) {
+ to->pStages = (VkPipelineShaderStageCreateInfo*)alloc->alloc(
+ from->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
to->stageCount = from->stageCount;
- for (uint32_t i = 0; i < (uint32_t)from->stageCount; ++i)
- {
- deepcopy_VkPipelineShaderStageCreateInfo(alloc, rootType, from->pStages + i, (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
+ for (uint32_t i = 0; i < (uint32_t)from->stageCount; ++i) {
+ deepcopy_VkPipelineShaderStageCreateInfo(
+ alloc, rootType, from->pStages + i,
+ (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pGroups = nullptr;
- if (from->pGroups)
- {
- to->pGroups = (VkRayTracingShaderGroupCreateInfoNV*)alloc->alloc(from->groupCount * sizeof(const VkRayTracingShaderGroupCreateInfoNV));
+ if (from->pGroups) {
+ to->pGroups = (VkRayTracingShaderGroupCreateInfoNV*)alloc->alloc(
+ from->groupCount * sizeof(const VkRayTracingShaderGroupCreateInfoNV));
to->groupCount = from->groupCount;
- for (uint32_t i = 0; i < (uint32_t)from->groupCount; ++i)
- {
- deepcopy_VkRayTracingShaderGroupCreateInfoNV(alloc, rootType, from->pGroups + i, (VkRayTracingShaderGroupCreateInfoNV*)(to->pGroups + i));
+ for (uint32_t i = 0; i < (uint32_t)from->groupCount; ++i) {
+ deepcopy_VkRayTracingShaderGroupCreateInfoNV(
+ alloc, rootType, from->pGroups + i,
+ (VkRayTracingShaderGroupCreateInfoNV*)(to->pGroups + i));
}
}
}
}
-void deepcopy_VkGeometryTrianglesNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkGeometryTrianglesNV* from,
- VkGeometryTrianglesNV* to)
-{
+void deepcopy_VkGeometryTrianglesNV(Allocator* alloc, VkStructureType rootType,
+ const VkGeometryTrianglesNV* from, VkGeometryTrianglesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkGeometryAABBNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkGeometryAABBNV* from,
- VkGeometryAABBNV* to)
-{
+void deepcopy_VkGeometryAABBNV(Allocator* alloc, VkStructureType rootType,
+ const VkGeometryAABBNV* from, VkGeometryAABBNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkGeometryDataNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkGeometryDataNV* from,
- VkGeometryDataNV* to)
-{
+void deepcopy_VkGeometryDataNV(Allocator* alloc, VkStructureType rootType,
+ const VkGeometryDataNV* from, VkGeometryDataNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- deepcopy_VkGeometryTrianglesNV(alloc, rootType, &from->triangles, (VkGeometryTrianglesNV*)(&to->triangles));
+ deepcopy_VkGeometryTrianglesNV(alloc, rootType, &from->triangles,
+ (VkGeometryTrianglesNV*)(&to->triangles));
deepcopy_VkGeometryAABBNV(alloc, rootType, &from->aabbs, (VkGeometryAABBNV*)(&to->aabbs));
}
-void deepcopy_VkGeometryNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkGeometryNV* from,
- VkGeometryNV* to)
-{
+void deepcopy_VkGeometryNV(Allocator* alloc, VkStructureType rootType, const VkGeometryNV* from,
+ VkGeometryNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
deepcopy_VkGeometryDataNV(alloc, rootType, &from->geometry, (VkGeometryDataNV*)(&to->geometry));
}
-void deepcopy_VkAccelerationStructureInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAccelerationStructureInfoNV* from,
- VkAccelerationStructureInfoNV* to)
-{
+void deepcopy_VkAccelerationStructureInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkAccelerationStructureInfoNV* from,
+ VkAccelerationStructureInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pGeometries = nullptr;
- if (from->pGeometries)
- {
- to->pGeometries = (VkGeometryNV*)alloc->alloc(from->geometryCount * sizeof(const VkGeometryNV));
+ if (from->pGeometries) {
+ to->pGeometries =
+ (VkGeometryNV*)alloc->alloc(from->geometryCount * sizeof(const VkGeometryNV));
to->geometryCount = from->geometryCount;
- for (uint32_t i = 0; i < (uint32_t)from->geometryCount; ++i)
- {
- deepcopy_VkGeometryNV(alloc, rootType, from->pGeometries + i, (VkGeometryNV*)(to->pGeometries + i));
+ for (uint32_t i = 0; i < (uint32_t)from->geometryCount; ++i) {
+ deepcopy_VkGeometryNV(alloc, rootType, from->pGeometries + i,
+ (VkGeometryNV*)(to->pGeometries + i));
}
}
}
}
-void deepcopy_VkAccelerationStructureCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAccelerationStructureCreateInfoNV* from,
- VkAccelerationStructureCreateInfoNV* to)
-{
+void deepcopy_VkAccelerationStructureCreateInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkAccelerationStructureCreateInfoNV* from,
+ VkAccelerationStructureCreateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkAccelerationStructureInfoNV(alloc, rootType, &from->info, (VkAccelerationStructureInfoNV*)(&to->info));
+ deepcopy_VkAccelerationStructureInfoNV(alloc, rootType, &from->info,
+ (VkAccelerationStructureInfoNV*)(&to->info));
}
void deepcopy_VkBindAccelerationStructureMemoryInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindAccelerationStructureMemoryInfoNV* from,
- VkBindAccelerationStructureMemoryInfoNV* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkBindAccelerationStructureMemoryInfoNV* from,
+ VkBindAccelerationStructureMemoryInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pDeviceIndices = nullptr;
- if (from->pDeviceIndices)
- {
- to->pDeviceIndices = (uint32_t*)alloc->dupArray(from->pDeviceIndices, from->deviceIndexCount * sizeof(const uint32_t));
+ if (from->pDeviceIndices) {
+ to->pDeviceIndices = (uint32_t*)alloc->dupArray(
+ from->pDeviceIndices, from->deviceIndexCount * sizeof(const uint32_t));
}
}
void deepcopy_VkWriteDescriptorSetAccelerationStructureNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkWriteDescriptorSetAccelerationStructureNV* from,
- VkWriteDescriptorSetAccelerationStructureNV* to)
-{
+ VkWriteDescriptorSetAccelerationStructureNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pAccelerationStructures = nullptr;
- if (from->pAccelerationStructures)
- {
- to->pAccelerationStructures = (VkAccelerationStructureNV*)alloc->dupArray(from->pAccelerationStructures, from->accelerationStructureCount * sizeof(const VkAccelerationStructureNV));
+ if (from->pAccelerationStructures) {
+ to->pAccelerationStructures = (VkAccelerationStructureNV*)alloc->dupArray(
+ from->pAccelerationStructures,
+ from->accelerationStructureCount * sizeof(const VkAccelerationStructureNV));
}
}
void deepcopy_VkAccelerationStructureMemoryRequirementsInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureMemoryRequirementsInfoNV* from,
- VkAccelerationStructureMemoryRequirementsInfoNV* to)
-{
+ VkAccelerationStructureMemoryRequirementsInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceRayTracingPropertiesNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingPropertiesNV* from,
- VkPhysicalDeviceRayTracingPropertiesNV* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceRayTracingPropertiesNV* from,
+ VkPhysicalDeviceRayTracingPropertiesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkTransformMatrixKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkTransformMatrixKHR* from,
- VkTransformMatrixKHR* to)
-{
+void deepcopy_VkTransformMatrixKHR(Allocator* alloc, VkStructureType rootType,
+ const VkTransformMatrixKHR* from, VkTransformMatrixKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- memcpy(to->matrix, from->matrix, ((3)*(4)) * sizeof(float));
+ memcpy(to->matrix, from->matrix, ((3) * (4)) * sizeof(float));
}
-void deepcopy_VkAabbPositionsKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAabbPositionsKHR* from,
- VkAabbPositionsKHR* to)
-{
+void deepcopy_VkAabbPositionsKHR(Allocator* alloc, VkStructureType rootType,
+ const VkAabbPositionsKHR* from, VkAabbPositionsKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkAccelerationStructureInstanceKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAccelerationStructureInstanceKHR* from,
- VkAccelerationStructureInstanceKHR* to)
-{
+void deepcopy_VkAccelerationStructureInstanceKHR(Allocator* alloc, VkStructureType rootType,
+ const VkAccelerationStructureInstanceKHR* from,
+ VkAccelerationStructureInstanceKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- deepcopy_VkTransformMatrixKHR(alloc, rootType, &from->transform, (VkTransformMatrixKHR*)(&to->transform));
+ deepcopy_VkTransformMatrixKHR(alloc, rootType, &from->transform,
+ (VkTransformMatrixKHR*)(&to->transform));
}
#endif
#ifdef VK_NV_representative_fragment_test
void deepcopy_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* from,
- VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* to)
-{
+ VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* from,
- VkPipelineRepresentativeFragmentTestStateCreateInfoNV* to)
-{
+ VkPipelineRepresentativeFragmentTestStateCreateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -15559,56 +12781,46 @@
#endif
#ifdef VK_EXT_filter_cubic
void deepcopy_VkPhysicalDeviceImageViewImageFormatInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceImageViewImageFormatInfoEXT* from,
- VkPhysicalDeviceImageViewImageFormatInfoEXT* to)
-{
+ VkPhysicalDeviceImageViewImageFormatInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkFilterCubicImageViewImageFormatPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkFilterCubicImageViewImageFormatPropertiesEXT* from,
- VkFilterCubicImageViewImageFormatPropertiesEXT* to)
-{
+ VkFilterCubicImageViewImageFormatPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -15619,28 +12831,23 @@
#endif
#ifdef VK_EXT_global_priority
void deepcopy_VkDeviceQueueGlobalPriorityCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkDeviceQueueGlobalPriorityCreateInfoEXT* from,
- VkDeviceQueueGlobalPriorityCreateInfoEXT* to)
-{
+ VkDeviceQueueGlobalPriorityCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -15648,90 +12855,72 @@
#endif
#ifdef VK_EXT_external_memory_host
-void deepcopy_VkImportMemoryHostPointerInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportMemoryHostPointerInfoEXT* from,
- VkImportMemoryHostPointerInfoEXT* to)
-{
+void deepcopy_VkImportMemoryHostPointerInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkImportMemoryHostPointerInfoEXT* from,
+ VkImportMemoryHostPointerInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pHostPointer = nullptr;
- if (from->pHostPointer)
- {
+ if (from->pHostPointer) {
to->pHostPointer = (void*)alloc->dupArray(from->pHostPointer, sizeof(uint8_t));
}
}
-void deepcopy_VkMemoryHostPointerPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryHostPointerPropertiesEXT* from,
- VkMemoryHostPointerPropertiesEXT* to)
-{
+void deepcopy_VkMemoryHostPointerPropertiesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryHostPointerPropertiesEXT* from,
+ VkMemoryHostPointerPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* from,
- VkPhysicalDeviceExternalMemoryHostPropertiesEXT* to)
-{
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -15742,28 +12931,22 @@
#endif
#ifdef VK_AMD_pipeline_compiler_control
void deepcopy_VkPipelineCompilerControlCreateInfoAMD(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineCompilerControlCreateInfoAMD* from,
- VkPipelineCompilerControlCreateInfoAMD* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPipelineCompilerControlCreateInfoAMD* from,
+ VkPipelineCompilerControlCreateInfoAMD* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -15771,29 +12954,23 @@
#endif
#ifdef VK_EXT_calibrated_timestamps
-void deepcopy_VkCalibratedTimestampInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCalibratedTimestampInfoEXT* from,
- VkCalibratedTimestampInfoEXT* to)
-{
+void deepcopy_VkCalibratedTimestampInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkCalibratedTimestampInfoEXT* from,
+ VkCalibratedTimestampInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -15802,28 +12979,22 @@
#endif
#ifdef VK_AMD_shader_core_properties
void deepcopy_VkPhysicalDeviceShaderCorePropertiesAMD(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderCorePropertiesAMD* from,
- VkPhysicalDeviceShaderCorePropertiesAMD* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceShaderCorePropertiesAMD* from,
+ VkPhysicalDeviceShaderCorePropertiesAMD* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -15831,265 +13002,224 @@
#endif
#ifdef VK_EXT_video_decode_h265
-void deepcopy_VkVideoDecodeH265ProfileEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH265ProfileEXT* from,
- VkVideoDecodeH265ProfileEXT* to)
-{
+void deepcopy_VkVideoDecodeH265ProfileEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoDecodeH265ProfileEXT* from,
+ VkVideoDecodeH265ProfileEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkVideoDecodeH265CapabilitiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH265CapabilitiesEXT* from,
- VkVideoDecodeH265CapabilitiesEXT* to)
-{
+void deepcopy_VkVideoDecodeH265CapabilitiesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoDecodeH265CapabilitiesEXT* from,
+ VkVideoDecodeH265CapabilitiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtensionProperties(alloc, rootType, &from->stdExtensionVersion, (VkExtensionProperties*)(&to->stdExtensionVersion));
+ deepcopy_VkExtensionProperties(alloc, rootType, &from->stdExtensionVersion,
+ (VkExtensionProperties*)(&to->stdExtensionVersion));
}
void deepcopy_VkVideoDecodeH265SessionCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH265SessionCreateInfoEXT* from,
- VkVideoDecodeH265SessionCreateInfoEXT* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkVideoDecodeH265SessionCreateInfoEXT* from,
+ VkVideoDecodeH265SessionCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pStdExtensionVersion = nullptr;
- if (from->pStdExtensionVersion)
- {
- to->pStdExtensionVersion = (VkExtensionProperties*)alloc->alloc(sizeof(const VkExtensionProperties));
- deepcopy_VkExtensionProperties(alloc, rootType, from->pStdExtensionVersion, (VkExtensionProperties*)(to->pStdExtensionVersion));
+ if (from->pStdExtensionVersion) {
+ to->pStdExtensionVersion =
+ (VkExtensionProperties*)alloc->alloc(sizeof(const VkExtensionProperties));
+ deepcopy_VkExtensionProperties(alloc, rootType, from->pStdExtensionVersion,
+ (VkExtensionProperties*)(to->pStdExtensionVersion));
}
}
void deepcopy_VkVideoDecodeH265SessionParametersAddInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVideoDecodeH265SessionParametersAddInfoEXT* from,
- VkVideoDecodeH265SessionParametersAddInfoEXT* to)
-{
+ VkVideoDecodeH265SessionParametersAddInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pSpsStd = nullptr;
- if (from->pSpsStd)
- {
- to->pSpsStd = (StdVideoH265SequenceParameterSet*)alloc->dupArray(from->pSpsStd, from->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
+ if (from->pSpsStd) {
+ to->pSpsStd = (StdVideoH265SequenceParameterSet*)alloc->dupArray(
+ from->pSpsStd, from->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
}
to->pPpsStd = nullptr;
- if (from->pPpsStd)
- {
- to->pPpsStd = (StdVideoH265PictureParameterSet*)alloc->dupArray(from->pPpsStd, from->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
+ if (from->pPpsStd) {
+ to->pPpsStd = (StdVideoH265PictureParameterSet*)alloc->dupArray(
+ from->pPpsStd, from->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
}
}
void deepcopy_VkVideoDecodeH265SessionParametersCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVideoDecodeH265SessionParametersCreateInfoEXT* from,
- VkVideoDecodeH265SessionParametersCreateInfoEXT* to)
-{
+ VkVideoDecodeH265SessionParametersCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pParametersAddInfo = nullptr;
- if (from->pParametersAddInfo)
- {
- to->pParametersAddInfo = (VkVideoDecodeH265SessionParametersAddInfoEXT*)alloc->alloc(sizeof(const VkVideoDecodeH265SessionParametersAddInfoEXT));
- deepcopy_VkVideoDecodeH265SessionParametersAddInfoEXT(alloc, rootType, from->pParametersAddInfo, (VkVideoDecodeH265SessionParametersAddInfoEXT*)(to->pParametersAddInfo));
+ if (from->pParametersAddInfo) {
+ to->pParametersAddInfo = (VkVideoDecodeH265SessionParametersAddInfoEXT*)alloc->alloc(
+ sizeof(const VkVideoDecodeH265SessionParametersAddInfoEXT));
+ deepcopy_VkVideoDecodeH265SessionParametersAddInfoEXT(
+ alloc, rootType, from->pParametersAddInfo,
+ (VkVideoDecodeH265SessionParametersAddInfoEXT*)(to->pParametersAddInfo));
}
}
-void deepcopy_VkVideoDecodeH265PictureInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH265PictureInfoEXT* from,
- VkVideoDecodeH265PictureInfoEXT* to)
-{
+void deepcopy_VkVideoDecodeH265PictureInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoDecodeH265PictureInfoEXT* from,
+ VkVideoDecodeH265PictureInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pStdPictureInfo = nullptr;
- if (from->pStdPictureInfo)
- {
- to->pStdPictureInfo = (StdVideoDecodeH265PictureInfo*)alloc->dupArray(from->pStdPictureInfo, sizeof(StdVideoDecodeH265PictureInfo));
+ if (from->pStdPictureInfo) {
+ to->pStdPictureInfo = (StdVideoDecodeH265PictureInfo*)alloc->dupArray(
+ from->pStdPictureInfo, sizeof(StdVideoDecodeH265PictureInfo));
}
to->pSlicesDataOffsets = nullptr;
- if (from->pSlicesDataOffsets)
- {
- to->pSlicesDataOffsets = (uint32_t*)alloc->dupArray(from->pSlicesDataOffsets, from->slicesCount * sizeof(const uint32_t));
+ if (from->pSlicesDataOffsets) {
+ to->pSlicesDataOffsets = (uint32_t*)alloc->dupArray(
+ from->pSlicesDataOffsets, from->slicesCount * sizeof(const uint32_t));
}
}
-void deepcopy_VkVideoDecodeH265DpbSlotInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH265DpbSlotInfoEXT* from,
- VkVideoDecodeH265DpbSlotInfoEXT* to)
-{
+void deepcopy_VkVideoDecodeH265DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoDecodeH265DpbSlotInfoEXT* from,
+ VkVideoDecodeH265DpbSlotInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pStdReferenceInfo = nullptr;
- if (from->pStdReferenceInfo)
- {
- to->pStdReferenceInfo = (StdVideoDecodeH265ReferenceInfo*)alloc->dupArray(from->pStdReferenceInfo, sizeof(const StdVideoDecodeH265ReferenceInfo));
+ if (from->pStdReferenceInfo) {
+ to->pStdReferenceInfo = (StdVideoDecodeH265ReferenceInfo*)alloc->dupArray(
+ from->pStdReferenceInfo, sizeof(const StdVideoDecodeH265ReferenceInfo));
}
}
#endif
#ifdef VK_AMD_memory_overallocation_behavior
void deepcopy_VkDeviceMemoryOverallocationCreateInfoAMD(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkDeviceMemoryOverallocationCreateInfoAMD* from,
- VkDeviceMemoryOverallocationCreateInfoAMD* to)
-{
+ VkDeviceMemoryOverallocationCreateInfoAMD* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -16098,108 +13228,92 @@
#endif
#ifdef VK_EXT_vertex_attribute_divisor
void deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* from,
- VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* to)
-{
+ VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkVertexInputBindingDivisorDescriptionEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVertexInputBindingDivisorDescriptionEXT* from,
- VkVertexInputBindingDivisorDescriptionEXT* to)
-{
+ VkVertexInputBindingDivisorDescriptionEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
void deepcopy_VkPipelineVertexInputDivisorStateCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineVertexInputDivisorStateCreateInfoEXT* from,
- VkPipelineVertexInputDivisorStateCreateInfoEXT* to)
-{
+ VkPipelineVertexInputDivisorStateCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pVertexBindingDivisors = nullptr;
- if (from->pVertexBindingDivisors)
- {
- to->pVertexBindingDivisors = (VkVertexInputBindingDivisorDescriptionEXT*)alloc->alloc(from->vertexBindingDivisorCount * sizeof(const VkVertexInputBindingDivisorDescriptionEXT));
+ if (from->pVertexBindingDivisors) {
+ to->pVertexBindingDivisors = (VkVertexInputBindingDivisorDescriptionEXT*)alloc->alloc(
+ from->vertexBindingDivisorCount *
+ sizeof(const VkVertexInputBindingDivisorDescriptionEXT));
to->vertexBindingDivisorCount = from->vertexBindingDivisorCount;
- for (uint32_t i = 0; i < (uint32_t)from->vertexBindingDivisorCount; ++i)
- {
- deepcopy_VkVertexInputBindingDivisorDescriptionEXT(alloc, rootType, from->pVertexBindingDivisors + i, (VkVertexInputBindingDivisorDescriptionEXT*)(to->pVertexBindingDivisors + i));
+ for (uint32_t i = 0; i < (uint32_t)from->vertexBindingDivisorCount; ++i) {
+ deepcopy_VkVertexInputBindingDivisorDescriptionEXT(
+ alloc, rootType, from->pVertexBindingDivisors + i,
+ (VkVertexInputBindingDivisorDescriptionEXT*)(to->pVertexBindingDivisors + i));
}
}
}
}
void deepcopy_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* from,
- VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* to)
-{
+ VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -16207,29 +13321,23 @@
#endif
#ifdef VK_GGP_frame_token
-void deepcopy_VkPresentFrameTokenGGP(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPresentFrameTokenGGP* from,
- VkPresentFrameTokenGGP* to)
-{
+void deepcopy_VkPresentFrameTokenGGP(Allocator* alloc, VkStructureType rootType,
+ const VkPresentFrameTokenGGP* from,
+ VkPresentFrameTokenGGP* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -16237,59 +13345,52 @@
#endif
#ifdef VK_EXT_pipeline_creation_feedback
-void deepcopy_VkPipelineCreationFeedbackEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineCreationFeedbackEXT* from,
- VkPipelineCreationFeedbackEXT* to)
-{
+void deepcopy_VkPipelineCreationFeedbackEXT(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineCreationFeedbackEXT* from,
+ VkPipelineCreationFeedbackEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
void deepcopy_VkPipelineCreationFeedbackCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineCreationFeedbackCreateInfoEXT* from,
- VkPipelineCreationFeedbackCreateInfoEXT* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPipelineCreationFeedbackCreateInfoEXT* from,
+ VkPipelineCreationFeedbackCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pPipelineCreationFeedback = nullptr;
- if (from->pPipelineCreationFeedback)
- {
- to->pPipelineCreationFeedback = (VkPipelineCreationFeedbackEXT*)alloc->alloc(sizeof(VkPipelineCreationFeedbackEXT));
- deepcopy_VkPipelineCreationFeedbackEXT(alloc, rootType, from->pPipelineCreationFeedback, (VkPipelineCreationFeedbackEXT*)(to->pPipelineCreationFeedback));
+ if (from->pPipelineCreationFeedback) {
+ to->pPipelineCreationFeedback =
+ (VkPipelineCreationFeedbackEXT*)alloc->alloc(sizeof(VkPipelineCreationFeedbackEXT));
+ deepcopy_VkPipelineCreationFeedbackEXT(
+ alloc, rootType, from->pPipelineCreationFeedback,
+ (VkPipelineCreationFeedbackEXT*)(to->pPipelineCreationFeedback));
}
- if (from)
- {
+ if (from) {
to->pPipelineStageCreationFeedbacks = nullptr;
- if (from->pPipelineStageCreationFeedbacks)
- {
- to->pPipelineStageCreationFeedbacks = (VkPipelineCreationFeedbackEXT*)alloc->alloc(from->pipelineStageCreationFeedbackCount * sizeof(VkPipelineCreationFeedbackEXT));
+ if (from->pPipelineStageCreationFeedbacks) {
+ to->pPipelineStageCreationFeedbacks = (VkPipelineCreationFeedbackEXT*)alloc->alloc(
+ from->pipelineStageCreationFeedbackCount * sizeof(VkPipelineCreationFeedbackEXT));
to->pipelineStageCreationFeedbackCount = from->pipelineStageCreationFeedbackCount;
- for (uint32_t i = 0; i < (uint32_t)from->pipelineStageCreationFeedbackCount; ++i)
- {
- deepcopy_VkPipelineCreationFeedbackEXT(alloc, rootType, from->pPipelineStageCreationFeedbacks + i, (VkPipelineCreationFeedbackEXT*)(to->pPipelineStageCreationFeedbacks + i));
+ for (uint32_t i = 0; i < (uint32_t)from->pipelineStageCreationFeedbackCount; ++i) {
+ deepcopy_VkPipelineCreationFeedbackEXT(
+ alloc, rootType, from->pPipelineStageCreationFeedbacks + i,
+ (VkPipelineCreationFeedbackEXT*)(to->pPipelineStageCreationFeedbacks + i));
}
}
}
@@ -16300,28 +13401,23 @@
#endif
#ifdef VK_NV_compute_shader_derivatives
void deepcopy_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* from,
- VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* to)
-{
+ VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -16329,57 +13425,45 @@
#endif
#ifdef VK_NV_mesh_shader
-void deepcopy_VkPhysicalDeviceMeshShaderFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceMeshShaderFeaturesNV* from,
- VkPhysicalDeviceMeshShaderFeaturesNV* to)
-{
+void deepcopy_VkPhysicalDeviceMeshShaderFeaturesNV(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceMeshShaderFeaturesNV* from,
+ VkPhysicalDeviceMeshShaderFeaturesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceMeshShaderPropertiesNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceMeshShaderPropertiesNV* from,
- VkPhysicalDeviceMeshShaderPropertiesNV* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMeshShaderPropertiesNV* from,
+ VkPhysicalDeviceMeshShaderPropertiesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -16387,12 +13471,9 @@
memcpy(to->maxMeshWorkGroupSize, from->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
}
-void deepcopy_VkDrawMeshTasksIndirectCommandNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDrawMeshTasksIndirectCommandNV* from,
- VkDrawMeshTasksIndirectCommandNV* to)
-{
+void deepcopy_VkDrawMeshTasksIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
+ const VkDrawMeshTasksIndirectCommandNV* from,
+ VkDrawMeshTasksIndirectCommandNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
@@ -16401,28 +13482,23 @@
#endif
#ifdef VK_NV_fragment_shader_barycentric
void deepcopy_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* from,
- VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* to)
-{
+ VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -16431,28 +13507,23 @@
#endif
#ifdef VK_NV_shader_image_footprint
void deepcopy_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderImageFootprintFeaturesNV* from,
- VkPhysicalDeviceShaderImageFootprintFeaturesNV* to)
-{
+ VkPhysicalDeviceShaderImageFootprintFeaturesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -16461,69 +13532,58 @@
#endif
#ifdef VK_NV_scissor_exclusive
void deepcopy_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineViewportExclusiveScissorStateCreateInfoNV* from,
- VkPipelineViewportExclusiveScissorStateCreateInfoNV* to)
-{
+ VkPipelineViewportExclusiveScissorStateCreateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pExclusiveScissors = nullptr;
- if (from->pExclusiveScissors)
- {
- to->pExclusiveScissors = (VkRect2D*)alloc->alloc(from->exclusiveScissorCount * sizeof(const VkRect2D));
+ if (from->pExclusiveScissors) {
+ to->pExclusiveScissors =
+ (VkRect2D*)alloc->alloc(from->exclusiveScissorCount * sizeof(const VkRect2D));
to->exclusiveScissorCount = from->exclusiveScissorCount;
- for (uint32_t i = 0; i < (uint32_t)from->exclusiveScissorCount; ++i)
- {
- deepcopy_VkRect2D(alloc, rootType, from->pExclusiveScissors + i, (VkRect2D*)(to->pExclusiveScissors + i));
+ for (uint32_t i = 0; i < (uint32_t)from->exclusiveScissorCount; ++i) {
+ deepcopy_VkRect2D(alloc, rootType, from->pExclusiveScissors + i,
+ (VkRect2D*)(to->pExclusiveScissors + i));
}
}
}
}
void deepcopy_VkPhysicalDeviceExclusiveScissorFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceExclusiveScissorFeaturesNV* from,
- VkPhysicalDeviceExclusiveScissorFeaturesNV* to)
-{
+ VkPhysicalDeviceExclusiveScissorFeaturesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -16531,63 +13591,49 @@
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
-void deepcopy_VkQueueFamilyCheckpointPropertiesNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkQueueFamilyCheckpointPropertiesNV* from,
- VkQueueFamilyCheckpointPropertiesNV* to)
-{
+void deepcopy_VkQueueFamilyCheckpointPropertiesNV(Allocator* alloc, VkStructureType rootType,
+ const VkQueueFamilyCheckpointPropertiesNV* from,
+ VkQueueFamilyCheckpointPropertiesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkCheckpointDataNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCheckpointDataNV* from,
- VkCheckpointDataNV* to)
-{
+void deepcopy_VkCheckpointDataNV(Allocator* alloc, VkStructureType rootType,
+ const VkCheckpointDataNV* from, VkCheckpointDataNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pCheckpointMarker = nullptr;
- if (from->pCheckpointMarker)
- {
+ if (from->pCheckpointMarker) {
to->pCheckpointMarker = (void*)alloc->dupArray(from->pCheckpointMarker, sizeof(uint8_t));
}
}
@@ -16595,28 +13641,23 @@
#endif
#ifdef VK_INTEL_shader_integer_functions2
void deepcopy_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* from,
- VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* to)
-{
+ VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -16624,202 +13665,161 @@
#endif
#ifdef VK_INTEL_performance_query
-void deepcopy_VkPerformanceValueDataINTEL(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPerformanceValueDataINTEL* from,
- VkPerformanceValueDataINTEL* to)
-{
+void deepcopy_VkPerformanceValueDataINTEL(Allocator* alloc, VkStructureType rootType,
+ const VkPerformanceValueDataINTEL* from,
+ VkPerformanceValueDataINTEL* to) {
(void)alloc;
(void)rootType;
*to = *from;
to->valueString = nullptr;
- if (from->valueString)
- {
+ if (from->valueString) {
to->valueString = alloc->strDup(from->valueString);
}
}
-void deepcopy_VkPerformanceValueINTEL(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPerformanceValueINTEL* from,
- VkPerformanceValueINTEL* to)
-{
+void deepcopy_VkPerformanceValueINTEL(Allocator* alloc, VkStructureType rootType,
+ const VkPerformanceValueINTEL* from,
+ VkPerformanceValueINTEL* to) {
(void)alloc;
(void)rootType;
*to = *from;
- deepcopy_VkPerformanceValueDataINTEL(alloc, rootType, &from->data, (VkPerformanceValueDataINTEL*)(&to->data));
+ deepcopy_VkPerformanceValueDataINTEL(alloc, rootType, &from->data,
+ (VkPerformanceValueDataINTEL*)(&to->data));
}
-void deepcopy_VkInitializePerformanceApiInfoINTEL(
- Allocator* alloc,
- VkStructureType rootType,
- const VkInitializePerformanceApiInfoINTEL* from,
- VkInitializePerformanceApiInfoINTEL* to)
-{
+void deepcopy_VkInitializePerformanceApiInfoINTEL(Allocator* alloc, VkStructureType rootType,
+ const VkInitializePerformanceApiInfoINTEL* from,
+ VkInitializePerformanceApiInfoINTEL* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pUserData = nullptr;
- if (from->pUserData)
- {
+ if (from->pUserData) {
to->pUserData = (void*)alloc->dupArray(from->pUserData, sizeof(uint8_t));
}
}
void deepcopy_VkQueryPoolPerformanceQueryCreateInfoINTEL(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkQueryPoolPerformanceQueryCreateInfoINTEL* from,
- VkQueryPoolPerformanceQueryCreateInfoINTEL* to)
-{
+ VkQueryPoolPerformanceQueryCreateInfoINTEL* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkPerformanceMarkerInfoINTEL(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPerformanceMarkerInfoINTEL* from,
- VkPerformanceMarkerInfoINTEL* to)
-{
+void deepcopy_VkPerformanceMarkerInfoINTEL(Allocator* alloc, VkStructureType rootType,
+ const VkPerformanceMarkerInfoINTEL* from,
+ VkPerformanceMarkerInfoINTEL* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkPerformanceStreamMarkerInfoINTEL(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPerformanceStreamMarkerInfoINTEL* from,
- VkPerformanceStreamMarkerInfoINTEL* to)
-{
+void deepcopy_VkPerformanceStreamMarkerInfoINTEL(Allocator* alloc, VkStructureType rootType,
+ const VkPerformanceStreamMarkerInfoINTEL* from,
+ VkPerformanceStreamMarkerInfoINTEL* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkPerformanceOverrideInfoINTEL(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPerformanceOverrideInfoINTEL* from,
- VkPerformanceOverrideInfoINTEL* to)
-{
+void deepcopy_VkPerformanceOverrideInfoINTEL(Allocator* alloc, VkStructureType rootType,
+ const VkPerformanceOverrideInfoINTEL* from,
+ VkPerformanceOverrideInfoINTEL* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPerformanceConfigurationAcquireInfoINTEL(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPerformanceConfigurationAcquireInfoINTEL* from,
- VkPerformanceConfigurationAcquireInfoINTEL* to)
-{
+ VkPerformanceConfigurationAcquireInfoINTEL* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -16828,28 +13828,22 @@
#endif
#ifdef VK_EXT_pci_bus_info
void deepcopy_VkPhysicalDevicePCIBusInfoPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDevicePCIBusInfoPropertiesEXT* from,
- VkPhysicalDevicePCIBusInfoPropertiesEXT* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDevicePCIBusInfoPropertiesEXT* from,
+ VkPhysicalDevicePCIBusInfoPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -16858,56 +13852,46 @@
#endif
#ifdef VK_AMD_display_native_hdr
void deepcopy_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkDisplayNativeHdrSurfaceCapabilitiesAMD* from,
- VkDisplayNativeHdrSurfaceCapabilitiesAMD* to)
-{
+ VkDisplayNativeHdrSurfaceCapabilitiesAMD* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSwapchainDisplayNativeHdrCreateInfoAMD(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkSwapchainDisplayNativeHdrCreateInfoAMD* from,
- VkSwapchainDisplayNativeHdrCreateInfoAMD* to)
-{
+ VkSwapchainDisplayNativeHdrCreateInfoAMD* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -16915,29 +13899,23 @@
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
-void deepcopy_VkImagePipeSurfaceCreateInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImagePipeSurfaceCreateInfoFUCHSIA* from,
- VkImagePipeSurfaceCreateInfoFUCHSIA* to)
-{
+void deepcopy_VkImagePipeSurfaceCreateInfoFUCHSIA(Allocator* alloc, VkStructureType rootType,
+ const VkImagePipeSurfaceCreateInfoFUCHSIA* from,
+ VkImagePipeSurfaceCreateInfoFUCHSIA* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -16945,35 +13923,28 @@
#endif
#ifdef VK_EXT_metal_surface
-void deepcopy_VkMetalSurfaceCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMetalSurfaceCreateInfoEXT* from,
- VkMetalSurfaceCreateInfoEXT* to)
-{
+void deepcopy_VkMetalSurfaceCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkMetalSurfaceCreateInfoEXT* from,
+ VkMetalSurfaceCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pLayer = nullptr;
- if (from->pLayer)
- {
+ if (from->pLayer) {
to->pLayer = (CAMetalLayer*)alloc->dupArray(from->pLayer, sizeof(const CAMetalLayer));
}
}
@@ -16981,90 +13952,78 @@
#endif
#ifdef VK_EXT_fragment_density_map
void deepcopy_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* from,
- VkPhysicalDeviceFragmentDensityMapFeaturesEXT* to)
-{
+ VkPhysicalDeviceFragmentDensityMapFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* from,
- VkPhysicalDeviceFragmentDensityMapPropertiesEXT* to)
-{
+ VkPhysicalDeviceFragmentDensityMapPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkExtent2D(alloc, rootType, &from->minFragmentDensityTexelSize, (VkExtent2D*)(&to->minFragmentDensityTexelSize));
- deepcopy_VkExtent2D(alloc, rootType, &from->maxFragmentDensityTexelSize, (VkExtent2D*)(&to->maxFragmentDensityTexelSize));
+ deepcopy_VkExtent2D(alloc, rootType, &from->minFragmentDensityTexelSize,
+ (VkExtent2D*)(&to->minFragmentDensityTexelSize));
+ deepcopy_VkExtent2D(alloc, rootType, &from->maxFragmentDensityTexelSize,
+ (VkExtent2D*)(&to->maxFragmentDensityTexelSize));
}
void deepcopy_VkRenderPassFragmentDensityMapCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkRenderPassFragmentDensityMapCreateInfoEXT* from,
- VkRenderPassFragmentDensityMapCreateInfoEXT* to)
-{
+ VkRenderPassFragmentDensityMapCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkAttachmentReference(alloc, rootType, &from->fragmentDensityMapAttachment, (VkAttachmentReference*)(&to->fragmentDensityMapAttachment));
+ deepcopy_VkAttachmentReference(alloc, rootType, &from->fragmentDensityMapAttachment,
+ (VkAttachmentReference*)(&to->fragmentDensityMapAttachment));
}
#endif
@@ -17076,84 +14035,69 @@
#endif
#ifdef VK_EXT_subgroup_size_control
void deepcopy_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* from,
- VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* to)
-{
+ VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* from,
- VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* to)
-{
+ VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* from,
- VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* to)
-{
+ VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -17162,28 +14106,23 @@
#endif
#ifdef VK_AMD_shader_core_properties2
void deepcopy_VkPhysicalDeviceShaderCoreProperties2AMD(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderCoreProperties2AMD* from,
- VkPhysicalDeviceShaderCoreProperties2AMD* to)
-{
+ VkPhysicalDeviceShaderCoreProperties2AMD* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -17192,28 +14131,23 @@
#endif
#ifdef VK_AMD_device_coherent_memory
void deepcopy_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceCoherentMemoryFeaturesAMD* from,
- VkPhysicalDeviceCoherentMemoryFeaturesAMD* to)
-{
+ VkPhysicalDeviceCoherentMemoryFeaturesAMD* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -17222,28 +14156,23 @@
#endif
#ifdef VK_EXT_shader_image_atomic_int64
void deepcopy_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* from,
- VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* to)
-{
+ VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -17252,28 +14181,23 @@
#endif
#ifdef VK_EXT_memory_budget
void deepcopy_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceMemoryBudgetPropertiesEXT* from,
- VkPhysicalDeviceMemoryBudgetPropertiesEXT* to)
-{
+ VkPhysicalDeviceMemoryBudgetPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -17284,56 +14208,45 @@
#endif
#ifdef VK_EXT_memory_priority
void deepcopy_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceMemoryPriorityFeaturesEXT* from,
- VkPhysicalDeviceMemoryPriorityFeaturesEXT* to)
-{
+ VkPhysicalDeviceMemoryPriorityFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkMemoryPriorityAllocateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryPriorityAllocateInfoEXT* from,
- VkMemoryPriorityAllocateInfoEXT* to)
-{
+void deepcopy_VkMemoryPriorityAllocateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryPriorityAllocateInfoEXT* from,
+ VkMemoryPriorityAllocateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -17342,28 +14255,23 @@
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
void deepcopy_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* from,
- VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* to)
-{
+ VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -17372,56 +14280,45 @@
#endif
#ifdef VK_EXT_buffer_device_address
void deepcopy_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* from,
- VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* to)
-{
+ VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkBufferDeviceAddressCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferDeviceAddressCreateInfoEXT* from,
- VkBufferDeviceAddressCreateInfoEXT* to)
-{
+void deepcopy_VkBufferDeviceAddressCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkBufferDeviceAddressCreateInfoEXT* from,
+ VkBufferDeviceAddressCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -17429,29 +14326,23 @@
#endif
#ifdef VK_EXT_tooling_info
-void deepcopy_VkPhysicalDeviceToolPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceToolPropertiesEXT* from,
- VkPhysicalDeviceToolPropertiesEXT* to)
-{
+void deepcopy_VkPhysicalDeviceToolPropertiesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceToolPropertiesEXT* from,
+ VkPhysicalDeviceToolPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -17465,125 +14356,105 @@
#ifdef VK_EXT_separate_stencil_usage
#endif
#ifdef VK_EXT_validation_features
-void deepcopy_VkValidationFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkValidationFeaturesEXT* from,
- VkValidationFeaturesEXT* to)
-{
+void deepcopy_VkValidationFeaturesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkValidationFeaturesEXT* from,
+ VkValidationFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pEnabledValidationFeatures = nullptr;
- if (from->pEnabledValidationFeatures)
- {
- to->pEnabledValidationFeatures = (VkValidationFeatureEnableEXT*)alloc->dupArray(from->pEnabledValidationFeatures, from->enabledValidationFeatureCount * sizeof(const VkValidationFeatureEnableEXT));
+ if (from->pEnabledValidationFeatures) {
+ to->pEnabledValidationFeatures = (VkValidationFeatureEnableEXT*)alloc->dupArray(
+ from->pEnabledValidationFeatures,
+ from->enabledValidationFeatureCount * sizeof(const VkValidationFeatureEnableEXT));
}
to->pDisabledValidationFeatures = nullptr;
- if (from->pDisabledValidationFeatures)
- {
- to->pDisabledValidationFeatures = (VkValidationFeatureDisableEXT*)alloc->dupArray(from->pDisabledValidationFeatures, from->disabledValidationFeatureCount * sizeof(const VkValidationFeatureDisableEXT));
+ if (from->pDisabledValidationFeatures) {
+ to->pDisabledValidationFeatures = (VkValidationFeatureDisableEXT*)alloc->dupArray(
+ from->pDisabledValidationFeatures,
+ from->disabledValidationFeatureCount * sizeof(const VkValidationFeatureDisableEXT));
}
}
#endif
#ifdef VK_NV_cooperative_matrix
-void deepcopy_VkCooperativeMatrixPropertiesNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCooperativeMatrixPropertiesNV* from,
- VkCooperativeMatrixPropertiesNV* to)
-{
+void deepcopy_VkCooperativeMatrixPropertiesNV(Allocator* alloc, VkStructureType rootType,
+ const VkCooperativeMatrixPropertiesNV* from,
+ VkCooperativeMatrixPropertiesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixFeaturesNV* from,
- VkPhysicalDeviceCooperativeMatrixFeaturesNV* to)
-{
+ VkPhysicalDeviceCooperativeMatrixFeaturesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixPropertiesNV* from,
- VkPhysicalDeviceCooperativeMatrixPropertiesNV* to)
-{
+ VkPhysicalDeviceCooperativeMatrixPropertiesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -17592,84 +14463,68 @@
#endif
#ifdef VK_NV_coverage_reduction_mode
void deepcopy_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceCoverageReductionModeFeaturesNV* from,
- VkPhysicalDeviceCoverageReductionModeFeaturesNV* to)
-{
+ VkPhysicalDeviceCoverageReductionModeFeaturesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineCoverageReductionStateCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineCoverageReductionStateCreateInfoNV* from,
- VkPipelineCoverageReductionStateCreateInfoNV* to)
-{
+ VkPipelineCoverageReductionStateCreateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkFramebufferMixedSamplesCombinationNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFramebufferMixedSamplesCombinationNV* from,
- VkFramebufferMixedSamplesCombinationNV* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkFramebufferMixedSamplesCombinationNV* from,
+ VkFramebufferMixedSamplesCombinationNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -17678,28 +14533,23 @@
#endif
#ifdef VK_EXT_fragment_shader_interlock
void deepcopy_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* from,
- VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* to)
-{
+ VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -17708,28 +14558,23 @@
#endif
#ifdef VK_EXT_ycbcr_image_arrays
void deepcopy_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* from,
- VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* to)
-{
+ VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -17738,84 +14583,69 @@
#endif
#ifdef VK_EXT_provoking_vertex
void deepcopy_VkPhysicalDeviceProvokingVertexFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceProvokingVertexFeaturesEXT* from,
- VkPhysicalDeviceProvokingVertexFeaturesEXT* to)
-{
+ VkPhysicalDeviceProvokingVertexFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceProvokingVertexPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceProvokingVertexPropertiesEXT* from,
- VkPhysicalDeviceProvokingVertexPropertiesEXT* to)
-{
+ VkPhysicalDeviceProvokingVertexPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* from,
- VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* to)
-{
+ VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -17823,85 +14653,69 @@
#endif
#ifdef VK_EXT_full_screen_exclusive
-void deepcopy_VkSurfaceFullScreenExclusiveInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSurfaceFullScreenExclusiveInfoEXT* from,
- VkSurfaceFullScreenExclusiveInfoEXT* to)
-{
+void deepcopy_VkSurfaceFullScreenExclusiveInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkSurfaceFullScreenExclusiveInfoEXT* from,
+ VkSurfaceFullScreenExclusiveInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkSurfaceCapabilitiesFullScreenExclusiveEXT* from,
- VkSurfaceCapabilitiesFullScreenExclusiveEXT* to)
-{
+ VkSurfaceCapabilitiesFullScreenExclusiveEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSurfaceFullScreenExclusiveWin32InfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkSurfaceFullScreenExclusiveWin32InfoEXT* from,
- VkSurfaceFullScreenExclusiveWin32InfoEXT* to)
-{
+ VkSurfaceFullScreenExclusiveWin32InfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -17909,29 +14723,23 @@
#endif
#ifdef VK_EXT_headless_surface
-void deepcopy_VkHeadlessSurfaceCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkHeadlessSurfaceCreateInfoEXT* from,
- VkHeadlessSurfaceCreateInfoEXT* to)
-{
+void deepcopy_VkHeadlessSurfaceCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkHeadlessSurfaceCreateInfoEXT* from,
+ VkHeadlessSurfaceCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -17940,84 +14748,69 @@
#endif
#ifdef VK_EXT_line_rasterization
void deepcopy_VkPhysicalDeviceLineRasterizationFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceLineRasterizationFeaturesEXT* from,
- VkPhysicalDeviceLineRasterizationFeaturesEXT* to)
-{
+ VkPhysicalDeviceLineRasterizationFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceLineRasterizationPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceLineRasterizationPropertiesEXT* from,
- VkPhysicalDeviceLineRasterizationPropertiesEXT* to)
-{
+ VkPhysicalDeviceLineRasterizationPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineRasterizationLineStateCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineRasterizationLineStateCreateInfoEXT* from,
- VkPipelineRasterizationLineStateCreateInfoEXT* to)
-{
+ VkPipelineRasterizationLineStateCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -18026,28 +14819,23 @@
#endif
#ifdef VK_EXT_shader_atomic_float
void deepcopy_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* from,
- VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* to)
-{
+ VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -18058,28 +14846,23 @@
#endif
#ifdef VK_EXT_index_type_uint8
void deepcopy_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* from,
- VkPhysicalDeviceIndexTypeUint8FeaturesEXT* to)
-{
+ VkPhysicalDeviceIndexTypeUint8FeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -18088,28 +14871,23 @@
#endif
#ifdef VK_EXT_extended_dynamic_state
void deepcopy_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* from,
- VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* to)
-{
+ VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -18118,28 +14896,23 @@
#endif
#ifdef VK_EXT_shader_atomic_float2
void deepcopy_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* from,
- VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* to)
-{
+ VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -18148,28 +14921,23 @@
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
void deepcopy_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* from,
- VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* to)
-{
+ VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -18178,363 +14946,308 @@
#endif
#ifdef VK_NV_device_generated_commands
void deepcopy_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* from,
- VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* to)
-{
+ VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* from,
- VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* to)
-{
+ VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkGraphicsShaderGroupCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkGraphicsShaderGroupCreateInfoNV* from,
- VkGraphicsShaderGroupCreateInfoNV* to)
-{
+void deepcopy_VkGraphicsShaderGroupCreateInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkGraphicsShaderGroupCreateInfoNV* from,
+ VkGraphicsShaderGroupCreateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pStages = nullptr;
- if (from->pStages)
- {
- to->pStages = (VkPipelineShaderStageCreateInfo*)alloc->alloc(from->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
+ if (from->pStages) {
+ to->pStages = (VkPipelineShaderStageCreateInfo*)alloc->alloc(
+ from->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
to->stageCount = from->stageCount;
- for (uint32_t i = 0; i < (uint32_t)from->stageCount; ++i)
- {
- deepcopy_VkPipelineShaderStageCreateInfo(alloc, rootType, from->pStages + i, (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
+ for (uint32_t i = 0; i < (uint32_t)from->stageCount; ++i) {
+ deepcopy_VkPipelineShaderStageCreateInfo(
+ alloc, rootType, from->pStages + i,
+ (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
}
}
}
to->pVertexInputState = nullptr;
- if (from->pVertexInputState)
- {
- to->pVertexInputState = (VkPipelineVertexInputStateCreateInfo*)alloc->alloc(sizeof(const VkPipelineVertexInputStateCreateInfo));
- deepcopy_VkPipelineVertexInputStateCreateInfo(alloc, rootType, from->pVertexInputState, (VkPipelineVertexInputStateCreateInfo*)(to->pVertexInputState));
+ if (from->pVertexInputState) {
+ to->pVertexInputState = (VkPipelineVertexInputStateCreateInfo*)alloc->alloc(
+ sizeof(const VkPipelineVertexInputStateCreateInfo));
+ deepcopy_VkPipelineVertexInputStateCreateInfo(
+ alloc, rootType, from->pVertexInputState,
+ (VkPipelineVertexInputStateCreateInfo*)(to->pVertexInputState));
}
to->pTessellationState = nullptr;
- if (from->pTessellationState)
- {
- to->pTessellationState = (VkPipelineTessellationStateCreateInfo*)alloc->alloc(sizeof(const VkPipelineTessellationStateCreateInfo));
- deepcopy_VkPipelineTessellationStateCreateInfo(alloc, rootType, from->pTessellationState, (VkPipelineTessellationStateCreateInfo*)(to->pTessellationState));
+ if (from->pTessellationState) {
+ to->pTessellationState = (VkPipelineTessellationStateCreateInfo*)alloc->alloc(
+ sizeof(const VkPipelineTessellationStateCreateInfo));
+ deepcopy_VkPipelineTessellationStateCreateInfo(
+ alloc, rootType, from->pTessellationState,
+ (VkPipelineTessellationStateCreateInfo*)(to->pTessellationState));
}
}
void deepcopy_VkGraphicsPipelineShaderGroupsCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkGraphicsPipelineShaderGroupsCreateInfoNV* from,
- VkGraphicsPipelineShaderGroupsCreateInfoNV* to)
-{
+ VkGraphicsPipelineShaderGroupsCreateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pGroups = nullptr;
- if (from->pGroups)
- {
- to->pGroups = (VkGraphicsShaderGroupCreateInfoNV*)alloc->alloc(from->groupCount * sizeof(const VkGraphicsShaderGroupCreateInfoNV));
+ if (from->pGroups) {
+ to->pGroups = (VkGraphicsShaderGroupCreateInfoNV*)alloc->alloc(
+ from->groupCount * sizeof(const VkGraphicsShaderGroupCreateInfoNV));
to->groupCount = from->groupCount;
- for (uint32_t i = 0; i < (uint32_t)from->groupCount; ++i)
- {
- deepcopy_VkGraphicsShaderGroupCreateInfoNV(alloc, rootType, from->pGroups + i, (VkGraphicsShaderGroupCreateInfoNV*)(to->pGroups + i));
+ for (uint32_t i = 0; i < (uint32_t)from->groupCount; ++i) {
+ deepcopy_VkGraphicsShaderGroupCreateInfoNV(
+ alloc, rootType, from->pGroups + i,
+ (VkGraphicsShaderGroupCreateInfoNV*)(to->pGroups + i));
}
}
}
to->pPipelines = nullptr;
- if (from->pPipelines)
- {
- to->pPipelines = (VkPipeline*)alloc->dupArray(from->pPipelines, from->pipelineCount * sizeof(const VkPipeline));
+ if (from->pPipelines) {
+ to->pPipelines = (VkPipeline*)alloc->dupArray(
+ from->pPipelines, from->pipelineCount * sizeof(const VkPipeline));
}
}
-void deepcopy_VkBindShaderGroupIndirectCommandNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindShaderGroupIndirectCommandNV* from,
- VkBindShaderGroupIndirectCommandNV* to)
-{
+void deepcopy_VkBindShaderGroupIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
+ const VkBindShaderGroupIndirectCommandNV* from,
+ VkBindShaderGroupIndirectCommandNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkBindIndexBufferIndirectCommandNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindIndexBufferIndirectCommandNV* from,
- VkBindIndexBufferIndirectCommandNV* to)
-{
+void deepcopy_VkBindIndexBufferIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
+ const VkBindIndexBufferIndirectCommandNV* from,
+ VkBindIndexBufferIndirectCommandNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkBindVertexBufferIndirectCommandNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindVertexBufferIndirectCommandNV* from,
- VkBindVertexBufferIndirectCommandNV* to)
-{
+void deepcopy_VkBindVertexBufferIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
+ const VkBindVertexBufferIndirectCommandNV* from,
+ VkBindVertexBufferIndirectCommandNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkSetStateFlagsIndirectCommandNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSetStateFlagsIndirectCommandNV* from,
- VkSetStateFlagsIndirectCommandNV* to)
-{
+void deepcopy_VkSetStateFlagsIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
+ const VkSetStateFlagsIndirectCommandNV* from,
+ VkSetStateFlagsIndirectCommandNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkIndirectCommandsStreamNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkIndirectCommandsStreamNV* from,
- VkIndirectCommandsStreamNV* to)
-{
+void deepcopy_VkIndirectCommandsStreamNV(Allocator* alloc, VkStructureType rootType,
+ const VkIndirectCommandsStreamNV* from,
+ VkIndirectCommandsStreamNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkIndirectCommandsLayoutTokenNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkIndirectCommandsLayoutTokenNV* from,
- VkIndirectCommandsLayoutTokenNV* to)
-{
+void deepcopy_VkIndirectCommandsLayoutTokenNV(Allocator* alloc, VkStructureType rootType,
+ const VkIndirectCommandsLayoutTokenNV* from,
+ VkIndirectCommandsLayoutTokenNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pIndexTypes = nullptr;
- if (from->pIndexTypes)
- {
- to->pIndexTypes = (VkIndexType*)alloc->dupArray(from->pIndexTypes, from->indexTypeCount * sizeof(const VkIndexType));
+ if (from->pIndexTypes) {
+ to->pIndexTypes = (VkIndexType*)alloc->dupArray(
+ from->pIndexTypes, from->indexTypeCount * sizeof(const VkIndexType));
}
to->pIndexTypeValues = nullptr;
- if (from->pIndexTypeValues)
- {
- to->pIndexTypeValues = (uint32_t*)alloc->dupArray(from->pIndexTypeValues, from->indexTypeCount * sizeof(const uint32_t));
+ if (from->pIndexTypeValues) {
+ to->pIndexTypeValues = (uint32_t*)alloc->dupArray(
+ from->pIndexTypeValues, from->indexTypeCount * sizeof(const uint32_t));
}
}
-void deepcopy_VkIndirectCommandsLayoutCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkIndirectCommandsLayoutCreateInfoNV* from,
- VkIndirectCommandsLayoutCreateInfoNV* to)
-{
+void deepcopy_VkIndirectCommandsLayoutCreateInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkIndirectCommandsLayoutCreateInfoNV* from,
+ VkIndirectCommandsLayoutCreateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pTokens = nullptr;
- if (from->pTokens)
- {
- to->pTokens = (VkIndirectCommandsLayoutTokenNV*)alloc->alloc(from->tokenCount * sizeof(const VkIndirectCommandsLayoutTokenNV));
+ if (from->pTokens) {
+ to->pTokens = (VkIndirectCommandsLayoutTokenNV*)alloc->alloc(
+ from->tokenCount * sizeof(const VkIndirectCommandsLayoutTokenNV));
to->tokenCount = from->tokenCount;
- for (uint32_t i = 0; i < (uint32_t)from->tokenCount; ++i)
- {
- deepcopy_VkIndirectCommandsLayoutTokenNV(alloc, rootType, from->pTokens + i, (VkIndirectCommandsLayoutTokenNV*)(to->pTokens + i));
+ for (uint32_t i = 0; i < (uint32_t)from->tokenCount; ++i) {
+ deepcopy_VkIndirectCommandsLayoutTokenNV(
+ alloc, rootType, from->pTokens + i,
+ (VkIndirectCommandsLayoutTokenNV*)(to->pTokens + i));
}
}
}
to->pStreamStrides = nullptr;
- if (from->pStreamStrides)
- {
- to->pStreamStrides = (uint32_t*)alloc->dupArray(from->pStreamStrides, from->streamCount * sizeof(const uint32_t));
+ if (from->pStreamStrides) {
+ to->pStreamStrides = (uint32_t*)alloc->dupArray(from->pStreamStrides,
+ from->streamCount * sizeof(const uint32_t));
}
}
-void deepcopy_VkGeneratedCommandsInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkGeneratedCommandsInfoNV* from,
- VkGeneratedCommandsInfoNV* to)
-{
+void deepcopy_VkGeneratedCommandsInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkGeneratedCommandsInfoNV* from,
+ VkGeneratedCommandsInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pStreams = nullptr;
- if (from->pStreams)
- {
- to->pStreams = (VkIndirectCommandsStreamNV*)alloc->alloc(from->streamCount * sizeof(const VkIndirectCommandsStreamNV));
+ if (from->pStreams) {
+ to->pStreams = (VkIndirectCommandsStreamNV*)alloc->alloc(
+ from->streamCount * sizeof(const VkIndirectCommandsStreamNV));
to->streamCount = from->streamCount;
- for (uint32_t i = 0; i < (uint32_t)from->streamCount; ++i)
- {
- deepcopy_VkIndirectCommandsStreamNV(alloc, rootType, from->pStreams + i, (VkIndirectCommandsStreamNV*)(to->pStreams + i));
+ for (uint32_t i = 0; i < (uint32_t)from->streamCount; ++i) {
+ deepcopy_VkIndirectCommandsStreamNV(
+ alloc, rootType, from->pStreams + i,
+ (VkIndirectCommandsStreamNV*)(to->pStreams + i));
}
}
}
}
void deepcopy_VkGeneratedCommandsMemoryRequirementsInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkGeneratedCommandsMemoryRequirementsInfoNV* from,
- VkGeneratedCommandsMemoryRequirementsInfoNV* to)
-{
+ VkGeneratedCommandsMemoryRequirementsInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -18543,120 +15256,100 @@
#endif
#ifdef VK_NV_inherited_viewport_scissor
void deepcopy_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* from,
- VkPhysicalDeviceInheritedViewportScissorFeaturesNV* to)
-{
+ VkPhysicalDeviceInheritedViewportScissorFeaturesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkCommandBufferInheritanceViewportScissorInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkCommandBufferInheritanceViewportScissorInfoNV* from,
- VkCommandBufferInheritanceViewportScissorInfoNV* to)
-{
+ VkCommandBufferInheritanceViewportScissorInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pViewportDepths = nullptr;
- if (from->pViewportDepths)
- {
+ if (from->pViewportDepths) {
to->pViewportDepths = (VkViewport*)alloc->alloc(sizeof(const VkViewport));
- deepcopy_VkViewport(alloc, rootType, from->pViewportDepths, (VkViewport*)(to->pViewportDepths));
+ deepcopy_VkViewport(alloc, rootType, from->pViewportDepths,
+ (VkViewport*)(to->pViewportDepths));
}
}
#endif
#ifdef VK_EXT_texel_buffer_alignment
void deepcopy_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* from,
- VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* to)
-{
+ VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* from,
- VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* to)
-{
+ VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -18664,57 +15357,46 @@
#endif
#ifdef VK_QCOM_render_pass_transform
-void deepcopy_VkRenderPassTransformBeginInfoQCOM(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRenderPassTransformBeginInfoQCOM* from,
- VkRenderPassTransformBeginInfoQCOM* to)
-{
+void deepcopy_VkRenderPassTransformBeginInfoQCOM(Allocator* alloc, VkStructureType rootType,
+ const VkRenderPassTransformBeginInfoQCOM* from,
+ VkRenderPassTransformBeginInfoQCOM* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* from,
- VkCommandBufferInheritanceRenderPassTransformInfoQCOM* to)
-{
+ VkCommandBufferInheritanceRenderPassTransformInfoQCOM* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -18724,90 +15406,72 @@
#endif
#ifdef VK_EXT_device_memory_report
void deepcopy_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* from,
- VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* to)
-{
+ VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkDeviceMemoryReportCallbackDataEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceMemoryReportCallbackDataEXT* from,
- VkDeviceMemoryReportCallbackDataEXT* to)
-{
+void deepcopy_VkDeviceMemoryReportCallbackDataEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceMemoryReportCallbackDataEXT* from,
+ VkDeviceMemoryReportCallbackDataEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDeviceDeviceMemoryReportCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceDeviceMemoryReportCreateInfoEXT* from,
- VkDeviceDeviceMemoryReportCreateInfoEXT* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkDeviceDeviceMemoryReportCreateInfoEXT* from,
+ VkDeviceDeviceMemoryReportCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pUserData = nullptr;
- if (from->pUserData)
- {
+ if (from->pUserData) {
to->pUserData = (void*)alloc->dupArray(from->pUserData, sizeof(uint8_t));
}
}
@@ -18817,56 +15481,45 @@
#endif
#ifdef VK_EXT_robustness2
void deepcopy_VkPhysicalDeviceRobustness2FeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceRobustness2FeaturesEXT* from,
- VkPhysicalDeviceRobustness2FeaturesEXT* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceRobustness2FeaturesEXT* from,
+ VkPhysicalDeviceRobustness2FeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceRobustness2PropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceRobustness2PropertiesEXT* from,
- VkPhysicalDeviceRobustness2PropertiesEXT* to)
-{
+ VkPhysicalDeviceRobustness2PropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -18875,85 +15528,70 @@
#endif
#ifdef VK_EXT_custom_border_color
void deepcopy_VkSamplerCustomBorderColorCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSamplerCustomBorderColorCreateInfoEXT* from,
- VkSamplerCustomBorderColorCreateInfoEXT* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkSamplerCustomBorderColorCreateInfoEXT* from,
+ VkSamplerCustomBorderColorCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkClearColorValue(alloc, rootType, &from->customBorderColor, (VkClearColorValue*)(&to->customBorderColor));
+ deepcopy_VkClearColorValue(alloc, rootType, &from->customBorderColor,
+ (VkClearColorValue*)(&to->customBorderColor));
}
void deepcopy_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorPropertiesEXT* from,
- VkPhysicalDeviceCustomBorderColorPropertiesEXT* to)
-{
+ VkPhysicalDeviceCustomBorderColorPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorFeaturesEXT* from,
- VkPhysicalDeviceCustomBorderColorFeaturesEXT* to)
-{
+ VkPhysicalDeviceCustomBorderColorFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -18964,84 +15602,66 @@
#endif
#ifdef VK_EXT_private_data
void deepcopy_VkPhysicalDevicePrivateDataFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDevicePrivateDataFeaturesEXT* from,
- VkPhysicalDevicePrivateDataFeaturesEXT* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDevicePrivateDataFeaturesEXT* from,
+ VkPhysicalDevicePrivateDataFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkDevicePrivateDataCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDevicePrivateDataCreateInfoEXT* from,
- VkDevicePrivateDataCreateInfoEXT* to)
-{
+void deepcopy_VkDevicePrivateDataCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDevicePrivateDataCreateInfoEXT* from,
+ VkDevicePrivateDataCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkPrivateDataSlotCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPrivateDataSlotCreateInfoEXT* from,
- VkPrivateDataSlotCreateInfoEXT* to)
-{
+void deepcopy_VkPrivateDataSlotCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkPrivateDataSlotCreateInfoEXT* from,
+ VkPrivateDataSlotCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -19050,28 +15670,23 @@
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
void deepcopy_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* from,
- VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* to)
-{
+ VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -19080,56 +15695,45 @@
#endif
#ifdef VK_NV_device_diagnostics_config
void deepcopy_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* from,
- VkPhysicalDeviceDiagnosticsConfigFeaturesNV* to)
-{
+ VkPhysicalDeviceDiagnosticsConfigFeaturesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkDeviceDiagnosticsConfigCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceDiagnosticsConfigCreateInfoNV* from,
- VkDeviceDiagnosticsConfigCreateInfoNV* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkDeviceDiagnosticsConfigCreateInfoNV* from,
+ VkDeviceDiagnosticsConfigCreateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -19140,84 +15744,69 @@
#endif
#ifdef VK_NV_fragment_shading_rate_enums
void deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* from,
- VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* to)
-{
+ VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* from,
- VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* to)
-{
+ VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* from,
- VkPipelineFragmentShadingRateEnumStateCreateInfoNV* to)
-{
+ VkPipelineFragmentShadingRateEnumStateCreateInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -19226,109 +15815,89 @@
#endif
#ifdef VK_NV_ray_tracing_motion_blur
-void deepcopy_VkDeviceOrHostAddressConstKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceOrHostAddressConstKHR* from,
- VkDeviceOrHostAddressConstKHR* to)
-{
+void deepcopy_VkDeviceOrHostAddressConstKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceOrHostAddressConstKHR* from,
+ VkDeviceOrHostAddressConstKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
to->hostAddress = nullptr;
- if (from->hostAddress)
- {
+ if (from->hostAddress) {
to->hostAddress = (void*)alloc->dupArray(from->hostAddress, sizeof(const uint8_t));
}
}
void deepcopy_VkAccelerationStructureGeometryMotionTrianglesDataNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureGeometryMotionTrianglesDataNV* from,
- VkAccelerationStructureGeometryMotionTrianglesDataNV* to)
-{
+ VkAccelerationStructureGeometryMotionTrianglesDataNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->vertexData, (VkDeviceOrHostAddressConstKHR*)(&to->vertexData));
+ deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->vertexData,
+ (VkDeviceOrHostAddressConstKHR*)(&to->vertexData));
}
-void deepcopy_VkAccelerationStructureMotionInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAccelerationStructureMotionInfoNV* from,
- VkAccelerationStructureMotionInfoNV* to)
-{
+void deepcopy_VkAccelerationStructureMotionInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkAccelerationStructureMotionInfoNV* from,
+ VkAccelerationStructureMotionInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkAccelerationStructureMatrixMotionInstanceNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureMatrixMotionInstanceNV* from,
- VkAccelerationStructureMatrixMotionInstanceNV* to)
-{
+ VkAccelerationStructureMatrixMotionInstanceNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- deepcopy_VkTransformMatrixKHR(alloc, rootType, &from->transformT0, (VkTransformMatrixKHR*)(&to->transformT0));
- deepcopy_VkTransformMatrixKHR(alloc, rootType, &from->transformT1, (VkTransformMatrixKHR*)(&to->transformT1));
+ deepcopy_VkTransformMatrixKHR(alloc, rootType, &from->transformT0,
+ (VkTransformMatrixKHR*)(&to->transformT0));
+ deepcopy_VkTransformMatrixKHR(alloc, rootType, &from->transformT1,
+ (VkTransformMatrixKHR*)(&to->transformT1));
}
-void deepcopy_VkSRTDataNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSRTDataNV* from,
- VkSRTDataNV* to)
-{
+void deepcopy_VkSRTDataNV(Allocator* alloc, VkStructureType rootType, const VkSRTDataNV* from,
+ VkSRTDataNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
void deepcopy_VkAccelerationStructureSRTMotionInstanceNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureSRTMotionInstanceNV* from,
- VkAccelerationStructureSRTMotionInstanceNV* to)
-{
+ VkAccelerationStructureSRTMotionInstanceNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
@@ -19337,54 +15906,51 @@
}
void deepcopy_VkAccelerationStructureMotionInstanceDataNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureMotionInstanceDataNV* from,
- VkAccelerationStructureMotionInstanceDataNV* to)
-{
+ VkAccelerationStructureMotionInstanceDataNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- deepcopy_VkAccelerationStructureInstanceKHR(alloc, rootType, &from->staticInstance, (VkAccelerationStructureInstanceKHR*)(&to->staticInstance));
- deepcopy_VkAccelerationStructureMatrixMotionInstanceNV(alloc, rootType, &from->matrixMotionInstance, (VkAccelerationStructureMatrixMotionInstanceNV*)(&to->matrixMotionInstance));
- deepcopy_VkAccelerationStructureSRTMotionInstanceNV(alloc, rootType, &from->srtMotionInstance, (VkAccelerationStructureSRTMotionInstanceNV*)(&to->srtMotionInstance));
+ deepcopy_VkAccelerationStructureInstanceKHR(
+ alloc, rootType, &from->staticInstance,
+ (VkAccelerationStructureInstanceKHR*)(&to->staticInstance));
+ deepcopy_VkAccelerationStructureMatrixMotionInstanceNV(
+ alloc, rootType, &from->matrixMotionInstance,
+ (VkAccelerationStructureMatrixMotionInstanceNV*)(&to->matrixMotionInstance));
+ deepcopy_VkAccelerationStructureSRTMotionInstanceNV(
+ alloc, rootType, &from->srtMotionInstance,
+ (VkAccelerationStructureSRTMotionInstanceNV*)(&to->srtMotionInstance));
}
void deepcopy_VkAccelerationStructureMotionInstanceNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAccelerationStructureMotionInstanceNV* from,
- VkAccelerationStructureMotionInstanceNV* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkAccelerationStructureMotionInstanceNV* from,
+ VkAccelerationStructureMotionInstanceNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- deepcopy_VkAccelerationStructureMotionInstanceDataNV(alloc, rootType, &from->data, (VkAccelerationStructureMotionInstanceDataNV*)(&to->data));
+ deepcopy_VkAccelerationStructureMotionInstanceDataNV(
+ alloc, rootType, &from->data, (VkAccelerationStructureMotionInstanceDataNV*)(&to->data));
}
void deepcopy_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* from,
- VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* to)
-{
+ VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -19393,28 +15959,23 @@
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
void deepcopy_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* from,
- VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* to)
-{
+ VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -19423,56 +15984,46 @@
#endif
#ifdef VK_EXT_fragment_density_map2
void deepcopy_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* from,
- VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* to)
-{
+ VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* from,
- VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* to)
-{
+ VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -19480,29 +16031,23 @@
#endif
#ifdef VK_QCOM_rotated_copy_commands
-void deepcopy_VkCopyCommandTransformInfoQCOM(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCopyCommandTransformInfoQCOM* from,
- VkCopyCommandTransformInfoQCOM* to)
-{
+void deepcopy_VkCopyCommandTransformInfoQCOM(Allocator* alloc, VkStructureType rootType,
+ const VkCopyCommandTransformInfoQCOM* from,
+ VkCopyCommandTransformInfoQCOM* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -19511,28 +16056,23 @@
#endif
#ifdef VK_EXT_image_robustness
void deepcopy_VkPhysicalDeviceImageRobustnessFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceImageRobustnessFeaturesEXT* from,
- VkPhysicalDeviceImageRobustnessFeaturesEXT* to)
-{
+ VkPhysicalDeviceImageRobustnessFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -19541,28 +16081,22 @@
#endif
#ifdef VK_EXT_4444_formats
void deepcopy_VkPhysicalDevice4444FormatsFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDevice4444FormatsFeaturesEXT* from,
- VkPhysicalDevice4444FormatsFeaturesEXT* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDevice4444FormatsFeaturesEXT* from,
+ VkPhysicalDevice4444FormatsFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -19571,28 +16105,23 @@
#endif
#ifdef VK_EXT_rgba10x6_formats
void deepcopy_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* from,
- VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* to)
-{
+ VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -19602,40 +16131,32 @@
#ifdef VK_NV_acquire_winrt_display
#endif
#ifdef VK_EXT_directfb_surface
-void deepcopy_VkDirectFBSurfaceCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDirectFBSurfaceCreateInfoEXT* from,
- VkDirectFBSurfaceCreateInfoEXT* to)
-{
+void deepcopy_VkDirectFBSurfaceCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDirectFBSurfaceCreateInfoEXT* from,
+ VkDirectFBSurfaceCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->dfb = nullptr;
- if (from->dfb)
- {
+ if (from->dfb) {
to->dfb = (IDirectFB*)alloc->dupArray(from->dfb, sizeof(IDirectFB));
}
to->surface = nullptr;
- if (from->surface)
- {
+ if (from->surface) {
to->surface = (IDirectFBSurface*)alloc->dupArray(from->surface, sizeof(IDirectFBSurface));
}
}
@@ -19643,85 +16164,72 @@
#endif
#ifdef VK_VALVE_mutable_descriptor_type
void deepcopy_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* from,
- VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* to)
-{
+ VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkMutableDescriptorTypeListVALVE(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMutableDescriptorTypeListVALVE* from,
- VkMutableDescriptorTypeListVALVE* to)
-{
+void deepcopy_VkMutableDescriptorTypeListVALVE(Allocator* alloc, VkStructureType rootType,
+ const VkMutableDescriptorTypeListVALVE* from,
+ VkMutableDescriptorTypeListVALVE* to) {
(void)alloc;
(void)rootType;
*to = *from;
to->pDescriptorTypes = nullptr;
- if (from->pDescriptorTypes)
- {
- to->pDescriptorTypes = (VkDescriptorType*)alloc->dupArray(from->pDescriptorTypes, from->descriptorTypeCount * sizeof(const VkDescriptorType));
+ if (from->pDescriptorTypes) {
+ to->pDescriptorTypes = (VkDescriptorType*)alloc->dupArray(
+ from->pDescriptorTypes, from->descriptorTypeCount * sizeof(const VkDescriptorType));
}
}
void deepcopy_VkMutableDescriptorTypeCreateInfoVALVE(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMutableDescriptorTypeCreateInfoVALVE* from,
- VkMutableDescriptorTypeCreateInfoVALVE* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkMutableDescriptorTypeCreateInfoVALVE* from,
+ VkMutableDescriptorTypeCreateInfoVALVE* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pMutableDescriptorTypeLists = nullptr;
- if (from->pMutableDescriptorTypeLists)
- {
- to->pMutableDescriptorTypeLists = (VkMutableDescriptorTypeListVALVE*)alloc->alloc(from->mutableDescriptorTypeListCount * sizeof(const VkMutableDescriptorTypeListVALVE));
+ if (from->pMutableDescriptorTypeLists) {
+ to->pMutableDescriptorTypeLists = (VkMutableDescriptorTypeListVALVE*)alloc->alloc(
+ from->mutableDescriptorTypeListCount *
+ sizeof(const VkMutableDescriptorTypeListVALVE));
to->mutableDescriptorTypeListCount = from->mutableDescriptorTypeListCount;
- for (uint32_t i = 0; i < (uint32_t)from->mutableDescriptorTypeListCount; ++i)
- {
- deepcopy_VkMutableDescriptorTypeListVALVE(alloc, rootType, from->pMutableDescriptorTypeLists + i, (VkMutableDescriptorTypeListVALVE*)(to->pMutableDescriptorTypeLists + i));
+ for (uint32_t i = 0; i < (uint32_t)from->mutableDescriptorTypeListCount; ++i) {
+ deepcopy_VkMutableDescriptorTypeListVALVE(
+ alloc, rootType, from->pMutableDescriptorTypeLists + i,
+ (VkMutableDescriptorTypeListVALVE*)(to->pMutableDescriptorTypeLists + i));
}
}
}
@@ -19730,84 +16238,67 @@
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
void deepcopy_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* from,
- VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* to)
-{
+ VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkVertexInputBindingDescription2EXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVertexInputBindingDescription2EXT* from,
- VkVertexInputBindingDescription2EXT* to)
-{
+void deepcopy_VkVertexInputBindingDescription2EXT(Allocator* alloc, VkStructureType rootType,
+ const VkVertexInputBindingDescription2EXT* from,
+ VkVertexInputBindingDescription2EXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkVertexInputAttributeDescription2EXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVertexInputAttributeDescription2EXT* from,
- VkVertexInputAttributeDescription2EXT* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkVertexInputAttributeDescription2EXT* from,
+ VkVertexInputAttributeDescription2EXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -19815,29 +16306,23 @@
#endif
#ifdef VK_EXT_physical_device_drm
-void deepcopy_VkPhysicalDeviceDrmPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceDrmPropertiesEXT* from,
- VkPhysicalDeviceDrmPropertiesEXT* to)
-{
+void deepcopy_VkPhysicalDeviceDrmPropertiesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceDrmPropertiesEXT* from,
+ VkPhysicalDeviceDrmPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -19846,28 +16331,23 @@
#endif
#ifdef VK_EXT_primitive_topology_list_restart
void deepcopy_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* from,
- VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* to)
-{
+ VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -19876,84 +16356,66 @@
#endif
#ifdef VK_FUCHSIA_external_memory
void deepcopy_VkImportMemoryZirconHandleInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportMemoryZirconHandleInfoFUCHSIA* from,
- VkImportMemoryZirconHandleInfoFUCHSIA* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkImportMemoryZirconHandleInfoFUCHSIA* from,
+ VkImportMemoryZirconHandleInfoFUCHSIA* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkMemoryZirconHandlePropertiesFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryZirconHandlePropertiesFUCHSIA* from,
- VkMemoryZirconHandlePropertiesFUCHSIA* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkMemoryZirconHandlePropertiesFUCHSIA* from,
+ VkMemoryZirconHandlePropertiesFUCHSIA* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkMemoryGetZirconHandleInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryGetZirconHandleInfoFUCHSIA* from,
- VkMemoryGetZirconHandleInfoFUCHSIA* to)
-{
+void deepcopy_VkMemoryGetZirconHandleInfoFUCHSIA(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* from,
+ VkMemoryGetZirconHandleInfoFUCHSIA* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -19962,56 +16424,45 @@
#endif
#ifdef VK_FUCHSIA_external_semaphore
void deepcopy_VkImportSemaphoreZirconHandleInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkImportSemaphoreZirconHandleInfoFUCHSIA* from,
- VkImportSemaphoreZirconHandleInfoFUCHSIA* to)
-{
+ VkImportSemaphoreZirconHandleInfoFUCHSIA* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSemaphoreGetZirconHandleInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSemaphoreGetZirconHandleInfoFUCHSIA* from,
- VkSemaphoreGetZirconHandleInfoFUCHSIA* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkSemaphoreGetZirconHandleInfoFUCHSIA* from,
+ VkSemaphoreGetZirconHandleInfoFUCHSIA* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -20019,392 +16470,329 @@
#endif
#ifdef VK_FUCHSIA_buffer_collection
-void deepcopy_VkBufferCollectionCreateInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferCollectionCreateInfoFUCHSIA* from,
- VkBufferCollectionCreateInfoFUCHSIA* to)
-{
+void deepcopy_VkBufferCollectionCreateInfoFUCHSIA(Allocator* alloc, VkStructureType rootType,
+ const VkBufferCollectionCreateInfoFUCHSIA* from,
+ VkBufferCollectionCreateInfoFUCHSIA* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkImportMemoryBufferCollectionFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportMemoryBufferCollectionFUCHSIA* from,
- VkImportMemoryBufferCollectionFUCHSIA* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkImportMemoryBufferCollectionFUCHSIA* from,
+ VkImportMemoryBufferCollectionFUCHSIA* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkBufferCollectionImageCreateInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkBufferCollectionImageCreateInfoFUCHSIA* from,
- VkBufferCollectionImageCreateInfoFUCHSIA* to)
-{
+ VkBufferCollectionImageCreateInfoFUCHSIA* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkBufferCollectionConstraintsInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkBufferCollectionConstraintsInfoFUCHSIA* from,
- VkBufferCollectionConstraintsInfoFUCHSIA* to)
-{
+ VkBufferCollectionConstraintsInfoFUCHSIA* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkBufferConstraintsInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferConstraintsInfoFUCHSIA* from,
- VkBufferConstraintsInfoFUCHSIA* to)
-{
+void deepcopy_VkBufferConstraintsInfoFUCHSIA(Allocator* alloc, VkStructureType rootType,
+ const VkBufferConstraintsInfoFUCHSIA* from,
+ VkBufferConstraintsInfoFUCHSIA* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkBufferCreateInfo(alloc, rootType, &from->createInfo, (VkBufferCreateInfo*)(&to->createInfo));
- deepcopy_VkBufferCollectionConstraintsInfoFUCHSIA(alloc, rootType, &from->bufferCollectionConstraints, (VkBufferCollectionConstraintsInfoFUCHSIA*)(&to->bufferCollectionConstraints));
+ deepcopy_VkBufferCreateInfo(alloc, rootType, &from->createInfo,
+ (VkBufferCreateInfo*)(&to->createInfo));
+ deepcopy_VkBufferCollectionConstraintsInfoFUCHSIA(
+ alloc, rootType, &from->bufferCollectionConstraints,
+ (VkBufferCollectionConstraintsInfoFUCHSIA*)(&to->bufferCollectionConstraints));
}
void deepcopy_VkBufferCollectionBufferCreateInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkBufferCollectionBufferCreateInfoFUCHSIA* from,
- VkBufferCollectionBufferCreateInfoFUCHSIA* to)
-{
+ VkBufferCollectionBufferCreateInfoFUCHSIA* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkSysmemColorSpaceFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSysmemColorSpaceFUCHSIA* from,
- VkSysmemColorSpaceFUCHSIA* to)
-{
+void deepcopy_VkSysmemColorSpaceFUCHSIA(Allocator* alloc, VkStructureType rootType,
+ const VkSysmemColorSpaceFUCHSIA* from,
+ VkSysmemColorSpaceFUCHSIA* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkBufferCollectionPropertiesFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferCollectionPropertiesFUCHSIA* from,
- VkBufferCollectionPropertiesFUCHSIA* to)
-{
+void deepcopy_VkBufferCollectionPropertiesFUCHSIA(Allocator* alloc, VkStructureType rootType,
+ const VkBufferCollectionPropertiesFUCHSIA* from,
+ VkBufferCollectionPropertiesFUCHSIA* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkSysmemColorSpaceFUCHSIA(alloc, rootType, &from->sysmemColorSpaceIndex, (VkSysmemColorSpaceFUCHSIA*)(&to->sysmemColorSpaceIndex));
- deepcopy_VkComponentMapping(alloc, rootType, &from->samplerYcbcrConversionComponents, (VkComponentMapping*)(&to->samplerYcbcrConversionComponents));
+ deepcopy_VkSysmemColorSpaceFUCHSIA(alloc, rootType, &from->sysmemColorSpaceIndex,
+ (VkSysmemColorSpaceFUCHSIA*)(&to->sysmemColorSpaceIndex));
+ deepcopy_VkComponentMapping(alloc, rootType, &from->samplerYcbcrConversionComponents,
+ (VkComponentMapping*)(&to->samplerYcbcrConversionComponents));
}
-void deepcopy_VkImageFormatConstraintsInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageFormatConstraintsInfoFUCHSIA* from,
- VkImageFormatConstraintsInfoFUCHSIA* to)
-{
+void deepcopy_VkImageFormatConstraintsInfoFUCHSIA(Allocator* alloc, VkStructureType rootType,
+ const VkImageFormatConstraintsInfoFUCHSIA* from,
+ VkImageFormatConstraintsInfoFUCHSIA* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkImageCreateInfo(alloc, rootType, &from->imageCreateInfo, (VkImageCreateInfo*)(&to->imageCreateInfo));
+ deepcopy_VkImageCreateInfo(alloc, rootType, &from->imageCreateInfo,
+ (VkImageCreateInfo*)(&to->imageCreateInfo));
to->pColorSpaces = nullptr;
- if (from->pColorSpaces)
- {
- to->pColorSpaces = (VkSysmemColorSpaceFUCHSIA*)alloc->alloc(sizeof(const VkSysmemColorSpaceFUCHSIA));
- deepcopy_VkSysmemColorSpaceFUCHSIA(alloc, rootType, from->pColorSpaces, (VkSysmemColorSpaceFUCHSIA*)(to->pColorSpaces));
+ if (from->pColorSpaces) {
+ to->pColorSpaces =
+ (VkSysmemColorSpaceFUCHSIA*)alloc->alloc(sizeof(const VkSysmemColorSpaceFUCHSIA));
+ deepcopy_VkSysmemColorSpaceFUCHSIA(alloc, rootType, from->pColorSpaces,
+ (VkSysmemColorSpaceFUCHSIA*)(to->pColorSpaces));
}
}
-void deepcopy_VkImageConstraintsInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageConstraintsInfoFUCHSIA* from,
- VkImageConstraintsInfoFUCHSIA* to)
-{
+void deepcopy_VkImageConstraintsInfoFUCHSIA(Allocator* alloc, VkStructureType rootType,
+ const VkImageConstraintsInfoFUCHSIA* from,
+ VkImageConstraintsInfoFUCHSIA* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pFormatConstraints = nullptr;
- if (from->pFormatConstraints)
- {
- to->pFormatConstraints = (VkImageFormatConstraintsInfoFUCHSIA*)alloc->alloc(from->formatConstraintsCount * sizeof(const VkImageFormatConstraintsInfoFUCHSIA));
+ if (from->pFormatConstraints) {
+ to->pFormatConstraints = (VkImageFormatConstraintsInfoFUCHSIA*)alloc->alloc(
+ from->formatConstraintsCount * sizeof(const VkImageFormatConstraintsInfoFUCHSIA));
to->formatConstraintsCount = from->formatConstraintsCount;
- for (uint32_t i = 0; i < (uint32_t)from->formatConstraintsCount; ++i)
- {
- deepcopy_VkImageFormatConstraintsInfoFUCHSIA(alloc, rootType, from->pFormatConstraints + i, (VkImageFormatConstraintsInfoFUCHSIA*)(to->pFormatConstraints + i));
+ for (uint32_t i = 0; i < (uint32_t)from->formatConstraintsCount; ++i) {
+ deepcopy_VkImageFormatConstraintsInfoFUCHSIA(
+ alloc, rootType, from->pFormatConstraints + i,
+ (VkImageFormatConstraintsInfoFUCHSIA*)(to->pFormatConstraints + i));
}
}
}
- deepcopy_VkBufferCollectionConstraintsInfoFUCHSIA(alloc, rootType, &from->bufferCollectionConstraints, (VkBufferCollectionConstraintsInfoFUCHSIA*)(&to->bufferCollectionConstraints));
+ deepcopy_VkBufferCollectionConstraintsInfoFUCHSIA(
+ alloc, rootType, &from->bufferCollectionConstraints,
+ (VkBufferCollectionConstraintsInfoFUCHSIA*)(&to->bufferCollectionConstraints));
}
#endif
#ifdef VK_HUAWEI_subpass_shading
void deepcopy_VkSubpassShadingPipelineCreateInfoHUAWEI(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkSubpassShadingPipelineCreateInfoHUAWEI* from,
- VkSubpassShadingPipelineCreateInfoHUAWEI* to)
-{
+ VkSubpassShadingPipelineCreateInfoHUAWEI* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* from,
- VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* to)
-{
+ VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* from,
- VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* to)
-{
+ VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -20413,28 +16801,23 @@
#endif
#ifdef VK_HUAWEI_invocation_mask
void deepcopy_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* from,
- VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* to)
-{
+ VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -20442,57 +16825,46 @@
#endif
#ifdef VK_NV_external_memory_rdma
-void deepcopy_VkMemoryGetRemoteAddressInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryGetRemoteAddressInfoNV* from,
- VkMemoryGetRemoteAddressInfoNV* to)
-{
+void deepcopy_VkMemoryGetRemoteAddressInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryGetRemoteAddressInfoNV* from,
+ VkMemoryGetRemoteAddressInfoNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* from,
- VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* to)
-{
+ VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -20501,28 +16873,23 @@
#endif
#ifdef VK_EXT_extended_dynamic_state2
void deepcopy_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* from,
- VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* to)
-{
+ VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -20530,40 +16897,32 @@
#endif
#ifdef VK_QNX_screen_surface
-void deepcopy_VkScreenSurfaceCreateInfoQNX(
- Allocator* alloc,
- VkStructureType rootType,
- const VkScreenSurfaceCreateInfoQNX* from,
- VkScreenSurfaceCreateInfoQNX* to)
-{
+void deepcopy_VkScreenSurfaceCreateInfoQNX(Allocator* alloc, VkStructureType rootType,
+ const VkScreenSurfaceCreateInfoQNX* from,
+ VkScreenSurfaceCreateInfoQNX* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->context = nullptr;
- if (from->context)
- {
+ if (from->context) {
to->context = (_screen_context*)alloc->dupArray(from->context, sizeof(_screen_context));
}
to->window = nullptr;
- if (from->window)
- {
+ if (from->window) {
to->window = (_screen_window*)alloc->dupArray(from->window, sizeof(_screen_window));
}
}
@@ -20571,147 +16930,117 @@
#endif
#ifdef VK_EXT_color_write_enable
void deepcopy_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceColorWriteEnableFeaturesEXT* from,
- VkPhysicalDeviceColorWriteEnableFeaturesEXT* to)
-{
+ VkPhysicalDeviceColorWriteEnableFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkPipelineColorWriteCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineColorWriteCreateInfoEXT* from,
- VkPipelineColorWriteCreateInfoEXT* to)
-{
+void deepcopy_VkPipelineColorWriteCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineColorWriteCreateInfoEXT* from,
+ VkPipelineColorWriteCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pColorWriteEnables = nullptr;
- if (from->pColorWriteEnables)
- {
- to->pColorWriteEnables = (VkBool32*)alloc->dupArray(from->pColorWriteEnables, from->attachmentCount * sizeof(const VkBool32));
+ if (from->pColorWriteEnables) {
+ to->pColorWriteEnables = (VkBool32*)alloc->dupArray(
+ from->pColorWriteEnables, from->attachmentCount * sizeof(const VkBool32));
}
}
#endif
#ifdef VK_GOOGLE_gfxstream
-void deepcopy_VkImportColorBufferGOOGLE(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportColorBufferGOOGLE* from,
- VkImportColorBufferGOOGLE* to)
-{
+void deepcopy_VkImportColorBufferGOOGLE(Allocator* alloc, VkStructureType rootType,
+ const VkImportColorBufferGOOGLE* from,
+ VkImportColorBufferGOOGLE* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkImportBufferGOOGLE(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportBufferGOOGLE* from,
- VkImportBufferGOOGLE* to)
-{
+void deepcopy_VkImportBufferGOOGLE(Allocator* alloc, VkStructureType rootType,
+ const VkImportBufferGOOGLE* from, VkImportBufferGOOGLE* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkImportPhysicalAddressGOOGLE(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportPhysicalAddressGOOGLE* from,
- VkImportPhysicalAddressGOOGLE* to)
-{
+void deepcopy_VkImportPhysicalAddressGOOGLE(Allocator* alloc, VkStructureType rootType,
+ const VkImportPhysicalAddressGOOGLE* from,
+ VkImportPhysicalAddressGOOGLE* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -20720,137 +17049,109 @@
#endif
#ifdef VK_EXT_global_priority_query
void deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* from,
- VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* to)
-{
+ VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkQueueFamilyGlobalPriorityPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkQueueFamilyGlobalPriorityPropertiesEXT* from,
- VkQueueFamilyGlobalPriorityPropertiesEXT* to)
-{
+ VkQueueFamilyGlobalPriorityPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- memcpy(to->priorities, from->priorities, VK_MAX_GLOBAL_PRIORITY_SIZE_EXT * sizeof(VkQueueGlobalPriorityEXT));
+ memcpy(to->priorities, from->priorities,
+ VK_MAX_GLOBAL_PRIORITY_SIZE_EXT * sizeof(VkQueueGlobalPriorityEXT));
}
#endif
#ifdef VK_EXT_multi_draw
-void deepcopy_VkPhysicalDeviceMultiDrawFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiDrawFeaturesEXT* from,
- VkPhysicalDeviceMultiDrawFeaturesEXT* to)
-{
+void deepcopy_VkPhysicalDeviceMultiDrawFeaturesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceMultiDrawFeaturesEXT* from,
+ VkPhysicalDeviceMultiDrawFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceMultiDrawPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiDrawPropertiesEXT* from,
- VkPhysicalDeviceMultiDrawPropertiesEXT* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMultiDrawPropertiesEXT* from,
+ VkPhysicalDeviceMultiDrawPropertiesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkMultiDrawInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMultiDrawInfoEXT* from,
- VkMultiDrawInfoEXT* to)
-{
+void deepcopy_VkMultiDrawInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkMultiDrawInfoEXT* from, VkMultiDrawInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkMultiDrawIndexedInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMultiDrawIndexedInfoEXT* from,
- VkMultiDrawIndexedInfoEXT* to)
-{
+void deepcopy_VkMultiDrawIndexedInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkMultiDrawIndexedInfoEXT* from,
+ VkMultiDrawIndexedInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
@@ -20861,87 +17162,73 @@
#endif
#ifdef VK_EXT_border_color_swizzle
void deepcopy_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* from,
- VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* to)
-{
+ VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkSamplerBorderColorComponentMappingCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkSamplerBorderColorComponentMappingCreateInfoEXT* from,
- VkSamplerBorderColorComponentMappingCreateInfoEXT* to)
-{
+ VkSamplerBorderColorComponentMappingCreateInfoEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkComponentMapping(alloc, rootType, &from->components, (VkComponentMapping*)(&to->components));
+ deepcopy_VkComponentMapping(alloc, rootType, &from->components,
+ (VkComponentMapping*)(&to->components));
}
#endif
#ifdef VK_EXT_pageable_device_local_memory
void deepcopy_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* from,
- VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* to)
-{
+ VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -20949,494 +17236,421 @@
#endif
#ifdef VK_KHR_acceleration_structure
-void deepcopy_VkDeviceOrHostAddressKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceOrHostAddressKHR* from,
- VkDeviceOrHostAddressKHR* to)
-{
+void deepcopy_VkDeviceOrHostAddressKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceOrHostAddressKHR* from,
+ VkDeviceOrHostAddressKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
to->hostAddress = nullptr;
- if (from->hostAddress)
- {
+ if (from->hostAddress) {
to->hostAddress = (void*)alloc->dupArray(from->hostAddress, sizeof(uint8_t));
}
}
void deepcopy_VkAccelerationStructureBuildRangeInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureBuildRangeInfoKHR* from,
- VkAccelerationStructureBuildRangeInfoKHR* to)
-{
+ VkAccelerationStructureBuildRangeInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
void deepcopy_VkAccelerationStructureGeometryTrianglesDataKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureGeometryTrianglesDataKHR* from,
- VkAccelerationStructureGeometryTrianglesDataKHR* to)
-{
+ VkAccelerationStructureGeometryTrianglesDataKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->vertexData, (VkDeviceOrHostAddressConstKHR*)(&to->vertexData));
- deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->indexData, (VkDeviceOrHostAddressConstKHR*)(&to->indexData));
- deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->transformData, (VkDeviceOrHostAddressConstKHR*)(&to->transformData));
+ deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->vertexData,
+ (VkDeviceOrHostAddressConstKHR*)(&to->vertexData));
+ deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->indexData,
+ (VkDeviceOrHostAddressConstKHR*)(&to->indexData));
+ deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->transformData,
+ (VkDeviceOrHostAddressConstKHR*)(&to->transformData));
}
void deepcopy_VkAccelerationStructureGeometryAabbsDataKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureGeometryAabbsDataKHR* from,
- VkAccelerationStructureGeometryAabbsDataKHR* to)
-{
+ VkAccelerationStructureGeometryAabbsDataKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->data, (VkDeviceOrHostAddressConstKHR*)(&to->data));
+ deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->data,
+ (VkDeviceOrHostAddressConstKHR*)(&to->data));
}
void deepcopy_VkAccelerationStructureGeometryInstancesDataKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureGeometryInstancesDataKHR* from,
- VkAccelerationStructureGeometryInstancesDataKHR* to)
-{
+ VkAccelerationStructureGeometryInstancesDataKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->data, (VkDeviceOrHostAddressConstKHR*)(&to->data));
+ deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->data,
+ (VkDeviceOrHostAddressConstKHR*)(&to->data));
}
void deepcopy_VkAccelerationStructureGeometryDataKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryDataKHR* from,
- VkAccelerationStructureGeometryDataKHR* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkAccelerationStructureGeometryDataKHR* from,
+ VkAccelerationStructureGeometryDataKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- deepcopy_VkAccelerationStructureGeometryTrianglesDataKHR(alloc, rootType, &from->triangles, (VkAccelerationStructureGeometryTrianglesDataKHR*)(&to->triangles));
- deepcopy_VkAccelerationStructureGeometryAabbsDataKHR(alloc, rootType, &from->aabbs, (VkAccelerationStructureGeometryAabbsDataKHR*)(&to->aabbs));
- deepcopy_VkAccelerationStructureGeometryInstancesDataKHR(alloc, rootType, &from->instances, (VkAccelerationStructureGeometryInstancesDataKHR*)(&to->instances));
+ deepcopy_VkAccelerationStructureGeometryTrianglesDataKHR(
+ alloc, rootType, &from->triangles,
+ (VkAccelerationStructureGeometryTrianglesDataKHR*)(&to->triangles));
+ deepcopy_VkAccelerationStructureGeometryAabbsDataKHR(
+ alloc, rootType, &from->aabbs, (VkAccelerationStructureGeometryAabbsDataKHR*)(&to->aabbs));
+ deepcopy_VkAccelerationStructureGeometryInstancesDataKHR(
+ alloc, rootType, &from->instances,
+ (VkAccelerationStructureGeometryInstancesDataKHR*)(&to->instances));
}
-void deepcopy_VkAccelerationStructureGeometryKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryKHR* from,
- VkAccelerationStructureGeometryKHR* to)
-{
+void deepcopy_VkAccelerationStructureGeometryKHR(Allocator* alloc, VkStructureType rootType,
+ const VkAccelerationStructureGeometryKHR* from,
+ VkAccelerationStructureGeometryKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkAccelerationStructureGeometryDataKHR(alloc, rootType, &from->geometry, (VkAccelerationStructureGeometryDataKHR*)(&to->geometry));
+ deepcopy_VkAccelerationStructureGeometryDataKHR(
+ alloc, rootType, &from->geometry, (VkAccelerationStructureGeometryDataKHR*)(&to->geometry));
}
void deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureBuildGeometryInfoKHR* from,
- VkAccelerationStructureBuildGeometryInfoKHR* to)
-{
+ VkAccelerationStructureBuildGeometryInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pGeometries = nullptr;
- if (from->pGeometries)
- {
- to->pGeometries = (VkAccelerationStructureGeometryKHR*)alloc->alloc(from->geometryCount * sizeof(const VkAccelerationStructureGeometryKHR));
+ if (from->pGeometries) {
+ to->pGeometries = (VkAccelerationStructureGeometryKHR*)alloc->alloc(
+ from->geometryCount * sizeof(const VkAccelerationStructureGeometryKHR));
to->geometryCount = from->geometryCount;
- for (uint32_t i = 0; i < (uint32_t)from->geometryCount; ++i)
- {
- deepcopy_VkAccelerationStructureGeometryKHR(alloc, rootType, from->pGeometries + i, (VkAccelerationStructureGeometryKHR*)(to->pGeometries + i));
+ for (uint32_t i = 0; i < (uint32_t)from->geometryCount; ++i) {
+ deepcopy_VkAccelerationStructureGeometryKHR(
+ alloc, rootType, from->pGeometries + i,
+ (VkAccelerationStructureGeometryKHR*)(to->pGeometries + i));
}
}
}
- deepcopy_VkDeviceOrHostAddressKHR(alloc, rootType, &from->scratchData, (VkDeviceOrHostAddressKHR*)(&to->scratchData));
+ deepcopy_VkDeviceOrHostAddressKHR(alloc, rootType, &from->scratchData,
+ (VkDeviceOrHostAddressKHR*)(&to->scratchData));
}
-void deepcopy_VkAccelerationStructureCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAccelerationStructureCreateInfoKHR* from,
- VkAccelerationStructureCreateInfoKHR* to)
-{
+void deepcopy_VkAccelerationStructureCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkAccelerationStructureCreateInfoKHR* from,
+ VkAccelerationStructureCreateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkWriteDescriptorSetAccelerationStructureKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkWriteDescriptorSetAccelerationStructureKHR* from,
- VkWriteDescriptorSetAccelerationStructureKHR* to)
-{
+ VkWriteDescriptorSetAccelerationStructureKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pAccelerationStructures = nullptr;
- if (from->pAccelerationStructures)
- {
- to->pAccelerationStructures = (VkAccelerationStructureKHR*)alloc->dupArray(from->pAccelerationStructures, from->accelerationStructureCount * sizeof(const VkAccelerationStructureKHR));
+ if (from->pAccelerationStructures) {
+ to->pAccelerationStructures = (VkAccelerationStructureKHR*)alloc->dupArray(
+ from->pAccelerationStructures,
+ from->accelerationStructureCount * sizeof(const VkAccelerationStructureKHR));
}
}
void deepcopy_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceAccelerationStructureFeaturesKHR* from,
- VkPhysicalDeviceAccelerationStructureFeaturesKHR* to)
-{
+ VkPhysicalDeviceAccelerationStructureFeaturesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceAccelerationStructurePropertiesKHR* from,
- VkPhysicalDeviceAccelerationStructurePropertiesKHR* to)
-{
+ VkPhysicalDeviceAccelerationStructurePropertiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkAccelerationStructureDeviceAddressInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureDeviceAddressInfoKHR* from,
- VkAccelerationStructureDeviceAddressInfoKHR* to)
-{
+ VkAccelerationStructureDeviceAddressInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkAccelerationStructureVersionInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAccelerationStructureVersionInfoKHR* from,
- VkAccelerationStructureVersionInfoKHR* to)
-{
+ Allocator* alloc, VkStructureType rootType, const VkAccelerationStructureVersionInfoKHR* from,
+ VkAccelerationStructureVersionInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pVersionData = nullptr;
- if (from->pVersionData)
- {
- to->pVersionData = (uint8_t*)alloc->dupArray(from->pVersionData, 2*VK_UUID_SIZE * sizeof(const uint8_t));
+ if (from->pVersionData) {
+ to->pVersionData =
+ (uint8_t*)alloc->dupArray(from->pVersionData, 2 * VK_UUID_SIZE * sizeof(const uint8_t));
}
}
void deepcopy_VkCopyAccelerationStructureToMemoryInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkCopyAccelerationStructureToMemoryInfoKHR* from,
- VkCopyAccelerationStructureToMemoryInfoKHR* to)
-{
+ VkCopyAccelerationStructureToMemoryInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDeviceOrHostAddressKHR(alloc, rootType, &from->dst, (VkDeviceOrHostAddressKHR*)(&to->dst));
+ deepcopy_VkDeviceOrHostAddressKHR(alloc, rootType, &from->dst,
+ (VkDeviceOrHostAddressKHR*)(&to->dst));
}
void deepcopy_VkCopyMemoryToAccelerationStructureInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkCopyMemoryToAccelerationStructureInfoKHR* from,
- VkCopyMemoryToAccelerationStructureInfoKHR* to)
-{
+ VkCopyMemoryToAccelerationStructureInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->src, (VkDeviceOrHostAddressConstKHR*)(&to->src));
+ deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->src,
+ (VkDeviceOrHostAddressConstKHR*)(&to->src));
}
-void deepcopy_VkCopyAccelerationStructureInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCopyAccelerationStructureInfoKHR* from,
- VkCopyAccelerationStructureInfoKHR* to)
-{
+void deepcopy_VkCopyAccelerationStructureInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkCopyAccelerationStructureInfoKHR* from,
+ VkCopyAccelerationStructureInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkAccelerationStructureBuildSizesInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureBuildSizesInfoKHR* from,
- VkAccelerationStructureBuildSizesInfoKHR* to)
-{
+ VkAccelerationStructureBuildSizesInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
@@ -21444,212 +17658,185 @@
#endif
#ifdef VK_KHR_ray_tracing_pipeline
-void deepcopy_VkRayTracingShaderGroupCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRayTracingShaderGroupCreateInfoKHR* from,
- VkRayTracingShaderGroupCreateInfoKHR* to)
-{
+void deepcopy_VkRayTracingShaderGroupCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkRayTracingShaderGroupCreateInfoKHR* from,
+ VkRayTracingShaderGroupCreateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
to->pShaderGroupCaptureReplayHandle = nullptr;
- if (from->pShaderGroupCaptureReplayHandle)
- {
- to->pShaderGroupCaptureReplayHandle = (void*)alloc->dupArray(from->pShaderGroupCaptureReplayHandle, sizeof(const uint8_t));
+ if (from->pShaderGroupCaptureReplayHandle) {
+ to->pShaderGroupCaptureReplayHandle =
+ (void*)alloc->dupArray(from->pShaderGroupCaptureReplayHandle, sizeof(const uint8_t));
}
}
void deepcopy_VkRayTracingPipelineInterfaceCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkRayTracingPipelineInterfaceCreateInfoKHR* from,
- VkRayTracingPipelineInterfaceCreateInfoKHR* to)
-{
+ VkRayTracingPipelineInterfaceCreateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkRayTracingPipelineCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRayTracingPipelineCreateInfoKHR* from,
- VkRayTracingPipelineCreateInfoKHR* to)
-{
+void deepcopy_VkRayTracingPipelineCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkRayTracingPipelineCreateInfoKHR* from,
+ VkRayTracingPipelineCreateInfoKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
- if (from)
- {
+ if (from) {
to->pStages = nullptr;
- if (from->pStages)
- {
- to->pStages = (VkPipelineShaderStageCreateInfo*)alloc->alloc(from->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
+ if (from->pStages) {
+ to->pStages = (VkPipelineShaderStageCreateInfo*)alloc->alloc(
+ from->stageCount * sizeof(const VkPipelineShaderStageCreateInfo));
to->stageCount = from->stageCount;
- for (uint32_t i = 0; i < (uint32_t)from->stageCount; ++i)
- {
- deepcopy_VkPipelineShaderStageCreateInfo(alloc, rootType, from->pStages + i, (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
+ for (uint32_t i = 0; i < (uint32_t)from->stageCount; ++i) {
+ deepcopy_VkPipelineShaderStageCreateInfo(
+ alloc, rootType, from->pStages + i,
+ (VkPipelineShaderStageCreateInfo*)(to->pStages + i));
}
}
}
- if (from)
- {
+ if (from) {
to->pGroups = nullptr;
- if (from->pGroups)
- {
- to->pGroups = (VkRayTracingShaderGroupCreateInfoKHR*)alloc->alloc(from->groupCount * sizeof(const VkRayTracingShaderGroupCreateInfoKHR));
+ if (from->pGroups) {
+ to->pGroups = (VkRayTracingShaderGroupCreateInfoKHR*)alloc->alloc(
+ from->groupCount * sizeof(const VkRayTracingShaderGroupCreateInfoKHR));
to->groupCount = from->groupCount;
- for (uint32_t i = 0; i < (uint32_t)from->groupCount; ++i)
- {
- deepcopy_VkRayTracingShaderGroupCreateInfoKHR(alloc, rootType, from->pGroups + i, (VkRayTracingShaderGroupCreateInfoKHR*)(to->pGroups + i));
+ for (uint32_t i = 0; i < (uint32_t)from->groupCount; ++i) {
+ deepcopy_VkRayTracingShaderGroupCreateInfoKHR(
+ alloc, rootType, from->pGroups + i,
+ (VkRayTracingShaderGroupCreateInfoKHR*)(to->pGroups + i));
}
}
}
to->pLibraryInfo = nullptr;
- if (from->pLibraryInfo)
- {
- to->pLibraryInfo = (VkPipelineLibraryCreateInfoKHR*)alloc->alloc(sizeof(const VkPipelineLibraryCreateInfoKHR));
- deepcopy_VkPipelineLibraryCreateInfoKHR(alloc, rootType, from->pLibraryInfo, (VkPipelineLibraryCreateInfoKHR*)(to->pLibraryInfo));
+ if (from->pLibraryInfo) {
+ to->pLibraryInfo = (VkPipelineLibraryCreateInfoKHR*)alloc->alloc(
+ sizeof(const VkPipelineLibraryCreateInfoKHR));
+ deepcopy_VkPipelineLibraryCreateInfoKHR(
+ alloc, rootType, from->pLibraryInfo,
+ (VkPipelineLibraryCreateInfoKHR*)(to->pLibraryInfo));
}
to->pLibraryInterface = nullptr;
- if (from->pLibraryInterface)
- {
- to->pLibraryInterface = (VkRayTracingPipelineInterfaceCreateInfoKHR*)alloc->alloc(sizeof(const VkRayTracingPipelineInterfaceCreateInfoKHR));
- deepcopy_VkRayTracingPipelineInterfaceCreateInfoKHR(alloc, rootType, from->pLibraryInterface, (VkRayTracingPipelineInterfaceCreateInfoKHR*)(to->pLibraryInterface));
+ if (from->pLibraryInterface) {
+ to->pLibraryInterface = (VkRayTracingPipelineInterfaceCreateInfoKHR*)alloc->alloc(
+ sizeof(const VkRayTracingPipelineInterfaceCreateInfoKHR));
+ deepcopy_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ alloc, rootType, from->pLibraryInterface,
+ (VkRayTracingPipelineInterfaceCreateInfoKHR*)(to->pLibraryInterface));
}
to->pDynamicState = nullptr;
- if (from->pDynamicState)
- {
- to->pDynamicState = (VkPipelineDynamicStateCreateInfo*)alloc->alloc(sizeof(const VkPipelineDynamicStateCreateInfo));
- deepcopy_VkPipelineDynamicStateCreateInfo(alloc, rootType, from->pDynamicState, (VkPipelineDynamicStateCreateInfo*)(to->pDynamicState));
+ if (from->pDynamicState) {
+ to->pDynamicState = (VkPipelineDynamicStateCreateInfo*)alloc->alloc(
+ sizeof(const VkPipelineDynamicStateCreateInfo));
+ deepcopy_VkPipelineDynamicStateCreateInfo(
+ alloc, rootType, from->pDynamicState,
+ (VkPipelineDynamicStateCreateInfo*)(to->pDynamicState));
}
}
void deepcopy_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* from,
- VkPhysicalDeviceRayTracingPipelineFeaturesKHR* to)
-{
+ VkPhysicalDeviceRayTracingPipelineFeaturesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
void deepcopy_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* from,
- VkPhysicalDeviceRayTracingPipelinePropertiesKHR* to)
-{
+ VkPhysicalDeviceRayTracingPipelinePropertiesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
-void deepcopy_VkStridedDeviceAddressRegionKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkStridedDeviceAddressRegionKHR* from,
- VkStridedDeviceAddressRegionKHR* to)
-{
+void deepcopy_VkStridedDeviceAddressRegionKHR(Allocator* alloc, VkStructureType rootType,
+ const VkStridedDeviceAddressRegionKHR* from,
+ VkStridedDeviceAddressRegionKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
}
-void deepcopy_VkTraceRaysIndirectCommandKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkTraceRaysIndirectCommandKHR* from,
- VkTraceRaysIndirectCommandKHR* to)
-{
+void deepcopy_VkTraceRaysIndirectCommandKHR(Allocator* alloc, VkStructureType rootType,
+ const VkTraceRaysIndirectCommandKHR* from,
+ VkTraceRaysIndirectCommandKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
@@ -21657,1568 +17844,2269 @@
#endif
#ifdef VK_KHR_ray_query
-void deepcopy_VkPhysicalDeviceRayQueryFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceRayQueryFeaturesKHR* from,
- VkPhysicalDeviceRayQueryFeaturesKHR* to)
-{
+void deepcopy_VkPhysicalDeviceRayQueryFeaturesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceRayQueryFeaturesKHR* from,
+ VkPhysicalDeviceRayQueryFeaturesKHR* to) {
(void)alloc;
(void)rootType;
*to = *from;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = from->sType;
}
const void* from_pNext = from;
size_t pNext_size = 0u;
- while (!pNext_size && from_pNext)
- {
+ while (!pNext_size && from_pNext) {
from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
}
to->pNext = nullptr;
- if (pNext_size)
- {
+ if (pNext_size) {
to->pNext = (void*)alloc->alloc(pNext_size);
deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
}
}
#endif
-void deepcopy_extension_struct(
- Allocator* alloc,
- VkStructureType rootType,
- const void* structExtension,
- void* structExtension_out)
-{
- if (!structExtension)
- {
+void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
+ const void* structExtension, void* structExtension_out) {
+ if (!structExtension) {
return;
}
uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension);
- switch(structType)
- {
+ switch (structType) {
#ifdef VK_VERSION_1_1
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
- {
- deepcopy_VkPhysicalDeviceSubgroupProperties(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
+ deepcopy_VkPhysicalDeviceSubgroupProperties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
- {
- deepcopy_VkPhysicalDevice16BitStorageFeatures(alloc, rootType, reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension), reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
+ deepcopy_VkPhysicalDevice16BitStorageFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension),
+ reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
- {
- deepcopy_VkMemoryDedicatedRequirements(alloc, rootType, reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension), reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
+ deepcopy_VkMemoryDedicatedRequirements(
+ alloc, rootType,
+ reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension),
+ reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
- {
- deepcopy_VkMemoryDedicatedAllocateInfo(alloc, rootType, reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension), reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: {
+ deepcopy_VkMemoryDedicatedAllocateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension),
+ reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
- {
- deepcopy_VkMemoryAllocateFlagsInfo(alloc, rootType, reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension), reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: {
+ deepcopy_VkMemoryAllocateFlagsInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension),
+ reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
- {
- deepcopy_VkDeviceGroupRenderPassBeginInfo(alloc, rootType, reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension), reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: {
+ deepcopy_VkDeviceGroupRenderPassBeginInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension),
+ reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
- {
- deepcopy_VkDeviceGroupCommandBufferBeginInfo(alloc, rootType, reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension), reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: {
+ deepcopy_VkDeviceGroupCommandBufferBeginInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension),
+ reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
- {
- deepcopy_VkDeviceGroupSubmitInfo(alloc, rootType, reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension), reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: {
+ deepcopy_VkDeviceGroupSubmitInfo(
+ alloc, rootType, reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension),
+ reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
- {
- deepcopy_VkDeviceGroupBindSparseInfo(alloc, rootType, reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension), reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: {
+ deepcopy_VkDeviceGroupBindSparseInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension),
+ reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
- {
- deepcopy_VkBindBufferMemoryDeviceGroupInfo(alloc, rootType, reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension), reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: {
+ deepcopy_VkBindBufferMemoryDeviceGroupInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension),
+ reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
- {
- deepcopy_VkBindImageMemoryDeviceGroupInfo(alloc, rootType, reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension), reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: {
+ deepcopy_VkBindImageMemoryDeviceGroupInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension),
+ reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
- {
- deepcopy_VkDeviceGroupDeviceCreateInfo(alloc, rootType, reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension), reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: {
+ deepcopy_VkDeviceGroupDeviceCreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension),
+ reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
- {
- deepcopy_VkPhysicalDeviceFeatures2(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension), reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
+ deepcopy_VkPhysicalDeviceFeatures2(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
- {
- deepcopy_VkPhysicalDevicePointClippingProperties(alloc, rootType, reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(structExtension), reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: {
+ deepcopy_VkPhysicalDevicePointClippingProperties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(structExtension),
+ reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
- {
- deepcopy_VkRenderPassInputAttachmentAspectCreateInfo(alloc, rootType, reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension), reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: {
+ deepcopy_VkRenderPassInputAttachmentAspectCreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(
+ structExtension),
+ reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
- {
- deepcopy_VkImageViewUsageCreateInfo(alloc, rootType, reinterpret_cast<const VkImageViewUsageCreateInfo*>(structExtension), reinterpret_cast<VkImageViewUsageCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: {
+ deepcopy_VkImageViewUsageCreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkImageViewUsageCreateInfo*>(structExtension),
+ reinterpret_cast<VkImageViewUsageCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
- {
- deepcopy_VkPipelineTessellationDomainOriginStateCreateInfo(alloc, rootType, reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension), reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: {
+ deepcopy_VkPipelineTessellationDomainOriginStateCreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(
+ structExtension),
+ reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
- {
- deepcopy_VkRenderPassMultiviewCreateInfo(alloc, rootType, reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension), reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: {
+ deepcopy_VkRenderPassMultiviewCreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension),
+ reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
- {
- deepcopy_VkPhysicalDeviceMultiviewFeatures(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
+ deepcopy_VkPhysicalDeviceMultiviewFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
- {
- deepcopy_VkPhysicalDeviceMultiviewProperties(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: {
+ deepcopy_VkPhysicalDeviceMultiviewProperties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
- {
- deepcopy_VkPhysicalDeviceVariablePointersFeatures(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
+ deepcopy_VkPhysicalDeviceVariablePointersFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
- {
- deepcopy_VkPhysicalDeviceProtectedMemoryFeatures(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
+ deepcopy_VkPhysicalDeviceProtectedMemoryFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
- {
- deepcopy_VkPhysicalDeviceProtectedMemoryProperties(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: {
+ deepcopy_VkPhysicalDeviceProtectedMemoryProperties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
- {
- deepcopy_VkProtectedSubmitInfo(alloc, rootType, reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension), reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: {
+ deepcopy_VkProtectedSubmitInfo(
+ alloc, rootType, reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension),
+ reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
- {
- deepcopy_VkSamplerYcbcrConversionInfo(alloc, rootType, reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension), reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: {
+ deepcopy_VkSamplerYcbcrConversionInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension),
+ reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
- {
- deepcopy_VkBindImagePlaneMemoryInfo(alloc, rootType, reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension), reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: {
+ deepcopy_VkBindImagePlaneMemoryInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension),
+ reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
- {
- deepcopy_VkImagePlaneMemoryRequirementsInfo(alloc, rootType, reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension), reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: {
+ deepcopy_VkImagePlaneMemoryRequirementsInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension),
+ reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
- {
- deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeatures(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
+ deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
- {
- deepcopy_VkSamplerYcbcrConversionImageFormatProperties(alloc, rootType, reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(structExtension), reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: {
+ deepcopy_VkSamplerYcbcrConversionImageFormatProperties(
+ alloc, rootType,
+ reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(
+ structExtension),
+ reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
- {
- deepcopy_VkPhysicalDeviceExternalImageFormatInfo(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension), reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: {
+ deepcopy_VkPhysicalDeviceExternalImageFormatInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
- {
- deepcopy_VkExternalImageFormatProperties(alloc, rootType, reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension), reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: {
+ deepcopy_VkExternalImageFormatProperties(
+ alloc, rootType,
+ reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension),
+ reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
- {
- deepcopy_VkPhysicalDeviceIDProperties(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: {
+ deepcopy_VkPhysicalDeviceIDProperties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
- {
- deepcopy_VkExternalMemoryImageCreateInfo(alloc, rootType, reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension), reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: {
+ deepcopy_VkExternalMemoryImageCreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension),
+ reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
- {
- deepcopy_VkExternalMemoryBufferCreateInfo(alloc, rootType, reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension), reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: {
+ deepcopy_VkExternalMemoryBufferCreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension),
+ reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
- {
- deepcopy_VkExportMemoryAllocateInfo(alloc, rootType, reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension), reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: {
+ deepcopy_VkExportMemoryAllocateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension),
+ reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
- {
- deepcopy_VkExportFenceCreateInfo(alloc, rootType, reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension), reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: {
+ deepcopy_VkExportFenceCreateInfo(
+ alloc, rootType, reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension),
+ reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
- {
- deepcopy_VkExportSemaphoreCreateInfo(alloc, rootType, reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension), reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: {
+ deepcopy_VkExportSemaphoreCreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension),
+ reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
- {
- deepcopy_VkPhysicalDeviceMaintenance3Properties(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension), reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: {
+ deepcopy_VkPhysicalDeviceMaintenance3Properties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
- {
- deepcopy_VkPhysicalDeviceShaderDrawParametersFeatures(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
+ deepcopy_VkPhysicalDeviceShaderDrawParametersFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_VERSION_1_2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
- {
- deepcopy_VkPhysicalDeviceVulkan11Features(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(structExtension), reinterpret_cast<VkPhysicalDeviceVulkan11Features*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: {
+ deepcopy_VkPhysicalDeviceVulkan11Features(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceVulkan11Features*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
- {
- deepcopy_VkPhysicalDeviceVulkan11Properties(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(structExtension), reinterpret_cast<VkPhysicalDeviceVulkan11Properties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: {
+ deepcopy_VkPhysicalDeviceVulkan11Properties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceVulkan11Properties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
- {
- deepcopy_VkPhysicalDeviceVulkan12Features(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(structExtension), reinterpret_cast<VkPhysicalDeviceVulkan12Features*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: {
+ deepcopy_VkPhysicalDeviceVulkan12Features(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceVulkan12Features*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
- {
- deepcopy_VkPhysicalDeviceVulkan12Properties(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(structExtension), reinterpret_cast<VkPhysicalDeviceVulkan12Properties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: {
+ deepcopy_VkPhysicalDeviceVulkan12Properties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceVulkan12Properties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
- {
- deepcopy_VkImageFormatListCreateInfo(alloc, rootType, reinterpret_cast<const VkImageFormatListCreateInfo*>(structExtension), reinterpret_cast<VkImageFormatListCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: {
+ deepcopy_VkImageFormatListCreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkImageFormatListCreateInfo*>(structExtension),
+ reinterpret_cast<VkImageFormatListCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
- {
- deepcopy_VkPhysicalDevice8BitStorageFeatures(alloc, rootType, reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(structExtension), reinterpret_cast<VkPhysicalDevice8BitStorageFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: {
+ deepcopy_VkPhysicalDevice8BitStorageFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(structExtension),
+ reinterpret_cast<VkPhysicalDevice8BitStorageFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
- {
- deepcopy_VkPhysicalDeviceDriverProperties(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceDriverProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: {
+ deepcopy_VkPhysicalDeviceDriverProperties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceDriverProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
- {
- deepcopy_VkPhysicalDeviceShaderAtomicInt64Features(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: {
+ deepcopy_VkPhysicalDeviceShaderAtomicInt64Features(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
- {
- deepcopy_VkPhysicalDeviceShaderFloat16Int8Features(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: {
+ deepcopy_VkPhysicalDeviceShaderFloat16Int8Features(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
- {
- deepcopy_VkPhysicalDeviceFloatControlsProperties(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceFloatControlsProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: {
+ deepcopy_VkPhysicalDeviceFloatControlsProperties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceFloatControlsProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
- {
- deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfo(alloc, rootType, reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension), reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: {
+ deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(
+ structExtension),
+ reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
- {
- deepcopy_VkPhysicalDeviceDescriptorIndexingFeatures(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: {
+ deepcopy_VkPhysicalDeviceDescriptorIndexingFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
- {
- deepcopy_VkPhysicalDeviceDescriptorIndexingProperties(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: {
+ deepcopy_VkPhysicalDeviceDescriptorIndexingProperties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
- {
- deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfo(alloc, rootType, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(structExtension), reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: {
+ deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(
+ structExtension),
+ reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
- {
- deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupport(alloc, rootType, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension), reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: {
+ deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupport(
+ alloc, rootType,
+ reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(
+ structExtension),
+ reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
- {
- deepcopy_VkSubpassDescriptionDepthStencilResolve(alloc, rootType, reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(structExtension), reinterpret_cast<VkSubpassDescriptionDepthStencilResolve*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: {
+ deepcopy_VkSubpassDescriptionDepthStencilResolve(
+ alloc, rootType,
+ reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(structExtension),
+ reinterpret_cast<VkSubpassDescriptionDepthStencilResolve*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
- {
- deepcopy_VkPhysicalDeviceDepthStencilResolveProperties(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: {
+ deepcopy_VkPhysicalDeviceDepthStencilResolveProperties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
- {
- deepcopy_VkPhysicalDeviceScalarBlockLayoutFeatures(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: {
+ deepcopy_VkPhysicalDeviceScalarBlockLayoutFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
- {
- deepcopy_VkImageStencilUsageCreateInfo(alloc, rootType, reinterpret_cast<const VkImageStencilUsageCreateInfo*>(structExtension), reinterpret_cast<VkImageStencilUsageCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: {
+ deepcopy_VkImageStencilUsageCreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkImageStencilUsageCreateInfo*>(structExtension),
+ reinterpret_cast<VkImageStencilUsageCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
- {
- deepcopy_VkSamplerReductionModeCreateInfo(alloc, rootType, reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(structExtension), reinterpret_cast<VkSamplerReductionModeCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: {
+ deepcopy_VkSamplerReductionModeCreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(structExtension),
+ reinterpret_cast<VkSamplerReductionModeCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
- {
- deepcopy_VkPhysicalDeviceSamplerFilterMinmaxProperties(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: {
+ deepcopy_VkPhysicalDeviceSamplerFilterMinmaxProperties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
- {
- deepcopy_VkPhysicalDeviceVulkanMemoryModelFeatures(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: {
+ deepcopy_VkPhysicalDeviceVulkanMemoryModelFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
- {
- deepcopy_VkPhysicalDeviceImagelessFramebufferFeatures(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: {
+ deepcopy_VkPhysicalDeviceImagelessFramebufferFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
- {
- deepcopy_VkFramebufferAttachmentsCreateInfo(alloc, rootType, reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(structExtension), reinterpret_cast<VkFramebufferAttachmentsCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: {
+ deepcopy_VkFramebufferAttachmentsCreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(structExtension),
+ reinterpret_cast<VkFramebufferAttachmentsCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
- {
- deepcopy_VkRenderPassAttachmentBeginInfo(alloc, rootType, reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(structExtension), reinterpret_cast<VkRenderPassAttachmentBeginInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: {
+ deepcopy_VkRenderPassAttachmentBeginInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(structExtension),
+ reinterpret_cast<VkRenderPassAttachmentBeginInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
- {
- deepcopy_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: {
+ deepcopy_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
- {
- deepcopy_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: {
+ deepcopy_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
- {
- deepcopy_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: {
+ deepcopy_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
- {
- deepcopy_VkAttachmentReferenceStencilLayout(alloc, rootType, reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(structExtension), reinterpret_cast<VkAttachmentReferenceStencilLayout*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: {
+ deepcopy_VkAttachmentReferenceStencilLayout(
+ alloc, rootType,
+ reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(structExtension),
+ reinterpret_cast<VkAttachmentReferenceStencilLayout*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
- {
- deepcopy_VkAttachmentDescriptionStencilLayout(alloc, rootType, reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(structExtension), reinterpret_cast<VkAttachmentDescriptionStencilLayout*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: {
+ deepcopy_VkAttachmentDescriptionStencilLayout(
+ alloc, rootType,
+ reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(structExtension),
+ reinterpret_cast<VkAttachmentDescriptionStencilLayout*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
- {
- deepcopy_VkPhysicalDeviceHostQueryResetFeatures(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: {
+ deepcopy_VkPhysicalDeviceHostQueryResetFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
- {
- deepcopy_VkPhysicalDeviceTimelineSemaphoreFeatures(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: {
+ deepcopy_VkPhysicalDeviceTimelineSemaphoreFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
- {
- deepcopy_VkPhysicalDeviceTimelineSemaphoreProperties(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension), reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: {
+ deepcopy_VkPhysicalDeviceTimelineSemaphoreProperties(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
- {
- deepcopy_VkSemaphoreTypeCreateInfo(alloc, rootType, reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(structExtension), reinterpret_cast<VkSemaphoreTypeCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: {
+ deepcopy_VkSemaphoreTypeCreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(structExtension),
+ reinterpret_cast<VkSemaphoreTypeCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
- {
- deepcopy_VkTimelineSemaphoreSubmitInfo(alloc, rootType, reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(structExtension), reinterpret_cast<VkTimelineSemaphoreSubmitInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: {
+ deepcopy_VkTimelineSemaphoreSubmitInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(structExtension),
+ reinterpret_cast<VkTimelineSemaphoreSubmitInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
- {
- deepcopy_VkPhysicalDeviceBufferDeviceAddressFeatures(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension), reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: {
+ deepcopy_VkPhysicalDeviceBufferDeviceAddressFeatures(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
- {
- deepcopy_VkBufferOpaqueCaptureAddressCreateInfo(alloc, rootType, reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension), reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: {
+ deepcopy_VkBufferOpaqueCaptureAddressCreateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension),
+ reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
- {
- deepcopy_VkMemoryOpaqueCaptureAddressAllocateInfo(alloc, rootType, reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension), reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: {
+ deepcopy_VkMemoryOpaqueCaptureAddressAllocateInfo(
+ alloc, rootType,
+ reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension),
+ reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_swapchain
- case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
- {
- deepcopy_VkImageSwapchainCreateInfoKHR(alloc, rootType, reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(structExtension), reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
+ deepcopy_VkImageSwapchainCreateInfoKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(structExtension),
+ reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
- {
- deepcopy_VkBindImageMemorySwapchainInfoKHR(alloc, rootType, reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(structExtension), reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: {
+ deepcopy_VkBindImageMemorySwapchainInfoKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(structExtension),
+ reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
- {
- deepcopy_VkDeviceGroupPresentInfoKHR(alloc, rootType, reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(structExtension), reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: {
+ deepcopy_VkDeviceGroupPresentInfoKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(structExtension),
+ reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
- {
- deepcopy_VkDeviceGroupSwapchainCreateInfoKHR(alloc, rootType, reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension), reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: {
+ deepcopy_VkDeviceGroupSwapchainCreateInfoKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension),
+ reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_display_swapchain
- case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
- {
- deepcopy_VkDisplayPresentInfoKHR(alloc, rootType, reinterpret_cast<const VkDisplayPresentInfoKHR*>(structExtension), reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: {
+ deepcopy_VkDisplayPresentInfoKHR(
+ alloc, rootType, reinterpret_cast<const VkDisplayPresentInfoKHR*>(structExtension),
+ reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_video_queue
- case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR:
- {
- deepcopy_VkVideoQueueFamilyProperties2KHR(alloc, rootType, reinterpret_cast<const VkVideoQueueFamilyProperties2KHR*>(structExtension), reinterpret_cast<VkVideoQueueFamilyProperties2KHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: {
+ deepcopy_VkVideoQueueFamilyProperties2KHR(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoQueueFamilyProperties2KHR*>(structExtension),
+ reinterpret_cast<VkVideoQueueFamilyProperties2KHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR:
- {
- deepcopy_VkVideoProfileKHR(alloc, rootType, reinterpret_cast<const VkVideoProfileKHR*>(structExtension), reinterpret_cast<VkVideoProfileKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR: {
+ deepcopy_VkVideoProfileKHR(alloc, rootType,
+ reinterpret_cast<const VkVideoProfileKHR*>(structExtension),
+ reinterpret_cast<VkVideoProfileKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR:
- {
- deepcopy_VkVideoProfilesKHR(alloc, rootType, reinterpret_cast<const VkVideoProfilesKHR*>(structExtension), reinterpret_cast<VkVideoProfilesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR: {
+ deepcopy_VkVideoProfilesKHR(
+ alloc, rootType, reinterpret_cast<const VkVideoProfilesKHR*>(structExtension),
+ reinterpret_cast<VkVideoProfilesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_dynamic_rendering
- case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR:
- {
- deepcopy_VkPipelineRenderingCreateInfoKHR(alloc, rootType, reinterpret_cast<const VkPipelineRenderingCreateInfoKHR*>(structExtension), reinterpret_cast<VkPipelineRenderingCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: {
+ deepcopy_VkPipelineRenderingCreateInfoKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineRenderingCreateInfoKHR*>(structExtension),
+ reinterpret_cast<VkPipelineRenderingCreateInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR:
- {
- deepcopy_VkPhysicalDeviceDynamicRenderingFeaturesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: {
+ deepcopy_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR:
- {
- deepcopy_VkCommandBufferInheritanceRenderingInfoKHR(alloc, rootType, reinterpret_cast<const VkCommandBufferInheritanceRenderingInfoKHR*>(structExtension), reinterpret_cast<VkCommandBufferInheritanceRenderingInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: {
+ deepcopy_VkCommandBufferInheritanceRenderingInfoKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkCommandBufferInheritanceRenderingInfoKHR*>(
+ structExtension),
+ reinterpret_cast<VkCommandBufferInheritanceRenderingInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
- {
- deepcopy_VkRenderingFragmentShadingRateAttachmentInfoKHR(alloc, rootType, reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(structExtension), reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
+ deepcopy_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
+ structExtension),
+ reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
- {
- deepcopy_VkRenderingFragmentDensityMapAttachmentInfoEXT(alloc, rootType, reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(structExtension), reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
+ deepcopy_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
- {
- deepcopy_VkAttachmentSampleCountInfoAMD(alloc, rootType, reinterpret_cast<const VkAttachmentSampleCountInfoAMD*>(structExtension), reinterpret_cast<VkAttachmentSampleCountInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
+ deepcopy_VkAttachmentSampleCountInfoAMD(
+ alloc, rootType,
+ reinterpret_cast<const VkAttachmentSampleCountInfoAMD*>(structExtension),
+ reinterpret_cast<VkAttachmentSampleCountInfoAMD*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
- {
- deepcopy_VkMultiviewPerViewAttributesInfoNVX(alloc, rootType, reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX*>(structExtension), reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
+ deepcopy_VkMultiviewPerViewAttributesInfoNVX(
+ alloc, rootType,
+ reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX*>(structExtension),
+ reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_memory_win32
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
- {
- deepcopy_VkImportMemoryWin32HandleInfoKHR(alloc, rootType, reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(structExtension), reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
+ deepcopy_VkImportMemoryWin32HandleInfoKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(structExtension),
+ reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
- {
- deepcopy_VkExportMemoryWin32HandleInfoKHR(alloc, rootType, reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(structExtension), reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
+ deepcopy_VkExportMemoryWin32HandleInfoKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(structExtension),
+ reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_memory_fd
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
- {
- deepcopy_VkImportMemoryFdInfoKHR(alloc, rootType, reinterpret_cast<const VkImportMemoryFdInfoKHR*>(structExtension), reinterpret_cast<VkImportMemoryFdInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: {
+ deepcopy_VkImportMemoryFdInfoKHR(
+ alloc, rootType, reinterpret_cast<const VkImportMemoryFdInfoKHR*>(structExtension),
+ reinterpret_cast<VkImportMemoryFdInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_win32_keyed_mutex
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
- {
- deepcopy_VkWin32KeyedMutexAcquireReleaseInfoKHR(alloc, rootType, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension), reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: {
+ deepcopy_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension),
+ reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_semaphore_win32
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
- {
- deepcopy_VkExportSemaphoreWin32HandleInfoKHR(alloc, rootType, reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(structExtension), reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: {
+ deepcopy_VkExportSemaphoreWin32HandleInfoKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(structExtension),
+ reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
- {
- deepcopy_VkD3D12FenceSubmitInfoKHR(alloc, rootType, reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(structExtension), reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: {
+ deepcopy_VkD3D12FenceSubmitInfoKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(structExtension),
+ reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_push_descriptor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
- {
- deepcopy_VkPhysicalDevicePushDescriptorPropertiesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: {
+ deepcopy_VkPhysicalDevicePushDescriptorPropertiesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_incremental_present
- case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
- {
- deepcopy_VkPresentRegionsKHR(alloc, rootType, reinterpret_cast<const VkPresentRegionsKHR*>(structExtension), reinterpret_cast<VkPresentRegionsKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: {
+ deepcopy_VkPresentRegionsKHR(
+ alloc, rootType, reinterpret_cast<const VkPresentRegionsKHR*>(structExtension),
+ reinterpret_cast<VkPresentRegionsKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shared_presentable_image
- case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
- {
- deepcopy_VkSharedPresentSurfaceCapabilitiesKHR(alloc, rootType, reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension), reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
+ deepcopy_VkSharedPresentSurfaceCapabilitiesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension),
+ reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_fence_win32
- case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
- {
- deepcopy_VkExportFenceWin32HandleInfoKHR(alloc, rootType, reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(structExtension), reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: {
+ deepcopy_VkExportFenceWin32HandleInfoKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(structExtension),
+ reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_performance_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
- {
- deepcopy_VkPhysicalDevicePerformanceQueryFeaturesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: {
+ deepcopy_VkPhysicalDevicePerformanceQueryFeaturesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
- {
- deepcopy_VkPhysicalDevicePerformanceQueryPropertiesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: {
+ deepcopy_VkPhysicalDevicePerformanceQueryPropertiesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
- {
- deepcopy_VkQueryPoolPerformanceCreateInfoKHR(alloc, rootType, reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(structExtension), reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: {
+ deepcopy_VkQueryPoolPerformanceCreateInfoKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(structExtension),
+ reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
- {
- deepcopy_VkPerformanceQuerySubmitInfoKHR(alloc, rootType, reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>(structExtension), reinterpret_cast<VkPerformanceQuerySubmitInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: {
+ deepcopy_VkPerformanceQuerySubmitInfoKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>(structExtension),
+ reinterpret_cast<VkPerformanceQuerySubmitInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_portability_subset
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
- {
- deepcopy_VkPhysicalDevicePortabilitySubsetFeaturesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
+ deepcopy_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
- {
- deepcopy_VkPhysicalDevicePortabilitySubsetPropertiesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
+ deepcopy_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shader_clock
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
- {
- deepcopy_VkPhysicalDeviceShaderClockFeaturesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
+ deepcopy_VkPhysicalDeviceShaderClockFeaturesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shader_terminate_invocation
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR:
- {
- deepcopy_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: {
+ deepcopy_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_fragment_shading_rate
- case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
- {
- deepcopy_VkFragmentShadingRateAttachmentInfoKHR(alloc, rootType, reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR*>(structExtension), reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
+ deepcopy_VkFragmentShadingRateAttachmentInfoKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR*>(structExtension),
+ reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
- {
- deepcopy_VkPipelineFragmentShadingRateStateCreateInfoKHR(alloc, rootType, reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR*>(structExtension), reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: {
+ deepcopy_VkPipelineFragmentShadingRateStateCreateInfoKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR*>(
+ structExtension),
+ reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
- {
- deepcopy_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: {
+ deepcopy_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
- {
- deepcopy_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: {
+ deepcopy_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_surface_protected_capabilities
- case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
- {
- deepcopy_VkSurfaceProtectedCapabilitiesKHR(alloc, rootType, reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(structExtension), reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: {
+ deepcopy_VkSurfaceProtectedCapabilitiesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(structExtension),
+ reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_present_wait
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
- {
- deepcopy_VkPhysicalDevicePresentWaitFeaturesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePresentWaitFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: {
+ deepcopy_VkPhysicalDevicePresentWaitFeaturesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR*>(structExtension),
+ reinterpret_cast<VkPhysicalDevicePresentWaitFeaturesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
- {
- deepcopy_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: {
+ deepcopy_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shader_integer_dot_product
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR:
- {
- deepcopy_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: {
+ deepcopy_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR:
- {
- deepcopy_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: {
+ deepcopy_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_present_id
- case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
- {
- deepcopy_VkPresentIdKHR(alloc, rootType, reinterpret_cast<const VkPresentIdKHR*>(structExtension), reinterpret_cast<VkPresentIdKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: {
+ deepcopy_VkPresentIdKHR(alloc, rootType,
+ reinterpret_cast<const VkPresentIdKHR*>(structExtension),
+ reinterpret_cast<VkPresentIdKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
- {
- deepcopy_VkPhysicalDevicePresentIdFeaturesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDevicePresentIdFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: {
+ deepcopy_VkPhysicalDevicePresentIdFeaturesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR*>(structExtension),
+ reinterpret_cast<VkPhysicalDevicePresentIdFeaturesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_video_encode_queue
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
- {
- deepcopy_VkVideoEncodeRateControlInfoKHR(alloc, rootType, reinterpret_cast<const VkVideoEncodeRateControlInfoKHR*>(structExtension), reinterpret_cast<VkVideoEncodeRateControlInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
+ deepcopy_VkVideoEncodeRateControlInfoKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoEncodeRateControlInfoKHR*>(structExtension),
+ reinterpret_cast<VkVideoEncodeRateControlInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_synchronization2
- case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR:
- {
- deepcopy_VkMemoryBarrier2KHR(alloc, rootType, reinterpret_cast<const VkMemoryBarrier2KHR*>(structExtension), reinterpret_cast<VkMemoryBarrier2KHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: {
+ deepcopy_VkMemoryBarrier2KHR(
+ alloc, rootType, reinterpret_cast<const VkMemoryBarrier2KHR*>(structExtension),
+ reinterpret_cast<VkMemoryBarrier2KHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR:
- {
- deepcopy_VkPhysicalDeviceSynchronization2FeaturesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceSynchronization2FeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceSynchronization2FeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: {
+ deepcopy_VkPhysicalDeviceSynchronization2FeaturesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSynchronization2FeaturesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceSynchronization2FeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
- {
- deepcopy_VkQueueFamilyCheckpointProperties2NV(alloc, rootType, reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension), reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
+ deepcopy_VkQueueFamilyCheckpointProperties2NV(
+ alloc, rootType,
+ reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension),
+ reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
- {
- deepcopy_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
+ deepcopy_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+ alloc, rootType,
+ reinterpret_cast<
+ const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR:
- {
- deepcopy_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: {
+ deepcopy_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
- {
- deepcopy_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
+ deepcopy_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_format_feature_flags2
- case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR:
- {
- deepcopy_VkFormatProperties3KHR(alloc, rootType, reinterpret_cast<const VkFormatProperties3KHR*>(structExtension), reinterpret_cast<VkFormatProperties3KHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: {
+ deepcopy_VkFormatProperties3KHR(
+ alloc, rootType, reinterpret_cast<const VkFormatProperties3KHR*>(structExtension),
+ reinterpret_cast<VkFormatProperties3KHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_maintenance4
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR:
- {
- deepcopy_VkPhysicalDeviceMaintenance4FeaturesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: {
+ deepcopy_VkPhysicalDeviceMaintenance4FeaturesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR:
- {
- deepcopy_VkPhysicalDeviceMaintenance4PropertiesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: {
+ deepcopy_VkPhysicalDeviceMaintenance4PropertiesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_ANDROID_native_buffer
- case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
- {
- deepcopy_VkNativeBufferANDROID(alloc, rootType, reinterpret_cast<const VkNativeBufferANDROID*>(structExtension), reinterpret_cast<VkNativeBufferANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
+ deepcopy_VkNativeBufferANDROID(
+ alloc, rootType, reinterpret_cast<const VkNativeBufferANDROID*>(structExtension),
+ reinterpret_cast<VkNativeBufferANDROID*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_debug_report
- case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
- {
- deepcopy_VkDebugReportCallbackCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(structExtension), reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: {
+ deepcopy_VkDebugReportCallbackCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(structExtension),
+ reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_rasterization_order
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
- {
- deepcopy_VkPipelineRasterizationStateRasterizationOrderAMD(alloc, rootType, reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension), reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: {
+ deepcopy_VkPipelineRasterizationStateRasterizationOrderAMD(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(
+ structExtension),
+ reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_dedicated_allocation
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
- {
- deepcopy_VkDedicatedAllocationImageCreateInfoNV(alloc, rootType, reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(structExtension), reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: {
+ deepcopy_VkDedicatedAllocationImageCreateInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(structExtension),
+ reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
- {
- deepcopy_VkDedicatedAllocationBufferCreateInfoNV(alloc, rootType, reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(structExtension), reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: {
+ deepcopy_VkDedicatedAllocationBufferCreateInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(structExtension),
+ reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
- {
- deepcopy_VkDedicatedAllocationMemoryAllocateInfoNV(alloc, rootType, reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension), reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: {
+ deepcopy_VkDedicatedAllocationMemoryAllocateInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension),
+ reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_transform_feedback
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceTransformFeedbackFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
- {
- deepcopy_VkPhysicalDeviceTransformFeedbackPropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: {
+ deepcopy_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
- {
- deepcopy_VkPipelineRasterizationStateStreamCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: {
+ deepcopy_VkPipelineRasterizationStateStreamCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_video_encode_h264
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT:
- {
- deepcopy_VkVideoEncodeH264CapabilitiesEXT(alloc, rootType, reinterpret_cast<const VkVideoEncodeH264CapabilitiesEXT*>(structExtension), reinterpret_cast<VkVideoEncodeH264CapabilitiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
+ deepcopy_VkVideoEncodeH264CapabilitiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoEncodeH264CapabilitiesEXT*>(structExtension),
+ reinterpret_cast<VkVideoEncodeH264CapabilitiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT:
- {
- deepcopy_VkVideoEncodeH264SessionCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension), reinterpret_cast<VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: {
+ deepcopy_VkVideoEncodeH264SessionCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension),
+ reinterpret_cast<VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- deepcopy_VkVideoEncodeH264SessionParametersAddInfoEXT(alloc, rootType, reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoEXT*>(structExtension), reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ deepcopy_VkVideoEncodeH264SessionParametersAddInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- deepcopy_VkVideoEncodeH264SessionParametersCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoEXT*>(structExtension), reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ deepcopy_VkVideoEncodeH264SessionParametersCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT:
- {
- deepcopy_VkVideoEncodeH264VclFrameInfoEXT(alloc, rootType, reinterpret_cast<const VkVideoEncodeH264VclFrameInfoEXT*>(structExtension), reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
+ deepcopy_VkVideoEncodeH264VclFrameInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoEncodeH264VclFrameInfoEXT*>(structExtension),
+ reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT:
- {
- deepcopy_VkVideoEncodeH264EmitPictureParametersEXT(alloc, rootType, reinterpret_cast<const VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension), reinterpret_cast<VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: {
+ deepcopy_VkVideoEncodeH264EmitPictureParametersEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension),
+ reinterpret_cast<VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT:
- {
- deepcopy_VkVideoEncodeH264ProfileEXT(alloc, rootType, reinterpret_cast<const VkVideoEncodeH264ProfileEXT*>(structExtension), reinterpret_cast<VkVideoEncodeH264ProfileEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT: {
+ deepcopy_VkVideoEncodeH264ProfileEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoEncodeH264ProfileEXT*>(structExtension),
+ reinterpret_cast<VkVideoEncodeH264ProfileEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_video_encode_h265
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT:
- {
- deepcopy_VkVideoEncodeH265CapabilitiesEXT(alloc, rootType, reinterpret_cast<const VkVideoEncodeH265CapabilitiesEXT*>(structExtension), reinterpret_cast<VkVideoEncodeH265CapabilitiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
+ deepcopy_VkVideoEncodeH265CapabilitiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoEncodeH265CapabilitiesEXT*>(structExtension),
+ reinterpret_cast<VkVideoEncodeH265CapabilitiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT:
- {
- deepcopy_VkVideoEncodeH265SessionCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension), reinterpret_cast<VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: {
+ deepcopy_VkVideoEncodeH265SessionCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension),
+ reinterpret_cast<VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- deepcopy_VkVideoEncodeH265SessionParametersAddInfoEXT(alloc, rootType, reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoEXT*>(structExtension), reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ deepcopy_VkVideoEncodeH265SessionParametersAddInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- deepcopy_VkVideoEncodeH265SessionParametersCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoEXT*>(structExtension), reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ deepcopy_VkVideoEncodeH265SessionParametersCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT:
- {
- deepcopy_VkVideoEncodeH265VclFrameInfoEXT(alloc, rootType, reinterpret_cast<const VkVideoEncodeH265VclFrameInfoEXT*>(structExtension), reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
+ deepcopy_VkVideoEncodeH265VclFrameInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoEncodeH265VclFrameInfoEXT*>(structExtension),
+ reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT:
- {
- deepcopy_VkVideoEncodeH265EmitPictureParametersEXT(alloc, rootType, reinterpret_cast<const VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension), reinterpret_cast<VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: {
+ deepcopy_VkVideoEncodeH265EmitPictureParametersEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension),
+ reinterpret_cast<VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT:
- {
- deepcopy_VkVideoEncodeH265ProfileEXT(alloc, rootType, reinterpret_cast<const VkVideoEncodeH265ProfileEXT*>(structExtension), reinterpret_cast<VkVideoEncodeH265ProfileEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT: {
+ deepcopy_VkVideoEncodeH265ProfileEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoEncodeH265ProfileEXT*>(structExtension),
+ reinterpret_cast<VkVideoEncodeH265ProfileEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_video_decode_h264
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT:
- {
- deepcopy_VkVideoDecodeH264ProfileEXT(alloc, rootType, reinterpret_cast<const VkVideoDecodeH264ProfileEXT*>(structExtension), reinterpret_cast<VkVideoDecodeH264ProfileEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT: {
+ deepcopy_VkVideoDecodeH264ProfileEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoDecodeH264ProfileEXT*>(structExtension),
+ reinterpret_cast<VkVideoDecodeH264ProfileEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT:
- {
- deepcopy_VkVideoDecodeH264CapabilitiesEXT(alloc, rootType, reinterpret_cast<const VkVideoDecodeH264CapabilitiesEXT*>(structExtension), reinterpret_cast<VkVideoDecodeH264CapabilitiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: {
+ deepcopy_VkVideoDecodeH264CapabilitiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoDecodeH264CapabilitiesEXT*>(structExtension),
+ reinterpret_cast<VkVideoDecodeH264CapabilitiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT:
- {
- deepcopy_VkVideoDecodeH264SessionCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension), reinterpret_cast<VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: {
+ deepcopy_VkVideoDecodeH264SessionCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension),
+ reinterpret_cast<VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- deepcopy_VkVideoDecodeH264SessionParametersAddInfoEXT(alloc, rootType, reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoEXT*>(structExtension), reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ deepcopy_VkVideoDecodeH264SessionParametersAddInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- deepcopy_VkVideoDecodeH264SessionParametersCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoEXT*>(structExtension), reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ deepcopy_VkVideoDecodeH264SessionParametersCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT:
- {
- deepcopy_VkVideoDecodeH264PictureInfoEXT(alloc, rootType, reinterpret_cast<const VkVideoDecodeH264PictureInfoEXT*>(structExtension), reinterpret_cast<VkVideoDecodeH264PictureInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: {
+ deepcopy_VkVideoDecodeH264PictureInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoDecodeH264PictureInfoEXT*>(structExtension),
+ reinterpret_cast<VkVideoDecodeH264PictureInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT:
- {
- deepcopy_VkVideoDecodeH264MvcEXT(alloc, rootType, reinterpret_cast<const VkVideoDecodeH264MvcEXT*>(structExtension), reinterpret_cast<VkVideoDecodeH264MvcEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT: {
+ deepcopy_VkVideoDecodeH264MvcEXT(
+ alloc, rootType, reinterpret_cast<const VkVideoDecodeH264MvcEXT*>(structExtension),
+ reinterpret_cast<VkVideoDecodeH264MvcEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT:
- {
- deepcopy_VkVideoDecodeH264DpbSlotInfoEXT(alloc, rootType, reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension), reinterpret_cast<VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: {
+ deepcopy_VkVideoDecodeH264DpbSlotInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension),
+ reinterpret_cast<VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_texture_gather_bias_lod
- case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
- {
- deepcopy_VkTextureLODGatherFormatPropertiesAMD(alloc, rootType, reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(structExtension), reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
+ deepcopy_VkTextureLODGatherFormatPropertiesAMD(
+ alloc, rootType,
+ reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(structExtension),
+ reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_corner_sampled_image
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
- {
- deepcopy_VkPhysicalDeviceCornerSampledImageFeaturesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: {
+ deepcopy_VkPhysicalDeviceCornerSampledImageFeaturesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_external_memory
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
- {
- deepcopy_VkExternalMemoryImageCreateInfoNV(alloc, rootType, reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(structExtension), reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: {
+ deepcopy_VkExternalMemoryImageCreateInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(structExtension),
+ reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
- {
- deepcopy_VkExportMemoryAllocateInfoNV(alloc, rootType, reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(structExtension), reinterpret_cast<VkExportMemoryAllocateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: {
+ deepcopy_VkExportMemoryAllocateInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(structExtension),
+ reinterpret_cast<VkExportMemoryAllocateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_external_memory_win32
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
- {
- deepcopy_VkImportMemoryWin32HandleInfoNV(alloc, rootType, reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(structExtension), reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
+ deepcopy_VkImportMemoryWin32HandleInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(structExtension),
+ reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
- {
- deepcopy_VkExportMemoryWin32HandleInfoNV(alloc, rootType, reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(structExtension), reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
+ deepcopy_VkExportMemoryWin32HandleInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(structExtension),
+ reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_win32_keyed_mutex
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
- {
- deepcopy_VkWin32KeyedMutexAcquireReleaseInfoNV(alloc, rootType, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension), reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: {
+ deepcopy_VkWin32KeyedMutexAcquireReleaseInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension),
+ reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_validation_flags
- case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
- {
- deepcopy_VkValidationFlagsEXT(alloc, rootType, reinterpret_cast<const VkValidationFlagsEXT*>(structExtension), reinterpret_cast<VkValidationFlagsEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: {
+ deepcopy_VkValidationFlagsEXT(
+ alloc, rootType, reinterpret_cast<const VkValidationFlagsEXT*>(structExtension),
+ reinterpret_cast<VkValidationFlagsEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_astc_decode_mode
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
- {
- deepcopy_VkImageViewASTCDecodeModeEXT(alloc, rootType, reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(structExtension), reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
+ deepcopy_VkImageViewASTCDecodeModeEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(structExtension),
+ reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceASTCDecodeFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceASTCDecodeFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_conditional_rendering
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceConditionalRenderingFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
- {
- deepcopy_VkCommandBufferInheritanceConditionalRenderingInfoEXT(alloc, rootType, reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension), reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: {
+ deepcopy_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_clip_space_w_scaling
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
- {
- deepcopy_VkPipelineViewportWScalingStateCreateInfoNV(alloc, rootType, reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: {
+ deepcopy_VkPipelineViewportWScalingStateCreateInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(
+ structExtension),
+ reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_display_control
- case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
- {
- deepcopy_VkSwapchainCounterCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(structExtension), reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: {
+ deepcopy_VkSwapchainCounterCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(structExtension),
+ reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_GOOGLE_display_timing
- case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
- {
- deepcopy_VkPresentTimesInfoGOOGLE(alloc, rootType, reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(structExtension), reinterpret_cast<VkPresentTimesInfoGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: {
+ deepcopy_VkPresentTimesInfoGOOGLE(
+ alloc, rootType, reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(structExtension),
+ reinterpret_cast<VkPresentTimesInfoGOOGLE*>(structExtension_out));
break;
}
#endif
#ifdef VK_NVX_multiview_per_view_attributes
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
- {
- deepcopy_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension), reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: {
+ deepcopy_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_viewport_swizzle
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
- {
- deepcopy_VkPipelineViewportSwizzleStateCreateInfoNV(alloc, rootType, reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: {
+ deepcopy_VkPipelineViewportSwizzleStateCreateInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(
+ structExtension),
+ reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_discard_rectangles
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
- {
- deepcopy_VkPhysicalDeviceDiscardRectanglePropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: {
+ deepcopy_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
- {
- deepcopy_VkPipelineDiscardRectangleStateCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: {
+ deepcopy_VkPipelineDiscardRectangleStateCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_conservative_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
- {
- deepcopy_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: {
+ deepcopy_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
- {
- deepcopy_VkPipelineRasterizationConservativeStateCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: {
+ deepcopy_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_depth_clip_enable
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceDepthClipEnableFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
- {
- deepcopy_VkPipelineRasterizationDepthClipStateCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ deepcopy_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_debug_utils
- case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
- {
- deepcopy_VkDebugUtilsMessengerCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(structExtension), reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
+ deepcopy_VkDebugUtilsMessengerCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(structExtension),
+ reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
- {
- deepcopy_VkAndroidHardwareBufferUsageANDROID(alloc, rootType, reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(structExtension), reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: {
+ deepcopy_VkAndroidHardwareBufferUsageANDROID(
+ alloc, rootType,
+ reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(structExtension),
+ reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
- {
- deepcopy_VkAndroidHardwareBufferFormatPropertiesANDROID(alloc, rootType, reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension), reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: {
+ deepcopy_VkAndroidHardwareBufferFormatPropertiesANDROID(
+ alloc, rootType,
+ reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(
+ structExtension),
+ reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
- {
- deepcopy_VkImportAndroidHardwareBufferInfoANDROID(alloc, rootType, reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension), reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: {
+ deepcopy_VkImportAndroidHardwareBufferInfoANDROID(
+ alloc, rootType,
+ reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension),
+ reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
- {
- deepcopy_VkExternalFormatANDROID(alloc, rootType, reinterpret_cast<const VkExternalFormatANDROID*>(structExtension), reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: {
+ deepcopy_VkExternalFormatANDROID(
+ alloc, rootType, reinterpret_cast<const VkExternalFormatANDROID*>(structExtension),
+ reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
- {
- deepcopy_VkAndroidHardwareBufferFormatProperties2ANDROID(alloc, rootType, reinterpret_cast<const VkAndroidHardwareBufferFormatProperties2ANDROID*>(structExtension), reinterpret_cast<VkAndroidHardwareBufferFormatProperties2ANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: {
+ deepcopy_VkAndroidHardwareBufferFormatProperties2ANDROID(
+ alloc, rootType,
+ reinterpret_cast<const VkAndroidHardwareBufferFormatProperties2ANDROID*>(
+ structExtension),
+ reinterpret_cast<VkAndroidHardwareBufferFormatProperties2ANDROID*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_inline_uniform_block
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
- {
- deepcopy_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
+ deepcopy_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT:
- {
- deepcopy_VkWriteDescriptorSetInlineUniformBlockEXT(alloc, rootType, reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension), reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
+ deepcopy_VkWriteDescriptorSetInlineUniformBlockEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension),
+ reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT:
- {
- deepcopy_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(structExtension), reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
+ deepcopy_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_sample_locations
- case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
- {
- deepcopy_VkSampleLocationsInfoEXT(alloc, rootType, reinterpret_cast<const VkSampleLocationsInfoEXT*>(structExtension), reinterpret_cast<VkSampleLocationsInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
+ deepcopy_VkSampleLocationsInfoEXT(
+ alloc, rootType, reinterpret_cast<const VkSampleLocationsInfoEXT*>(structExtension),
+ reinterpret_cast<VkSampleLocationsInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
- {
- deepcopy_VkRenderPassSampleLocationsBeginInfoEXT(alloc, rootType, reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension), reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: {
+ deepcopy_VkRenderPassSampleLocationsBeginInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension),
+ reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
- {
- deepcopy_VkPipelineSampleLocationsStateCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: {
+ deepcopy_VkPipelineSampleLocationsStateCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
- {
- deepcopy_VkPhysicalDeviceSampleLocationsPropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: {
+ deepcopy_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_blend_operation_advanced
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
- {
- deepcopy_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: {
+ deepcopy_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
- {
- deepcopy_VkPipelineColorBlendAdvancedStateCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: {
+ deepcopy_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_fragment_coverage_to_color
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
- {
- deepcopy_VkPipelineCoverageToColorStateCreateInfoNV(alloc, rootType, reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: {
+ deepcopy_VkPipelineCoverageToColorStateCreateInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(
+ structExtension),
+ reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_framebuffer_mixed_samples
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
- {
- deepcopy_VkPipelineCoverageModulationStateCreateInfoNV(alloc, rootType, reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: {
+ deepcopy_VkPipelineCoverageModulationStateCreateInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(
+ structExtension),
+ reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_shader_sm_builtins
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
- {
- deepcopy_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: {
+ deepcopy_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
- {
- deepcopy_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: {
+ deepcopy_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_image_drm_format_modifier
- case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
- {
- deepcopy_VkDrmFormatModifierPropertiesListEXT(alloc, rootType, reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(structExtension), reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: {
+ deepcopy_VkDrmFormatModifierPropertiesListEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(structExtension),
+ reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
- {
- deepcopy_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: {
+ deepcopy_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
- {
- deepcopy_VkImageDrmFormatModifierListCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension), reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: {
+ deepcopy_VkImageDrmFormatModifierListCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension),
+ reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
- {
- deepcopy_VkImageDrmFormatModifierExplicitCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension), reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: {
+ deepcopy_VkImageDrmFormatModifierExplicitCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
- {
- deepcopy_VkDrmFormatModifierPropertiesList2EXT(alloc, rootType, reinterpret_cast<const VkDrmFormatModifierPropertiesList2EXT*>(structExtension), reinterpret_cast<VkDrmFormatModifierPropertiesList2EXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: {
+ deepcopy_VkDrmFormatModifierPropertiesList2EXT(
+ alloc, rootType,
+ reinterpret_cast<const VkDrmFormatModifierPropertiesList2EXT*>(structExtension),
+ reinterpret_cast<VkDrmFormatModifierPropertiesList2EXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_validation_cache
- case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
- {
- deepcopy_VkShaderModuleValidationCacheCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension), reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: {
+ deepcopy_VkShaderModuleValidationCacheCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_shading_rate_image
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
- {
- deepcopy_VkPipelineViewportShadingRateImageStateCreateInfoNV(alloc, rootType, reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: {
+ deepcopy_VkPipelineViewportShadingRateImageStateCreateInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(
+ structExtension),
+ reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
- {
- deepcopy_VkPhysicalDeviceShadingRateImageFeaturesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: {
+ deepcopy_VkPhysicalDeviceShadingRateImageFeaturesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
- {
- deepcopy_VkPhysicalDeviceShadingRateImagePropertiesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: {
+ deepcopy_VkPhysicalDeviceShadingRateImagePropertiesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
- {
- deepcopy_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(alloc, rootType, reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: {
+ deepcopy_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(
+ structExtension),
+ reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_ray_tracing
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
- {
- deepcopy_VkWriteDescriptorSetAccelerationStructureNV(alloc, rootType, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(structExtension), reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: {
+ deepcopy_VkWriteDescriptorSetAccelerationStructureNV(
+ alloc, rootType,
+ reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(
+ structExtension),
+ reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
- {
- deepcopy_VkPhysicalDeviceRayTracingPropertiesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: {
+ deepcopy_VkPhysicalDeviceRayTracingPropertiesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_representative_fragment_test
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
- {
- deepcopy_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: {
+ deepcopy_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
- {
- deepcopy_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(alloc, rootType, reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: {
+ deepcopy_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(
+ structExtension),
+ reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_filter_cubic
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
- {
- deepcopy_VkPhysicalDeviceImageViewImageFormatInfoEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: {
+ deepcopy_VkPhysicalDeviceImageViewImageFormatInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
- {
- deepcopy_VkFilterCubicImageViewImageFormatPropertiesEXT(alloc, rootType, reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>(structExtension), reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: {
+ deepcopy_VkFilterCubicImageViewImageFormatPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>(
+ structExtension),
+ reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_global_priority
- case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
- {
- deepcopy_VkDeviceQueueGlobalPriorityCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension), reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
+ deepcopy_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension),
+ reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_external_memory_host
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
- {
- deepcopy_VkImportMemoryHostPointerInfoEXT(alloc, rootType, reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(structExtension), reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
+ deepcopy_VkImportMemoryHostPointerInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(structExtension),
+ reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
- {
- deepcopy_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: {
+ deepcopy_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_AMD_pipeline_compiler_control
- case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
- {
- deepcopy_VkPipelineCompilerControlCreateInfoAMD(alloc, rootType, reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>(structExtension), reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: {
+ deepcopy_VkPipelineCompilerControlCreateInfoAMD(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>(structExtension),
+ reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_shader_core_properties
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
- {
- deepcopy_VkPhysicalDeviceShaderCorePropertiesAMD(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: {
+ deepcopy_VkPhysicalDeviceShaderCorePropertiesAMD(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_video_decode_h265
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT:
- {
- deepcopy_VkVideoDecodeH265ProfileEXT(alloc, rootType, reinterpret_cast<const VkVideoDecodeH265ProfileEXT*>(structExtension), reinterpret_cast<VkVideoDecodeH265ProfileEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT: {
+ deepcopy_VkVideoDecodeH265ProfileEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoDecodeH265ProfileEXT*>(structExtension),
+ reinterpret_cast<VkVideoDecodeH265ProfileEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT:
- {
- deepcopy_VkVideoDecodeH265CapabilitiesEXT(alloc, rootType, reinterpret_cast<const VkVideoDecodeH265CapabilitiesEXT*>(structExtension), reinterpret_cast<VkVideoDecodeH265CapabilitiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: {
+ deepcopy_VkVideoDecodeH265CapabilitiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoDecodeH265CapabilitiesEXT*>(structExtension),
+ reinterpret_cast<VkVideoDecodeH265CapabilitiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT:
- {
- deepcopy_VkVideoDecodeH265SessionCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension), reinterpret_cast<VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: {
+ deepcopy_VkVideoDecodeH265SessionCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension),
+ reinterpret_cast<VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- deepcopy_VkVideoDecodeH265SessionParametersAddInfoEXT(alloc, rootType, reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoEXT*>(structExtension), reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ deepcopy_VkVideoDecodeH265SessionParametersAddInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- deepcopy_VkVideoDecodeH265SessionParametersCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoEXT*>(structExtension), reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ deepcopy_VkVideoDecodeH265SessionParametersCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT:
- {
- deepcopy_VkVideoDecodeH265PictureInfoEXT(alloc, rootType, reinterpret_cast<const VkVideoDecodeH265PictureInfoEXT*>(structExtension), reinterpret_cast<VkVideoDecodeH265PictureInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: {
+ deepcopy_VkVideoDecodeH265PictureInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoDecodeH265PictureInfoEXT*>(structExtension),
+ reinterpret_cast<VkVideoDecodeH265PictureInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT:
- {
- deepcopy_VkVideoDecodeH265DpbSlotInfoEXT(alloc, rootType, reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension), reinterpret_cast<VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: {
+ deepcopy_VkVideoDecodeH265DpbSlotInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension),
+ reinterpret_cast<VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_memory_overallocation_behavior
- case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
- {
- deepcopy_VkDeviceMemoryOverallocationCreateInfoAMD(alloc, rootType, reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension), reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
+ deepcopy_VkDeviceMemoryOverallocationCreateInfoAMD(
+ alloc, rootType,
+ reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension),
+ reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_vertex_attribute_divisor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
- {
- deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
+ deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
- {
- deepcopy_VkPipelineVertexInputDivisorStateCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: {
+ deepcopy_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_GGP_frame_token
- case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
- {
- deepcopy_VkPresentFrameTokenGGP(alloc, rootType, reinterpret_cast<const VkPresentFrameTokenGGP*>(structExtension), reinterpret_cast<VkPresentFrameTokenGGP*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: {
+ deepcopy_VkPresentFrameTokenGGP(
+ alloc, rootType, reinterpret_cast<const VkPresentFrameTokenGGP*>(structExtension),
+ reinterpret_cast<VkPresentFrameTokenGGP*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_pipeline_creation_feedback
- case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT:
- {
- deepcopy_VkPipelineCreationFeedbackCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
+ deepcopy_VkPipelineCreationFeedbackCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension),
+ reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_compute_shader_derivatives
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
- {
- deepcopy_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
+ deepcopy_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_mesh_shader
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
- {
- deepcopy_VkPhysicalDeviceMeshShaderFeaturesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: {
+ deepcopy_VkPhysicalDeviceMeshShaderFeaturesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
- {
- deepcopy_VkPhysicalDeviceMeshShaderPropertiesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: {
+ deepcopy_VkPhysicalDeviceMeshShaderPropertiesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_fragment_shader_barycentric
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV:
- {
- deepcopy_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
+ deepcopy_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_shader_image_footprint
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
- {
- deepcopy_VkPhysicalDeviceShaderImageFootprintFeaturesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
+ deepcopy_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_scissor_exclusive
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
- {
- deepcopy_VkPipelineViewportExclusiveScissorStateCreateInfoNV(alloc, rootType, reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: {
+ deepcopy_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(
+ structExtension),
+ reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
- {
- deepcopy_VkPhysicalDeviceExclusiveScissorFeaturesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: {
+ deepcopy_VkPhysicalDeviceExclusiveScissorFeaturesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
- {
- deepcopy_VkQueueFamilyCheckpointPropertiesNV(alloc, rootType, reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(structExtension), reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: {
+ deepcopy_VkQueueFamilyCheckpointPropertiesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(structExtension),
+ reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_INTEL_shader_integer_functions2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
- {
- deepcopy_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: {
+ deepcopy_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_INTEL_performance_query
- case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
- {
- deepcopy_VkQueryPoolPerformanceQueryCreateInfoINTEL(alloc, rootType, reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension), reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: {
+ deepcopy_VkQueryPoolPerformanceQueryCreateInfoINTEL(
+ alloc, rootType,
+ reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>(
+ structExtension),
+ reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_pci_bus_info
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
- {
- deepcopy_VkPhysicalDevicePCIBusInfoPropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: {
+ deepcopy_VkPhysicalDevicePCIBusInfoPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension),
+ reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_display_native_hdr
- case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
- {
- deepcopy_VkDisplayNativeHdrSurfaceCapabilitiesAMD(alloc, rootType, reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension), reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: {
+ deepcopy_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
+ alloc, rootType,
+ reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension),
+ reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
- {
- deepcopy_VkSwapchainDisplayNativeHdrCreateInfoAMD(alloc, rootType, reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension), reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: {
+ deepcopy_VkSwapchainDisplayNativeHdrCreateInfoAMD(
+ alloc, rootType,
+ reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension),
+ reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_fragment_density_map
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
- {
- deepcopy_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
+ deepcopy_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
- {
- deepcopy_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: {
+ deepcopy_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
- deepcopy_VkImportColorBufferGOOGLE(alloc, rootType, reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension), reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
+ deepcopy_VkImportColorBufferGOOGLE(
+ alloc, rootType,
+ reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension),
+ reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
break;
}
- default:
- {
- deepcopy_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension_out));
+ default: {
+ deepcopy_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension_out));
break;
}
}
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2:
- {
- deepcopy_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: {
+ deepcopy_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
- deepcopy_VkImportPhysicalAddressGOOGLE(alloc, rootType, reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension), reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
+ deepcopy_VkImportPhysicalAddressGOOGLE(
+ alloc, rootType,
+ reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension),
+ reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
break;
}
- default:
- {
- deepcopy_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension_out));
+ default: {
+ deepcopy_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
+ structExtension_out));
break;
}
}
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
- {
- deepcopy_VkRenderPassFragmentDensityMapCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension), reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: {
+ deepcopy_VkRenderPassFragmentDensityMapCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2:
- {
- deepcopy_VkRenderPassFragmentDensityMapCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension), reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: {
+ deepcopy_VkRenderPassFragmentDensityMapCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
- deepcopy_VkImportBufferGOOGLE(alloc, rootType, reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension), reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
+ deepcopy_VkImportBufferGOOGLE(
+ alloc, rootType,
+ reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension),
+ reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
break;
}
- default:
- {
- deepcopy_VkRenderPassFragmentDensityMapCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension), reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension_out));
+ default: {
+ deepcopy_VkRenderPassFragmentDensityMapCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension_out));
break;
}
}
@@ -23226,627 +20114,947 @@
}
#endif
#ifdef VK_EXT_subgroup_size_control
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
- {
- deepcopy_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: {
+ deepcopy_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:
- {
- deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: {
+ deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_AMD_shader_core_properties2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
- {
- deepcopy_VkPhysicalDeviceShaderCoreProperties2AMD(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
+ deepcopy_VkPhysicalDeviceShaderCoreProperties2AMD(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_device_coherent_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
- {
- deepcopy_VkPhysicalDeviceCoherentMemoryFeaturesAMD(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension), reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: {
+ deepcopy_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_shader_image_atomic_int64
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_memory_budget
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
- {
- deepcopy_VkPhysicalDeviceMemoryBudgetPropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: {
+ deepcopy_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_memory_priority
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceMemoryPriorityFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
- {
- deepcopy_VkMemoryPriorityAllocateInfoEXT(alloc, rootType, reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>(structExtension), reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: {
+ deepcopy_VkMemoryPriorityAllocateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>(structExtension),
+ reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
- {
- deepcopy_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: {
+ deepcopy_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_buffer_device_address
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
- {
- deepcopy_VkBufferDeviceAddressCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>(structExtension), reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: {
+ deepcopy_VkBufferDeviceAddressCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>(structExtension),
+ reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_validation_features
- case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
- {
- deepcopy_VkValidationFeaturesEXT(alloc, rootType, reinterpret_cast<const VkValidationFeaturesEXT*>(structExtension), reinterpret_cast<VkValidationFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: {
+ deepcopy_VkValidationFeaturesEXT(
+ alloc, rootType, reinterpret_cast<const VkValidationFeaturesEXT*>(structExtension),
+ reinterpret_cast<VkValidationFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_cooperative_matrix
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
- {
- deepcopy_VkPhysicalDeviceCooperativeMatrixFeaturesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: {
+ deepcopy_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
- {
- deepcopy_VkPhysicalDeviceCooperativeMatrixPropertiesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: {
+ deepcopy_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_coverage_reduction_mode
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
- {
- deepcopy_VkPhysicalDeviceCoverageReductionModeFeaturesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: {
+ deepcopy_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
- {
- deepcopy_VkPipelineCoverageReductionStateCreateInfoNV(alloc, rootType, reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: {
+ deepcopy_VkPipelineCoverageReductionStateCreateInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>(
+ structExtension),
+ reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_fragment_shader_interlock
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_ycbcr_image_arrays
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_provoking_vertex
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceProvokingVertexFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceProvokingVertexFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
- {
- deepcopy_VkPhysicalDeviceProvokingVertexPropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceProvokingVertexPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: {
+ deepcopy_VkPhysicalDeviceProvokingVertexPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceProvokingVertexPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
- {
- deepcopy_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: {
+ deepcopy_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_full_screen_exclusive
- case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
- {
- deepcopy_VkSurfaceFullScreenExclusiveInfoEXT(alloc, rootType, reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension), reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: {
+ deepcopy_VkSurfaceFullScreenExclusiveInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension),
+ reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
- {
- deepcopy_VkSurfaceCapabilitiesFullScreenExclusiveEXT(alloc, rootType, reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(structExtension), reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: {
+ deepcopy_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(
+ structExtension),
+ reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
- {
- deepcopy_VkSurfaceFullScreenExclusiveWin32InfoEXT(alloc, rootType, reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension), reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: {
+ deepcopy_VkSurfaceFullScreenExclusiveWin32InfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension),
+ reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_line_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceLineRasterizationFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceLineRasterizationFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
- {
- deepcopy_VkPhysicalDeviceLineRasterizationPropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: {
+ deepcopy_VkPhysicalDeviceLineRasterizationPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
- {
- deepcopy_VkPipelineRasterizationLineStateCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: {
+ deepcopy_VkPipelineRasterizationLineStateCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_shader_atomic_float
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_index_type_uint8
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_shader_atomic_float2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_device_generated_commands
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
- {
- deepcopy_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: {
+ deepcopy_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
- {
- deepcopy_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: {
+ deepcopy_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
- {
- deepcopy_VkGraphicsPipelineShaderGroupsCreateInfoNV(alloc, rootType, reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension), reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: {
+ deepcopy_VkGraphicsPipelineShaderGroupsCreateInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(
+ structExtension),
+ reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_inherited_viewport_scissor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
- {
- deepcopy_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: {
+ deepcopy_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
- {
- deepcopy_VkCommandBufferInheritanceViewportScissorInfoNV(alloc, rootType, reinterpret_cast<const VkCommandBufferInheritanceViewportScissorInfoNV*>(structExtension), reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: {
+ deepcopy_VkCommandBufferInheritanceViewportScissorInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkCommandBufferInheritanceViewportScissorInfoNV*>(
+ structExtension),
+ reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_texel_buffer_alignment
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
- {
- deepcopy_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
+ deepcopy_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_QCOM_render_pass_transform
- case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
- {
- deepcopy_VkRenderPassTransformBeginInfoQCOM(alloc, rootType, reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>(structExtension), reinterpret_cast<VkRenderPassTransformBeginInfoQCOM*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
+ deepcopy_VkRenderPassTransformBeginInfoQCOM(
+ alloc, rootType,
+ reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>(structExtension),
+ reinterpret_cast<VkRenderPassTransformBeginInfoQCOM*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
- {
- deepcopy_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(alloc, rootType, reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(structExtension), reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: {
+ deepcopy_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
+ alloc, rootType,
+ reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(
+ structExtension),
+ reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_device_memory_report
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
- {
- deepcopy_VkDeviceDeviceMemoryReportCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension), reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: {
+ deepcopy_VkDeviceDeviceMemoryReportCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension),
+ reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_robustness2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceRobustness2FeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceRobustness2FeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
- {
- deepcopy_VkPhysicalDeviceRobustness2PropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: {
+ deepcopy_VkPhysicalDeviceRobustness2PropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_custom_border_color
- case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
- {
- deepcopy_VkSamplerCustomBorderColorCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension), reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: {
+ deepcopy_VkSamplerCustomBorderColorCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension),
+ reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
- {
- deepcopy_VkPhysicalDeviceCustomBorderColorPropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: {
+ deepcopy_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceCustomBorderColorFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_private_data
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDevicePrivateDataFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
+ deepcopy_VkPhysicalDevicePrivateDataFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension),
+ reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
- {
- deepcopy_VkDevicePrivateDataCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkDevicePrivateDataCreateInfoEXT*>(structExtension), reinterpret_cast<VkDevicePrivateDataCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: {
+ deepcopy_VkDevicePrivateDataCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkDevicePrivateDataCreateInfoEXT*>(structExtension),
+ reinterpret_cast<VkDevicePrivateDataCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
+ deepcopy_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_device_diagnostics_config
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
- {
- deepcopy_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: {
+ deepcopy_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
- {
- deepcopy_VkDeviceDiagnosticsConfigCreateInfoNV(alloc, rootType, reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension), reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: {
+ deepcopy_VkDeviceDiagnosticsConfigCreateInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension),
+ reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_fragment_shading_rate_enums
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
- {
- deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
+ deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
- {
- deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: {
+ deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
- {
- deepcopy_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(alloc, rootType, reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(structExtension), reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: {
+ deepcopy_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(
+ structExtension),
+ reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_ray_tracing_motion_blur
- case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
- {
- deepcopy_VkAccelerationStructureGeometryMotionTrianglesDataNV(alloc, rootType, reinterpret_cast<const VkAccelerationStructureGeometryMotionTrianglesDataNV*>(structExtension), reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: {
+ deepcopy_VkAccelerationStructureGeometryMotionTrianglesDataNV(
+ alloc, rootType,
+ reinterpret_cast<const VkAccelerationStructureGeometryMotionTrianglesDataNV*>(
+ structExtension),
+ reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
- {
- deepcopy_VkAccelerationStructureMotionInfoNV(alloc, rootType, reinterpret_cast<const VkAccelerationStructureMotionInfoNV*>(structExtension), reinterpret_cast<VkAccelerationStructureMotionInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: {
+ deepcopy_VkAccelerationStructureMotionInfoNV(
+ alloc, rootType,
+ reinterpret_cast<const VkAccelerationStructureMotionInfoNV*>(structExtension),
+ reinterpret_cast<VkAccelerationStructureMotionInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
- {
- deepcopy_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: {
+ deepcopy_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_fragment_density_map2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
- {
- deepcopy_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: {
+ deepcopy_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_QCOM_rotated_copy_commands
- case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
- {
- deepcopy_VkCopyCommandTransformInfoQCOM(alloc, rootType, reinterpret_cast<const VkCopyCommandTransformInfoQCOM*>(structExtension), reinterpret_cast<VkCopyCommandTransformInfoQCOM*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: {
+ deepcopy_VkCopyCommandTransformInfoQCOM(
+ alloc, rootType,
+ reinterpret_cast<const VkCopyCommandTransformInfoQCOM*>(structExtension),
+ reinterpret_cast<VkCopyCommandTransformInfoQCOM*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_image_robustness
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceImageRobustnessFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_4444_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDevice4444FormatsFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: {
+ deepcopy_VkPhysicalDevice4444FormatsFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension),
+ reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_rgba10x6_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_VALVE_mutable_descriptor_type
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE:
- {
- deepcopy_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(structExtension), reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: {
+ deepcopy_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE:
- {
- deepcopy_VkMutableDescriptorTypeCreateInfoVALVE(alloc, rootType, reinterpret_cast<const VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension), reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: {
+ deepcopy_VkMutableDescriptorTypeCreateInfoVALVE(
+ alloc, rootType,
+ reinterpret_cast<const VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension),
+ reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_physical_device_drm
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
- {
- deepcopy_VkPhysicalDeviceDrmPropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceDrmPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceDrmPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: {
+ deepcopy_VkPhysicalDeviceDrmPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDrmPropertiesEXT*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceDrmPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_primitive_topology_list_restart
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
+ deepcopy_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_FUCHSIA_external_memory
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
- {
- deepcopy_VkImportMemoryZirconHandleInfoFUCHSIA(alloc, rootType, reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA*>(structExtension), reinterpret_cast<VkImportMemoryZirconHandleInfoFUCHSIA*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: {
+ deepcopy_VkImportMemoryZirconHandleInfoFUCHSIA(
+ alloc, rootType,
+ reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA*>(structExtension),
+ reinterpret_cast<VkImportMemoryZirconHandleInfoFUCHSIA*>(structExtension_out));
break;
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
- {
- deepcopy_VkImportMemoryBufferCollectionFUCHSIA(alloc, rootType, reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIA*>(structExtension), reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIA*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: {
+ deepcopy_VkImportMemoryBufferCollectionFUCHSIA(
+ alloc, rootType,
+ reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIA*>(structExtension),
+ reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIA*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
- {
- deepcopy_VkBufferCollectionImageCreateInfoFUCHSIA(alloc, rootType, reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIA*>(structExtension), reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: {
+ deepcopy_VkBufferCollectionImageCreateInfoFUCHSIA(
+ alloc, rootType,
+ reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIA*>(structExtension),
+ reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
- {
- deepcopy_VkBufferCollectionBufferCreateInfoFUCHSIA(alloc, rootType, reinterpret_cast<const VkBufferCollectionBufferCreateInfoFUCHSIA*>(structExtension), reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: {
+ deepcopy_VkBufferCollectionBufferCreateInfoFUCHSIA(
+ alloc, rootType,
+ reinterpret_cast<const VkBufferCollectionBufferCreateInfoFUCHSIA*>(structExtension),
+ reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA*>(structExtension_out));
break;
}
#endif
#ifdef VK_HUAWEI_subpass_shading
- case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
- {
- deepcopy_VkSubpassShadingPipelineCreateInfoHUAWEI(alloc, rootType, reinterpret_cast<const VkSubpassShadingPipelineCreateInfoHUAWEI*>(structExtension), reinterpret_cast<VkSubpassShadingPipelineCreateInfoHUAWEI*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: {
+ deepcopy_VkSubpassShadingPipelineCreateInfoHUAWEI(
+ alloc, rootType,
+ reinterpret_cast<const VkSubpassShadingPipelineCreateInfoHUAWEI*>(structExtension),
+ reinterpret_cast<VkSubpassShadingPipelineCreateInfoHUAWEI*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
- {
- deepcopy_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(structExtension), reinterpret_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: {
+ deepcopy_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
- {
- deepcopy_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(structExtension), reinterpret_cast<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: {
+ deepcopy_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_HUAWEI_invocation_mask
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
- {
- deepcopy_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(structExtension), reinterpret_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: {
+ deepcopy_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_external_memory_rdma
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
- {
- deepcopy_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(structExtension), reinterpret_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: {
+ deepcopy_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_extended_dynamic_state2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_color_write_enable
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceColorWriteEnableFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
- {
- deepcopy_VkPipelineColorWriteCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkPipelineColorWriteCreateInfoEXT*>(structExtension), reinterpret_cast<VkPipelineColorWriteCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: {
+ deepcopy_VkPipelineColorWriteCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPipelineColorWriteCreateInfoEXT*>(structExtension),
+ reinterpret_cast<VkPipelineColorWriteCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_GOOGLE_gfxstream
- case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
- {
- deepcopy_VkImportColorBufferGOOGLE(alloc, rootType, reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension), reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
+ deepcopy_VkImportColorBufferGOOGLE(
+ alloc, rootType,
+ reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension),
+ reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
- {
- deepcopy_VkImportBufferGOOGLE(alloc, rootType, reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension), reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE: {
+ deepcopy_VkImportBufferGOOGLE(
+ alloc, rootType, reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension),
+ reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
- {
- deepcopy_VkImportPhysicalAddressGOOGLE(alloc, rootType, reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension), reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE: {
+ deepcopy_VkImportPhysicalAddressGOOGLE(
+ alloc, rootType,
+ reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension),
+ reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_global_priority_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT:
- {
- deepcopy_VkQueueFamilyGlobalPriorityPropertiesEXT(alloc, rootType, reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension), reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: {
+ deepcopy_VkQueueFamilyGlobalPriorityPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension),
+ reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_multi_draw
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceMultiDrawFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceMultiDrawFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceMultiDrawFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceMultiDrawFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
- {
- deepcopy_VkPhysicalDeviceMultiDrawPropertiesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceMultiDrawPropertiesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceMultiDrawPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: {
+ deepcopy_VkPhysicalDeviceMultiDrawPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMultiDrawPropertiesEXT*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceMultiDrawPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_border_color_swizzle
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
+ deepcopy_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
- {
- deepcopy_VkSamplerBorderColorComponentMappingCreateInfoEXT(alloc, rootType, reinterpret_cast<const VkSamplerBorderColorComponentMappingCreateInfoEXT*>(structExtension), reinterpret_cast<VkSamplerBorderColorComponentMappingCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: {
+ deepcopy_VkSamplerBorderColorComponentMappingCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkSamplerBorderColorComponentMappingCreateInfoEXT*>(
+ structExtension),
+ reinterpret_cast<VkSamplerBorderColorComponentMappingCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_pageable_device_local_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
- {
- deepcopy_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(alloc, rootType, reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(structExtension), reinterpret_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: {
+ deepcopy_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_acceleration_structure
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
- {
- deepcopy_VkWriteDescriptorSetAccelerationStructureKHR(alloc, rootType, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension), reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
+ deepcopy_VkWriteDescriptorSetAccelerationStructureKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(
+ structExtension),
+ reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
- {
- deepcopy_VkPhysicalDeviceAccelerationStructureFeaturesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: {
+ deepcopy_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
- {
- deepcopy_VkPhysicalDeviceAccelerationStructurePropertiesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: {
+ deepcopy_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
- {
- deepcopy_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
+ deepcopy_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
- {
- deepcopy_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: {
+ deepcopy_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_ray_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
- {
- deepcopy_VkPhysicalDeviceRayQueryFeaturesKHR(alloc, rootType, reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension), reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: {
+ deepcopy_VkPhysicalDeviceRayQueryFeaturesKHR(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension),
+ reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension_out));
break;
}
#endif
- default:
- {
+ default: {
return;
}
}
}
-
-} // namespace goldfish_vk
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_deepcopy_guest.h b/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
index 1728261..5bdd148 100644
--- a/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
+++ b/system/vulkan_enc/goldfish_vk_deepcopy_guest.h
@@ -14,24 +14,27 @@
// limitations under the License.
// Autogenerated module goldfish_vk_deepcopy_guest
-// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal -o ../qemu/android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+//
+// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
+// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
-// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
-
+//
+// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
+// $CEREAL_OUTPUT_DIR
+//
#pragma once
-
#include <vulkan/vulkan.h>
-
-#include "vk_platform_compat.h"
-
-#include "goldfish_vk_private_defs.h"
#include "android/base/BumpPool.h"
+#include "goldfish_vk_private_defs.h"
+#include "vk_platform_compat.h"
+#include "vulkan_gfxstream.h"
using android::base::Allocator;
using android::base::BumpPool;
// Stuff we are not going to use but if included,
@@ -41,1721 +44,1122 @@
#undef VK_KHR_android_surface
#undef VK_ANDROID_external_memory_android_hardware_buffer
-
namespace goldfish_vk {
-
#ifdef VK_VERSION_1_0
-void deepcopy_VkExtent2D(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExtent2D* from,
- VkExtent2D* to);
+void deepcopy_VkExtent2D(Allocator* alloc, VkStructureType rootType, const VkExtent2D* from,
+ VkExtent2D* to);
-void deepcopy_VkExtent3D(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExtent3D* from,
- VkExtent3D* to);
+void deepcopy_VkExtent3D(Allocator* alloc, VkStructureType rootType, const VkExtent3D* from,
+ VkExtent3D* to);
-void deepcopy_VkOffset2D(
- Allocator* alloc,
- VkStructureType rootType,
- const VkOffset2D* from,
- VkOffset2D* to);
+void deepcopy_VkOffset2D(Allocator* alloc, VkStructureType rootType, const VkOffset2D* from,
+ VkOffset2D* to);
-void deepcopy_VkOffset3D(
- Allocator* alloc,
- VkStructureType rootType,
- const VkOffset3D* from,
- VkOffset3D* to);
+void deepcopy_VkOffset3D(Allocator* alloc, VkStructureType rootType, const VkOffset3D* from,
+ VkOffset3D* to);
-void deepcopy_VkRect2D(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRect2D* from,
- VkRect2D* to);
+void deepcopy_VkRect2D(Allocator* alloc, VkStructureType rootType, const VkRect2D* from,
+ VkRect2D* to);
-void deepcopy_VkBaseInStructure(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBaseInStructure* from,
- VkBaseInStructure* to);
+void deepcopy_VkBaseInStructure(Allocator* alloc, VkStructureType rootType,
+ const VkBaseInStructure* from, VkBaseInStructure* to);
-void deepcopy_VkBaseOutStructure(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBaseOutStructure* from,
- VkBaseOutStructure* to);
+void deepcopy_VkBaseOutStructure(Allocator* alloc, VkStructureType rootType,
+ const VkBaseOutStructure* from, VkBaseOutStructure* to);
-void deepcopy_VkBufferMemoryBarrier(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferMemoryBarrier* from,
- VkBufferMemoryBarrier* to);
+void deepcopy_VkBufferMemoryBarrier(Allocator* alloc, VkStructureType rootType,
+ const VkBufferMemoryBarrier* from, VkBufferMemoryBarrier* to);
-void deepcopy_VkDispatchIndirectCommand(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDispatchIndirectCommand* from,
- VkDispatchIndirectCommand* to);
+void deepcopy_VkDispatchIndirectCommand(Allocator* alloc, VkStructureType rootType,
+ const VkDispatchIndirectCommand* from,
+ VkDispatchIndirectCommand* to);
-void deepcopy_VkDrawIndexedIndirectCommand(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDrawIndexedIndirectCommand* from,
- VkDrawIndexedIndirectCommand* to);
+void deepcopy_VkDrawIndexedIndirectCommand(Allocator* alloc, VkStructureType rootType,
+ const VkDrawIndexedIndirectCommand* from,
+ VkDrawIndexedIndirectCommand* to);
-void deepcopy_VkDrawIndirectCommand(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDrawIndirectCommand* from,
- VkDrawIndirectCommand* to);
+void deepcopy_VkDrawIndirectCommand(Allocator* alloc, VkStructureType rootType,
+ const VkDrawIndirectCommand* from, VkDrawIndirectCommand* to);
-void deepcopy_VkImageSubresourceRange(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageSubresourceRange* from,
- VkImageSubresourceRange* to);
+void deepcopy_VkImageSubresourceRange(Allocator* alloc, VkStructureType rootType,
+ const VkImageSubresourceRange* from,
+ VkImageSubresourceRange* to);
-void deepcopy_VkImageMemoryBarrier(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageMemoryBarrier* from,
- VkImageMemoryBarrier* to);
+void deepcopy_VkImageMemoryBarrier(Allocator* alloc, VkStructureType rootType,
+ const VkImageMemoryBarrier* from, VkImageMemoryBarrier* to);
-void deepcopy_VkMemoryBarrier(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryBarrier* from,
- VkMemoryBarrier* to);
+void deepcopy_VkMemoryBarrier(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryBarrier* from, VkMemoryBarrier* to);
-void deepcopy_VkPipelineCacheHeaderVersionOne(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineCacheHeaderVersionOne* from,
- VkPipelineCacheHeaderVersionOne* to);
+void deepcopy_VkPipelineCacheHeaderVersionOne(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineCacheHeaderVersionOne* from,
+ VkPipelineCacheHeaderVersionOne* to);
-void deepcopy_VkAllocationCallbacks(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAllocationCallbacks* from,
- VkAllocationCallbacks* to);
+void deepcopy_VkAllocationCallbacks(Allocator* alloc, VkStructureType rootType,
+ const VkAllocationCallbacks* from, VkAllocationCallbacks* to);
-void deepcopy_VkApplicationInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkApplicationInfo* from,
- VkApplicationInfo* to);
+void deepcopy_VkApplicationInfo(Allocator* alloc, VkStructureType rootType,
+ const VkApplicationInfo* from, VkApplicationInfo* to);
-void deepcopy_VkFormatProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFormatProperties* from,
- VkFormatProperties* to);
+void deepcopy_VkFormatProperties(Allocator* alloc, VkStructureType rootType,
+ const VkFormatProperties* from, VkFormatProperties* to);
-void deepcopy_VkImageFormatProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageFormatProperties* from,
- VkImageFormatProperties* to);
+void deepcopy_VkImageFormatProperties(Allocator* alloc, VkStructureType rootType,
+ const VkImageFormatProperties* from,
+ VkImageFormatProperties* to);
-void deepcopy_VkInstanceCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkInstanceCreateInfo* from,
- VkInstanceCreateInfo* to);
+void deepcopy_VkInstanceCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkInstanceCreateInfo* from, VkInstanceCreateInfo* to);
-void deepcopy_VkMemoryHeap(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryHeap* from,
- VkMemoryHeap* to);
+void deepcopy_VkMemoryHeap(Allocator* alloc, VkStructureType rootType, const VkMemoryHeap* from,
+ VkMemoryHeap* to);
-void deepcopy_VkMemoryType(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryType* from,
- VkMemoryType* to);
+void deepcopy_VkMemoryType(Allocator* alloc, VkStructureType rootType, const VkMemoryType* from,
+ VkMemoryType* to);
-void deepcopy_VkPhysicalDeviceFeatures(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceFeatures* from,
- VkPhysicalDeviceFeatures* to);
+void deepcopy_VkPhysicalDeviceFeatures(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceFeatures* from,
+ VkPhysicalDeviceFeatures* to);
-void deepcopy_VkPhysicalDeviceLimits(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceLimits* from,
- VkPhysicalDeviceLimits* to);
+void deepcopy_VkPhysicalDeviceLimits(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceLimits* from,
+ VkPhysicalDeviceLimits* to);
-void deepcopy_VkPhysicalDeviceMemoryProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryProperties* from,
- VkPhysicalDeviceMemoryProperties* to);
+void deepcopy_VkPhysicalDeviceMemoryProperties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryProperties* from,
+ VkPhysicalDeviceMemoryProperties* to);
-void deepcopy_VkPhysicalDeviceSparseProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceSparseProperties* from,
- VkPhysicalDeviceSparseProperties* to);
+void deepcopy_VkPhysicalDeviceSparseProperties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceSparseProperties* from,
+ VkPhysicalDeviceSparseProperties* to);
-void deepcopy_VkPhysicalDeviceProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceProperties* from,
- VkPhysicalDeviceProperties* to);
+void deepcopy_VkPhysicalDeviceProperties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceProperties* from,
+ VkPhysicalDeviceProperties* to);
-void deepcopy_VkQueueFamilyProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkQueueFamilyProperties* from,
- VkQueueFamilyProperties* to);
+void deepcopy_VkQueueFamilyProperties(Allocator* alloc, VkStructureType rootType,
+ const VkQueueFamilyProperties* from,
+ VkQueueFamilyProperties* to);
-void deepcopy_VkDeviceQueueCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceQueueCreateInfo* from,
- VkDeviceQueueCreateInfo* to);
+void deepcopy_VkDeviceQueueCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceQueueCreateInfo* from,
+ VkDeviceQueueCreateInfo* to);
-void deepcopy_VkDeviceCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceCreateInfo* from,
- VkDeviceCreateInfo* to);
+void deepcopy_VkDeviceCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceCreateInfo* from, VkDeviceCreateInfo* to);
-void deepcopy_VkExtensionProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExtensionProperties* from,
- VkExtensionProperties* to);
+void deepcopy_VkExtensionProperties(Allocator* alloc, VkStructureType rootType,
+ const VkExtensionProperties* from, VkExtensionProperties* to);
-void deepcopy_VkLayerProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkLayerProperties* from,
- VkLayerProperties* to);
+void deepcopy_VkLayerProperties(Allocator* alloc, VkStructureType rootType,
+ const VkLayerProperties* from, VkLayerProperties* to);
-void deepcopy_VkSubmitInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubmitInfo* from,
- VkSubmitInfo* to);
+void deepcopy_VkSubmitInfo(Allocator* alloc, VkStructureType rootType, const VkSubmitInfo* from,
+ VkSubmitInfo* to);
-void deepcopy_VkMappedMemoryRange(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMappedMemoryRange* from,
- VkMappedMemoryRange* to);
+void deepcopy_VkMappedMemoryRange(Allocator* alloc, VkStructureType rootType,
+ const VkMappedMemoryRange* from, VkMappedMemoryRange* to);
-void deepcopy_VkMemoryAllocateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryAllocateInfo* from,
- VkMemoryAllocateInfo* to);
+void deepcopy_VkMemoryAllocateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryAllocateInfo* from, VkMemoryAllocateInfo* to);
-void deepcopy_VkMemoryRequirements(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryRequirements* from,
- VkMemoryRequirements* to);
+void deepcopy_VkMemoryRequirements(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryRequirements* from, VkMemoryRequirements* to);
-void deepcopy_VkSparseMemoryBind(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSparseMemoryBind* from,
- VkSparseMemoryBind* to);
+void deepcopy_VkSparseMemoryBind(Allocator* alloc, VkStructureType rootType,
+ const VkSparseMemoryBind* from, VkSparseMemoryBind* to);
-void deepcopy_VkSparseBufferMemoryBindInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSparseBufferMemoryBindInfo* from,
- VkSparseBufferMemoryBindInfo* to);
+void deepcopy_VkSparseBufferMemoryBindInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSparseBufferMemoryBindInfo* from,
+ VkSparseBufferMemoryBindInfo* to);
-void deepcopy_VkSparseImageOpaqueMemoryBindInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSparseImageOpaqueMemoryBindInfo* from,
- VkSparseImageOpaqueMemoryBindInfo* to);
+void deepcopy_VkSparseImageOpaqueMemoryBindInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSparseImageOpaqueMemoryBindInfo* from,
+ VkSparseImageOpaqueMemoryBindInfo* to);
-void deepcopy_VkImageSubresource(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageSubresource* from,
- VkImageSubresource* to);
+void deepcopy_VkImageSubresource(Allocator* alloc, VkStructureType rootType,
+ const VkImageSubresource* from, VkImageSubresource* to);
-void deepcopy_VkSparseImageMemoryBind(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSparseImageMemoryBind* from,
- VkSparseImageMemoryBind* to);
+void deepcopy_VkSparseImageMemoryBind(Allocator* alloc, VkStructureType rootType,
+ const VkSparseImageMemoryBind* from,
+ VkSparseImageMemoryBind* to);
-void deepcopy_VkSparseImageMemoryBindInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSparseImageMemoryBindInfo* from,
- VkSparseImageMemoryBindInfo* to);
+void deepcopy_VkSparseImageMemoryBindInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSparseImageMemoryBindInfo* from,
+ VkSparseImageMemoryBindInfo* to);
-void deepcopy_VkBindSparseInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindSparseInfo* from,
- VkBindSparseInfo* to);
+void deepcopy_VkBindSparseInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBindSparseInfo* from, VkBindSparseInfo* to);
-void deepcopy_VkSparseImageFormatProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSparseImageFormatProperties* from,
- VkSparseImageFormatProperties* to);
+void deepcopy_VkSparseImageFormatProperties(Allocator* alloc, VkStructureType rootType,
+ const VkSparseImageFormatProperties* from,
+ VkSparseImageFormatProperties* to);
-void deepcopy_VkSparseImageMemoryRequirements(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSparseImageMemoryRequirements* from,
- VkSparseImageMemoryRequirements* to);
+void deepcopy_VkSparseImageMemoryRequirements(Allocator* alloc, VkStructureType rootType,
+ const VkSparseImageMemoryRequirements* from,
+ VkSparseImageMemoryRequirements* to);
-void deepcopy_VkFenceCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFenceCreateInfo* from,
- VkFenceCreateInfo* to);
+void deepcopy_VkFenceCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkFenceCreateInfo* from, VkFenceCreateInfo* to);
-void deepcopy_VkSemaphoreCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSemaphoreCreateInfo* from,
- VkSemaphoreCreateInfo* to);
+void deepcopy_VkSemaphoreCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSemaphoreCreateInfo* from, VkSemaphoreCreateInfo* to);
-void deepcopy_VkEventCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkEventCreateInfo* from,
- VkEventCreateInfo* to);
+void deepcopy_VkEventCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkEventCreateInfo* from, VkEventCreateInfo* to);
-void deepcopy_VkQueryPoolCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkQueryPoolCreateInfo* from,
- VkQueryPoolCreateInfo* to);
+void deepcopy_VkQueryPoolCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkQueryPoolCreateInfo* from, VkQueryPoolCreateInfo* to);
-void deepcopy_VkBufferCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferCreateInfo* from,
- VkBufferCreateInfo* to);
+void deepcopy_VkBufferCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBufferCreateInfo* from, VkBufferCreateInfo* to);
-void deepcopy_VkBufferViewCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferViewCreateInfo* from,
- VkBufferViewCreateInfo* to);
+void deepcopy_VkBufferViewCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBufferViewCreateInfo* from,
+ VkBufferViewCreateInfo* to);
-void deepcopy_VkImageCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageCreateInfo* from,
- VkImageCreateInfo* to);
+void deepcopy_VkImageCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkImageCreateInfo* from, VkImageCreateInfo* to);
-void deepcopy_VkSubresourceLayout(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubresourceLayout* from,
- VkSubresourceLayout* to);
+void deepcopy_VkSubresourceLayout(Allocator* alloc, VkStructureType rootType,
+ const VkSubresourceLayout* from, VkSubresourceLayout* to);
-void deepcopy_VkComponentMapping(
- Allocator* alloc,
- VkStructureType rootType,
- const VkComponentMapping* from,
- VkComponentMapping* to);
+void deepcopy_VkComponentMapping(Allocator* alloc, VkStructureType rootType,
+ const VkComponentMapping* from, VkComponentMapping* to);
-void deepcopy_VkImageViewCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageViewCreateInfo* from,
- VkImageViewCreateInfo* to);
+void deepcopy_VkImageViewCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkImageViewCreateInfo* from, VkImageViewCreateInfo* to);
-void deepcopy_VkShaderModuleCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkShaderModuleCreateInfo* from,
- VkShaderModuleCreateInfo* to);
+void deepcopy_VkShaderModuleCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkShaderModuleCreateInfo* from,
+ VkShaderModuleCreateInfo* to);
-void deepcopy_VkPipelineCacheCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineCacheCreateInfo* from,
- VkPipelineCacheCreateInfo* to);
+void deepcopy_VkPipelineCacheCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineCacheCreateInfo* from,
+ VkPipelineCacheCreateInfo* to);
-void deepcopy_VkSpecializationMapEntry(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSpecializationMapEntry* from,
- VkSpecializationMapEntry* to);
+void deepcopy_VkSpecializationMapEntry(Allocator* alloc, VkStructureType rootType,
+ const VkSpecializationMapEntry* from,
+ VkSpecializationMapEntry* to);
-void deepcopy_VkSpecializationInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSpecializationInfo* from,
- VkSpecializationInfo* to);
+void deepcopy_VkSpecializationInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSpecializationInfo* from, VkSpecializationInfo* to);
-void deepcopy_VkPipelineShaderStageCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineShaderStageCreateInfo* from,
- VkPipelineShaderStageCreateInfo* to);
+void deepcopy_VkPipelineShaderStageCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineShaderStageCreateInfo* from,
+ VkPipelineShaderStageCreateInfo* to);
-void deepcopy_VkComputePipelineCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkComputePipelineCreateInfo* from,
- VkComputePipelineCreateInfo* to);
+void deepcopy_VkComputePipelineCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkComputePipelineCreateInfo* from,
+ VkComputePipelineCreateInfo* to);
-void deepcopy_VkVertexInputBindingDescription(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVertexInputBindingDescription* from,
- VkVertexInputBindingDescription* to);
+void deepcopy_VkVertexInputBindingDescription(Allocator* alloc, VkStructureType rootType,
+ const VkVertexInputBindingDescription* from,
+ VkVertexInputBindingDescription* to);
-void deepcopy_VkVertexInputAttributeDescription(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVertexInputAttributeDescription* from,
- VkVertexInputAttributeDescription* to);
+void deepcopy_VkVertexInputAttributeDescription(Allocator* alloc, VkStructureType rootType,
+ const VkVertexInputAttributeDescription* from,
+ VkVertexInputAttributeDescription* to);
-void deepcopy_VkPipelineVertexInputStateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineVertexInputStateCreateInfo* from,
- VkPipelineVertexInputStateCreateInfo* to);
+void deepcopy_VkPipelineVertexInputStateCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineVertexInputStateCreateInfo* from,
+ VkPipelineVertexInputStateCreateInfo* to);
void deepcopy_VkPipelineInputAssemblyStateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineInputAssemblyStateCreateInfo* from,
+ Allocator* alloc, VkStructureType rootType, const VkPipelineInputAssemblyStateCreateInfo* from,
VkPipelineInputAssemblyStateCreateInfo* to);
void deepcopy_VkPipelineTessellationStateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineTessellationStateCreateInfo* from,
+ Allocator* alloc, VkStructureType rootType, const VkPipelineTessellationStateCreateInfo* from,
VkPipelineTessellationStateCreateInfo* to);
-void deepcopy_VkViewport(
- Allocator* alloc,
- VkStructureType rootType,
- const VkViewport* from,
- VkViewport* to);
+void deepcopy_VkViewport(Allocator* alloc, VkStructureType rootType, const VkViewport* from,
+ VkViewport* to);
-void deepcopy_VkPipelineViewportStateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineViewportStateCreateInfo* from,
- VkPipelineViewportStateCreateInfo* to);
+void deepcopy_VkPipelineViewportStateCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineViewportStateCreateInfo* from,
+ VkPipelineViewportStateCreateInfo* to);
void deepcopy_VkPipelineRasterizationStateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineRasterizationStateCreateInfo* from,
+ Allocator* alloc, VkStructureType rootType, const VkPipelineRasterizationStateCreateInfo* from,
VkPipelineRasterizationStateCreateInfo* to);
-void deepcopy_VkPipelineMultisampleStateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineMultisampleStateCreateInfo* from,
- VkPipelineMultisampleStateCreateInfo* to);
+void deepcopy_VkPipelineMultisampleStateCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineMultisampleStateCreateInfo* from,
+ VkPipelineMultisampleStateCreateInfo* to);
-void deepcopy_VkStencilOpState(
- Allocator* alloc,
- VkStructureType rootType,
- const VkStencilOpState* from,
- VkStencilOpState* to);
+void deepcopy_VkStencilOpState(Allocator* alloc, VkStructureType rootType,
+ const VkStencilOpState* from, VkStencilOpState* to);
void deepcopy_VkPipelineDepthStencilStateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineDepthStencilStateCreateInfo* from,
+ Allocator* alloc, VkStructureType rootType, const VkPipelineDepthStencilStateCreateInfo* from,
VkPipelineDepthStencilStateCreateInfo* to);
-void deepcopy_VkPipelineColorBlendAttachmentState(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineColorBlendAttachmentState* from,
- VkPipelineColorBlendAttachmentState* to);
+void deepcopy_VkPipelineColorBlendAttachmentState(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineColorBlendAttachmentState* from,
+ VkPipelineColorBlendAttachmentState* to);
-void deepcopy_VkPipelineColorBlendStateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineColorBlendStateCreateInfo* from,
- VkPipelineColorBlendStateCreateInfo* to);
+void deepcopy_VkPipelineColorBlendStateCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineColorBlendStateCreateInfo* from,
+ VkPipelineColorBlendStateCreateInfo* to);
-void deepcopy_VkPipelineDynamicStateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineDynamicStateCreateInfo* from,
- VkPipelineDynamicStateCreateInfo* to);
+void deepcopy_VkPipelineDynamicStateCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineDynamicStateCreateInfo* from,
+ VkPipelineDynamicStateCreateInfo* to);
-void deepcopy_VkGraphicsPipelineCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkGraphicsPipelineCreateInfo* from,
- VkGraphicsPipelineCreateInfo* to);
+void deepcopy_VkGraphicsPipelineCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkGraphicsPipelineCreateInfo* from,
+ VkGraphicsPipelineCreateInfo* to);
-void deepcopy_VkPushConstantRange(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPushConstantRange* from,
- VkPushConstantRange* to);
+void deepcopy_VkPushConstantRange(Allocator* alloc, VkStructureType rootType,
+ const VkPushConstantRange* from, VkPushConstantRange* to);
-void deepcopy_VkPipelineLayoutCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineLayoutCreateInfo* from,
- VkPipelineLayoutCreateInfo* to);
+void deepcopy_VkPipelineLayoutCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineLayoutCreateInfo* from,
+ VkPipelineLayoutCreateInfo* to);
-void deepcopy_VkSamplerCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSamplerCreateInfo* from,
- VkSamplerCreateInfo* to);
+void deepcopy_VkSamplerCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSamplerCreateInfo* from, VkSamplerCreateInfo* to);
-void deepcopy_VkCopyDescriptorSet(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCopyDescriptorSet* from,
- VkCopyDescriptorSet* to);
+void deepcopy_VkCopyDescriptorSet(Allocator* alloc, VkStructureType rootType,
+ const VkCopyDescriptorSet* from, VkCopyDescriptorSet* to);
-void deepcopy_VkDescriptorBufferInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDescriptorBufferInfo* from,
- VkDescriptorBufferInfo* to);
+void deepcopy_VkDescriptorBufferInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDescriptorBufferInfo* from,
+ VkDescriptorBufferInfo* to);
-void deepcopy_VkDescriptorImageInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDescriptorImageInfo* from,
- VkDescriptorImageInfo* to);
+void deepcopy_VkDescriptorImageInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDescriptorImageInfo* from, VkDescriptorImageInfo* to);
-void deepcopy_VkDescriptorPoolSize(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDescriptorPoolSize* from,
- VkDescriptorPoolSize* to);
+void deepcopy_VkDescriptorPoolSize(Allocator* alloc, VkStructureType rootType,
+ const VkDescriptorPoolSize* from, VkDescriptorPoolSize* to);
-void deepcopy_VkDescriptorPoolCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDescriptorPoolCreateInfo* from,
- VkDescriptorPoolCreateInfo* to);
+void deepcopy_VkDescriptorPoolCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDescriptorPoolCreateInfo* from,
+ VkDescriptorPoolCreateInfo* to);
-void deepcopy_VkDescriptorSetAllocateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDescriptorSetAllocateInfo* from,
- VkDescriptorSetAllocateInfo* to);
+void deepcopy_VkDescriptorSetAllocateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDescriptorSetAllocateInfo* from,
+ VkDescriptorSetAllocateInfo* to);
-void deepcopy_VkDescriptorSetLayoutBinding(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDescriptorSetLayoutBinding* from,
- VkDescriptorSetLayoutBinding* to);
+void deepcopy_VkDescriptorSetLayoutBinding(Allocator* alloc, VkStructureType rootType,
+ const VkDescriptorSetLayoutBinding* from,
+ VkDescriptorSetLayoutBinding* to);
-void deepcopy_VkDescriptorSetLayoutCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDescriptorSetLayoutCreateInfo* from,
- VkDescriptorSetLayoutCreateInfo* to);
+void deepcopy_VkDescriptorSetLayoutCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDescriptorSetLayoutCreateInfo* from,
+ VkDescriptorSetLayoutCreateInfo* to);
-void deepcopy_VkWriteDescriptorSet(
- Allocator* alloc,
- VkStructureType rootType,
- const VkWriteDescriptorSet* from,
- VkWriteDescriptorSet* to);
+void deepcopy_VkWriteDescriptorSet(Allocator* alloc, VkStructureType rootType,
+ const VkWriteDescriptorSet* from, VkWriteDescriptorSet* to);
-void deepcopy_VkAttachmentDescription(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAttachmentDescription* from,
- VkAttachmentDescription* to);
+void deepcopy_VkAttachmentDescription(Allocator* alloc, VkStructureType rootType,
+ const VkAttachmentDescription* from,
+ VkAttachmentDescription* to);
-void deepcopy_VkAttachmentReference(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAttachmentReference* from,
- VkAttachmentReference* to);
+void deepcopy_VkAttachmentReference(Allocator* alloc, VkStructureType rootType,
+ const VkAttachmentReference* from, VkAttachmentReference* to);
-void deepcopy_VkFramebufferCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFramebufferCreateInfo* from,
- VkFramebufferCreateInfo* to);
+void deepcopy_VkFramebufferCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkFramebufferCreateInfo* from,
+ VkFramebufferCreateInfo* to);
-void deepcopy_VkSubpassDescription(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubpassDescription* from,
- VkSubpassDescription* to);
+void deepcopy_VkSubpassDescription(Allocator* alloc, VkStructureType rootType,
+ const VkSubpassDescription* from, VkSubpassDescription* to);
-void deepcopy_VkSubpassDependency(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubpassDependency* from,
- VkSubpassDependency* to);
+void deepcopy_VkSubpassDependency(Allocator* alloc, VkStructureType rootType,
+ const VkSubpassDependency* from, VkSubpassDependency* to);
-void deepcopy_VkRenderPassCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRenderPassCreateInfo* from,
- VkRenderPassCreateInfo* to);
+void deepcopy_VkRenderPassCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkRenderPassCreateInfo* from,
+ VkRenderPassCreateInfo* to);
-void deepcopy_VkCommandPoolCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCommandPoolCreateInfo* from,
- VkCommandPoolCreateInfo* to);
+void deepcopy_VkCommandPoolCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkCommandPoolCreateInfo* from,
+ VkCommandPoolCreateInfo* to);
-void deepcopy_VkCommandBufferAllocateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCommandBufferAllocateInfo* from,
- VkCommandBufferAllocateInfo* to);
+void deepcopy_VkCommandBufferAllocateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkCommandBufferAllocateInfo* from,
+ VkCommandBufferAllocateInfo* to);
-void deepcopy_VkCommandBufferInheritanceInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCommandBufferInheritanceInfo* from,
- VkCommandBufferInheritanceInfo* to);
+void deepcopy_VkCommandBufferInheritanceInfo(Allocator* alloc, VkStructureType rootType,
+ const VkCommandBufferInheritanceInfo* from,
+ VkCommandBufferInheritanceInfo* to);
-void deepcopy_VkCommandBufferBeginInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCommandBufferBeginInfo* from,
- VkCommandBufferBeginInfo* to);
+void deepcopy_VkCommandBufferBeginInfo(Allocator* alloc, VkStructureType rootType,
+ const VkCommandBufferBeginInfo* from,
+ VkCommandBufferBeginInfo* to);
-void deepcopy_VkBufferCopy(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferCopy* from,
- VkBufferCopy* to);
+void deepcopy_VkBufferCopy(Allocator* alloc, VkStructureType rootType, const VkBufferCopy* from,
+ VkBufferCopy* to);
-void deepcopy_VkImageSubresourceLayers(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageSubresourceLayers* from,
- VkImageSubresourceLayers* to);
+void deepcopy_VkImageSubresourceLayers(Allocator* alloc, VkStructureType rootType,
+ const VkImageSubresourceLayers* from,
+ VkImageSubresourceLayers* to);
-void deepcopy_VkBufferImageCopy(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferImageCopy* from,
- VkBufferImageCopy* to);
+void deepcopy_VkBufferImageCopy(Allocator* alloc, VkStructureType rootType,
+ const VkBufferImageCopy* from, VkBufferImageCopy* to);
-void deepcopy_VkClearColorValue(
- Allocator* alloc,
- VkStructureType rootType,
- const VkClearColorValue* from,
- VkClearColorValue* to);
+void deepcopy_VkClearColorValue(Allocator* alloc, VkStructureType rootType,
+ const VkClearColorValue* from, VkClearColorValue* to);
-void deepcopy_VkClearDepthStencilValue(
- Allocator* alloc,
- VkStructureType rootType,
- const VkClearDepthStencilValue* from,
- VkClearDepthStencilValue* to);
+void deepcopy_VkClearDepthStencilValue(Allocator* alloc, VkStructureType rootType,
+ const VkClearDepthStencilValue* from,
+ VkClearDepthStencilValue* to);
-void deepcopy_VkClearValue(
- Allocator* alloc,
- VkStructureType rootType,
- const VkClearValue* from,
- VkClearValue* to);
+void deepcopy_VkClearValue(Allocator* alloc, VkStructureType rootType, const VkClearValue* from,
+ VkClearValue* to);
-void deepcopy_VkClearAttachment(
- Allocator* alloc,
- VkStructureType rootType,
- const VkClearAttachment* from,
- VkClearAttachment* to);
+void deepcopy_VkClearAttachment(Allocator* alloc, VkStructureType rootType,
+ const VkClearAttachment* from, VkClearAttachment* to);
-void deepcopy_VkClearRect(
- Allocator* alloc,
- VkStructureType rootType,
- const VkClearRect* from,
- VkClearRect* to);
+void deepcopy_VkClearRect(Allocator* alloc, VkStructureType rootType, const VkClearRect* from,
+ VkClearRect* to);
-void deepcopy_VkImageBlit(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageBlit* from,
- VkImageBlit* to);
+void deepcopy_VkImageBlit(Allocator* alloc, VkStructureType rootType, const VkImageBlit* from,
+ VkImageBlit* to);
-void deepcopy_VkImageCopy(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageCopy* from,
- VkImageCopy* to);
+void deepcopy_VkImageCopy(Allocator* alloc, VkStructureType rootType, const VkImageCopy* from,
+ VkImageCopy* to);
-void deepcopy_VkImageResolve(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageResolve* from,
- VkImageResolve* to);
+void deepcopy_VkImageResolve(Allocator* alloc, VkStructureType rootType, const VkImageResolve* from,
+ VkImageResolve* to);
-void deepcopy_VkRenderPassBeginInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRenderPassBeginInfo* from,
- VkRenderPassBeginInfo* to);
+void deepcopy_VkRenderPassBeginInfo(Allocator* alloc, VkStructureType rootType,
+ const VkRenderPassBeginInfo* from, VkRenderPassBeginInfo* to);
#endif
#ifdef VK_VERSION_1_1
-void deepcopy_VkPhysicalDeviceSubgroupProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceSubgroupProperties* from,
- VkPhysicalDeviceSubgroupProperties* to);
+void deepcopy_VkPhysicalDeviceSubgroupProperties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceSubgroupProperties* from,
+ VkPhysicalDeviceSubgroupProperties* to);
-void deepcopy_VkBindBufferMemoryInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindBufferMemoryInfo* from,
- VkBindBufferMemoryInfo* to);
+void deepcopy_VkBindBufferMemoryInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBindBufferMemoryInfo* from,
+ VkBindBufferMemoryInfo* to);
-void deepcopy_VkBindImageMemoryInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindImageMemoryInfo* from,
- VkBindImageMemoryInfo* to);
+void deepcopy_VkBindImageMemoryInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBindImageMemoryInfo* from, VkBindImageMemoryInfo* to);
-void deepcopy_VkPhysicalDevice16BitStorageFeatures(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDevice16BitStorageFeatures* from,
- VkPhysicalDevice16BitStorageFeatures* to);
+void deepcopy_VkPhysicalDevice16BitStorageFeatures(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDevice16BitStorageFeatures* from,
+ VkPhysicalDevice16BitStorageFeatures* to);
-void deepcopy_VkMemoryDedicatedRequirements(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryDedicatedRequirements* from,
- VkMemoryDedicatedRequirements* to);
+void deepcopy_VkMemoryDedicatedRequirements(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryDedicatedRequirements* from,
+ VkMemoryDedicatedRequirements* to);
-void deepcopy_VkMemoryDedicatedAllocateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryDedicatedAllocateInfo* from,
- VkMemoryDedicatedAllocateInfo* to);
+void deepcopy_VkMemoryDedicatedAllocateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryDedicatedAllocateInfo* from,
+ VkMemoryDedicatedAllocateInfo* to);
-void deepcopy_VkMemoryAllocateFlagsInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryAllocateFlagsInfo* from,
- VkMemoryAllocateFlagsInfo* to);
+void deepcopy_VkMemoryAllocateFlagsInfo(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryAllocateFlagsInfo* from,
+ VkMemoryAllocateFlagsInfo* to);
-void deepcopy_VkDeviceGroupRenderPassBeginInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceGroupRenderPassBeginInfo* from,
- VkDeviceGroupRenderPassBeginInfo* to);
+void deepcopy_VkDeviceGroupRenderPassBeginInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceGroupRenderPassBeginInfo* from,
+ VkDeviceGroupRenderPassBeginInfo* to);
-void deepcopy_VkDeviceGroupCommandBufferBeginInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceGroupCommandBufferBeginInfo* from,
- VkDeviceGroupCommandBufferBeginInfo* to);
+void deepcopy_VkDeviceGroupCommandBufferBeginInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceGroupCommandBufferBeginInfo* from,
+ VkDeviceGroupCommandBufferBeginInfo* to);
-void deepcopy_VkDeviceGroupSubmitInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceGroupSubmitInfo* from,
- VkDeviceGroupSubmitInfo* to);
+void deepcopy_VkDeviceGroupSubmitInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceGroupSubmitInfo* from,
+ VkDeviceGroupSubmitInfo* to);
-void deepcopy_VkDeviceGroupBindSparseInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceGroupBindSparseInfo* from,
- VkDeviceGroupBindSparseInfo* to);
+void deepcopy_VkDeviceGroupBindSparseInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceGroupBindSparseInfo* from,
+ VkDeviceGroupBindSparseInfo* to);
-void deepcopy_VkBindBufferMemoryDeviceGroupInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindBufferMemoryDeviceGroupInfo* from,
- VkBindBufferMemoryDeviceGroupInfo* to);
+void deepcopy_VkBindBufferMemoryDeviceGroupInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBindBufferMemoryDeviceGroupInfo* from,
+ VkBindBufferMemoryDeviceGroupInfo* to);
-void deepcopy_VkBindImageMemoryDeviceGroupInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindImageMemoryDeviceGroupInfo* from,
- VkBindImageMemoryDeviceGroupInfo* to);
+void deepcopy_VkBindImageMemoryDeviceGroupInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBindImageMemoryDeviceGroupInfo* from,
+ VkBindImageMemoryDeviceGroupInfo* to);
-void deepcopy_VkPhysicalDeviceGroupProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceGroupProperties* from,
- VkPhysicalDeviceGroupProperties* to);
+void deepcopy_VkPhysicalDeviceGroupProperties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceGroupProperties* from,
+ VkPhysicalDeviceGroupProperties* to);
-void deepcopy_VkDeviceGroupDeviceCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceGroupDeviceCreateInfo* from,
- VkDeviceGroupDeviceCreateInfo* to);
+void deepcopy_VkDeviceGroupDeviceCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceGroupDeviceCreateInfo* from,
+ VkDeviceGroupDeviceCreateInfo* to);
-void deepcopy_VkBufferMemoryRequirementsInfo2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferMemoryRequirementsInfo2* from,
- VkBufferMemoryRequirementsInfo2* to);
+void deepcopy_VkBufferMemoryRequirementsInfo2(Allocator* alloc, VkStructureType rootType,
+ const VkBufferMemoryRequirementsInfo2* from,
+ VkBufferMemoryRequirementsInfo2* to);
-void deepcopy_VkImageMemoryRequirementsInfo2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageMemoryRequirementsInfo2* from,
- VkImageMemoryRequirementsInfo2* to);
+void deepcopy_VkImageMemoryRequirementsInfo2(Allocator* alloc, VkStructureType rootType,
+ const VkImageMemoryRequirementsInfo2* from,
+ VkImageMemoryRequirementsInfo2* to);
-void deepcopy_VkImageSparseMemoryRequirementsInfo2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageSparseMemoryRequirementsInfo2* from,
- VkImageSparseMemoryRequirementsInfo2* to);
+void deepcopy_VkImageSparseMemoryRequirementsInfo2(Allocator* alloc, VkStructureType rootType,
+ const VkImageSparseMemoryRequirementsInfo2* from,
+ VkImageSparseMemoryRequirementsInfo2* to);
-void deepcopy_VkMemoryRequirements2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryRequirements2* from,
- VkMemoryRequirements2* to);
+void deepcopy_VkMemoryRequirements2(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryRequirements2* from, VkMemoryRequirements2* to);
-void deepcopy_VkSparseImageMemoryRequirements2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSparseImageMemoryRequirements2* from,
- VkSparseImageMemoryRequirements2* to);
+void deepcopy_VkSparseImageMemoryRequirements2(Allocator* alloc, VkStructureType rootType,
+ const VkSparseImageMemoryRequirements2* from,
+ VkSparseImageMemoryRequirements2* to);
-void deepcopy_VkPhysicalDeviceFeatures2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceFeatures2* from,
- VkPhysicalDeviceFeatures2* to);
+void deepcopy_VkPhysicalDeviceFeatures2(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceFeatures2* from,
+ VkPhysicalDeviceFeatures2* to);
-void deepcopy_VkPhysicalDeviceProperties2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceProperties2* from,
- VkPhysicalDeviceProperties2* to);
+void deepcopy_VkPhysicalDeviceProperties2(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceProperties2* from,
+ VkPhysicalDeviceProperties2* to);
-void deepcopy_VkFormatProperties2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFormatProperties2* from,
- VkFormatProperties2* to);
+void deepcopy_VkFormatProperties2(Allocator* alloc, VkStructureType rootType,
+ const VkFormatProperties2* from, VkFormatProperties2* to);
-void deepcopy_VkImageFormatProperties2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageFormatProperties2* from,
- VkImageFormatProperties2* to);
+void deepcopy_VkImageFormatProperties2(Allocator* alloc, VkStructureType rootType,
+ const VkImageFormatProperties2* from,
+ VkImageFormatProperties2* to);
-void deepcopy_VkPhysicalDeviceImageFormatInfo2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceImageFormatInfo2* from,
- VkPhysicalDeviceImageFormatInfo2* to);
+void deepcopy_VkPhysicalDeviceImageFormatInfo2(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceImageFormatInfo2* from,
+ VkPhysicalDeviceImageFormatInfo2* to);
-void deepcopy_VkQueueFamilyProperties2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkQueueFamilyProperties2* from,
- VkQueueFamilyProperties2* to);
+void deepcopy_VkQueueFamilyProperties2(Allocator* alloc, VkStructureType rootType,
+ const VkQueueFamilyProperties2* from,
+ VkQueueFamilyProperties2* to);
-void deepcopy_VkPhysicalDeviceMemoryProperties2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryProperties2* from,
- VkPhysicalDeviceMemoryProperties2* to);
+void deepcopy_VkPhysicalDeviceMemoryProperties2(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryProperties2* from,
+ VkPhysicalDeviceMemoryProperties2* to);
-void deepcopy_VkSparseImageFormatProperties2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSparseImageFormatProperties2* from,
- VkSparseImageFormatProperties2* to);
+void deepcopy_VkSparseImageFormatProperties2(Allocator* alloc, VkStructureType rootType,
+ const VkSparseImageFormatProperties2* from,
+ VkSparseImageFormatProperties2* to);
void deepcopy_VkPhysicalDeviceSparseImageFormatInfo2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceSparseImageFormatInfo2* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceSparseImageFormatInfo2* from,
VkPhysicalDeviceSparseImageFormatInfo2* to);
void deepcopy_VkPhysicalDevicePointClippingProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDevicePointClippingProperties* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDevicePointClippingProperties* from,
VkPhysicalDevicePointClippingProperties* to);
-void deepcopy_VkInputAttachmentAspectReference(
- Allocator* alloc,
- VkStructureType rootType,
- const VkInputAttachmentAspectReference* from,
- VkInputAttachmentAspectReference* to);
+void deepcopy_VkInputAttachmentAspectReference(Allocator* alloc, VkStructureType rootType,
+ const VkInputAttachmentAspectReference* from,
+ VkInputAttachmentAspectReference* to);
void deepcopy_VkRenderPassInputAttachmentAspectCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkRenderPassInputAttachmentAspectCreateInfo* from,
VkRenderPassInputAttachmentAspectCreateInfo* to);
-void deepcopy_VkImageViewUsageCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageViewUsageCreateInfo* from,
- VkImageViewUsageCreateInfo* to);
+void deepcopy_VkImageViewUsageCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkImageViewUsageCreateInfo* from,
+ VkImageViewUsageCreateInfo* to);
void deepcopy_VkPipelineTessellationDomainOriginStateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineTessellationDomainOriginStateCreateInfo* from,
VkPipelineTessellationDomainOriginStateCreateInfo* to);
-void deepcopy_VkRenderPassMultiviewCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRenderPassMultiviewCreateInfo* from,
- VkRenderPassMultiviewCreateInfo* to);
+void deepcopy_VkRenderPassMultiviewCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkRenderPassMultiviewCreateInfo* from,
+ VkRenderPassMultiviewCreateInfo* to);
-void deepcopy_VkPhysicalDeviceMultiviewFeatures(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiviewFeatures* from,
- VkPhysicalDeviceMultiviewFeatures* to);
+void deepcopy_VkPhysicalDeviceMultiviewFeatures(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceMultiviewFeatures* from,
+ VkPhysicalDeviceMultiviewFeatures* to);
-void deepcopy_VkPhysicalDeviceMultiviewProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiviewProperties* from,
- VkPhysicalDeviceMultiviewProperties* to);
+void deepcopy_VkPhysicalDeviceMultiviewProperties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceMultiviewProperties* from,
+ VkPhysicalDeviceMultiviewProperties* to);
void deepcopy_VkPhysicalDeviceVariablePointersFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceVariablePointersFeatures* from,
VkPhysicalDeviceVariablePointersFeatures* to);
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceVariablePointersFeatures, deepcopy_VkPhysicalDeviceVariablePointerFeatures)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceVariablePointersFeatures,
+ deepcopy_VkPhysicalDeviceVariablePointerFeatures)
void deepcopy_VkPhysicalDeviceProtectedMemoryFeatures(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceProtectedMemoryFeatures* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceProtectedMemoryFeatures* from,
VkPhysicalDeviceProtectedMemoryFeatures* to);
void deepcopy_VkPhysicalDeviceProtectedMemoryProperties(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceProtectedMemoryProperties* from,
VkPhysicalDeviceProtectedMemoryProperties* to);
-void deepcopy_VkDeviceQueueInfo2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceQueueInfo2* from,
- VkDeviceQueueInfo2* to);
+void deepcopy_VkDeviceQueueInfo2(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceQueueInfo2* from, VkDeviceQueueInfo2* to);
-void deepcopy_VkProtectedSubmitInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkProtectedSubmitInfo* from,
- VkProtectedSubmitInfo* to);
+void deepcopy_VkProtectedSubmitInfo(Allocator* alloc, VkStructureType rootType,
+ const VkProtectedSubmitInfo* from, VkProtectedSubmitInfo* to);
-void deepcopy_VkSamplerYcbcrConversionCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSamplerYcbcrConversionCreateInfo* from,
- VkSamplerYcbcrConversionCreateInfo* to);
+void deepcopy_VkSamplerYcbcrConversionCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSamplerYcbcrConversionCreateInfo* from,
+ VkSamplerYcbcrConversionCreateInfo* to);
-void deepcopy_VkSamplerYcbcrConversionInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSamplerYcbcrConversionInfo* from,
- VkSamplerYcbcrConversionInfo* to);
+void deepcopy_VkSamplerYcbcrConversionInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSamplerYcbcrConversionInfo* from,
+ VkSamplerYcbcrConversionInfo* to);
-void deepcopy_VkBindImagePlaneMemoryInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindImagePlaneMemoryInfo* from,
- VkBindImagePlaneMemoryInfo* to);
+void deepcopy_VkBindImagePlaneMemoryInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBindImagePlaneMemoryInfo* from,
+ VkBindImagePlaneMemoryInfo* to);
-void deepcopy_VkImagePlaneMemoryRequirementsInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImagePlaneMemoryRequirementsInfo* from,
- VkImagePlaneMemoryRequirementsInfo* to);
+void deepcopy_VkImagePlaneMemoryRequirementsInfo(Allocator* alloc, VkStructureType rootType,
+ const VkImagePlaneMemoryRequirementsInfo* from,
+ VkImagePlaneMemoryRequirementsInfo* to);
void deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceSamplerYcbcrConversionFeatures* from,
VkPhysicalDeviceSamplerYcbcrConversionFeatures* to);
void deepcopy_VkSamplerYcbcrConversionImageFormatProperties(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkSamplerYcbcrConversionImageFormatProperties* from,
VkSamplerYcbcrConversionImageFormatProperties* to);
-void deepcopy_VkDescriptorUpdateTemplateEntry(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDescriptorUpdateTemplateEntry* from,
- VkDescriptorUpdateTemplateEntry* to);
+void deepcopy_VkDescriptorUpdateTemplateEntry(Allocator* alloc, VkStructureType rootType,
+ const VkDescriptorUpdateTemplateEntry* from,
+ VkDescriptorUpdateTemplateEntry* to);
-void deepcopy_VkDescriptorUpdateTemplateCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDescriptorUpdateTemplateCreateInfo* from,
- VkDescriptorUpdateTemplateCreateInfo* to);
+void deepcopy_VkDescriptorUpdateTemplateCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkDescriptorUpdateTemplateCreateInfo* from,
+ VkDescriptorUpdateTemplateCreateInfo* to);
-void deepcopy_VkExternalMemoryProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExternalMemoryProperties* from,
- VkExternalMemoryProperties* to);
+void deepcopy_VkExternalMemoryProperties(Allocator* alloc, VkStructureType rootType,
+ const VkExternalMemoryProperties* from,
+ VkExternalMemoryProperties* to);
void deepcopy_VkPhysicalDeviceExternalImageFormatInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalImageFormatInfo* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceExternalImageFormatInfo* from,
VkPhysicalDeviceExternalImageFormatInfo* to);
-void deepcopy_VkExternalImageFormatProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExternalImageFormatProperties* from,
- VkExternalImageFormatProperties* to);
+void deepcopy_VkExternalImageFormatProperties(Allocator* alloc, VkStructureType rootType,
+ const VkExternalImageFormatProperties* from,
+ VkExternalImageFormatProperties* to);
-void deepcopy_VkPhysicalDeviceExternalBufferInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalBufferInfo* from,
- VkPhysicalDeviceExternalBufferInfo* to);
+void deepcopy_VkPhysicalDeviceExternalBufferInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceExternalBufferInfo* from,
+ VkPhysicalDeviceExternalBufferInfo* to);
-void deepcopy_VkExternalBufferProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExternalBufferProperties* from,
- VkExternalBufferProperties* to);
+void deepcopy_VkExternalBufferProperties(Allocator* alloc, VkStructureType rootType,
+ const VkExternalBufferProperties* from,
+ VkExternalBufferProperties* to);
-void deepcopy_VkPhysicalDeviceIDProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceIDProperties* from,
- VkPhysicalDeviceIDProperties* to);
+void deepcopy_VkPhysicalDeviceIDProperties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceIDProperties* from,
+ VkPhysicalDeviceIDProperties* to);
-void deepcopy_VkExternalMemoryImageCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExternalMemoryImageCreateInfo* from,
- VkExternalMemoryImageCreateInfo* to);
+void deepcopy_VkExternalMemoryImageCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkExternalMemoryImageCreateInfo* from,
+ VkExternalMemoryImageCreateInfo* to);
-void deepcopy_VkExternalMemoryBufferCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExternalMemoryBufferCreateInfo* from,
- VkExternalMemoryBufferCreateInfo* to);
+void deepcopy_VkExternalMemoryBufferCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkExternalMemoryBufferCreateInfo* from,
+ VkExternalMemoryBufferCreateInfo* to);
-void deepcopy_VkExportMemoryAllocateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExportMemoryAllocateInfo* from,
- VkExportMemoryAllocateInfo* to);
+void deepcopy_VkExportMemoryAllocateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkExportMemoryAllocateInfo* from,
+ VkExportMemoryAllocateInfo* to);
-void deepcopy_VkPhysicalDeviceExternalFenceInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalFenceInfo* from,
- VkPhysicalDeviceExternalFenceInfo* to);
+void deepcopy_VkPhysicalDeviceExternalFenceInfo(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceExternalFenceInfo* from,
+ VkPhysicalDeviceExternalFenceInfo* to);
-void deepcopy_VkExternalFenceProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExternalFenceProperties* from,
- VkExternalFenceProperties* to);
+void deepcopy_VkExternalFenceProperties(Allocator* alloc, VkStructureType rootType,
+ const VkExternalFenceProperties* from,
+ VkExternalFenceProperties* to);
-void deepcopy_VkExportFenceCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExportFenceCreateInfo* from,
- VkExportFenceCreateInfo* to);
+void deepcopy_VkExportFenceCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkExportFenceCreateInfo* from,
+ VkExportFenceCreateInfo* to);
-void deepcopy_VkExportSemaphoreCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExportSemaphoreCreateInfo* from,
- VkExportSemaphoreCreateInfo* to);
+void deepcopy_VkExportSemaphoreCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkExportSemaphoreCreateInfo* from,
+ VkExportSemaphoreCreateInfo* to);
void deepcopy_VkPhysicalDeviceExternalSemaphoreInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalSemaphoreInfo* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceExternalSemaphoreInfo* from,
VkPhysicalDeviceExternalSemaphoreInfo* to);
-void deepcopy_VkExternalSemaphoreProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExternalSemaphoreProperties* from,
- VkExternalSemaphoreProperties* to);
+void deepcopy_VkExternalSemaphoreProperties(Allocator* alloc, VkStructureType rootType,
+ const VkExternalSemaphoreProperties* from,
+ VkExternalSemaphoreProperties* to);
void deepcopy_VkPhysicalDeviceMaintenance3Properties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceMaintenance3Properties* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMaintenance3Properties* from,
VkPhysicalDeviceMaintenance3Properties* to);
-void deepcopy_VkDescriptorSetLayoutSupport(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDescriptorSetLayoutSupport* from,
- VkDescriptorSetLayoutSupport* to);
+void deepcopy_VkDescriptorSetLayoutSupport(Allocator* alloc, VkStructureType rootType,
+ const VkDescriptorSetLayoutSupport* from,
+ VkDescriptorSetLayoutSupport* to);
void deepcopy_VkPhysicalDeviceShaderDrawParametersFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderDrawParametersFeatures* from,
VkPhysicalDeviceShaderDrawParametersFeatures* to);
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderDrawParametersFeatures, deepcopy_VkPhysicalDeviceShaderDrawParameterFeatures)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderDrawParametersFeatures,
+ deepcopy_VkPhysicalDeviceShaderDrawParameterFeatures)
#endif
#ifdef VK_VERSION_1_2
-void deepcopy_VkPhysicalDeviceVulkan11Features(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan11Features* from,
- VkPhysicalDeviceVulkan11Features* to);
+void deepcopy_VkPhysicalDeviceVulkan11Features(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan11Features* from,
+ VkPhysicalDeviceVulkan11Features* to);
-void deepcopy_VkPhysicalDeviceVulkan11Properties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan11Properties* from,
- VkPhysicalDeviceVulkan11Properties* to);
+void deepcopy_VkPhysicalDeviceVulkan11Properties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan11Properties* from,
+ VkPhysicalDeviceVulkan11Properties* to);
-void deepcopy_VkPhysicalDeviceVulkan12Features(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan12Features* from,
- VkPhysicalDeviceVulkan12Features* to);
+void deepcopy_VkPhysicalDeviceVulkan12Features(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan12Features* from,
+ VkPhysicalDeviceVulkan12Features* to);
-void deepcopy_VkConformanceVersion(
- Allocator* alloc,
- VkStructureType rootType,
- const VkConformanceVersion* from,
- VkConformanceVersion* to);
+void deepcopy_VkConformanceVersion(Allocator* alloc, VkStructureType rootType,
+ const VkConformanceVersion* from, VkConformanceVersion* to);
-void deepcopy_VkPhysicalDeviceVulkan12Properties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan12Properties* from,
- VkPhysicalDeviceVulkan12Properties* to);
+void deepcopy_VkPhysicalDeviceVulkan12Properties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan12Properties* from,
+ VkPhysicalDeviceVulkan12Properties* to);
-void deepcopy_VkImageFormatListCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageFormatListCreateInfo* from,
- VkImageFormatListCreateInfo* to);
+void deepcopy_VkImageFormatListCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkImageFormatListCreateInfo* from,
+ VkImageFormatListCreateInfo* to);
-void deepcopy_VkAttachmentDescription2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAttachmentDescription2* from,
- VkAttachmentDescription2* to);
+void deepcopy_VkAttachmentDescription2(Allocator* alloc, VkStructureType rootType,
+ const VkAttachmentDescription2* from,
+ VkAttachmentDescription2* to);
-void deepcopy_VkAttachmentReference2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAttachmentReference2* from,
- VkAttachmentReference2* to);
+void deepcopy_VkAttachmentReference2(Allocator* alloc, VkStructureType rootType,
+ const VkAttachmentReference2* from,
+ VkAttachmentReference2* to);
-void deepcopy_VkSubpassDescription2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubpassDescription2* from,
- VkSubpassDescription2* to);
+void deepcopy_VkSubpassDescription2(Allocator* alloc, VkStructureType rootType,
+ const VkSubpassDescription2* from, VkSubpassDescription2* to);
-void deepcopy_VkSubpassDependency2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubpassDependency2* from,
- VkSubpassDependency2* to);
+void deepcopy_VkSubpassDependency2(Allocator* alloc, VkStructureType rootType,
+ const VkSubpassDependency2* from, VkSubpassDependency2* to);
-void deepcopy_VkRenderPassCreateInfo2(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRenderPassCreateInfo2* from,
- VkRenderPassCreateInfo2* to);
+void deepcopy_VkRenderPassCreateInfo2(Allocator* alloc, VkStructureType rootType,
+ const VkRenderPassCreateInfo2* from,
+ VkRenderPassCreateInfo2* to);
-void deepcopy_VkSubpassBeginInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubpassBeginInfo* from,
- VkSubpassBeginInfo* to);
+void deepcopy_VkSubpassBeginInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSubpassBeginInfo* from, VkSubpassBeginInfo* to);
-void deepcopy_VkSubpassEndInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubpassEndInfo* from,
- VkSubpassEndInfo* to);
+void deepcopy_VkSubpassEndInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSubpassEndInfo* from, VkSubpassEndInfo* to);
-void deepcopy_VkPhysicalDevice8BitStorageFeatures(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDevice8BitStorageFeatures* from,
- VkPhysicalDevice8BitStorageFeatures* to);
+void deepcopy_VkPhysicalDevice8BitStorageFeatures(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDevice8BitStorageFeatures* from,
+ VkPhysicalDevice8BitStorageFeatures* to);
-void deepcopy_VkPhysicalDeviceDriverProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceDriverProperties* from,
- VkPhysicalDeviceDriverProperties* to);
+void deepcopy_VkPhysicalDeviceDriverProperties(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceDriverProperties* from,
+ VkPhysicalDeviceDriverProperties* to);
void deepcopy_VkPhysicalDeviceShaderAtomicInt64Features(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicInt64Features* from,
VkPhysicalDeviceShaderAtomicInt64Features* to);
void deepcopy_VkPhysicalDeviceShaderFloat16Int8Features(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderFloat16Int8Features* from,
VkPhysicalDeviceShaderFloat16Int8Features* to);
void deepcopy_VkPhysicalDeviceFloatControlsProperties(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceFloatControlsProperties* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceFloatControlsProperties* from,
VkPhysicalDeviceFloatControlsProperties* to);
void deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkDescriptorSetLayoutBindingFlagsCreateInfo* from,
VkDescriptorSetLayoutBindingFlagsCreateInfo* to);
void deepcopy_VkPhysicalDeviceDescriptorIndexingFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDescriptorIndexingFeatures* from,
VkPhysicalDeviceDescriptorIndexingFeatures* to);
void deepcopy_VkPhysicalDeviceDescriptorIndexingProperties(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDescriptorIndexingProperties* from,
VkPhysicalDeviceDescriptorIndexingProperties* to);
void deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfo(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkDescriptorSetVariableDescriptorCountAllocateInfo* from,
VkDescriptorSetVariableDescriptorCountAllocateInfo* to);
void deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupport(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkDescriptorSetVariableDescriptorCountLayoutSupport* from,
VkDescriptorSetVariableDescriptorCountLayoutSupport* to);
void deepcopy_VkSubpassDescriptionDepthStencilResolve(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubpassDescriptionDepthStencilResolve* from,
+ Allocator* alloc, VkStructureType rootType, const VkSubpassDescriptionDepthStencilResolve* from,
VkSubpassDescriptionDepthStencilResolve* to);
void deepcopy_VkPhysicalDeviceDepthStencilResolveProperties(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDepthStencilResolveProperties* from,
VkPhysicalDeviceDepthStencilResolveProperties* to);
void deepcopy_VkPhysicalDeviceScalarBlockLayoutFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceScalarBlockLayoutFeatures* from,
VkPhysicalDeviceScalarBlockLayoutFeatures* to);
-void deepcopy_VkImageStencilUsageCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageStencilUsageCreateInfo* from,
- VkImageStencilUsageCreateInfo* to);
+void deepcopy_VkImageStencilUsageCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkImageStencilUsageCreateInfo* from,
+ VkImageStencilUsageCreateInfo* to);
-void deepcopy_VkSamplerReductionModeCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSamplerReductionModeCreateInfo* from,
- VkSamplerReductionModeCreateInfo* to);
+void deepcopy_VkSamplerReductionModeCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSamplerReductionModeCreateInfo* from,
+ VkSamplerReductionModeCreateInfo* to);
void deepcopy_VkPhysicalDeviceSamplerFilterMinmaxProperties(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceSamplerFilterMinmaxProperties* from,
VkPhysicalDeviceSamplerFilterMinmaxProperties* to);
void deepcopy_VkPhysicalDeviceVulkanMemoryModelFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceVulkanMemoryModelFeatures* from,
VkPhysicalDeviceVulkanMemoryModelFeatures* to);
void deepcopy_VkPhysicalDeviceImagelessFramebufferFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceImagelessFramebufferFeatures* from,
VkPhysicalDeviceImagelessFramebufferFeatures* to);
-void deepcopy_VkFramebufferAttachmentImageInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFramebufferAttachmentImageInfo* from,
- VkFramebufferAttachmentImageInfo* to);
+void deepcopy_VkFramebufferAttachmentImageInfo(Allocator* alloc, VkStructureType rootType,
+ const VkFramebufferAttachmentImageInfo* from,
+ VkFramebufferAttachmentImageInfo* to);
-void deepcopy_VkFramebufferAttachmentsCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFramebufferAttachmentsCreateInfo* from,
- VkFramebufferAttachmentsCreateInfo* to);
+void deepcopy_VkFramebufferAttachmentsCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkFramebufferAttachmentsCreateInfo* from,
+ VkFramebufferAttachmentsCreateInfo* to);
-void deepcopy_VkRenderPassAttachmentBeginInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRenderPassAttachmentBeginInfo* from,
- VkRenderPassAttachmentBeginInfo* to);
+void deepcopy_VkRenderPassAttachmentBeginInfo(Allocator* alloc, VkStructureType rootType,
+ const VkRenderPassAttachmentBeginInfo* from,
+ VkRenderPassAttachmentBeginInfo* to);
void deepcopy_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* from,
VkPhysicalDeviceUniformBufferStandardLayoutFeatures* to);
void deepcopy_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* from,
VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* to);
void deepcopy_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* from,
VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* to);
-void deepcopy_VkAttachmentReferenceStencilLayout(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAttachmentReferenceStencilLayout* from,
- VkAttachmentReferenceStencilLayout* to);
+void deepcopy_VkAttachmentReferenceStencilLayout(Allocator* alloc, VkStructureType rootType,
+ const VkAttachmentReferenceStencilLayout* from,
+ VkAttachmentReferenceStencilLayout* to);
-void deepcopy_VkAttachmentDescriptionStencilLayout(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAttachmentDescriptionStencilLayout* from,
- VkAttachmentDescriptionStencilLayout* to);
+void deepcopy_VkAttachmentDescriptionStencilLayout(Allocator* alloc, VkStructureType rootType,
+ const VkAttachmentDescriptionStencilLayout* from,
+ VkAttachmentDescriptionStencilLayout* to);
void deepcopy_VkPhysicalDeviceHostQueryResetFeatures(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceHostQueryResetFeatures* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceHostQueryResetFeatures* from,
VkPhysicalDeviceHostQueryResetFeatures* to);
void deepcopy_VkPhysicalDeviceTimelineSemaphoreFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceTimelineSemaphoreFeatures* from,
VkPhysicalDeviceTimelineSemaphoreFeatures* to);
void deepcopy_VkPhysicalDeviceTimelineSemaphoreProperties(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceTimelineSemaphoreProperties* from,
VkPhysicalDeviceTimelineSemaphoreProperties* to);
-void deepcopy_VkSemaphoreTypeCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSemaphoreTypeCreateInfo* from,
- VkSemaphoreTypeCreateInfo* to);
+void deepcopy_VkSemaphoreTypeCreateInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSemaphoreTypeCreateInfo* from,
+ VkSemaphoreTypeCreateInfo* to);
-void deepcopy_VkTimelineSemaphoreSubmitInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkTimelineSemaphoreSubmitInfo* from,
- VkTimelineSemaphoreSubmitInfo* to);
+void deepcopy_VkTimelineSemaphoreSubmitInfo(Allocator* alloc, VkStructureType rootType,
+ const VkTimelineSemaphoreSubmitInfo* from,
+ VkTimelineSemaphoreSubmitInfo* to);
-void deepcopy_VkSemaphoreWaitInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSemaphoreWaitInfo* from,
- VkSemaphoreWaitInfo* to);
+void deepcopy_VkSemaphoreWaitInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSemaphoreWaitInfo* from, VkSemaphoreWaitInfo* to);
-void deepcopy_VkSemaphoreSignalInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSemaphoreSignalInfo* from,
- VkSemaphoreSignalInfo* to);
+void deepcopy_VkSemaphoreSignalInfo(Allocator* alloc, VkStructureType rootType,
+ const VkSemaphoreSignalInfo* from, VkSemaphoreSignalInfo* to);
void deepcopy_VkPhysicalDeviceBufferDeviceAddressFeatures(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceBufferDeviceAddressFeatures* from,
VkPhysicalDeviceBufferDeviceAddressFeatures* to);
-void deepcopy_VkBufferDeviceAddressInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferDeviceAddressInfo* from,
- VkBufferDeviceAddressInfo* to);
+void deepcopy_VkBufferDeviceAddressInfo(Allocator* alloc, VkStructureType rootType,
+ const VkBufferDeviceAddressInfo* from,
+ VkBufferDeviceAddressInfo* to);
void deepcopy_VkBufferOpaqueCaptureAddressCreateInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferOpaqueCaptureAddressCreateInfo* from,
+ Allocator* alloc, VkStructureType rootType, const VkBufferOpaqueCaptureAddressCreateInfo* from,
VkBufferOpaqueCaptureAddressCreateInfo* to);
void deepcopy_VkMemoryOpaqueCaptureAddressAllocateInfo(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkMemoryOpaqueCaptureAddressAllocateInfo* from,
VkMemoryOpaqueCaptureAddressAllocateInfo* to);
void deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfo(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceMemoryOpaqueCaptureAddressInfo* from,
+ Allocator* alloc, VkStructureType rootType, const VkDeviceMemoryOpaqueCaptureAddressInfo* from,
VkDeviceMemoryOpaqueCaptureAddressInfo* to);
#endif
#ifdef VK_KHR_surface
-void deepcopy_VkSurfaceCapabilitiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSurfaceCapabilitiesKHR* from,
- VkSurfaceCapabilitiesKHR* to);
+void deepcopy_VkSurfaceCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkSurfaceCapabilitiesKHR* from,
+ VkSurfaceCapabilitiesKHR* to);
-void deepcopy_VkSurfaceFormatKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSurfaceFormatKHR* from,
- VkSurfaceFormatKHR* to);
+void deepcopy_VkSurfaceFormatKHR(Allocator* alloc, VkStructureType rootType,
+ const VkSurfaceFormatKHR* from, VkSurfaceFormatKHR* to);
#endif
#ifdef VK_KHR_swapchain
-void deepcopy_VkSwapchainCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSwapchainCreateInfoKHR* from,
- VkSwapchainCreateInfoKHR* to);
+void deepcopy_VkSwapchainCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkSwapchainCreateInfoKHR* from,
+ VkSwapchainCreateInfoKHR* to);
-void deepcopy_VkPresentInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPresentInfoKHR* from,
- VkPresentInfoKHR* to);
+void deepcopy_VkPresentInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPresentInfoKHR* from, VkPresentInfoKHR* to);
-void deepcopy_VkImageSwapchainCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageSwapchainCreateInfoKHR* from,
- VkImageSwapchainCreateInfoKHR* to);
+void deepcopy_VkImageSwapchainCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkImageSwapchainCreateInfoKHR* from,
+ VkImageSwapchainCreateInfoKHR* to);
-void deepcopy_VkBindImageMemorySwapchainInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindImageMemorySwapchainInfoKHR* from,
- VkBindImageMemorySwapchainInfoKHR* to);
+void deepcopy_VkBindImageMemorySwapchainInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkBindImageMemorySwapchainInfoKHR* from,
+ VkBindImageMemorySwapchainInfoKHR* to);
-void deepcopy_VkAcquireNextImageInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAcquireNextImageInfoKHR* from,
- VkAcquireNextImageInfoKHR* to);
+void deepcopy_VkAcquireNextImageInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkAcquireNextImageInfoKHR* from,
+ VkAcquireNextImageInfoKHR* to);
-void deepcopy_VkDeviceGroupPresentCapabilitiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceGroupPresentCapabilitiesKHR* from,
- VkDeviceGroupPresentCapabilitiesKHR* to);
+void deepcopy_VkDeviceGroupPresentCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceGroupPresentCapabilitiesKHR* from,
+ VkDeviceGroupPresentCapabilitiesKHR* to);
-void deepcopy_VkDeviceGroupPresentInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceGroupPresentInfoKHR* from,
- VkDeviceGroupPresentInfoKHR* to);
+void deepcopy_VkDeviceGroupPresentInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceGroupPresentInfoKHR* from,
+ VkDeviceGroupPresentInfoKHR* to);
-void deepcopy_VkDeviceGroupSwapchainCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceGroupSwapchainCreateInfoKHR* from,
- VkDeviceGroupSwapchainCreateInfoKHR* to);
+void deepcopy_VkDeviceGroupSwapchainCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceGroupSwapchainCreateInfoKHR* from,
+ VkDeviceGroupSwapchainCreateInfoKHR* to);
#endif
#ifdef VK_KHR_display
-void deepcopy_VkDisplayModeParametersKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayModeParametersKHR* from,
- VkDisplayModeParametersKHR* to);
+void deepcopy_VkDisplayModeParametersKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayModeParametersKHR* from,
+ VkDisplayModeParametersKHR* to);
-void deepcopy_VkDisplayModeCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayModeCreateInfoKHR* from,
- VkDisplayModeCreateInfoKHR* to);
+void deepcopy_VkDisplayModeCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayModeCreateInfoKHR* from,
+ VkDisplayModeCreateInfoKHR* to);
-void deepcopy_VkDisplayModePropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayModePropertiesKHR* from,
- VkDisplayModePropertiesKHR* to);
+void deepcopy_VkDisplayModePropertiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayModePropertiesKHR* from,
+ VkDisplayModePropertiesKHR* to);
-void deepcopy_VkDisplayPlaneCapabilitiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayPlaneCapabilitiesKHR* from,
- VkDisplayPlaneCapabilitiesKHR* to);
+void deepcopy_VkDisplayPlaneCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayPlaneCapabilitiesKHR* from,
+ VkDisplayPlaneCapabilitiesKHR* to);
-void deepcopy_VkDisplayPlanePropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayPlanePropertiesKHR* from,
- VkDisplayPlanePropertiesKHR* to);
+void deepcopy_VkDisplayPlanePropertiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayPlanePropertiesKHR* from,
+ VkDisplayPlanePropertiesKHR* to);
-void deepcopy_VkDisplayPropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayPropertiesKHR* from,
- VkDisplayPropertiesKHR* to);
+void deepcopy_VkDisplayPropertiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayPropertiesKHR* from,
+ VkDisplayPropertiesKHR* to);
-void deepcopy_VkDisplaySurfaceCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplaySurfaceCreateInfoKHR* from,
- VkDisplaySurfaceCreateInfoKHR* to);
+void deepcopy_VkDisplaySurfaceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplaySurfaceCreateInfoKHR* from,
+ VkDisplaySurfaceCreateInfoKHR* to);
#endif
#ifdef VK_KHR_display_swapchain
-void deepcopy_VkDisplayPresentInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayPresentInfoKHR* from,
- VkDisplayPresentInfoKHR* to);
+void deepcopy_VkDisplayPresentInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayPresentInfoKHR* from,
+ VkDisplayPresentInfoKHR* to);
#endif
#ifdef VK_KHR_xlib_surface
-void deepcopy_VkXlibSurfaceCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkXlibSurfaceCreateInfoKHR* from,
- VkXlibSurfaceCreateInfoKHR* to);
+void deepcopy_VkXlibSurfaceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkXlibSurfaceCreateInfoKHR* from,
+ VkXlibSurfaceCreateInfoKHR* to);
#endif
#ifdef VK_KHR_xcb_surface
-void deepcopy_VkXcbSurfaceCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkXcbSurfaceCreateInfoKHR* from,
- VkXcbSurfaceCreateInfoKHR* to);
+void deepcopy_VkXcbSurfaceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkXcbSurfaceCreateInfoKHR* from,
+ VkXcbSurfaceCreateInfoKHR* to);
#endif
#ifdef VK_KHR_wayland_surface
-void deepcopy_VkWaylandSurfaceCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkWaylandSurfaceCreateInfoKHR* from,
- VkWaylandSurfaceCreateInfoKHR* to);
+void deepcopy_VkWaylandSurfaceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkWaylandSurfaceCreateInfoKHR* from,
+ VkWaylandSurfaceCreateInfoKHR* to);
#endif
#ifdef VK_KHR_android_surface
-void deepcopy_VkAndroidSurfaceCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAndroidSurfaceCreateInfoKHR* from,
- VkAndroidSurfaceCreateInfoKHR* to);
+void deepcopy_VkAndroidSurfaceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkAndroidSurfaceCreateInfoKHR* from,
+ VkAndroidSurfaceCreateInfoKHR* to);
#endif
#ifdef VK_KHR_win32_surface
-void deepcopy_VkWin32SurfaceCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkWin32SurfaceCreateInfoKHR* from,
- VkWin32SurfaceCreateInfoKHR* to);
+void deepcopy_VkWin32SurfaceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkWin32SurfaceCreateInfoKHR* from,
+ VkWin32SurfaceCreateInfoKHR* to);
#endif
#ifdef VK_KHR_sampler_mirror_clamp_to_edge
#endif
#ifdef VK_KHR_video_queue
-void deepcopy_VkVideoQueueFamilyProperties2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoQueueFamilyProperties2KHR* from,
- VkVideoQueueFamilyProperties2KHR* to);
+void deepcopy_VkVideoQueueFamilyProperties2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoQueueFamilyProperties2KHR* from,
+ VkVideoQueueFamilyProperties2KHR* to);
-void deepcopy_VkVideoProfileKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoProfileKHR* from,
- VkVideoProfileKHR* to);
+void deepcopy_VkVideoProfileKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoProfileKHR* from, VkVideoProfileKHR* to);
-void deepcopy_VkVideoProfilesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoProfilesKHR* from,
- VkVideoProfilesKHR* to);
+void deepcopy_VkVideoProfilesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoProfilesKHR* from, VkVideoProfilesKHR* to);
-void deepcopy_VkVideoCapabilitiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoCapabilitiesKHR* from,
- VkVideoCapabilitiesKHR* to);
+void deepcopy_VkVideoCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoCapabilitiesKHR* from,
+ VkVideoCapabilitiesKHR* to);
-void deepcopy_VkPhysicalDeviceVideoFormatInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceVideoFormatInfoKHR* from,
- VkPhysicalDeviceVideoFormatInfoKHR* to);
+void deepcopy_VkPhysicalDeviceVideoFormatInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceVideoFormatInfoKHR* from,
+ VkPhysicalDeviceVideoFormatInfoKHR* to);
-void deepcopy_VkVideoFormatPropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoFormatPropertiesKHR* from,
- VkVideoFormatPropertiesKHR* to);
+void deepcopy_VkVideoFormatPropertiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoFormatPropertiesKHR* from,
+ VkVideoFormatPropertiesKHR* to);
-void deepcopy_VkVideoPictureResourceKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoPictureResourceKHR* from,
- VkVideoPictureResourceKHR* to);
+void deepcopy_VkVideoPictureResourceKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoPictureResourceKHR* from,
+ VkVideoPictureResourceKHR* to);
-void deepcopy_VkVideoReferenceSlotKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoReferenceSlotKHR* from,
- VkVideoReferenceSlotKHR* to);
+void deepcopy_VkVideoReferenceSlotKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoReferenceSlotKHR* from,
+ VkVideoReferenceSlotKHR* to);
-void deepcopy_VkVideoGetMemoryPropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoGetMemoryPropertiesKHR* from,
- VkVideoGetMemoryPropertiesKHR* to);
+void deepcopy_VkVideoGetMemoryPropertiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoGetMemoryPropertiesKHR* from,
+ VkVideoGetMemoryPropertiesKHR* to);
-void deepcopy_VkVideoBindMemoryKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoBindMemoryKHR* from,
- VkVideoBindMemoryKHR* to);
+void deepcopy_VkVideoBindMemoryKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoBindMemoryKHR* from, VkVideoBindMemoryKHR* to);
-void deepcopy_VkVideoSessionCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoSessionCreateInfoKHR* from,
- VkVideoSessionCreateInfoKHR* to);
+void deepcopy_VkVideoSessionCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoSessionCreateInfoKHR* from,
+ VkVideoSessionCreateInfoKHR* to);
void deepcopy_VkVideoSessionParametersCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoSessionParametersCreateInfoKHR* from,
+ Allocator* alloc, VkStructureType rootType, const VkVideoSessionParametersCreateInfoKHR* from,
VkVideoSessionParametersCreateInfoKHR* to);
void deepcopy_VkVideoSessionParametersUpdateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoSessionParametersUpdateInfoKHR* from,
+ Allocator* alloc, VkStructureType rootType, const VkVideoSessionParametersUpdateInfoKHR* from,
VkVideoSessionParametersUpdateInfoKHR* to);
-void deepcopy_VkVideoBeginCodingInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoBeginCodingInfoKHR* from,
- VkVideoBeginCodingInfoKHR* to);
+void deepcopy_VkVideoBeginCodingInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoBeginCodingInfoKHR* from,
+ VkVideoBeginCodingInfoKHR* to);
-void deepcopy_VkVideoEndCodingInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEndCodingInfoKHR* from,
- VkVideoEndCodingInfoKHR* to);
+void deepcopy_VkVideoEndCodingInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEndCodingInfoKHR* from,
+ VkVideoEndCodingInfoKHR* to);
-void deepcopy_VkVideoCodingControlInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoCodingControlInfoKHR* from,
- VkVideoCodingControlInfoKHR* to);
+void deepcopy_VkVideoCodingControlInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoCodingControlInfoKHR* from,
+ VkVideoCodingControlInfoKHR* to);
#endif
#ifdef VK_KHR_video_decode_queue
-void deepcopy_VkVideoDecodeInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeInfoKHR* from,
- VkVideoDecodeInfoKHR* to);
+void deepcopy_VkVideoDecodeInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoDecodeInfoKHR* from, VkVideoDecodeInfoKHR* to);
#endif
#ifdef VK_KHR_dynamic_rendering
-void deepcopy_VkRenderingAttachmentInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRenderingAttachmentInfoKHR* from,
- VkRenderingAttachmentInfoKHR* to);
+void deepcopy_VkRenderingAttachmentInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkRenderingAttachmentInfoKHR* from,
+ VkRenderingAttachmentInfoKHR* to);
-void deepcopy_VkRenderingInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRenderingInfoKHR* from,
- VkRenderingInfoKHR* to);
+void deepcopy_VkRenderingInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkRenderingInfoKHR* from, VkRenderingInfoKHR* to);
-void deepcopy_VkPipelineRenderingCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineRenderingCreateInfoKHR* from,
- VkPipelineRenderingCreateInfoKHR* to);
+void deepcopy_VkPipelineRenderingCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineRenderingCreateInfoKHR* from,
+ VkPipelineRenderingCreateInfoKHR* to);
void deepcopy_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDynamicRenderingFeaturesKHR* from,
VkPhysicalDeviceDynamicRenderingFeaturesKHR* to);
void deepcopy_VkCommandBufferInheritanceRenderingInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkCommandBufferInheritanceRenderingInfoKHR* from,
VkCommandBufferInheritanceRenderingInfoKHR* to);
void deepcopy_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkRenderingFragmentShadingRateAttachmentInfoKHR* from,
VkRenderingFragmentShadingRateAttachmentInfoKHR* to);
void deepcopy_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkRenderingFragmentDensityMapAttachmentInfoEXT* from,
VkRenderingFragmentDensityMapAttachmentInfoEXT* to);
-void deepcopy_VkAttachmentSampleCountInfoAMD(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAttachmentSampleCountInfoAMD* from,
- VkAttachmentSampleCountInfoAMD* to);
+void deepcopy_VkAttachmentSampleCountInfoAMD(Allocator* alloc, VkStructureType rootType,
+ const VkAttachmentSampleCountInfoAMD* from,
+ VkAttachmentSampleCountInfoAMD* to);
-DEFINE_ALIAS_FUNCTION(deepcopy_VkAttachmentSampleCountInfoAMD, deepcopy_VkAttachmentSampleCountInfoNV)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkAttachmentSampleCountInfoAMD,
+ deepcopy_VkAttachmentSampleCountInfoNV)
-void deepcopy_VkMultiviewPerViewAttributesInfoNVX(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMultiviewPerViewAttributesInfoNVX* from,
- VkMultiviewPerViewAttributesInfoNVX* to);
+void deepcopy_VkMultiviewPerViewAttributesInfoNVX(Allocator* alloc, VkStructureType rootType,
+ const VkMultiviewPerViewAttributesInfoNVX* from,
+ VkMultiviewPerViewAttributesInfoNVX* to);
#endif
#ifdef VK_KHR_multiview
-DEFINE_ALIAS_FUNCTION(deepcopy_VkRenderPassMultiviewCreateInfo, deepcopy_VkRenderPassMultiviewCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkRenderPassMultiviewCreateInfo,
+ deepcopy_VkRenderPassMultiviewCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceMultiviewFeatures, deepcopy_VkPhysicalDeviceMultiviewFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceMultiviewFeatures,
+ deepcopy_VkPhysicalDeviceMultiviewFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceMultiviewProperties, deepcopy_VkPhysicalDeviceMultiviewPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceMultiviewProperties,
+ deepcopy_VkPhysicalDeviceMultiviewPropertiesKHR)
#endif
#ifdef VK_KHR_get_physical_device_properties2
@@ -1767,31 +1171,39 @@
DEFINE_ALIAS_FUNCTION(deepcopy_VkImageFormatProperties2, deepcopy_VkImageFormatProperties2KHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceImageFormatInfo2, deepcopy_VkPhysicalDeviceImageFormatInfo2KHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceImageFormatInfo2,
+ deepcopy_VkPhysicalDeviceImageFormatInfo2KHR)
DEFINE_ALIAS_FUNCTION(deepcopy_VkQueueFamilyProperties2, deepcopy_VkQueueFamilyProperties2KHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceMemoryProperties2, deepcopy_VkPhysicalDeviceMemoryProperties2KHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceMemoryProperties2,
+ deepcopy_VkPhysicalDeviceMemoryProperties2KHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkSparseImageFormatProperties2, deepcopy_VkSparseImageFormatProperties2KHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkSparseImageFormatProperties2,
+ deepcopy_VkSparseImageFormatProperties2KHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceSparseImageFormatInfo2, deepcopy_VkPhysicalDeviceSparseImageFormatInfo2KHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceSparseImageFormatInfo2,
+ deepcopy_VkPhysicalDeviceSparseImageFormatInfo2KHR)
#endif
#ifdef VK_KHR_device_group
DEFINE_ALIAS_FUNCTION(deepcopy_VkMemoryAllocateFlagsInfo, deepcopy_VkMemoryAllocateFlagsInfoKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceGroupRenderPassBeginInfo, deepcopy_VkDeviceGroupRenderPassBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceGroupRenderPassBeginInfo,
+ deepcopy_VkDeviceGroupRenderPassBeginInfoKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceGroupCommandBufferBeginInfo, deepcopy_VkDeviceGroupCommandBufferBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceGroupCommandBufferBeginInfo,
+ deepcopy_VkDeviceGroupCommandBufferBeginInfoKHR)
DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceGroupSubmitInfo, deepcopy_VkDeviceGroupSubmitInfoKHR)
DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceGroupBindSparseInfo, deepcopy_VkDeviceGroupBindSparseInfoKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkBindBufferMemoryDeviceGroupInfo, deepcopy_VkBindBufferMemoryDeviceGroupInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkBindBufferMemoryDeviceGroupInfo,
+ deepcopy_VkBindBufferMemoryDeviceGroupInfoKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkBindImageMemoryDeviceGroupInfo, deepcopy_VkBindImageMemoryDeviceGroupInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkBindImageMemoryDeviceGroupInfo,
+ deepcopy_VkBindImageMemoryDeviceGroupInfoKHR)
#endif
#ifdef VK_KHR_shader_draw_parameters
@@ -1799,91 +1211,84 @@
#ifdef VK_KHR_maintenance1
#endif
#ifdef VK_KHR_device_group_creation
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceGroupProperties, deepcopy_VkPhysicalDeviceGroupPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceGroupProperties,
+ deepcopy_VkPhysicalDeviceGroupPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceGroupDeviceCreateInfo, deepcopy_VkDeviceGroupDeviceCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceGroupDeviceCreateInfo,
+ deepcopy_VkDeviceGroupDeviceCreateInfoKHR)
#endif
#ifdef VK_KHR_external_memory_capabilities
DEFINE_ALIAS_FUNCTION(deepcopy_VkExternalMemoryProperties, deepcopy_VkExternalMemoryPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceExternalImageFormatInfo, deepcopy_VkPhysicalDeviceExternalImageFormatInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceExternalImageFormatInfo,
+ deepcopy_VkPhysicalDeviceExternalImageFormatInfoKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkExternalImageFormatProperties, deepcopy_VkExternalImageFormatPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkExternalImageFormatProperties,
+ deepcopy_VkExternalImageFormatPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceExternalBufferInfo, deepcopy_VkPhysicalDeviceExternalBufferInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceExternalBufferInfo,
+ deepcopy_VkPhysicalDeviceExternalBufferInfoKHR)
DEFINE_ALIAS_FUNCTION(deepcopy_VkExternalBufferProperties, deepcopy_VkExternalBufferPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceIDProperties, deepcopy_VkPhysicalDeviceIDPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceIDProperties,
+ deepcopy_VkPhysicalDeviceIDPropertiesKHR)
#endif
#ifdef VK_KHR_external_memory
-DEFINE_ALIAS_FUNCTION(deepcopy_VkExternalMemoryImageCreateInfo, deepcopy_VkExternalMemoryImageCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkExternalMemoryImageCreateInfo,
+ deepcopy_VkExternalMemoryImageCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkExternalMemoryBufferCreateInfo, deepcopy_VkExternalMemoryBufferCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkExternalMemoryBufferCreateInfo,
+ deepcopy_VkExternalMemoryBufferCreateInfoKHR)
DEFINE_ALIAS_FUNCTION(deepcopy_VkExportMemoryAllocateInfo, deepcopy_VkExportMemoryAllocateInfoKHR)
#endif
#ifdef VK_KHR_external_memory_win32
-void deepcopy_VkImportMemoryWin32HandleInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportMemoryWin32HandleInfoKHR* from,
- VkImportMemoryWin32HandleInfoKHR* to);
+void deepcopy_VkImportMemoryWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkImportMemoryWin32HandleInfoKHR* from,
+ VkImportMemoryWin32HandleInfoKHR* to);
-void deepcopy_VkExportMemoryWin32HandleInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExportMemoryWin32HandleInfoKHR* from,
- VkExportMemoryWin32HandleInfoKHR* to);
+void deepcopy_VkExportMemoryWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkExportMemoryWin32HandleInfoKHR* from,
+ VkExportMemoryWin32HandleInfoKHR* to);
-void deepcopy_VkMemoryWin32HandlePropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryWin32HandlePropertiesKHR* from,
- VkMemoryWin32HandlePropertiesKHR* to);
+void deepcopy_VkMemoryWin32HandlePropertiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryWin32HandlePropertiesKHR* from,
+ VkMemoryWin32HandlePropertiesKHR* to);
-void deepcopy_VkMemoryGetWin32HandleInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryGetWin32HandleInfoKHR* from,
- VkMemoryGetWin32HandleInfoKHR* to);
+void deepcopy_VkMemoryGetWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryGetWin32HandleInfoKHR* from,
+ VkMemoryGetWin32HandleInfoKHR* to);
#endif
#ifdef VK_KHR_external_memory_fd
-void deepcopy_VkImportMemoryFdInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportMemoryFdInfoKHR* from,
- VkImportMemoryFdInfoKHR* to);
+void deepcopy_VkImportMemoryFdInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkImportMemoryFdInfoKHR* from,
+ VkImportMemoryFdInfoKHR* to);
-void deepcopy_VkMemoryFdPropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryFdPropertiesKHR* from,
- VkMemoryFdPropertiesKHR* to);
+void deepcopy_VkMemoryFdPropertiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryFdPropertiesKHR* from,
+ VkMemoryFdPropertiesKHR* to);
-void deepcopy_VkMemoryGetFdInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryGetFdInfoKHR* from,
- VkMemoryGetFdInfoKHR* to);
+void deepcopy_VkMemoryGetFdInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryGetFdInfoKHR* from, VkMemoryGetFdInfoKHR* to);
#endif
#ifdef VK_KHR_win32_keyed_mutex
void deepcopy_VkWin32KeyedMutexAcquireReleaseInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkWin32KeyedMutexAcquireReleaseInfoKHR* from,
+ Allocator* alloc, VkStructureType rootType, const VkWin32KeyedMutexAcquireReleaseInfoKHR* from,
VkWin32KeyedMutexAcquireReleaseInfoKHR* to);
#endif
#ifdef VK_KHR_external_semaphore_capabilities
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceExternalSemaphoreInfo, deepcopy_VkPhysicalDeviceExternalSemaphoreInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceExternalSemaphoreInfo,
+ deepcopy_VkPhysicalDeviceExternalSemaphoreInfoKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkExternalSemaphoreProperties, deepcopy_VkExternalSemaphorePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkExternalSemaphoreProperties,
+ deepcopy_VkExternalSemaphorePropertiesKHR)
#endif
#ifdef VK_KHR_external_semaphore
@@ -1891,97 +1296,84 @@
#endif
#ifdef VK_KHR_external_semaphore_win32
-void deepcopy_VkImportSemaphoreWin32HandleInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportSemaphoreWin32HandleInfoKHR* from,
- VkImportSemaphoreWin32HandleInfoKHR* to);
+void deepcopy_VkImportSemaphoreWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkImportSemaphoreWin32HandleInfoKHR* from,
+ VkImportSemaphoreWin32HandleInfoKHR* to);
-void deepcopy_VkExportSemaphoreWin32HandleInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExportSemaphoreWin32HandleInfoKHR* from,
- VkExportSemaphoreWin32HandleInfoKHR* to);
+void deepcopy_VkExportSemaphoreWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkExportSemaphoreWin32HandleInfoKHR* from,
+ VkExportSemaphoreWin32HandleInfoKHR* to);
-void deepcopy_VkD3D12FenceSubmitInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkD3D12FenceSubmitInfoKHR* from,
- VkD3D12FenceSubmitInfoKHR* to);
+void deepcopy_VkD3D12FenceSubmitInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkD3D12FenceSubmitInfoKHR* from,
+ VkD3D12FenceSubmitInfoKHR* to);
-void deepcopy_VkSemaphoreGetWin32HandleInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSemaphoreGetWin32HandleInfoKHR* from,
- VkSemaphoreGetWin32HandleInfoKHR* to);
+void deepcopy_VkSemaphoreGetWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkSemaphoreGetWin32HandleInfoKHR* from,
+ VkSemaphoreGetWin32HandleInfoKHR* to);
#endif
#ifdef VK_KHR_external_semaphore_fd
-void deepcopy_VkImportSemaphoreFdInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportSemaphoreFdInfoKHR* from,
- VkImportSemaphoreFdInfoKHR* to);
+void deepcopy_VkImportSemaphoreFdInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkImportSemaphoreFdInfoKHR* from,
+ VkImportSemaphoreFdInfoKHR* to);
-void deepcopy_VkSemaphoreGetFdInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSemaphoreGetFdInfoKHR* from,
- VkSemaphoreGetFdInfoKHR* to);
+void deepcopy_VkSemaphoreGetFdInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkSemaphoreGetFdInfoKHR* from,
+ VkSemaphoreGetFdInfoKHR* to);
#endif
#ifdef VK_KHR_push_descriptor
void deepcopy_VkPhysicalDevicePushDescriptorPropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDevicePushDescriptorPropertiesKHR* from,
VkPhysicalDevicePushDescriptorPropertiesKHR* to);
#endif
#ifdef VK_KHR_shader_float16_int8
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderFloat16Int8Features, deepcopy_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderFloat16Int8Features,
+ deepcopy_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderFloat16Int8Features, deepcopy_VkPhysicalDeviceFloat16Int8FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderFloat16Int8Features,
+ deepcopy_VkPhysicalDeviceFloat16Int8FeaturesKHR)
#endif
#ifdef VK_KHR_16bit_storage
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDevice16BitStorageFeatures, deepcopy_VkPhysicalDevice16BitStorageFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDevice16BitStorageFeatures,
+ deepcopy_VkPhysicalDevice16BitStorageFeaturesKHR)
#endif
#ifdef VK_KHR_incremental_present
-void deepcopy_VkRectLayerKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRectLayerKHR* from,
- VkRectLayerKHR* to);
+void deepcopy_VkRectLayerKHR(Allocator* alloc, VkStructureType rootType, const VkRectLayerKHR* from,
+ VkRectLayerKHR* to);
-void deepcopy_VkPresentRegionKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPresentRegionKHR* from,
- VkPresentRegionKHR* to);
+void deepcopy_VkPresentRegionKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPresentRegionKHR* from, VkPresentRegionKHR* to);
-void deepcopy_VkPresentRegionsKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPresentRegionsKHR* from,
- VkPresentRegionsKHR* to);
+void deepcopy_VkPresentRegionsKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPresentRegionsKHR* from, VkPresentRegionsKHR* to);
#endif
#ifdef VK_KHR_descriptor_update_template
-DEFINE_ALIAS_FUNCTION(deepcopy_VkDescriptorUpdateTemplateEntry, deepcopy_VkDescriptorUpdateTemplateEntryKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkDescriptorUpdateTemplateEntry,
+ deepcopy_VkDescriptorUpdateTemplateEntryKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkDescriptorUpdateTemplateCreateInfo, deepcopy_VkDescriptorUpdateTemplateCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkDescriptorUpdateTemplateCreateInfo,
+ deepcopy_VkDescriptorUpdateTemplateCreateInfoKHR)
#endif
#ifdef VK_KHR_imageless_framebuffer
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceImagelessFramebufferFeatures, deepcopy_VkPhysicalDeviceImagelessFramebufferFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceImagelessFramebufferFeatures,
+ deepcopy_VkPhysicalDeviceImagelessFramebufferFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkFramebufferAttachmentsCreateInfo, deepcopy_VkFramebufferAttachmentsCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkFramebufferAttachmentsCreateInfo,
+ deepcopy_VkFramebufferAttachmentsCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkFramebufferAttachmentImageInfo, deepcopy_VkFramebufferAttachmentImageInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkFramebufferAttachmentImageInfo,
+ deepcopy_VkFramebufferAttachmentImageInfoKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkRenderPassAttachmentBeginInfo, deepcopy_VkRenderPassAttachmentBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkRenderPassAttachmentBeginInfo,
+ deepcopy_VkRenderPassAttachmentBeginInfoKHR)
#endif
#ifdef VK_KHR_create_renderpass2
@@ -2002,14 +1394,13 @@
#endif
#ifdef VK_KHR_shared_presentable_image
void deepcopy_VkSharedPresentSurfaceCapabilitiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSharedPresentSurfaceCapabilitiesKHR* from,
+ Allocator* alloc, VkStructureType rootType, const VkSharedPresentSurfaceCapabilitiesKHR* from,
VkSharedPresentSurfaceCapabilitiesKHR* to);
#endif
#ifdef VK_KHR_external_fence_capabilities
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceExternalFenceInfo, deepcopy_VkPhysicalDeviceExternalFenceInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceExternalFenceInfo,
+ deepcopy_VkPhysicalDeviceExternalFenceInfoKHR)
DEFINE_ALIAS_FUNCTION(deepcopy_VkExternalFenceProperties, deepcopy_VkExternalFencePropertiesKHR)
@@ -2019,163 +1410,129 @@
#endif
#ifdef VK_KHR_external_fence_win32
-void deepcopy_VkImportFenceWin32HandleInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportFenceWin32HandleInfoKHR* from,
- VkImportFenceWin32HandleInfoKHR* to);
+void deepcopy_VkImportFenceWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkImportFenceWin32HandleInfoKHR* from,
+ VkImportFenceWin32HandleInfoKHR* to);
-void deepcopy_VkExportFenceWin32HandleInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExportFenceWin32HandleInfoKHR* from,
- VkExportFenceWin32HandleInfoKHR* to);
+void deepcopy_VkExportFenceWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkExportFenceWin32HandleInfoKHR* from,
+ VkExportFenceWin32HandleInfoKHR* to);
-void deepcopy_VkFenceGetWin32HandleInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFenceGetWin32HandleInfoKHR* from,
- VkFenceGetWin32HandleInfoKHR* to);
+void deepcopy_VkFenceGetWin32HandleInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkFenceGetWin32HandleInfoKHR* from,
+ VkFenceGetWin32HandleInfoKHR* to);
#endif
#ifdef VK_KHR_external_fence_fd
-void deepcopy_VkImportFenceFdInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportFenceFdInfoKHR* from,
- VkImportFenceFdInfoKHR* to);
+void deepcopy_VkImportFenceFdInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkImportFenceFdInfoKHR* from,
+ VkImportFenceFdInfoKHR* to);
-void deepcopy_VkFenceGetFdInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFenceGetFdInfoKHR* from,
- VkFenceGetFdInfoKHR* to);
+void deepcopy_VkFenceGetFdInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkFenceGetFdInfoKHR* from, VkFenceGetFdInfoKHR* to);
#endif
#ifdef VK_KHR_performance_query
void deepcopy_VkPhysicalDevicePerformanceQueryFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDevicePerformanceQueryFeaturesKHR* from,
VkPhysicalDevicePerformanceQueryFeaturesKHR* to);
void deepcopy_VkPhysicalDevicePerformanceQueryPropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDevicePerformanceQueryPropertiesKHR* from,
VkPhysicalDevicePerformanceQueryPropertiesKHR* to);
-void deepcopy_VkPerformanceCounterKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPerformanceCounterKHR* from,
- VkPerformanceCounterKHR* to);
+void deepcopy_VkPerformanceCounterKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPerformanceCounterKHR* from,
+ VkPerformanceCounterKHR* to);
-void deepcopy_VkPerformanceCounterDescriptionKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPerformanceCounterDescriptionKHR* from,
- VkPerformanceCounterDescriptionKHR* to);
+void deepcopy_VkPerformanceCounterDescriptionKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPerformanceCounterDescriptionKHR* from,
+ VkPerformanceCounterDescriptionKHR* to);
-void deepcopy_VkQueryPoolPerformanceCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkQueryPoolPerformanceCreateInfoKHR* from,
- VkQueryPoolPerformanceCreateInfoKHR* to);
+void deepcopy_VkQueryPoolPerformanceCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkQueryPoolPerformanceCreateInfoKHR* from,
+ VkQueryPoolPerformanceCreateInfoKHR* to);
-void deepcopy_VkPerformanceCounterResultKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPerformanceCounterResultKHR* from,
- VkPerformanceCounterResultKHR* to);
+void deepcopy_VkPerformanceCounterResultKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPerformanceCounterResultKHR* from,
+ VkPerformanceCounterResultKHR* to);
-void deepcopy_VkAcquireProfilingLockInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAcquireProfilingLockInfoKHR* from,
- VkAcquireProfilingLockInfoKHR* to);
+void deepcopy_VkAcquireProfilingLockInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkAcquireProfilingLockInfoKHR* from,
+ VkAcquireProfilingLockInfoKHR* to);
-void deepcopy_VkPerformanceQuerySubmitInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPerformanceQuerySubmitInfoKHR* from,
- VkPerformanceQuerySubmitInfoKHR* to);
+void deepcopy_VkPerformanceQuerySubmitInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPerformanceQuerySubmitInfoKHR* from,
+ VkPerformanceQuerySubmitInfoKHR* to);
#endif
#ifdef VK_KHR_maintenance2
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDevicePointClippingProperties, deepcopy_VkPhysicalDevicePointClippingPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDevicePointClippingProperties,
+ deepcopy_VkPhysicalDevicePointClippingPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkRenderPassInputAttachmentAspectCreateInfo, deepcopy_VkRenderPassInputAttachmentAspectCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkRenderPassInputAttachmentAspectCreateInfo,
+ deepcopy_VkRenderPassInputAttachmentAspectCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkInputAttachmentAspectReference, deepcopy_VkInputAttachmentAspectReferenceKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkInputAttachmentAspectReference,
+ deepcopy_VkInputAttachmentAspectReferenceKHR)
DEFINE_ALIAS_FUNCTION(deepcopy_VkImageViewUsageCreateInfo, deepcopy_VkImageViewUsageCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineTessellationDomainOriginStateCreateInfo, deepcopy_VkPipelineTessellationDomainOriginStateCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineTessellationDomainOriginStateCreateInfo,
+ deepcopy_VkPipelineTessellationDomainOriginStateCreateInfoKHR)
#endif
#ifdef VK_KHR_get_surface_capabilities2
-void deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceSurfaceInfo2KHR* from,
- VkPhysicalDeviceSurfaceInfo2KHR* to);
+void deepcopy_VkPhysicalDeviceSurfaceInfo2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceSurfaceInfo2KHR* from,
+ VkPhysicalDeviceSurfaceInfo2KHR* to);
-void deepcopy_VkSurfaceCapabilities2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSurfaceCapabilities2KHR* from,
- VkSurfaceCapabilities2KHR* to);
+void deepcopy_VkSurfaceCapabilities2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkSurfaceCapabilities2KHR* from,
+ VkSurfaceCapabilities2KHR* to);
-void deepcopy_VkSurfaceFormat2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSurfaceFormat2KHR* from,
- VkSurfaceFormat2KHR* to);
+void deepcopy_VkSurfaceFormat2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkSurfaceFormat2KHR* from, VkSurfaceFormat2KHR* to);
#endif
#ifdef VK_KHR_variable_pointers
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceVariablePointersFeatures, deepcopy_VkPhysicalDeviceVariablePointerFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceVariablePointersFeatures,
+ deepcopy_VkPhysicalDeviceVariablePointerFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceVariablePointersFeatures, deepcopy_VkPhysicalDeviceVariablePointersFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceVariablePointersFeatures,
+ deepcopy_VkPhysicalDeviceVariablePointersFeaturesKHR)
#endif
#ifdef VK_KHR_get_display_properties2
-void deepcopy_VkDisplayProperties2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayProperties2KHR* from,
- VkDisplayProperties2KHR* to);
+void deepcopy_VkDisplayProperties2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayProperties2KHR* from,
+ VkDisplayProperties2KHR* to);
-void deepcopy_VkDisplayPlaneProperties2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayPlaneProperties2KHR* from,
- VkDisplayPlaneProperties2KHR* to);
+void deepcopy_VkDisplayPlaneProperties2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayPlaneProperties2KHR* from,
+ VkDisplayPlaneProperties2KHR* to);
-void deepcopy_VkDisplayModeProperties2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayModeProperties2KHR* from,
- VkDisplayModeProperties2KHR* to);
+void deepcopy_VkDisplayModeProperties2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayModeProperties2KHR* from,
+ VkDisplayModeProperties2KHR* to);
-void deepcopy_VkDisplayPlaneInfo2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayPlaneInfo2KHR* from,
- VkDisplayPlaneInfo2KHR* to);
+void deepcopy_VkDisplayPlaneInfo2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayPlaneInfo2KHR* from,
+ VkDisplayPlaneInfo2KHR* to);
-void deepcopy_VkDisplayPlaneCapabilities2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayPlaneCapabilities2KHR* from,
- VkDisplayPlaneCapabilities2KHR* to);
+void deepcopy_VkDisplayPlaneCapabilities2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayPlaneCapabilities2KHR* from,
+ VkDisplayPlaneCapabilities2KHR* to);
#endif
#ifdef VK_KHR_dedicated_allocation
-DEFINE_ALIAS_FUNCTION(deepcopy_VkMemoryDedicatedRequirements, deepcopy_VkMemoryDedicatedRequirementsKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkMemoryDedicatedRequirements,
+ deepcopy_VkMemoryDedicatedRequirementsKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkMemoryDedicatedAllocateInfo, deepcopy_VkMemoryDedicatedAllocateInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkMemoryDedicatedAllocateInfo,
+ deepcopy_VkMemoryDedicatedAllocateInfoKHR)
#endif
#ifdef VK_KHR_storage_buffer_storage_class
@@ -2183,15 +1540,19 @@
#ifdef VK_KHR_relaxed_block_layout
#endif
#ifdef VK_KHR_get_memory_requirements2
-DEFINE_ALIAS_FUNCTION(deepcopy_VkBufferMemoryRequirementsInfo2, deepcopy_VkBufferMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkBufferMemoryRequirementsInfo2,
+ deepcopy_VkBufferMemoryRequirementsInfo2KHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkImageMemoryRequirementsInfo2, deepcopy_VkImageMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkImageMemoryRequirementsInfo2,
+ deepcopy_VkImageMemoryRequirementsInfo2KHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkImageSparseMemoryRequirementsInfo2, deepcopy_VkImageSparseMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkImageSparseMemoryRequirementsInfo2,
+ deepcopy_VkImageSparseMemoryRequirementsInfo2KHR)
DEFINE_ALIAS_FUNCTION(deepcopy_VkMemoryRequirements2, deepcopy_VkMemoryRequirements2KHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkSparseImageMemoryRequirements2, deepcopy_VkSparseImageMemoryRequirements2KHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkSparseImageMemoryRequirements2,
+ deepcopy_VkSparseImageMemoryRequirements2KHR)
#endif
#ifdef VK_KHR_image_format_list
@@ -2199,17 +1560,22 @@
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
-DEFINE_ALIAS_FUNCTION(deepcopy_VkSamplerYcbcrConversionCreateInfo, deepcopy_VkSamplerYcbcrConversionCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkSamplerYcbcrConversionCreateInfo,
+ deepcopy_VkSamplerYcbcrConversionCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkSamplerYcbcrConversionInfo, deepcopy_VkSamplerYcbcrConversionInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkSamplerYcbcrConversionInfo,
+ deepcopy_VkSamplerYcbcrConversionInfoKHR)
DEFINE_ALIAS_FUNCTION(deepcopy_VkBindImagePlaneMemoryInfo, deepcopy_VkBindImagePlaneMemoryInfoKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkImagePlaneMemoryRequirementsInfo, deepcopy_VkImagePlaneMemoryRequirementsInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkImagePlaneMemoryRequirementsInfo,
+ deepcopy_VkImagePlaneMemoryRequirementsInfoKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeatures, deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeatures,
+ deepcopy_VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkSamplerYcbcrConversionImageFormatProperties, deepcopy_VkSamplerYcbcrConversionImageFormatPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkSamplerYcbcrConversionImageFormatProperties,
+ deepcopy_VkSamplerYcbcrConversionImageFormatPropertiesKHR)
#endif
#ifdef VK_KHR_bind_memory2
@@ -2220,72 +1586,80 @@
#endif
#ifdef VK_KHR_portability_subset
void deepcopy_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDevicePortabilitySubsetFeaturesKHR* from,
VkPhysicalDevicePortabilitySubsetFeaturesKHR* to);
void deepcopy_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDevicePortabilitySubsetPropertiesKHR* from,
VkPhysicalDevicePortabilitySubsetPropertiesKHR* to);
#endif
#ifdef VK_KHR_maintenance3
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceMaintenance3Properties, deepcopy_VkPhysicalDeviceMaintenance3PropertiesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceMaintenance3Properties,
+ deepcopy_VkPhysicalDeviceMaintenance3PropertiesKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkDescriptorSetLayoutSupport, deepcopy_VkDescriptorSetLayoutSupportKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkDescriptorSetLayoutSupport,
+ deepcopy_VkDescriptorSetLayoutSupportKHR)
#endif
#ifdef VK_KHR_draw_indirect_count
#endif
#ifdef VK_KHR_shader_subgroup_extended_types
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, deepcopy_VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures,
+ deepcopy_VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)
#endif
#ifdef VK_KHR_8bit_storage
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDevice8BitStorageFeatures, deepcopy_VkPhysicalDevice8BitStorageFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDevice8BitStorageFeatures,
+ deepcopy_VkPhysicalDevice8BitStorageFeaturesKHR)
#endif
#ifdef VK_KHR_shader_atomic_int64
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderAtomicInt64Features, deepcopy_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderAtomicInt64Features,
+ deepcopy_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR)
#endif
#ifdef VK_KHR_shader_clock
void deepcopy_VkPhysicalDeviceShaderClockFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderClockFeaturesKHR* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceShaderClockFeaturesKHR* from,
VkPhysicalDeviceShaderClockFeaturesKHR* to);
#endif
#ifdef VK_KHR_driver_properties
DEFINE_ALIAS_FUNCTION(deepcopy_VkConformanceVersion, deepcopy_VkConformanceVersionKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceDriverProperties, deepcopy_VkPhysicalDeviceDriverPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceDriverProperties,
+ deepcopy_VkPhysicalDeviceDriverPropertiesKHR)
#endif
#ifdef VK_KHR_shader_float_controls
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceFloatControlsProperties, deepcopy_VkPhysicalDeviceFloatControlsPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceFloatControlsProperties,
+ deepcopy_VkPhysicalDeviceFloatControlsPropertiesKHR)
#endif
#ifdef VK_KHR_depth_stencil_resolve
-DEFINE_ALIAS_FUNCTION(deepcopy_VkSubpassDescriptionDepthStencilResolve, deepcopy_VkSubpassDescriptionDepthStencilResolveKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkSubpassDescriptionDepthStencilResolve,
+ deepcopy_VkSubpassDescriptionDepthStencilResolveKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceDepthStencilResolveProperties, deepcopy_VkPhysicalDeviceDepthStencilResolvePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceDepthStencilResolveProperties,
+ deepcopy_VkPhysicalDeviceDepthStencilResolvePropertiesKHR)
#endif
#ifdef VK_KHR_swapchain_mutable_format
#endif
#ifdef VK_KHR_timeline_semaphore
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceTimelineSemaphoreFeatures, deepcopy_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceTimelineSemaphoreFeatures,
+ deepcopy_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceTimelineSemaphoreProperties, deepcopy_VkPhysicalDeviceTimelineSemaphorePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceTimelineSemaphoreProperties,
+ deepcopy_VkPhysicalDeviceTimelineSemaphorePropertiesKHR)
DEFINE_ALIAS_FUNCTION(deepcopy_VkSemaphoreTypeCreateInfo, deepcopy_VkSemaphoreTypeCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkTimelineSemaphoreSubmitInfo, deepcopy_VkTimelineSemaphoreSubmitInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkTimelineSemaphoreSubmitInfo,
+ deepcopy_VkTimelineSemaphoreSubmitInfoKHR)
DEFINE_ALIAS_FUNCTION(deepcopy_VkSemaphoreWaitInfo, deepcopy_VkSemaphoreWaitInfoKHR)
@@ -2293,391 +1667,291 @@
#endif
#ifdef VK_KHR_vulkan_memory_model
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceVulkanMemoryModelFeatures, deepcopy_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceVulkanMemoryModelFeatures,
+ deepcopy_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR)
#endif
#ifdef VK_KHR_shader_terminate_invocation
void deepcopy_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* from,
VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* to);
#endif
#ifdef VK_KHR_fragment_shading_rate
void deepcopy_VkFragmentShadingRateAttachmentInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFragmentShadingRateAttachmentInfoKHR* from,
+ Allocator* alloc, VkStructureType rootType, const VkFragmentShadingRateAttachmentInfoKHR* from,
VkFragmentShadingRateAttachmentInfoKHR* to);
void deepcopy_VkPipelineFragmentShadingRateStateCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineFragmentShadingRateStateCreateInfoKHR* from,
VkPipelineFragmentShadingRateStateCreateInfoKHR* to);
void deepcopy_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* from,
VkPhysicalDeviceFragmentShadingRateFeaturesKHR* to);
void deepcopy_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* from,
VkPhysicalDeviceFragmentShadingRatePropertiesKHR* to);
void deepcopy_VkPhysicalDeviceFragmentShadingRateKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateKHR* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceFragmentShadingRateKHR* from,
VkPhysicalDeviceFragmentShadingRateKHR* to);
#endif
#ifdef VK_KHR_spirv_1_4
#endif
#ifdef VK_KHR_surface_protected_capabilities
-void deepcopy_VkSurfaceProtectedCapabilitiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSurfaceProtectedCapabilitiesKHR* from,
- VkSurfaceProtectedCapabilitiesKHR* to);
+void deepcopy_VkSurfaceProtectedCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkSurfaceProtectedCapabilitiesKHR* from,
+ VkSurfaceProtectedCapabilitiesKHR* to);
#endif
#ifdef VK_KHR_separate_depth_stencil_layouts
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, deepcopy_VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures,
+ deepcopy_VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkAttachmentReferenceStencilLayout, deepcopy_VkAttachmentReferenceStencilLayoutKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkAttachmentReferenceStencilLayout,
+ deepcopy_VkAttachmentReferenceStencilLayoutKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkAttachmentDescriptionStencilLayout, deepcopy_VkAttachmentDescriptionStencilLayoutKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkAttachmentDescriptionStencilLayout,
+ deepcopy_VkAttachmentDescriptionStencilLayoutKHR)
#endif
#ifdef VK_KHR_present_wait
void deepcopy_VkPhysicalDevicePresentWaitFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDevicePresentWaitFeaturesKHR* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDevicePresentWaitFeaturesKHR* from,
VkPhysicalDevicePresentWaitFeaturesKHR* to);
#endif
#ifdef VK_KHR_uniform_buffer_standard_layout
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceUniformBufferStandardLayoutFeatures, deepcopy_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceUniformBufferStandardLayoutFeatures,
+ deepcopy_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)
#endif
#ifdef VK_KHR_buffer_device_address
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceBufferDeviceAddressFeatures, deepcopy_VkPhysicalDeviceBufferDeviceAddressFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceBufferDeviceAddressFeatures,
+ deepcopy_VkPhysicalDeviceBufferDeviceAddressFeaturesKHR)
DEFINE_ALIAS_FUNCTION(deepcopy_VkBufferDeviceAddressInfo, deepcopy_VkBufferDeviceAddressInfoKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkBufferOpaqueCaptureAddressCreateInfo, deepcopy_VkBufferOpaqueCaptureAddressCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkBufferOpaqueCaptureAddressCreateInfo,
+ deepcopy_VkBufferOpaqueCaptureAddressCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkMemoryOpaqueCaptureAddressAllocateInfo, deepcopy_VkMemoryOpaqueCaptureAddressAllocateInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkMemoryOpaqueCaptureAddressAllocateInfo,
+ deepcopy_VkMemoryOpaqueCaptureAddressAllocateInfoKHR)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfo, deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfoKHR)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfo,
+ deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfoKHR)
#endif
#ifdef VK_KHR_deferred_host_operations
#endif
#ifdef VK_KHR_pipeline_executable_properties
void deepcopy_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* from,
VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* to);
-void deepcopy_VkPipelineInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineInfoKHR* from,
- VkPipelineInfoKHR* to);
+void deepcopy_VkPipelineInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineInfoKHR* from, VkPipelineInfoKHR* to);
-void deepcopy_VkPipelineExecutablePropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineExecutablePropertiesKHR* from,
- VkPipelineExecutablePropertiesKHR* to);
+void deepcopy_VkPipelineExecutablePropertiesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineExecutablePropertiesKHR* from,
+ VkPipelineExecutablePropertiesKHR* to);
-void deepcopy_VkPipelineExecutableInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineExecutableInfoKHR* from,
- VkPipelineExecutableInfoKHR* to);
+void deepcopy_VkPipelineExecutableInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineExecutableInfoKHR* from,
+ VkPipelineExecutableInfoKHR* to);
void deepcopy_VkPipelineExecutableStatisticValueKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineExecutableStatisticValueKHR* from,
+ Allocator* alloc, VkStructureType rootType, const VkPipelineExecutableStatisticValueKHR* from,
VkPipelineExecutableStatisticValueKHR* to);
-void deepcopy_VkPipelineExecutableStatisticKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineExecutableStatisticKHR* from,
- VkPipelineExecutableStatisticKHR* to);
+void deepcopy_VkPipelineExecutableStatisticKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineExecutableStatisticKHR* from,
+ VkPipelineExecutableStatisticKHR* to);
void deepcopy_VkPipelineExecutableInternalRepresentationKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineExecutableInternalRepresentationKHR* from,
VkPipelineExecutableInternalRepresentationKHR* to);
#endif
#ifdef VK_KHR_shader_integer_dot_product
void deepcopy_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* from,
VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* to);
void deepcopy_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* from,
VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* to);
#endif
#ifdef VK_KHR_pipeline_library
-void deepcopy_VkPipelineLibraryCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineLibraryCreateInfoKHR* from,
- VkPipelineLibraryCreateInfoKHR* to);
+void deepcopy_VkPipelineLibraryCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineLibraryCreateInfoKHR* from,
+ VkPipelineLibraryCreateInfoKHR* to);
#endif
#ifdef VK_KHR_shader_non_semantic_info
#endif
#ifdef VK_KHR_present_id
-void deepcopy_VkPresentIdKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPresentIdKHR* from,
- VkPresentIdKHR* to);
+void deepcopy_VkPresentIdKHR(Allocator* alloc, VkStructureType rootType, const VkPresentIdKHR* from,
+ VkPresentIdKHR* to);
-void deepcopy_VkPhysicalDevicePresentIdFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDevicePresentIdFeaturesKHR* from,
- VkPhysicalDevicePresentIdFeaturesKHR* to);
+void deepcopy_VkPhysicalDevicePresentIdFeaturesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDevicePresentIdFeaturesKHR* from,
+ VkPhysicalDevicePresentIdFeaturesKHR* to);
#endif
#ifdef VK_KHR_video_encode_queue
-void deepcopy_VkVideoEncodeInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeInfoKHR* from,
- VkVideoEncodeInfoKHR* to);
+void deepcopy_VkVideoEncodeInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeInfoKHR* from, VkVideoEncodeInfoKHR* to);
-void deepcopy_VkVideoEncodeRateControlInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeRateControlInfoKHR* from,
- VkVideoEncodeRateControlInfoKHR* to);
+void deepcopy_VkVideoEncodeRateControlInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeRateControlInfoKHR* from,
+ VkVideoEncodeRateControlInfoKHR* to);
#endif
#ifdef VK_KHR_synchronization2
-void deepcopy_VkMemoryBarrier2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryBarrier2KHR* from,
- VkMemoryBarrier2KHR* to);
+void deepcopy_VkMemoryBarrier2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryBarrier2KHR* from, VkMemoryBarrier2KHR* to);
-void deepcopy_VkBufferMemoryBarrier2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferMemoryBarrier2KHR* from,
- VkBufferMemoryBarrier2KHR* to);
+void deepcopy_VkBufferMemoryBarrier2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkBufferMemoryBarrier2KHR* from,
+ VkBufferMemoryBarrier2KHR* to);
-void deepcopy_VkImageMemoryBarrier2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageMemoryBarrier2KHR* from,
- VkImageMemoryBarrier2KHR* to);
+void deepcopy_VkImageMemoryBarrier2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkImageMemoryBarrier2KHR* from,
+ VkImageMemoryBarrier2KHR* to);
-void deepcopy_VkDependencyInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDependencyInfoKHR* from,
- VkDependencyInfoKHR* to);
+void deepcopy_VkDependencyInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDependencyInfoKHR* from, VkDependencyInfoKHR* to);
-void deepcopy_VkSemaphoreSubmitInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSemaphoreSubmitInfoKHR* from,
- VkSemaphoreSubmitInfoKHR* to);
+void deepcopy_VkSemaphoreSubmitInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkSemaphoreSubmitInfoKHR* from,
+ VkSemaphoreSubmitInfoKHR* to);
-void deepcopy_VkCommandBufferSubmitInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCommandBufferSubmitInfoKHR* from,
- VkCommandBufferSubmitInfoKHR* to);
+void deepcopy_VkCommandBufferSubmitInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkCommandBufferSubmitInfoKHR* from,
+ VkCommandBufferSubmitInfoKHR* to);
-void deepcopy_VkSubmitInfo2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubmitInfo2KHR* from,
- VkSubmitInfo2KHR* to);
+void deepcopy_VkSubmitInfo2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkSubmitInfo2KHR* from, VkSubmitInfo2KHR* to);
void deepcopy_VkPhysicalDeviceSynchronization2FeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceSynchronization2FeaturesKHR* from,
VkPhysicalDeviceSynchronization2FeaturesKHR* to);
-void deepcopy_VkQueueFamilyCheckpointProperties2NV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkQueueFamilyCheckpointProperties2NV* from,
- VkQueueFamilyCheckpointProperties2NV* to);
+void deepcopy_VkQueueFamilyCheckpointProperties2NV(Allocator* alloc, VkStructureType rootType,
+ const VkQueueFamilyCheckpointProperties2NV* from,
+ VkQueueFamilyCheckpointProperties2NV* to);
-void deepcopy_VkCheckpointData2NV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCheckpointData2NV* from,
- VkCheckpointData2NV* to);
+void deepcopy_VkCheckpointData2NV(Allocator* alloc, VkStructureType rootType,
+ const VkCheckpointData2NV* from, VkCheckpointData2NV* to);
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
void deepcopy_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* from,
VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* to);
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
void deepcopy_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* from,
VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* to);
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
void deepcopy_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* from,
VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* to);
#endif
#ifdef VK_KHR_copy_commands2
-void deepcopy_VkBufferCopy2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferCopy2KHR* from,
- VkBufferCopy2KHR* to);
+void deepcopy_VkBufferCopy2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkBufferCopy2KHR* from, VkBufferCopy2KHR* to);
-void deepcopy_VkCopyBufferInfo2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCopyBufferInfo2KHR* from,
- VkCopyBufferInfo2KHR* to);
+void deepcopy_VkCopyBufferInfo2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkCopyBufferInfo2KHR* from, VkCopyBufferInfo2KHR* to);
-void deepcopy_VkImageCopy2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageCopy2KHR* from,
- VkImageCopy2KHR* to);
+void deepcopy_VkImageCopy2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkImageCopy2KHR* from, VkImageCopy2KHR* to);
-void deepcopy_VkCopyImageInfo2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCopyImageInfo2KHR* from,
- VkCopyImageInfo2KHR* to);
+void deepcopy_VkCopyImageInfo2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkCopyImageInfo2KHR* from, VkCopyImageInfo2KHR* to);
-void deepcopy_VkBufferImageCopy2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferImageCopy2KHR* from,
- VkBufferImageCopy2KHR* to);
+void deepcopy_VkBufferImageCopy2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkBufferImageCopy2KHR* from, VkBufferImageCopy2KHR* to);
-void deepcopy_VkCopyBufferToImageInfo2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCopyBufferToImageInfo2KHR* from,
- VkCopyBufferToImageInfo2KHR* to);
+void deepcopy_VkCopyBufferToImageInfo2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkCopyBufferToImageInfo2KHR* from,
+ VkCopyBufferToImageInfo2KHR* to);
-void deepcopy_VkCopyImageToBufferInfo2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCopyImageToBufferInfo2KHR* from,
- VkCopyImageToBufferInfo2KHR* to);
+void deepcopy_VkCopyImageToBufferInfo2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkCopyImageToBufferInfo2KHR* from,
+ VkCopyImageToBufferInfo2KHR* to);
-void deepcopy_VkImageBlit2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageBlit2KHR* from,
- VkImageBlit2KHR* to);
+void deepcopy_VkImageBlit2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkImageBlit2KHR* from, VkImageBlit2KHR* to);
-void deepcopy_VkBlitImageInfo2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBlitImageInfo2KHR* from,
- VkBlitImageInfo2KHR* to);
+void deepcopy_VkBlitImageInfo2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkBlitImageInfo2KHR* from, VkBlitImageInfo2KHR* to);
-void deepcopy_VkImageResolve2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageResolve2KHR* from,
- VkImageResolve2KHR* to);
+void deepcopy_VkImageResolve2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkImageResolve2KHR* from, VkImageResolve2KHR* to);
-void deepcopy_VkResolveImageInfo2KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkResolveImageInfo2KHR* from,
- VkResolveImageInfo2KHR* to);
+void deepcopy_VkResolveImageInfo2KHR(Allocator* alloc, VkStructureType rootType,
+ const VkResolveImageInfo2KHR* from,
+ VkResolveImageInfo2KHR* to);
#endif
#ifdef VK_KHR_format_feature_flags2
-void deepcopy_VkFormatProperties3KHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFormatProperties3KHR* from,
- VkFormatProperties3KHR* to);
+void deepcopy_VkFormatProperties3KHR(Allocator* alloc, VkStructureType rootType,
+ const VkFormatProperties3KHR* from,
+ VkFormatProperties3KHR* to);
#endif
#ifdef VK_KHR_maintenance4
void deepcopy_VkPhysicalDeviceMaintenance4FeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceMaintenance4FeaturesKHR* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMaintenance4FeaturesKHR* from,
VkPhysicalDeviceMaintenance4FeaturesKHR* to);
void deepcopy_VkPhysicalDeviceMaintenance4PropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceMaintenance4PropertiesKHR* from,
VkPhysicalDeviceMaintenance4PropertiesKHR* to);
-void deepcopy_VkDeviceBufferMemoryRequirementsKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceBufferMemoryRequirementsKHR* from,
- VkDeviceBufferMemoryRequirementsKHR* to);
+void deepcopy_VkDeviceBufferMemoryRequirementsKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceBufferMemoryRequirementsKHR* from,
+ VkDeviceBufferMemoryRequirementsKHR* to);
-void deepcopy_VkDeviceImageMemoryRequirementsKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceImageMemoryRequirementsKHR* from,
- VkDeviceImageMemoryRequirementsKHR* to);
+void deepcopy_VkDeviceImageMemoryRequirementsKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceImageMemoryRequirementsKHR* from,
+ VkDeviceImageMemoryRequirementsKHR* to);
#endif
#ifdef VK_ANDROID_native_buffer
-void deepcopy_VkNativeBufferANDROID(
- Allocator* alloc,
- VkStructureType rootType,
- const VkNativeBufferANDROID* from,
- VkNativeBufferANDROID* to);
+void deepcopy_VkNativeBufferANDROID(Allocator* alloc, VkStructureType rootType,
+ const VkNativeBufferANDROID* from, VkNativeBufferANDROID* to);
#endif
#ifdef VK_EXT_debug_report
-void deepcopy_VkDebugReportCallbackCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDebugReportCallbackCreateInfoEXT* from,
- VkDebugReportCallbackCreateInfoEXT* to);
+void deepcopy_VkDebugReportCallbackCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugReportCallbackCreateInfoEXT* from,
+ VkDebugReportCallbackCreateInfoEXT* to);
#endif
#ifdef VK_NV_glsl_shader
@@ -2688,8 +1962,7 @@
#endif
#ifdef VK_AMD_rasterization_order
void deepcopy_VkPipelineRasterizationStateRasterizationOrderAMD(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineRasterizationStateRasterizationOrderAMD* from,
VkPipelineRasterizationStateRasterizationOrderAMD* to);
@@ -2699,99 +1972,74 @@
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
-void deepcopy_VkDebugMarkerObjectNameInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDebugMarkerObjectNameInfoEXT* from,
- VkDebugMarkerObjectNameInfoEXT* to);
+void deepcopy_VkDebugMarkerObjectNameInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugMarkerObjectNameInfoEXT* from,
+ VkDebugMarkerObjectNameInfoEXT* to);
-void deepcopy_VkDebugMarkerObjectTagInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDebugMarkerObjectTagInfoEXT* from,
- VkDebugMarkerObjectTagInfoEXT* to);
+void deepcopy_VkDebugMarkerObjectTagInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugMarkerObjectTagInfoEXT* from,
+ VkDebugMarkerObjectTagInfoEXT* to);
-void deepcopy_VkDebugMarkerMarkerInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDebugMarkerMarkerInfoEXT* from,
- VkDebugMarkerMarkerInfoEXT* to);
+void deepcopy_VkDebugMarkerMarkerInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugMarkerMarkerInfoEXT* from,
+ VkDebugMarkerMarkerInfoEXT* to);
#endif
#ifdef VK_AMD_gcn_shader
#endif
#ifdef VK_NV_dedicated_allocation
void deepcopy_VkDedicatedAllocationImageCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDedicatedAllocationImageCreateInfoNV* from,
+ Allocator* alloc, VkStructureType rootType, const VkDedicatedAllocationImageCreateInfoNV* from,
VkDedicatedAllocationImageCreateInfoNV* to);
void deepcopy_VkDedicatedAllocationBufferCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDedicatedAllocationBufferCreateInfoNV* from,
+ Allocator* alloc, VkStructureType rootType, const VkDedicatedAllocationBufferCreateInfoNV* from,
VkDedicatedAllocationBufferCreateInfoNV* to);
void deepcopy_VkDedicatedAllocationMemoryAllocateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkDedicatedAllocationMemoryAllocateInfoNV* from,
VkDedicatedAllocationMemoryAllocateInfoNV* to);
#endif
#ifdef VK_EXT_transform_feedback
void deepcopy_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceTransformFeedbackFeaturesEXT* from,
VkPhysicalDeviceTransformFeedbackFeaturesEXT* to);
void deepcopy_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceTransformFeedbackPropertiesEXT* from,
VkPhysicalDeviceTransformFeedbackPropertiesEXT* to);
void deepcopy_VkPipelineRasterizationStateStreamCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineRasterizationStateStreamCreateInfoEXT* from,
VkPipelineRasterizationStateStreamCreateInfoEXT* to);
#endif
#ifdef VK_NVX_binary_import
-void deepcopy_VkCuModuleCreateInfoNVX(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCuModuleCreateInfoNVX* from,
- VkCuModuleCreateInfoNVX* to);
+void deepcopy_VkCuModuleCreateInfoNVX(Allocator* alloc, VkStructureType rootType,
+ const VkCuModuleCreateInfoNVX* from,
+ VkCuModuleCreateInfoNVX* to);
-void deepcopy_VkCuFunctionCreateInfoNVX(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCuFunctionCreateInfoNVX* from,
- VkCuFunctionCreateInfoNVX* to);
+void deepcopy_VkCuFunctionCreateInfoNVX(Allocator* alloc, VkStructureType rootType,
+ const VkCuFunctionCreateInfoNVX* from,
+ VkCuFunctionCreateInfoNVX* to);
-void deepcopy_VkCuLaunchInfoNVX(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCuLaunchInfoNVX* from,
- VkCuLaunchInfoNVX* to);
+void deepcopy_VkCuLaunchInfoNVX(Allocator* alloc, VkStructureType rootType,
+ const VkCuLaunchInfoNVX* from, VkCuLaunchInfoNVX* to);
#endif
#ifdef VK_NVX_image_view_handle
-void deepcopy_VkImageViewHandleInfoNVX(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageViewHandleInfoNVX* from,
- VkImageViewHandleInfoNVX* to);
+void deepcopy_VkImageViewHandleInfoNVX(Allocator* alloc, VkStructureType rootType,
+ const VkImageViewHandleInfoNVX* from,
+ VkImageViewHandleInfoNVX* to);
-void deepcopy_VkImageViewAddressPropertiesNVX(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageViewAddressPropertiesNVX* from,
- VkImageViewAddressPropertiesNVX* to);
+void deepcopy_VkImageViewAddressPropertiesNVX(Allocator* alloc, VkStructureType rootType,
+ const VkImageViewAddressPropertiesNVX* from,
+ VkImageViewAddressPropertiesNVX* to);
#endif
#ifdef VK_AMD_draw_indirect_count
@@ -2803,209 +2051,154 @@
#ifdef VK_AMD_shader_ballot
#endif
#ifdef VK_EXT_video_encode_h264
-void deepcopy_VkVideoEncodeH264CapabilitiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH264CapabilitiesEXT* from,
- VkVideoEncodeH264CapabilitiesEXT* to);
+void deepcopy_VkVideoEncodeH264CapabilitiesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH264CapabilitiesEXT* from,
+ VkVideoEncodeH264CapabilitiesEXT* to);
void deepcopy_VkVideoEncodeH264SessionCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH264SessionCreateInfoEXT* from,
+ Allocator* alloc, VkStructureType rootType, const VkVideoEncodeH264SessionCreateInfoEXT* from,
VkVideoEncodeH264SessionCreateInfoEXT* to);
void deepcopy_VkVideoEncodeH264SessionParametersAddInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVideoEncodeH264SessionParametersAddInfoEXT* from,
VkVideoEncodeH264SessionParametersAddInfoEXT* to);
void deepcopy_VkVideoEncodeH264SessionParametersCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVideoEncodeH264SessionParametersCreateInfoEXT* from,
VkVideoEncodeH264SessionParametersCreateInfoEXT* to);
-void deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH264DpbSlotInfoEXT* from,
- VkVideoEncodeH264DpbSlotInfoEXT* to);
+void deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH264DpbSlotInfoEXT* from,
+ VkVideoEncodeH264DpbSlotInfoEXT* to);
-void deepcopy_VkVideoEncodeH264NaluSliceEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH264NaluSliceEXT* from,
- VkVideoEncodeH264NaluSliceEXT* to);
+void deepcopy_VkVideoEncodeH264NaluSliceEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH264NaluSliceEXT* from,
+ VkVideoEncodeH264NaluSliceEXT* to);
-void deepcopy_VkVideoEncodeH264VclFrameInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH264VclFrameInfoEXT* from,
- VkVideoEncodeH264VclFrameInfoEXT* to);
+void deepcopy_VkVideoEncodeH264VclFrameInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH264VclFrameInfoEXT* from,
+ VkVideoEncodeH264VclFrameInfoEXT* to);
void deepcopy_VkVideoEncodeH264EmitPictureParametersEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVideoEncodeH264EmitPictureParametersEXT* from,
VkVideoEncodeH264EmitPictureParametersEXT* to);
-void deepcopy_VkVideoEncodeH264ProfileEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH264ProfileEXT* from,
- VkVideoEncodeH264ProfileEXT* to);
+void deepcopy_VkVideoEncodeH264ProfileEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH264ProfileEXT* from,
+ VkVideoEncodeH264ProfileEXT* to);
#endif
#ifdef VK_EXT_video_encode_h265
-void deepcopy_VkVideoEncodeH265CapabilitiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH265CapabilitiesEXT* from,
- VkVideoEncodeH265CapabilitiesEXT* to);
+void deepcopy_VkVideoEncodeH265CapabilitiesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH265CapabilitiesEXT* from,
+ VkVideoEncodeH265CapabilitiesEXT* to);
void deepcopy_VkVideoEncodeH265SessionCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH265SessionCreateInfoEXT* from,
+ Allocator* alloc, VkStructureType rootType, const VkVideoEncodeH265SessionCreateInfoEXT* from,
VkVideoEncodeH265SessionCreateInfoEXT* to);
void deepcopy_VkVideoEncodeH265SessionParametersAddInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVideoEncodeH265SessionParametersAddInfoEXT* from,
VkVideoEncodeH265SessionParametersAddInfoEXT* to);
void deepcopy_VkVideoEncodeH265SessionParametersCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVideoEncodeH265SessionParametersCreateInfoEXT* from,
VkVideoEncodeH265SessionParametersCreateInfoEXT* to);
-void deepcopy_VkVideoEncodeH265DpbSlotInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH265DpbSlotInfoEXT* from,
- VkVideoEncodeH265DpbSlotInfoEXT* to);
+void deepcopy_VkVideoEncodeH265DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH265DpbSlotInfoEXT* from,
+ VkVideoEncodeH265DpbSlotInfoEXT* to);
-void deepcopy_VkVideoEncodeH265ReferenceListsEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH265ReferenceListsEXT* from,
- VkVideoEncodeH265ReferenceListsEXT* to);
+void deepcopy_VkVideoEncodeH265ReferenceListsEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH265ReferenceListsEXT* from,
+ VkVideoEncodeH265ReferenceListsEXT* to);
-void deepcopy_VkVideoEncodeH265NaluSliceEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH265NaluSliceEXT* from,
- VkVideoEncodeH265NaluSliceEXT* to);
+void deepcopy_VkVideoEncodeH265NaluSliceEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH265NaluSliceEXT* from,
+ VkVideoEncodeH265NaluSliceEXT* to);
-void deepcopy_VkVideoEncodeH265VclFrameInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH265VclFrameInfoEXT* from,
- VkVideoEncodeH265VclFrameInfoEXT* to);
+void deepcopy_VkVideoEncodeH265VclFrameInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH265VclFrameInfoEXT* from,
+ VkVideoEncodeH265VclFrameInfoEXT* to);
void deepcopy_VkVideoEncodeH265EmitPictureParametersEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVideoEncodeH265EmitPictureParametersEXT* from,
VkVideoEncodeH265EmitPictureParametersEXT* to);
-void deepcopy_VkVideoEncodeH265ProfileEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoEncodeH265ProfileEXT* from,
- VkVideoEncodeH265ProfileEXT* to);
+void deepcopy_VkVideoEncodeH265ProfileEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoEncodeH265ProfileEXT* from,
+ VkVideoEncodeH265ProfileEXT* to);
#endif
#ifdef VK_EXT_video_decode_h264
-void deepcopy_VkVideoDecodeH264ProfileEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH264ProfileEXT* from,
- VkVideoDecodeH264ProfileEXT* to);
+void deepcopy_VkVideoDecodeH264ProfileEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoDecodeH264ProfileEXT* from,
+ VkVideoDecodeH264ProfileEXT* to);
-void deepcopy_VkVideoDecodeH264CapabilitiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH264CapabilitiesEXT* from,
- VkVideoDecodeH264CapabilitiesEXT* to);
+void deepcopy_VkVideoDecodeH264CapabilitiesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoDecodeH264CapabilitiesEXT* from,
+ VkVideoDecodeH264CapabilitiesEXT* to);
void deepcopy_VkVideoDecodeH264SessionCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH264SessionCreateInfoEXT* from,
+ Allocator* alloc, VkStructureType rootType, const VkVideoDecodeH264SessionCreateInfoEXT* from,
VkVideoDecodeH264SessionCreateInfoEXT* to);
void deepcopy_VkVideoDecodeH264SessionParametersAddInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVideoDecodeH264SessionParametersAddInfoEXT* from,
VkVideoDecodeH264SessionParametersAddInfoEXT* to);
void deepcopy_VkVideoDecodeH264SessionParametersCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVideoDecodeH264SessionParametersCreateInfoEXT* from,
VkVideoDecodeH264SessionParametersCreateInfoEXT* to);
-void deepcopy_VkVideoDecodeH264PictureInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH264PictureInfoEXT* from,
- VkVideoDecodeH264PictureInfoEXT* to);
+void deepcopy_VkVideoDecodeH264PictureInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoDecodeH264PictureInfoEXT* from,
+ VkVideoDecodeH264PictureInfoEXT* to);
-void deepcopy_VkVideoDecodeH264MvcEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH264MvcEXT* from,
- VkVideoDecodeH264MvcEXT* to);
+void deepcopy_VkVideoDecodeH264MvcEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoDecodeH264MvcEXT* from,
+ VkVideoDecodeH264MvcEXT* to);
-void deepcopy_VkVideoDecodeH264DpbSlotInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH264DpbSlotInfoEXT* from,
- VkVideoDecodeH264DpbSlotInfoEXT* to);
+void deepcopy_VkVideoDecodeH264DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoDecodeH264DpbSlotInfoEXT* from,
+ VkVideoDecodeH264DpbSlotInfoEXT* to);
#endif
#ifdef VK_AMD_texture_gather_bias_lod
void deepcopy_VkTextureLODGatherFormatPropertiesAMD(
- Allocator* alloc,
- VkStructureType rootType,
- const VkTextureLODGatherFormatPropertiesAMD* from,
+ Allocator* alloc, VkStructureType rootType, const VkTextureLODGatherFormatPropertiesAMD* from,
VkTextureLODGatherFormatPropertiesAMD* to);
#endif
#ifdef VK_AMD_shader_info
-void deepcopy_VkShaderResourceUsageAMD(
- Allocator* alloc,
- VkStructureType rootType,
- const VkShaderResourceUsageAMD* from,
- VkShaderResourceUsageAMD* to);
+void deepcopy_VkShaderResourceUsageAMD(Allocator* alloc, VkStructureType rootType,
+ const VkShaderResourceUsageAMD* from,
+ VkShaderResourceUsageAMD* to);
-void deepcopy_VkShaderStatisticsInfoAMD(
- Allocator* alloc,
- VkStructureType rootType,
- const VkShaderStatisticsInfoAMD* from,
- VkShaderStatisticsInfoAMD* to);
+void deepcopy_VkShaderStatisticsInfoAMD(Allocator* alloc, VkStructureType rootType,
+ const VkShaderStatisticsInfoAMD* from,
+ VkShaderStatisticsInfoAMD* to);
#endif
#ifdef VK_AMD_shader_image_load_store_lod
#endif
#ifdef VK_GGP_stream_descriptor_surface
void deepcopy_VkStreamDescriptorSurfaceCreateInfoGGP(
- Allocator* alloc,
- VkStructureType rootType,
- const VkStreamDescriptorSurfaceCreateInfoGGP* from,
+ Allocator* alloc, VkStructureType rootType, const VkStreamDescriptorSurfaceCreateInfoGGP* from,
VkStreamDescriptorSurfaceCreateInfoGGP* to);
#endif
#ifdef VK_NV_corner_sampled_image
void deepcopy_VkPhysicalDeviceCornerSampledImageFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceCornerSampledImageFeaturesNV* from,
VkPhysicalDeviceCornerSampledImageFeaturesNV* to);
@@ -3013,63 +2206,46 @@
#ifdef VK_IMG_format_pvrtc
#endif
#ifdef VK_NV_external_memory_capabilities
-void deepcopy_VkExternalImageFormatPropertiesNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExternalImageFormatPropertiesNV* from,
- VkExternalImageFormatPropertiesNV* to);
+void deepcopy_VkExternalImageFormatPropertiesNV(Allocator* alloc, VkStructureType rootType,
+ const VkExternalImageFormatPropertiesNV* from,
+ VkExternalImageFormatPropertiesNV* to);
#endif
#ifdef VK_NV_external_memory
-void deepcopy_VkExternalMemoryImageCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExternalMemoryImageCreateInfoNV* from,
- VkExternalMemoryImageCreateInfoNV* to);
+void deepcopy_VkExternalMemoryImageCreateInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkExternalMemoryImageCreateInfoNV* from,
+ VkExternalMemoryImageCreateInfoNV* to);
-void deepcopy_VkExportMemoryAllocateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExportMemoryAllocateInfoNV* from,
- VkExportMemoryAllocateInfoNV* to);
+void deepcopy_VkExportMemoryAllocateInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkExportMemoryAllocateInfoNV* from,
+ VkExportMemoryAllocateInfoNV* to);
#endif
#ifdef VK_NV_external_memory_win32
-void deepcopy_VkImportMemoryWin32HandleInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportMemoryWin32HandleInfoNV* from,
- VkImportMemoryWin32HandleInfoNV* to);
+void deepcopy_VkImportMemoryWin32HandleInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkImportMemoryWin32HandleInfoNV* from,
+ VkImportMemoryWin32HandleInfoNV* to);
-void deepcopy_VkExportMemoryWin32HandleInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExportMemoryWin32HandleInfoNV* from,
- VkExportMemoryWin32HandleInfoNV* to);
+void deepcopy_VkExportMemoryWin32HandleInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkExportMemoryWin32HandleInfoNV* from,
+ VkExportMemoryWin32HandleInfoNV* to);
#endif
#ifdef VK_NV_win32_keyed_mutex
void deepcopy_VkWin32KeyedMutexAcquireReleaseInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkWin32KeyedMutexAcquireReleaseInfoNV* from,
+ Allocator* alloc, VkStructureType rootType, const VkWin32KeyedMutexAcquireReleaseInfoNV* from,
VkWin32KeyedMutexAcquireReleaseInfoNV* to);
#endif
#ifdef VK_EXT_validation_flags
-void deepcopy_VkValidationFlagsEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkValidationFlagsEXT* from,
- VkValidationFlagsEXT* to);
+void deepcopy_VkValidationFlagsEXT(Allocator* alloc, VkStructureType rootType,
+ const VkValidationFlagsEXT* from, VkValidationFlagsEXT* to);
#endif
#ifdef VK_NN_vi_surface
-void deepcopy_VkViSurfaceCreateInfoNN(
- Allocator* alloc,
- VkStructureType rootType,
- const VkViSurfaceCreateInfoNN* from,
- VkViSurfaceCreateInfoNN* to);
+void deepcopy_VkViSurfaceCreateInfoNN(Allocator* alloc, VkStructureType rootType,
+ const VkViSurfaceCreateInfoNN* from,
+ VkViSurfaceCreateInfoNN* to);
#endif
#ifdef VK_EXT_shader_subgroup_ballot
@@ -3078,56 +2254,43 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
void deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* from,
VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* to);
#endif
#ifdef VK_EXT_astc_decode_mode
-void deepcopy_VkImageViewASTCDecodeModeEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageViewASTCDecodeModeEXT* from,
- VkImageViewASTCDecodeModeEXT* to);
+void deepcopy_VkImageViewASTCDecodeModeEXT(Allocator* alloc, VkStructureType rootType,
+ const VkImageViewASTCDecodeModeEXT* from,
+ VkImageViewASTCDecodeModeEXT* to);
void deepcopy_VkPhysicalDeviceASTCDecodeFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceASTCDecodeFeaturesEXT* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceASTCDecodeFeaturesEXT* from,
VkPhysicalDeviceASTCDecodeFeaturesEXT* to);
#endif
#ifdef VK_EXT_conditional_rendering
-void deepcopy_VkConditionalRenderingBeginInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkConditionalRenderingBeginInfoEXT* from,
- VkConditionalRenderingBeginInfoEXT* to);
+void deepcopy_VkConditionalRenderingBeginInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkConditionalRenderingBeginInfoEXT* from,
+ VkConditionalRenderingBeginInfoEXT* to);
void deepcopy_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceConditionalRenderingFeaturesEXT* from,
VkPhysicalDeviceConditionalRenderingFeaturesEXT* to);
void deepcopy_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkCommandBufferInheritanceConditionalRenderingInfoEXT* from,
VkCommandBufferInheritanceConditionalRenderingInfoEXT* to);
#endif
#ifdef VK_NV_clip_space_w_scaling
-void deepcopy_VkViewportWScalingNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkViewportWScalingNV* from,
- VkViewportWScalingNV* to);
+void deepcopy_VkViewportWScalingNV(Allocator* alloc, VkStructureType rootType,
+ const VkViewportWScalingNV* from, VkViewportWScalingNV* to);
void deepcopy_VkPipelineViewportWScalingStateCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineViewportWScalingStateCreateInfoNV* from,
VkPipelineViewportWScalingStateCreateInfoNV* to);
@@ -3137,63 +2300,41 @@
#ifdef VK_EXT_acquire_xlib_display
#endif
#ifdef VK_EXT_display_surface_counter
-void deepcopy_VkSurfaceCapabilities2EXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSurfaceCapabilities2EXT* from,
- VkSurfaceCapabilities2EXT* to);
+void deepcopy_VkSurfaceCapabilities2EXT(Allocator* alloc, VkStructureType rootType,
+ const VkSurfaceCapabilities2EXT* from,
+ VkSurfaceCapabilities2EXT* to);
#endif
#ifdef VK_EXT_display_control
-void deepcopy_VkDisplayPowerInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayPowerInfoEXT* from,
- VkDisplayPowerInfoEXT* to);
+void deepcopy_VkDisplayPowerInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayPowerInfoEXT* from, VkDisplayPowerInfoEXT* to);
-void deepcopy_VkDeviceEventInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceEventInfoEXT* from,
- VkDeviceEventInfoEXT* to);
+void deepcopy_VkDeviceEventInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceEventInfoEXT* from, VkDeviceEventInfoEXT* to);
-void deepcopy_VkDisplayEventInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDisplayEventInfoEXT* from,
- VkDisplayEventInfoEXT* to);
+void deepcopy_VkDisplayEventInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDisplayEventInfoEXT* from, VkDisplayEventInfoEXT* to);
-void deepcopy_VkSwapchainCounterCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSwapchainCounterCreateInfoEXT* from,
- VkSwapchainCounterCreateInfoEXT* to);
+void deepcopy_VkSwapchainCounterCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkSwapchainCounterCreateInfoEXT* from,
+ VkSwapchainCounterCreateInfoEXT* to);
#endif
#ifdef VK_GOOGLE_display_timing
-void deepcopy_VkRefreshCycleDurationGOOGLE(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRefreshCycleDurationGOOGLE* from,
- VkRefreshCycleDurationGOOGLE* to);
+void deepcopy_VkRefreshCycleDurationGOOGLE(Allocator* alloc, VkStructureType rootType,
+ const VkRefreshCycleDurationGOOGLE* from,
+ VkRefreshCycleDurationGOOGLE* to);
-void deepcopy_VkPastPresentationTimingGOOGLE(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPastPresentationTimingGOOGLE* from,
- VkPastPresentationTimingGOOGLE* to);
+void deepcopy_VkPastPresentationTimingGOOGLE(Allocator* alloc, VkStructureType rootType,
+ const VkPastPresentationTimingGOOGLE* from,
+ VkPastPresentationTimingGOOGLE* to);
-void deepcopy_VkPresentTimeGOOGLE(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPresentTimeGOOGLE* from,
- VkPresentTimeGOOGLE* to);
+void deepcopy_VkPresentTimeGOOGLE(Allocator* alloc, VkStructureType rootType,
+ const VkPresentTimeGOOGLE* from, VkPresentTimeGOOGLE* to);
-void deepcopy_VkPresentTimesInfoGOOGLE(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPresentTimesInfoGOOGLE* from,
- VkPresentTimesInfoGOOGLE* to);
+void deepcopy_VkPresentTimesInfoGOOGLE(Allocator* alloc, VkStructureType rootType,
+ const VkPresentTimesInfoGOOGLE* from,
+ VkPresentTimesInfoGOOGLE* to);
#endif
#ifdef VK_NV_sample_mask_override_coverage
@@ -3204,64 +2345,53 @@
#endif
#ifdef VK_NVX_multiview_per_view_attributes
void deepcopy_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* from,
VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* to);
#endif
#ifdef VK_NV_viewport_swizzle
-void deepcopy_VkViewportSwizzleNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkViewportSwizzleNV* from,
- VkViewportSwizzleNV* to);
+void deepcopy_VkViewportSwizzleNV(Allocator* alloc, VkStructureType rootType,
+ const VkViewportSwizzleNV* from, VkViewportSwizzleNV* to);
void deepcopy_VkPipelineViewportSwizzleStateCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineViewportSwizzleStateCreateInfoNV* from,
VkPipelineViewportSwizzleStateCreateInfoNV* to);
#endif
#ifdef VK_EXT_discard_rectangles
void deepcopy_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDiscardRectanglePropertiesEXT* from,
VkPhysicalDeviceDiscardRectanglePropertiesEXT* to);
void deepcopy_VkPipelineDiscardRectangleStateCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineDiscardRectangleStateCreateInfoEXT* from,
VkPipelineDiscardRectangleStateCreateInfoEXT* to);
#endif
#ifdef VK_EXT_conservative_rasterization
void deepcopy_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* from,
VkPhysicalDeviceConservativeRasterizationPropertiesEXT* to);
void deepcopy_VkPipelineRasterizationConservativeStateCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineRasterizationConservativeStateCreateInfoEXT* from,
VkPipelineRasterizationConservativeStateCreateInfoEXT* to);
#endif
#ifdef VK_EXT_depth_clip_enable
void deepcopy_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDepthClipEnableFeaturesEXT* from,
VkPhysicalDeviceDepthClipEnableFeaturesEXT* to);
void deepcopy_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineRasterizationDepthClipStateCreateInfoEXT* from,
VkPipelineRasterizationDepthClipStateCreateInfoEXT* to);
@@ -3269,33 +2399,23 @@
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
-void deepcopy_VkXYColorEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkXYColorEXT* from,
- VkXYColorEXT* to);
+void deepcopy_VkXYColorEXT(Allocator* alloc, VkStructureType rootType, const VkXYColorEXT* from,
+ VkXYColorEXT* to);
-void deepcopy_VkHdrMetadataEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkHdrMetadataEXT* from,
- VkHdrMetadataEXT* to);
+void deepcopy_VkHdrMetadataEXT(Allocator* alloc, VkStructureType rootType,
+ const VkHdrMetadataEXT* from, VkHdrMetadataEXT* to);
#endif
#ifdef VK_MVK_ios_surface
-void deepcopy_VkIOSSurfaceCreateInfoMVK(
- Allocator* alloc,
- VkStructureType rootType,
- const VkIOSSurfaceCreateInfoMVK* from,
- VkIOSSurfaceCreateInfoMVK* to);
+void deepcopy_VkIOSSurfaceCreateInfoMVK(Allocator* alloc, VkStructureType rootType,
+ const VkIOSSurfaceCreateInfoMVK* from,
+ VkIOSSurfaceCreateInfoMVK* to);
#endif
#ifdef VK_MVK_macos_surface
-void deepcopy_VkMacOSSurfaceCreateInfoMVK(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMacOSSurfaceCreateInfoMVK* from,
- VkMacOSSurfaceCreateInfoMVK* to);
+void deepcopy_VkMacOSSurfaceCreateInfoMVK(Allocator* alloc, VkStructureType rootType,
+ const VkMacOSSurfaceCreateInfoMVK* from,
+ VkMacOSSurfaceCreateInfoMVK* to);
#endif
#ifdef VK_MVK_moltenvk
@@ -3305,85 +2425,67 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
-void deepcopy_VkDebugUtilsLabelEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDebugUtilsLabelEXT* from,
- VkDebugUtilsLabelEXT* to);
+void deepcopy_VkDebugUtilsLabelEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugUtilsLabelEXT* from, VkDebugUtilsLabelEXT* to);
-void deepcopy_VkDebugUtilsObjectNameInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDebugUtilsObjectNameInfoEXT* from,
- VkDebugUtilsObjectNameInfoEXT* to);
+void deepcopy_VkDebugUtilsObjectNameInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugUtilsObjectNameInfoEXT* from,
+ VkDebugUtilsObjectNameInfoEXT* to);
-void deepcopy_VkDebugUtilsMessengerCallbackDataEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDebugUtilsMessengerCallbackDataEXT* from,
- VkDebugUtilsMessengerCallbackDataEXT* to);
+void deepcopy_VkDebugUtilsMessengerCallbackDataEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugUtilsMessengerCallbackDataEXT* from,
+ VkDebugUtilsMessengerCallbackDataEXT* to);
-void deepcopy_VkDebugUtilsMessengerCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDebugUtilsMessengerCreateInfoEXT* from,
- VkDebugUtilsMessengerCreateInfoEXT* to);
+void deepcopy_VkDebugUtilsMessengerCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugUtilsMessengerCreateInfoEXT* from,
+ VkDebugUtilsMessengerCreateInfoEXT* to);
-void deepcopy_VkDebugUtilsObjectTagInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDebugUtilsObjectTagInfoEXT* from,
- VkDebugUtilsObjectTagInfoEXT* to);
+void deepcopy_VkDebugUtilsObjectTagInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugUtilsObjectTagInfoEXT* from,
+ VkDebugUtilsObjectTagInfoEXT* to);
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
-void deepcopy_VkAndroidHardwareBufferUsageANDROID(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAndroidHardwareBufferUsageANDROID* from,
- VkAndroidHardwareBufferUsageANDROID* to);
+void deepcopy_VkAndroidHardwareBufferUsageANDROID(Allocator* alloc, VkStructureType rootType,
+ const VkAndroidHardwareBufferUsageANDROID* from,
+ VkAndroidHardwareBufferUsageANDROID* to);
void deepcopy_VkAndroidHardwareBufferPropertiesANDROID(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAndroidHardwareBufferPropertiesANDROID* from,
VkAndroidHardwareBufferPropertiesANDROID* to);
void deepcopy_VkAndroidHardwareBufferFormatPropertiesANDROID(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAndroidHardwareBufferFormatPropertiesANDROID* from,
VkAndroidHardwareBufferFormatPropertiesANDROID* to);
void deepcopy_VkImportAndroidHardwareBufferInfoANDROID(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkImportAndroidHardwareBufferInfoANDROID* from,
VkImportAndroidHardwareBufferInfoANDROID* to);
void deepcopy_VkMemoryGetAndroidHardwareBufferInfoANDROID(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkMemoryGetAndroidHardwareBufferInfoANDROID* from,
VkMemoryGetAndroidHardwareBufferInfoANDROID* to);
-void deepcopy_VkExternalFormatANDROID(
- Allocator* alloc,
- VkStructureType rootType,
- const VkExternalFormatANDROID* from,
- VkExternalFormatANDROID* to);
+void deepcopy_VkExternalFormatANDROID(Allocator* alloc, VkStructureType rootType,
+ const VkExternalFormatANDROID* from,
+ VkExternalFormatANDROID* to);
void deepcopy_VkAndroidHardwareBufferFormatProperties2ANDROID(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAndroidHardwareBufferFormatProperties2ANDROID* from,
VkAndroidHardwareBufferFormatProperties2ANDROID* to);
#endif
#ifdef VK_EXT_sampler_filter_minmax
-DEFINE_ALIAS_FUNCTION(deepcopy_VkSamplerReductionModeCreateInfo, deepcopy_VkSamplerReductionModeCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkSamplerReductionModeCreateInfo,
+ deepcopy_VkSamplerReductionModeCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceSamplerFilterMinmaxProperties, deepcopy_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceSamplerFilterMinmaxProperties,
+ deepcopy_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT)
#endif
#ifdef VK_AMD_gpu_shader_int16
@@ -3394,26 +2496,22 @@
#endif
#ifdef VK_EXT_inline_uniform_block
void deepcopy_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* from,
VkPhysicalDeviceInlineUniformBlockFeaturesEXT* to);
void deepcopy_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* from,
VkPhysicalDeviceInlineUniformBlockPropertiesEXT* to);
void deepcopy_VkWriteDescriptorSetInlineUniformBlockEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkWriteDescriptorSetInlineUniformBlockEXT* from,
VkWriteDescriptorSetInlineUniformBlockEXT* to);
void deepcopy_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* from,
VkDescriptorPoolInlineUniformBlockCreateInfoEXT* to);
@@ -3421,87 +2519,67 @@
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
-void deepcopy_VkSampleLocationEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSampleLocationEXT* from,
- VkSampleLocationEXT* to);
+void deepcopy_VkSampleLocationEXT(Allocator* alloc, VkStructureType rootType,
+ const VkSampleLocationEXT* from, VkSampleLocationEXT* to);
-void deepcopy_VkSampleLocationsInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSampleLocationsInfoEXT* from,
- VkSampleLocationsInfoEXT* to);
+void deepcopy_VkSampleLocationsInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkSampleLocationsInfoEXT* from,
+ VkSampleLocationsInfoEXT* to);
-void deepcopy_VkAttachmentSampleLocationsEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAttachmentSampleLocationsEXT* from,
- VkAttachmentSampleLocationsEXT* to);
+void deepcopy_VkAttachmentSampleLocationsEXT(Allocator* alloc, VkStructureType rootType,
+ const VkAttachmentSampleLocationsEXT* from,
+ VkAttachmentSampleLocationsEXT* to);
-void deepcopy_VkSubpassSampleLocationsEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSubpassSampleLocationsEXT* from,
- VkSubpassSampleLocationsEXT* to);
+void deepcopy_VkSubpassSampleLocationsEXT(Allocator* alloc, VkStructureType rootType,
+ const VkSubpassSampleLocationsEXT* from,
+ VkSubpassSampleLocationsEXT* to);
void deepcopy_VkRenderPassSampleLocationsBeginInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRenderPassSampleLocationsBeginInfoEXT* from,
+ Allocator* alloc, VkStructureType rootType, const VkRenderPassSampleLocationsBeginInfoEXT* from,
VkRenderPassSampleLocationsBeginInfoEXT* to);
void deepcopy_VkPipelineSampleLocationsStateCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineSampleLocationsStateCreateInfoEXT* from,
VkPipelineSampleLocationsStateCreateInfoEXT* to);
void deepcopy_VkPhysicalDeviceSampleLocationsPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceSampleLocationsPropertiesEXT* from,
VkPhysicalDeviceSampleLocationsPropertiesEXT* to);
-void deepcopy_VkMultisamplePropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMultisamplePropertiesEXT* from,
- VkMultisamplePropertiesEXT* to);
+void deepcopy_VkMultisamplePropertiesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkMultisamplePropertiesEXT* from,
+ VkMultisamplePropertiesEXT* to);
#endif
#ifdef VK_EXT_blend_operation_advanced
void deepcopy_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* from,
VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* to);
void deepcopy_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* from,
VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* to);
void deepcopy_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineColorBlendAdvancedStateCreateInfoEXT* from,
VkPipelineColorBlendAdvancedStateCreateInfoEXT* to);
#endif
#ifdef VK_NV_fragment_coverage_to_color
void deepcopy_VkPipelineCoverageToColorStateCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineCoverageToColorStateCreateInfoNV* from,
VkPipelineCoverageToColorStateCreateInfoNV* to);
#endif
#ifdef VK_NV_framebuffer_mixed_samples
void deepcopy_VkPipelineCoverageModulationStateCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineCoverageModulationStateCreateInfoNV* from,
VkPipelineCoverageModulationStateCreateInfoNV* to);
@@ -3510,14 +2588,12 @@
#endif
#ifdef VK_NV_shader_sm_builtins
void deepcopy_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* from,
VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* to);
void deepcopy_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* from,
VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* to);
@@ -3525,249 +2601,191 @@
#ifdef VK_EXT_post_depth_coverage
#endif
#ifdef VK_EXT_image_drm_format_modifier
-void deepcopy_VkDrmFormatModifierPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesEXT* from,
- VkDrmFormatModifierPropertiesEXT* to);
+void deepcopy_VkDrmFormatModifierPropertiesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDrmFormatModifierPropertiesEXT* from,
+ VkDrmFormatModifierPropertiesEXT* to);
-void deepcopy_VkDrmFormatModifierPropertiesListEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesListEXT* from,
- VkDrmFormatModifierPropertiesListEXT* to);
+void deepcopy_VkDrmFormatModifierPropertiesListEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDrmFormatModifierPropertiesListEXT* from,
+ VkDrmFormatModifierPropertiesListEXT* to);
void deepcopy_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* from,
VkPhysicalDeviceImageDrmFormatModifierInfoEXT* to);
void deepcopy_VkImageDrmFormatModifierListCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkImageDrmFormatModifierListCreateInfoEXT* from,
VkImageDrmFormatModifierListCreateInfoEXT* to);
void deepcopy_VkImageDrmFormatModifierExplicitCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkImageDrmFormatModifierExplicitCreateInfoEXT* from,
VkImageDrmFormatModifierExplicitCreateInfoEXT* to);
void deepcopy_VkImageDrmFormatModifierPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageDrmFormatModifierPropertiesEXT* from,
+ Allocator* alloc, VkStructureType rootType, const VkImageDrmFormatModifierPropertiesEXT* from,
VkImageDrmFormatModifierPropertiesEXT* to);
-void deepcopy_VkDrmFormatModifierProperties2EXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDrmFormatModifierProperties2EXT* from,
- VkDrmFormatModifierProperties2EXT* to);
+void deepcopy_VkDrmFormatModifierProperties2EXT(Allocator* alloc, VkStructureType rootType,
+ const VkDrmFormatModifierProperties2EXT* from,
+ VkDrmFormatModifierProperties2EXT* to);
void deepcopy_VkDrmFormatModifierPropertiesList2EXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesList2EXT* from,
+ Allocator* alloc, VkStructureType rootType, const VkDrmFormatModifierPropertiesList2EXT* from,
VkDrmFormatModifierPropertiesList2EXT* to);
#endif
#ifdef VK_EXT_validation_cache
-void deepcopy_VkValidationCacheCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkValidationCacheCreateInfoEXT* from,
- VkValidationCacheCreateInfoEXT* to);
+void deepcopy_VkValidationCacheCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkValidationCacheCreateInfoEXT* from,
+ VkValidationCacheCreateInfoEXT* to);
void deepcopy_VkShaderModuleValidationCacheCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkShaderModuleValidationCacheCreateInfoEXT* from,
VkShaderModuleValidationCacheCreateInfoEXT* to);
#endif
#ifdef VK_EXT_descriptor_indexing
-DEFINE_ALIAS_FUNCTION(deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfo, deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfo,
+ deepcopy_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceDescriptorIndexingFeatures, deepcopy_VkPhysicalDeviceDescriptorIndexingFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceDescriptorIndexingFeatures,
+ deepcopy_VkPhysicalDeviceDescriptorIndexingFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceDescriptorIndexingProperties, deepcopy_VkPhysicalDeviceDescriptorIndexingPropertiesEXT)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceDescriptorIndexingProperties,
+ deepcopy_VkPhysicalDeviceDescriptorIndexingPropertiesEXT)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfo, deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfo,
+ deepcopy_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT)
-DEFINE_ALIAS_FUNCTION(deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupport, deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupport,
+ deepcopy_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT)
#endif
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_NV_shading_rate_image
-void deepcopy_VkShadingRatePaletteNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkShadingRatePaletteNV* from,
- VkShadingRatePaletteNV* to);
+void deepcopy_VkShadingRatePaletteNV(Allocator* alloc, VkStructureType rootType,
+ const VkShadingRatePaletteNV* from,
+ VkShadingRatePaletteNV* to);
void deepcopy_VkPipelineViewportShadingRateImageStateCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineViewportShadingRateImageStateCreateInfoNV* from,
VkPipelineViewportShadingRateImageStateCreateInfoNV* to);
void deepcopy_VkPhysicalDeviceShadingRateImageFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShadingRateImageFeaturesNV* from,
VkPhysicalDeviceShadingRateImageFeaturesNV* to);
void deepcopy_VkPhysicalDeviceShadingRateImagePropertiesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShadingRateImagePropertiesNV* from,
VkPhysicalDeviceShadingRateImagePropertiesNV* to);
-void deepcopy_VkCoarseSampleLocationNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCoarseSampleLocationNV* from,
- VkCoarseSampleLocationNV* to);
+void deepcopy_VkCoarseSampleLocationNV(Allocator* alloc, VkStructureType rootType,
+ const VkCoarseSampleLocationNV* from,
+ VkCoarseSampleLocationNV* to);
-void deepcopy_VkCoarseSampleOrderCustomNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCoarseSampleOrderCustomNV* from,
- VkCoarseSampleOrderCustomNV* to);
+void deepcopy_VkCoarseSampleOrderCustomNV(Allocator* alloc, VkStructureType rootType,
+ const VkCoarseSampleOrderCustomNV* from,
+ VkCoarseSampleOrderCustomNV* to);
void deepcopy_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* from,
VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* to);
#endif
#ifdef VK_NV_ray_tracing
-void deepcopy_VkRayTracingShaderGroupCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRayTracingShaderGroupCreateInfoNV* from,
- VkRayTracingShaderGroupCreateInfoNV* to);
+void deepcopy_VkRayTracingShaderGroupCreateInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkRayTracingShaderGroupCreateInfoNV* from,
+ VkRayTracingShaderGroupCreateInfoNV* to);
-void deepcopy_VkRayTracingPipelineCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRayTracingPipelineCreateInfoNV* from,
- VkRayTracingPipelineCreateInfoNV* to);
+void deepcopy_VkRayTracingPipelineCreateInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkRayTracingPipelineCreateInfoNV* from,
+ VkRayTracingPipelineCreateInfoNV* to);
-void deepcopy_VkGeometryTrianglesNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkGeometryTrianglesNV* from,
- VkGeometryTrianglesNV* to);
+void deepcopy_VkGeometryTrianglesNV(Allocator* alloc, VkStructureType rootType,
+ const VkGeometryTrianglesNV* from, VkGeometryTrianglesNV* to);
-void deepcopy_VkGeometryAABBNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkGeometryAABBNV* from,
- VkGeometryAABBNV* to);
+void deepcopy_VkGeometryAABBNV(Allocator* alloc, VkStructureType rootType,
+ const VkGeometryAABBNV* from, VkGeometryAABBNV* to);
-void deepcopy_VkGeometryDataNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkGeometryDataNV* from,
- VkGeometryDataNV* to);
+void deepcopy_VkGeometryDataNV(Allocator* alloc, VkStructureType rootType,
+ const VkGeometryDataNV* from, VkGeometryDataNV* to);
-void deepcopy_VkGeometryNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkGeometryNV* from,
- VkGeometryNV* to);
+void deepcopy_VkGeometryNV(Allocator* alloc, VkStructureType rootType, const VkGeometryNV* from,
+ VkGeometryNV* to);
-void deepcopy_VkAccelerationStructureInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAccelerationStructureInfoNV* from,
- VkAccelerationStructureInfoNV* to);
+void deepcopy_VkAccelerationStructureInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkAccelerationStructureInfoNV* from,
+ VkAccelerationStructureInfoNV* to);
-void deepcopy_VkAccelerationStructureCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAccelerationStructureCreateInfoNV* from,
- VkAccelerationStructureCreateInfoNV* to);
+void deepcopy_VkAccelerationStructureCreateInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkAccelerationStructureCreateInfoNV* from,
+ VkAccelerationStructureCreateInfoNV* to);
void deepcopy_VkBindAccelerationStructureMemoryInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindAccelerationStructureMemoryInfoNV* from,
+ Allocator* alloc, VkStructureType rootType, const VkBindAccelerationStructureMemoryInfoNV* from,
VkBindAccelerationStructureMemoryInfoNV* to);
void deepcopy_VkWriteDescriptorSetAccelerationStructureNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkWriteDescriptorSetAccelerationStructureNV* from,
VkWriteDescriptorSetAccelerationStructureNV* to);
void deepcopy_VkAccelerationStructureMemoryRequirementsInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureMemoryRequirementsInfoNV* from,
VkAccelerationStructureMemoryRequirementsInfoNV* to);
void deepcopy_VkPhysicalDeviceRayTracingPropertiesNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingPropertiesNV* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceRayTracingPropertiesNV* from,
VkPhysicalDeviceRayTracingPropertiesNV* to);
-void deepcopy_VkTransformMatrixKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkTransformMatrixKHR* from,
- VkTransformMatrixKHR* to);
+void deepcopy_VkTransformMatrixKHR(Allocator* alloc, VkStructureType rootType,
+ const VkTransformMatrixKHR* from, VkTransformMatrixKHR* to);
DEFINE_ALIAS_FUNCTION(deepcopy_VkTransformMatrixKHR, deepcopy_VkTransformMatrixNV)
-void deepcopy_VkAabbPositionsKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAabbPositionsKHR* from,
- VkAabbPositionsKHR* to);
+void deepcopy_VkAabbPositionsKHR(Allocator* alloc, VkStructureType rootType,
+ const VkAabbPositionsKHR* from, VkAabbPositionsKHR* to);
DEFINE_ALIAS_FUNCTION(deepcopy_VkAabbPositionsKHR, deepcopy_VkAabbPositionsNV)
-void deepcopy_VkAccelerationStructureInstanceKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAccelerationStructureInstanceKHR* from,
- VkAccelerationStructureInstanceKHR* to);
+void deepcopy_VkAccelerationStructureInstanceKHR(Allocator* alloc, VkStructureType rootType,
+ const VkAccelerationStructureInstanceKHR* from,
+ VkAccelerationStructureInstanceKHR* to);
-DEFINE_ALIAS_FUNCTION(deepcopy_VkAccelerationStructureInstanceKHR, deepcopy_VkAccelerationStructureInstanceNV)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkAccelerationStructureInstanceKHR,
+ deepcopy_VkAccelerationStructureInstanceNV)
#endif
#ifdef VK_NV_representative_fragment_test
void deepcopy_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* from,
VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* to);
void deepcopy_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* from,
VkPipelineRepresentativeFragmentTestStateCreateInfoNV* to);
#endif
#ifdef VK_EXT_filter_cubic
void deepcopy_VkPhysicalDeviceImageViewImageFormatInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceImageViewImageFormatInfoEXT* from,
VkPhysicalDeviceImageViewImageFormatInfoEXT* to);
void deepcopy_VkFilterCubicImageViewImageFormatPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkFilterCubicImageViewImageFormatPropertiesEXT* from,
VkFilterCubicImageViewImageFormatPropertiesEXT* to);
@@ -3776,28 +2794,22 @@
#endif
#ifdef VK_EXT_global_priority
void deepcopy_VkDeviceQueueGlobalPriorityCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkDeviceQueueGlobalPriorityCreateInfoEXT* from,
VkDeviceQueueGlobalPriorityCreateInfoEXT* to);
#endif
#ifdef VK_EXT_external_memory_host
-void deepcopy_VkImportMemoryHostPointerInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportMemoryHostPointerInfoEXT* from,
- VkImportMemoryHostPointerInfoEXT* to);
+void deepcopy_VkImportMemoryHostPointerInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkImportMemoryHostPointerInfoEXT* from,
+ VkImportMemoryHostPointerInfoEXT* to);
-void deepcopy_VkMemoryHostPointerPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryHostPointerPropertiesEXT* from,
- VkMemoryHostPointerPropertiesEXT* to);
+void deepcopy_VkMemoryHostPointerPropertiesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryHostPointerPropertiesEXT* from,
+ VkMemoryHostPointerPropertiesEXT* to);
void deepcopy_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* from,
VkPhysicalDeviceExternalMemoryHostPropertiesEXT* to);
@@ -3806,125 +2818,96 @@
#endif
#ifdef VK_AMD_pipeline_compiler_control
void deepcopy_VkPipelineCompilerControlCreateInfoAMD(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineCompilerControlCreateInfoAMD* from,
+ Allocator* alloc, VkStructureType rootType, const VkPipelineCompilerControlCreateInfoAMD* from,
VkPipelineCompilerControlCreateInfoAMD* to);
#endif
#ifdef VK_EXT_calibrated_timestamps
-void deepcopy_VkCalibratedTimestampInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCalibratedTimestampInfoEXT* from,
- VkCalibratedTimestampInfoEXT* to);
+void deepcopy_VkCalibratedTimestampInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkCalibratedTimestampInfoEXT* from,
+ VkCalibratedTimestampInfoEXT* to);
#endif
#ifdef VK_AMD_shader_core_properties
void deepcopy_VkPhysicalDeviceShaderCorePropertiesAMD(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderCorePropertiesAMD* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceShaderCorePropertiesAMD* from,
VkPhysicalDeviceShaderCorePropertiesAMD* to);
#endif
#ifdef VK_EXT_video_decode_h265
-void deepcopy_VkVideoDecodeH265ProfileEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH265ProfileEXT* from,
- VkVideoDecodeH265ProfileEXT* to);
+void deepcopy_VkVideoDecodeH265ProfileEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoDecodeH265ProfileEXT* from,
+ VkVideoDecodeH265ProfileEXT* to);
-void deepcopy_VkVideoDecodeH265CapabilitiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH265CapabilitiesEXT* from,
- VkVideoDecodeH265CapabilitiesEXT* to);
+void deepcopy_VkVideoDecodeH265CapabilitiesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoDecodeH265CapabilitiesEXT* from,
+ VkVideoDecodeH265CapabilitiesEXT* to);
void deepcopy_VkVideoDecodeH265SessionCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH265SessionCreateInfoEXT* from,
+ Allocator* alloc, VkStructureType rootType, const VkVideoDecodeH265SessionCreateInfoEXT* from,
VkVideoDecodeH265SessionCreateInfoEXT* to);
void deepcopy_VkVideoDecodeH265SessionParametersAddInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVideoDecodeH265SessionParametersAddInfoEXT* from,
VkVideoDecodeH265SessionParametersAddInfoEXT* to);
void deepcopy_VkVideoDecodeH265SessionParametersCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVideoDecodeH265SessionParametersCreateInfoEXT* from,
VkVideoDecodeH265SessionParametersCreateInfoEXT* to);
-void deepcopy_VkVideoDecodeH265PictureInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH265PictureInfoEXT* from,
- VkVideoDecodeH265PictureInfoEXT* to);
+void deepcopy_VkVideoDecodeH265PictureInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoDecodeH265PictureInfoEXT* from,
+ VkVideoDecodeH265PictureInfoEXT* to);
-void deepcopy_VkVideoDecodeH265DpbSlotInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVideoDecodeH265DpbSlotInfoEXT* from,
- VkVideoDecodeH265DpbSlotInfoEXT* to);
+void deepcopy_VkVideoDecodeH265DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkVideoDecodeH265DpbSlotInfoEXT* from,
+ VkVideoDecodeH265DpbSlotInfoEXT* to);
#endif
#ifdef VK_AMD_memory_overallocation_behavior
void deepcopy_VkDeviceMemoryOverallocationCreateInfoAMD(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkDeviceMemoryOverallocationCreateInfoAMD* from,
VkDeviceMemoryOverallocationCreateInfoAMD* to);
#endif
#ifdef VK_EXT_vertex_attribute_divisor
void deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* from,
VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* to);
void deepcopy_VkVertexInputBindingDivisorDescriptionEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkVertexInputBindingDivisorDescriptionEXT* from,
VkVertexInputBindingDivisorDescriptionEXT* to);
void deepcopy_VkPipelineVertexInputDivisorStateCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineVertexInputDivisorStateCreateInfoEXT* from,
VkPipelineVertexInputDivisorStateCreateInfoEXT* to);
void deepcopy_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* from,
VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* to);
#endif
#ifdef VK_GGP_frame_token
-void deepcopy_VkPresentFrameTokenGGP(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPresentFrameTokenGGP* from,
- VkPresentFrameTokenGGP* to);
+void deepcopy_VkPresentFrameTokenGGP(Allocator* alloc, VkStructureType rootType,
+ const VkPresentFrameTokenGGP* from,
+ VkPresentFrameTokenGGP* to);
#endif
#ifdef VK_EXT_pipeline_creation_feedback
-void deepcopy_VkPipelineCreationFeedbackEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineCreationFeedbackEXT* from,
- VkPipelineCreationFeedbackEXT* to);
+void deepcopy_VkPipelineCreationFeedbackEXT(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineCreationFeedbackEXT* from,
+ VkPipelineCreationFeedbackEXT* to);
void deepcopy_VkPipelineCreationFeedbackCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineCreationFeedbackCreateInfoEXT* from,
+ Allocator* alloc, VkStructureType rootType, const VkPipelineCreationFeedbackCreateInfoEXT* from,
VkPipelineCreationFeedbackCreateInfoEXT* to);
#endif
@@ -3932,196 +2915,156 @@
#endif
#ifdef VK_NV_compute_shader_derivatives
void deepcopy_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* from,
VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* to);
#endif
#ifdef VK_NV_mesh_shader
-void deepcopy_VkPhysicalDeviceMeshShaderFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceMeshShaderFeaturesNV* from,
- VkPhysicalDeviceMeshShaderFeaturesNV* to);
+void deepcopy_VkPhysicalDeviceMeshShaderFeaturesNV(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceMeshShaderFeaturesNV* from,
+ VkPhysicalDeviceMeshShaderFeaturesNV* to);
void deepcopy_VkPhysicalDeviceMeshShaderPropertiesNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceMeshShaderPropertiesNV* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMeshShaderPropertiesNV* from,
VkPhysicalDeviceMeshShaderPropertiesNV* to);
-void deepcopy_VkDrawMeshTasksIndirectCommandNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDrawMeshTasksIndirectCommandNV* from,
- VkDrawMeshTasksIndirectCommandNV* to);
+void deepcopy_VkDrawMeshTasksIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
+ const VkDrawMeshTasksIndirectCommandNV* from,
+ VkDrawMeshTasksIndirectCommandNV* to);
#endif
#ifdef VK_NV_fragment_shader_barycentric
void deepcopy_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* from,
VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* to);
#endif
#ifdef VK_NV_shader_image_footprint
void deepcopy_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderImageFootprintFeaturesNV* from,
VkPhysicalDeviceShaderImageFootprintFeaturesNV* to);
#endif
#ifdef VK_NV_scissor_exclusive
void deepcopy_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineViewportExclusiveScissorStateCreateInfoNV* from,
VkPipelineViewportExclusiveScissorStateCreateInfoNV* to);
void deepcopy_VkPhysicalDeviceExclusiveScissorFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceExclusiveScissorFeaturesNV* from,
VkPhysicalDeviceExclusiveScissorFeaturesNV* to);
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
-void deepcopy_VkQueueFamilyCheckpointPropertiesNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkQueueFamilyCheckpointPropertiesNV* from,
- VkQueueFamilyCheckpointPropertiesNV* to);
+void deepcopy_VkQueueFamilyCheckpointPropertiesNV(Allocator* alloc, VkStructureType rootType,
+ const VkQueueFamilyCheckpointPropertiesNV* from,
+ VkQueueFamilyCheckpointPropertiesNV* to);
-void deepcopy_VkCheckpointDataNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCheckpointDataNV* from,
- VkCheckpointDataNV* to);
+void deepcopy_VkCheckpointDataNV(Allocator* alloc, VkStructureType rootType,
+ const VkCheckpointDataNV* from, VkCheckpointDataNV* to);
#endif
#ifdef VK_INTEL_shader_integer_functions2
void deepcopy_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* from,
VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* to);
#endif
#ifdef VK_INTEL_performance_query
-void deepcopy_VkPerformanceValueDataINTEL(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPerformanceValueDataINTEL* from,
- VkPerformanceValueDataINTEL* to);
+void deepcopy_VkPerformanceValueDataINTEL(Allocator* alloc, VkStructureType rootType,
+ const VkPerformanceValueDataINTEL* from,
+ VkPerformanceValueDataINTEL* to);
-void deepcopy_VkPerformanceValueINTEL(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPerformanceValueINTEL* from,
- VkPerformanceValueINTEL* to);
+void deepcopy_VkPerformanceValueINTEL(Allocator* alloc, VkStructureType rootType,
+ const VkPerformanceValueINTEL* from,
+ VkPerformanceValueINTEL* to);
-void deepcopy_VkInitializePerformanceApiInfoINTEL(
- Allocator* alloc,
- VkStructureType rootType,
- const VkInitializePerformanceApiInfoINTEL* from,
- VkInitializePerformanceApiInfoINTEL* to);
+void deepcopy_VkInitializePerformanceApiInfoINTEL(Allocator* alloc, VkStructureType rootType,
+ const VkInitializePerformanceApiInfoINTEL* from,
+ VkInitializePerformanceApiInfoINTEL* to);
void deepcopy_VkQueryPoolPerformanceQueryCreateInfoINTEL(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkQueryPoolPerformanceQueryCreateInfoINTEL* from,
VkQueryPoolPerformanceQueryCreateInfoINTEL* to);
-DEFINE_ALIAS_FUNCTION(deepcopy_VkQueryPoolPerformanceQueryCreateInfoINTEL, deepcopy_VkQueryPoolCreateInfoINTEL)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkQueryPoolPerformanceQueryCreateInfoINTEL,
+ deepcopy_VkQueryPoolCreateInfoINTEL)
-void deepcopy_VkPerformanceMarkerInfoINTEL(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPerformanceMarkerInfoINTEL* from,
- VkPerformanceMarkerInfoINTEL* to);
+void deepcopy_VkPerformanceMarkerInfoINTEL(Allocator* alloc, VkStructureType rootType,
+ const VkPerformanceMarkerInfoINTEL* from,
+ VkPerformanceMarkerInfoINTEL* to);
-void deepcopy_VkPerformanceStreamMarkerInfoINTEL(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPerformanceStreamMarkerInfoINTEL* from,
- VkPerformanceStreamMarkerInfoINTEL* to);
+void deepcopy_VkPerformanceStreamMarkerInfoINTEL(Allocator* alloc, VkStructureType rootType,
+ const VkPerformanceStreamMarkerInfoINTEL* from,
+ VkPerformanceStreamMarkerInfoINTEL* to);
-void deepcopy_VkPerformanceOverrideInfoINTEL(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPerformanceOverrideInfoINTEL* from,
- VkPerformanceOverrideInfoINTEL* to);
+void deepcopy_VkPerformanceOverrideInfoINTEL(Allocator* alloc, VkStructureType rootType,
+ const VkPerformanceOverrideInfoINTEL* from,
+ VkPerformanceOverrideInfoINTEL* to);
void deepcopy_VkPerformanceConfigurationAcquireInfoINTEL(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPerformanceConfigurationAcquireInfoINTEL* from,
VkPerformanceConfigurationAcquireInfoINTEL* to);
#endif
#ifdef VK_EXT_pci_bus_info
void deepcopy_VkPhysicalDevicePCIBusInfoPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDevicePCIBusInfoPropertiesEXT* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDevicePCIBusInfoPropertiesEXT* from,
VkPhysicalDevicePCIBusInfoPropertiesEXT* to);
#endif
#ifdef VK_AMD_display_native_hdr
void deepcopy_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkDisplayNativeHdrSurfaceCapabilitiesAMD* from,
VkDisplayNativeHdrSurfaceCapabilitiesAMD* to);
void deepcopy_VkSwapchainDisplayNativeHdrCreateInfoAMD(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkSwapchainDisplayNativeHdrCreateInfoAMD* from,
VkSwapchainDisplayNativeHdrCreateInfoAMD* to);
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
-void deepcopy_VkImagePipeSurfaceCreateInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImagePipeSurfaceCreateInfoFUCHSIA* from,
- VkImagePipeSurfaceCreateInfoFUCHSIA* to);
+void deepcopy_VkImagePipeSurfaceCreateInfoFUCHSIA(Allocator* alloc, VkStructureType rootType,
+ const VkImagePipeSurfaceCreateInfoFUCHSIA* from,
+ VkImagePipeSurfaceCreateInfoFUCHSIA* to);
#endif
#ifdef VK_EXT_metal_surface
-void deepcopy_VkMetalSurfaceCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMetalSurfaceCreateInfoEXT* from,
- VkMetalSurfaceCreateInfoEXT* to);
+void deepcopy_VkMetalSurfaceCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkMetalSurfaceCreateInfoEXT* from,
+ VkMetalSurfaceCreateInfoEXT* to);
#endif
#ifdef VK_EXT_fragment_density_map
void deepcopy_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* from,
VkPhysicalDeviceFragmentDensityMapFeaturesEXT* to);
void deepcopy_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* from,
VkPhysicalDeviceFragmentDensityMapPropertiesEXT* to);
void deepcopy_VkRenderPassFragmentDensityMapCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkRenderPassFragmentDensityMapCreateInfoEXT* from,
VkRenderPassFragmentDensityMapCreateInfoEXT* to);
#endif
#ifdef VK_EXT_scalar_block_layout
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceScalarBlockLayoutFeatures, deepcopy_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceScalarBlockLayoutFeatures,
+ deepcopy_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT)
#endif
#ifdef VK_GOOGLE_hlsl_functionality1
@@ -4130,423 +3073,347 @@
#endif
#ifdef VK_EXT_subgroup_size_control
void deepcopy_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* from,
VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* to);
void deepcopy_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* from,
VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* to);
void deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* from,
VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* to);
#endif
#ifdef VK_AMD_shader_core_properties2
void deepcopy_VkPhysicalDeviceShaderCoreProperties2AMD(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderCoreProperties2AMD* from,
VkPhysicalDeviceShaderCoreProperties2AMD* to);
#endif
#ifdef VK_AMD_device_coherent_memory
void deepcopy_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceCoherentMemoryFeaturesAMD* from,
VkPhysicalDeviceCoherentMemoryFeaturesAMD* to);
#endif
#ifdef VK_EXT_shader_image_atomic_int64
void deepcopy_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* from,
VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* to);
#endif
#ifdef VK_EXT_memory_budget
void deepcopy_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceMemoryBudgetPropertiesEXT* from,
VkPhysicalDeviceMemoryBudgetPropertiesEXT* to);
#endif
#ifdef VK_EXT_memory_priority
void deepcopy_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceMemoryPriorityFeaturesEXT* from,
VkPhysicalDeviceMemoryPriorityFeaturesEXT* to);
-void deepcopy_VkMemoryPriorityAllocateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryPriorityAllocateInfoEXT* from,
- VkMemoryPriorityAllocateInfoEXT* to);
+void deepcopy_VkMemoryPriorityAllocateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryPriorityAllocateInfoEXT* from,
+ VkMemoryPriorityAllocateInfoEXT* to);
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
void deepcopy_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* from,
VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* to);
#endif
#ifdef VK_EXT_buffer_device_address
void deepcopy_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* from,
VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* to);
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, deepcopy_VkPhysicalDeviceBufferAddressFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT,
+ deepcopy_VkPhysicalDeviceBufferAddressFeaturesEXT)
DEFINE_ALIAS_FUNCTION(deepcopy_VkBufferDeviceAddressInfo, deepcopy_VkBufferDeviceAddressInfoEXT)
-void deepcopy_VkBufferDeviceAddressCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferDeviceAddressCreateInfoEXT* from,
- VkBufferDeviceAddressCreateInfoEXT* to);
+void deepcopy_VkBufferDeviceAddressCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkBufferDeviceAddressCreateInfoEXT* from,
+ VkBufferDeviceAddressCreateInfoEXT* to);
#endif
#ifdef VK_EXT_tooling_info
-void deepcopy_VkPhysicalDeviceToolPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceToolPropertiesEXT* from,
- VkPhysicalDeviceToolPropertiesEXT* to);
+void deepcopy_VkPhysicalDeviceToolPropertiesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceToolPropertiesEXT* from,
+ VkPhysicalDeviceToolPropertiesEXT* to);
#endif
#ifdef VK_EXT_separate_stencil_usage
-DEFINE_ALIAS_FUNCTION(deepcopy_VkImageStencilUsageCreateInfo, deepcopy_VkImageStencilUsageCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkImageStencilUsageCreateInfo,
+ deepcopy_VkImageStencilUsageCreateInfoEXT)
#endif
#ifdef VK_EXT_validation_features
-void deepcopy_VkValidationFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkValidationFeaturesEXT* from,
- VkValidationFeaturesEXT* to);
+void deepcopy_VkValidationFeaturesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkValidationFeaturesEXT* from,
+ VkValidationFeaturesEXT* to);
#endif
#ifdef VK_NV_cooperative_matrix
-void deepcopy_VkCooperativeMatrixPropertiesNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCooperativeMatrixPropertiesNV* from,
- VkCooperativeMatrixPropertiesNV* to);
+void deepcopy_VkCooperativeMatrixPropertiesNV(Allocator* alloc, VkStructureType rootType,
+ const VkCooperativeMatrixPropertiesNV* from,
+ VkCooperativeMatrixPropertiesNV* to);
void deepcopy_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixFeaturesNV* from,
VkPhysicalDeviceCooperativeMatrixFeaturesNV* to);
void deepcopy_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixPropertiesNV* from,
VkPhysicalDeviceCooperativeMatrixPropertiesNV* to);
#endif
#ifdef VK_NV_coverage_reduction_mode
void deepcopy_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceCoverageReductionModeFeaturesNV* from,
VkPhysicalDeviceCoverageReductionModeFeaturesNV* to);
void deepcopy_VkPipelineCoverageReductionStateCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineCoverageReductionStateCreateInfoNV* from,
VkPipelineCoverageReductionStateCreateInfoNV* to);
void deepcopy_VkFramebufferMixedSamplesCombinationNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkFramebufferMixedSamplesCombinationNV* from,
+ Allocator* alloc, VkStructureType rootType, const VkFramebufferMixedSamplesCombinationNV* from,
VkFramebufferMixedSamplesCombinationNV* to);
#endif
#ifdef VK_EXT_fragment_shader_interlock
void deepcopy_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* from,
VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* to);
#endif
#ifdef VK_EXT_ycbcr_image_arrays
void deepcopy_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* from,
VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* to);
#endif
#ifdef VK_EXT_provoking_vertex
void deepcopy_VkPhysicalDeviceProvokingVertexFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceProvokingVertexFeaturesEXT* from,
VkPhysicalDeviceProvokingVertexFeaturesEXT* to);
void deepcopy_VkPhysicalDeviceProvokingVertexPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceProvokingVertexPropertiesEXT* from,
VkPhysicalDeviceProvokingVertexPropertiesEXT* to);
void deepcopy_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* from,
VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* to);
#endif
#ifdef VK_EXT_full_screen_exclusive
-void deepcopy_VkSurfaceFullScreenExclusiveInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSurfaceFullScreenExclusiveInfoEXT* from,
- VkSurfaceFullScreenExclusiveInfoEXT* to);
+void deepcopy_VkSurfaceFullScreenExclusiveInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkSurfaceFullScreenExclusiveInfoEXT* from,
+ VkSurfaceFullScreenExclusiveInfoEXT* to);
void deepcopy_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkSurfaceCapabilitiesFullScreenExclusiveEXT* from,
VkSurfaceCapabilitiesFullScreenExclusiveEXT* to);
void deepcopy_VkSurfaceFullScreenExclusiveWin32InfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkSurfaceFullScreenExclusiveWin32InfoEXT* from,
VkSurfaceFullScreenExclusiveWin32InfoEXT* to);
#endif
#ifdef VK_EXT_headless_surface
-void deepcopy_VkHeadlessSurfaceCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkHeadlessSurfaceCreateInfoEXT* from,
- VkHeadlessSurfaceCreateInfoEXT* to);
+void deepcopy_VkHeadlessSurfaceCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkHeadlessSurfaceCreateInfoEXT* from,
+ VkHeadlessSurfaceCreateInfoEXT* to);
#endif
#ifdef VK_EXT_line_rasterization
void deepcopy_VkPhysicalDeviceLineRasterizationFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceLineRasterizationFeaturesEXT* from,
VkPhysicalDeviceLineRasterizationFeaturesEXT* to);
void deepcopy_VkPhysicalDeviceLineRasterizationPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceLineRasterizationPropertiesEXT* from,
VkPhysicalDeviceLineRasterizationPropertiesEXT* to);
void deepcopy_VkPipelineRasterizationLineStateCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineRasterizationLineStateCreateInfoEXT* from,
VkPipelineRasterizationLineStateCreateInfoEXT* to);
#endif
#ifdef VK_EXT_shader_atomic_float
void deepcopy_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* from,
VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* to);
#endif
#ifdef VK_EXT_host_query_reset
-DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceHostQueryResetFeatures, deepcopy_VkPhysicalDeviceHostQueryResetFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceHostQueryResetFeatures,
+ deepcopy_VkPhysicalDeviceHostQueryResetFeaturesEXT)
#endif
#ifdef VK_EXT_index_type_uint8
void deepcopy_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* from,
VkPhysicalDeviceIndexTypeUint8FeaturesEXT* to);
#endif
#ifdef VK_EXT_extended_dynamic_state
void deepcopy_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* from,
VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* to);
#endif
#ifdef VK_EXT_shader_atomic_float2
void deepcopy_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* from,
VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* to);
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
void deepcopy_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* from,
VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* to);
#endif
#ifdef VK_NV_device_generated_commands
void deepcopy_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* from,
VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* to);
void deepcopy_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* from,
VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* to);
-void deepcopy_VkGraphicsShaderGroupCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkGraphicsShaderGroupCreateInfoNV* from,
- VkGraphicsShaderGroupCreateInfoNV* to);
+void deepcopy_VkGraphicsShaderGroupCreateInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkGraphicsShaderGroupCreateInfoNV* from,
+ VkGraphicsShaderGroupCreateInfoNV* to);
void deepcopy_VkGraphicsPipelineShaderGroupsCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkGraphicsPipelineShaderGroupsCreateInfoNV* from,
VkGraphicsPipelineShaderGroupsCreateInfoNV* to);
-void deepcopy_VkBindShaderGroupIndirectCommandNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindShaderGroupIndirectCommandNV* from,
- VkBindShaderGroupIndirectCommandNV* to);
+void deepcopy_VkBindShaderGroupIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
+ const VkBindShaderGroupIndirectCommandNV* from,
+ VkBindShaderGroupIndirectCommandNV* to);
-void deepcopy_VkBindIndexBufferIndirectCommandNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindIndexBufferIndirectCommandNV* from,
- VkBindIndexBufferIndirectCommandNV* to);
+void deepcopy_VkBindIndexBufferIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
+ const VkBindIndexBufferIndirectCommandNV* from,
+ VkBindIndexBufferIndirectCommandNV* to);
-void deepcopy_VkBindVertexBufferIndirectCommandNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBindVertexBufferIndirectCommandNV* from,
- VkBindVertexBufferIndirectCommandNV* to);
+void deepcopy_VkBindVertexBufferIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
+ const VkBindVertexBufferIndirectCommandNV* from,
+ VkBindVertexBufferIndirectCommandNV* to);
-void deepcopy_VkSetStateFlagsIndirectCommandNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSetStateFlagsIndirectCommandNV* from,
- VkSetStateFlagsIndirectCommandNV* to);
+void deepcopy_VkSetStateFlagsIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
+ const VkSetStateFlagsIndirectCommandNV* from,
+ VkSetStateFlagsIndirectCommandNV* to);
-void deepcopy_VkIndirectCommandsStreamNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkIndirectCommandsStreamNV* from,
- VkIndirectCommandsStreamNV* to);
+void deepcopy_VkIndirectCommandsStreamNV(Allocator* alloc, VkStructureType rootType,
+ const VkIndirectCommandsStreamNV* from,
+ VkIndirectCommandsStreamNV* to);
-void deepcopy_VkIndirectCommandsLayoutTokenNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkIndirectCommandsLayoutTokenNV* from,
- VkIndirectCommandsLayoutTokenNV* to);
+void deepcopy_VkIndirectCommandsLayoutTokenNV(Allocator* alloc, VkStructureType rootType,
+ const VkIndirectCommandsLayoutTokenNV* from,
+ VkIndirectCommandsLayoutTokenNV* to);
-void deepcopy_VkIndirectCommandsLayoutCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkIndirectCommandsLayoutCreateInfoNV* from,
- VkIndirectCommandsLayoutCreateInfoNV* to);
+void deepcopy_VkIndirectCommandsLayoutCreateInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkIndirectCommandsLayoutCreateInfoNV* from,
+ VkIndirectCommandsLayoutCreateInfoNV* to);
-void deepcopy_VkGeneratedCommandsInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkGeneratedCommandsInfoNV* from,
- VkGeneratedCommandsInfoNV* to);
+void deepcopy_VkGeneratedCommandsInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkGeneratedCommandsInfoNV* from,
+ VkGeneratedCommandsInfoNV* to);
void deepcopy_VkGeneratedCommandsMemoryRequirementsInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkGeneratedCommandsMemoryRequirementsInfoNV* from,
VkGeneratedCommandsMemoryRequirementsInfoNV* to);
#endif
#ifdef VK_NV_inherited_viewport_scissor
void deepcopy_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* from,
VkPhysicalDeviceInheritedViewportScissorFeaturesNV* to);
void deepcopy_VkCommandBufferInheritanceViewportScissorInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkCommandBufferInheritanceViewportScissorInfoNV* from,
VkCommandBufferInheritanceViewportScissorInfoNV* to);
#endif
#ifdef VK_EXT_texel_buffer_alignment
void deepcopy_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* from,
VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* to);
void deepcopy_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* from,
VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* to);
#endif
#ifdef VK_QCOM_render_pass_transform
-void deepcopy_VkRenderPassTransformBeginInfoQCOM(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRenderPassTransformBeginInfoQCOM* from,
- VkRenderPassTransformBeginInfoQCOM* to);
+void deepcopy_VkRenderPassTransformBeginInfoQCOM(Allocator* alloc, VkStructureType rootType,
+ const VkRenderPassTransformBeginInfoQCOM* from,
+ VkRenderPassTransformBeginInfoQCOM* to);
void deepcopy_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* from,
VkCommandBufferInheritanceRenderPassTransformInfoQCOM* to);
#endif
#ifdef VK_EXT_device_memory_report
void deepcopy_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* from,
VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* to);
-void deepcopy_VkDeviceMemoryReportCallbackDataEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceMemoryReportCallbackDataEXT* from,
- VkDeviceMemoryReportCallbackDataEXT* to);
+void deepcopy_VkDeviceMemoryReportCallbackDataEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceMemoryReportCallbackDataEXT* from,
+ VkDeviceMemoryReportCallbackDataEXT* to);
void deepcopy_VkDeviceDeviceMemoryReportCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceDeviceMemoryReportCreateInfoEXT* from,
+ Allocator* alloc, VkStructureType rootType, const VkDeviceDeviceMemoryReportCreateInfoEXT* from,
VkDeviceDeviceMemoryReportCreateInfoEXT* to);
#endif
@@ -4554,34 +3421,27 @@
#endif
#ifdef VK_EXT_robustness2
void deepcopy_VkPhysicalDeviceRobustness2FeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceRobustness2FeaturesEXT* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceRobustness2FeaturesEXT* from,
VkPhysicalDeviceRobustness2FeaturesEXT* to);
void deepcopy_VkPhysicalDeviceRobustness2PropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceRobustness2PropertiesEXT* from,
VkPhysicalDeviceRobustness2PropertiesEXT* to);
#endif
#ifdef VK_EXT_custom_border_color
void deepcopy_VkSamplerCustomBorderColorCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSamplerCustomBorderColorCreateInfoEXT* from,
+ Allocator* alloc, VkStructureType rootType, const VkSamplerCustomBorderColorCreateInfoEXT* from,
VkSamplerCustomBorderColorCreateInfoEXT* to);
void deepcopy_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorPropertiesEXT* from,
VkPhysicalDeviceCustomBorderColorPropertiesEXT* to);
void deepcopy_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorFeaturesEXT* from,
VkPhysicalDeviceCustomBorderColorFeaturesEXT* to);
@@ -4590,43 +3450,33 @@
#endif
#ifdef VK_EXT_private_data
void deepcopy_VkPhysicalDevicePrivateDataFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDevicePrivateDataFeaturesEXT* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDevicePrivateDataFeaturesEXT* from,
VkPhysicalDevicePrivateDataFeaturesEXT* to);
-void deepcopy_VkDevicePrivateDataCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDevicePrivateDataCreateInfoEXT* from,
- VkDevicePrivateDataCreateInfoEXT* to);
+void deepcopy_VkDevicePrivateDataCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDevicePrivateDataCreateInfoEXT* from,
+ VkDevicePrivateDataCreateInfoEXT* to);
-void deepcopy_VkPrivateDataSlotCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPrivateDataSlotCreateInfoEXT* from,
- VkPrivateDataSlotCreateInfoEXT* to);
+void deepcopy_VkPrivateDataSlotCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkPrivateDataSlotCreateInfoEXT* from,
+ VkPrivateDataSlotCreateInfoEXT* to);
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
void deepcopy_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* from,
VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* to);
#endif
#ifdef VK_NV_device_diagnostics_config
void deepcopy_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* from,
VkPhysicalDeviceDiagnosticsConfigFeaturesNV* to);
void deepcopy_VkDeviceDiagnosticsConfigCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceDiagnosticsConfigCreateInfoNV* from,
+ Allocator* alloc, VkStructureType rootType, const VkDeviceDiagnosticsConfigCreateInfoNV* from,
VkDeviceDiagnosticsConfigCreateInfoNV* to);
#endif
@@ -4634,130 +3484,104 @@
#endif
#ifdef VK_NV_fragment_shading_rate_enums
void deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* from,
VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* to);
void deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* from,
VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* to);
void deepcopy_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* from,
VkPipelineFragmentShadingRateEnumStateCreateInfoNV* to);
#endif
#ifdef VK_NV_ray_tracing_motion_blur
-void deepcopy_VkDeviceOrHostAddressConstKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceOrHostAddressConstKHR* from,
- VkDeviceOrHostAddressConstKHR* to);
+void deepcopy_VkDeviceOrHostAddressConstKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceOrHostAddressConstKHR* from,
+ VkDeviceOrHostAddressConstKHR* to);
void deepcopy_VkAccelerationStructureGeometryMotionTrianglesDataNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureGeometryMotionTrianglesDataNV* from,
VkAccelerationStructureGeometryMotionTrianglesDataNV* to);
-void deepcopy_VkAccelerationStructureMotionInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAccelerationStructureMotionInfoNV* from,
- VkAccelerationStructureMotionInfoNV* to);
+void deepcopy_VkAccelerationStructureMotionInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkAccelerationStructureMotionInfoNV* from,
+ VkAccelerationStructureMotionInfoNV* to);
void deepcopy_VkAccelerationStructureMatrixMotionInstanceNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureMatrixMotionInstanceNV* from,
VkAccelerationStructureMatrixMotionInstanceNV* to);
-void deepcopy_VkSRTDataNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSRTDataNV* from,
- VkSRTDataNV* to);
+void deepcopy_VkSRTDataNV(Allocator* alloc, VkStructureType rootType, const VkSRTDataNV* from,
+ VkSRTDataNV* to);
void deepcopy_VkAccelerationStructureSRTMotionInstanceNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureSRTMotionInstanceNV* from,
VkAccelerationStructureSRTMotionInstanceNV* to);
void deepcopy_VkAccelerationStructureMotionInstanceDataNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureMotionInstanceDataNV* from,
VkAccelerationStructureMotionInstanceDataNV* to);
void deepcopy_VkAccelerationStructureMotionInstanceNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAccelerationStructureMotionInstanceNV* from,
+ Allocator* alloc, VkStructureType rootType, const VkAccelerationStructureMotionInstanceNV* from,
VkAccelerationStructureMotionInstanceNV* to);
void deepcopy_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* from,
VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* to);
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
void deepcopy_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* from,
VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* to);
#endif
#ifdef VK_EXT_fragment_density_map2
void deepcopy_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* from,
VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* to);
void deepcopy_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* from,
VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* to);
#endif
#ifdef VK_QCOM_rotated_copy_commands
-void deepcopy_VkCopyCommandTransformInfoQCOM(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCopyCommandTransformInfoQCOM* from,
- VkCopyCommandTransformInfoQCOM* to);
+void deepcopy_VkCopyCommandTransformInfoQCOM(Allocator* alloc, VkStructureType rootType,
+ const VkCopyCommandTransformInfoQCOM* from,
+ VkCopyCommandTransformInfoQCOM* to);
#endif
#ifdef VK_EXT_image_robustness
void deepcopy_VkPhysicalDeviceImageRobustnessFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceImageRobustnessFeaturesEXT* from,
VkPhysicalDeviceImageRobustnessFeaturesEXT* to);
#endif
#ifdef VK_EXT_4444_formats
void deepcopy_VkPhysicalDevice4444FormatsFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDevice4444FormatsFeaturesEXT* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDevice4444FormatsFeaturesEXT* from,
VkPhysicalDevice4444FormatsFeaturesEXT* to);
#endif
#ifdef VK_EXT_rgba10x6_formats
void deepcopy_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* from,
VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* to);
@@ -4765,482 +3589,370 @@
#ifdef VK_NV_acquire_winrt_display
#endif
#ifdef VK_EXT_directfb_surface
-void deepcopy_VkDirectFBSurfaceCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDirectFBSurfaceCreateInfoEXT* from,
- VkDirectFBSurfaceCreateInfoEXT* to);
+void deepcopy_VkDirectFBSurfaceCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDirectFBSurfaceCreateInfoEXT* from,
+ VkDirectFBSurfaceCreateInfoEXT* to);
#endif
#ifdef VK_VALVE_mutable_descriptor_type
void deepcopy_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* from,
VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* to);
-void deepcopy_VkMutableDescriptorTypeListVALVE(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMutableDescriptorTypeListVALVE* from,
- VkMutableDescriptorTypeListVALVE* to);
+void deepcopy_VkMutableDescriptorTypeListVALVE(Allocator* alloc, VkStructureType rootType,
+ const VkMutableDescriptorTypeListVALVE* from,
+ VkMutableDescriptorTypeListVALVE* to);
void deepcopy_VkMutableDescriptorTypeCreateInfoVALVE(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMutableDescriptorTypeCreateInfoVALVE* from,
+ Allocator* alloc, VkStructureType rootType, const VkMutableDescriptorTypeCreateInfoVALVE* from,
VkMutableDescriptorTypeCreateInfoVALVE* to);
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
void deepcopy_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* from,
VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* to);
-void deepcopy_VkVertexInputBindingDescription2EXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVertexInputBindingDescription2EXT* from,
- VkVertexInputBindingDescription2EXT* to);
+void deepcopy_VkVertexInputBindingDescription2EXT(Allocator* alloc, VkStructureType rootType,
+ const VkVertexInputBindingDescription2EXT* from,
+ VkVertexInputBindingDescription2EXT* to);
void deepcopy_VkVertexInputAttributeDescription2EXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkVertexInputAttributeDescription2EXT* from,
+ Allocator* alloc, VkStructureType rootType, const VkVertexInputAttributeDescription2EXT* from,
VkVertexInputAttributeDescription2EXT* to);
#endif
#ifdef VK_EXT_physical_device_drm
-void deepcopy_VkPhysicalDeviceDrmPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceDrmPropertiesEXT* from,
- VkPhysicalDeviceDrmPropertiesEXT* to);
+void deepcopy_VkPhysicalDeviceDrmPropertiesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceDrmPropertiesEXT* from,
+ VkPhysicalDeviceDrmPropertiesEXT* to);
#endif
#ifdef VK_EXT_primitive_topology_list_restart
void deepcopy_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* from,
VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* to);
#endif
#ifdef VK_FUCHSIA_external_memory
void deepcopy_VkImportMemoryZirconHandleInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportMemoryZirconHandleInfoFUCHSIA* from,
+ Allocator* alloc, VkStructureType rootType, const VkImportMemoryZirconHandleInfoFUCHSIA* from,
VkImportMemoryZirconHandleInfoFUCHSIA* to);
void deepcopy_VkMemoryZirconHandlePropertiesFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryZirconHandlePropertiesFUCHSIA* from,
+ Allocator* alloc, VkStructureType rootType, const VkMemoryZirconHandlePropertiesFUCHSIA* from,
VkMemoryZirconHandlePropertiesFUCHSIA* to);
-void deepcopy_VkMemoryGetZirconHandleInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryGetZirconHandleInfoFUCHSIA* from,
- VkMemoryGetZirconHandleInfoFUCHSIA* to);
+void deepcopy_VkMemoryGetZirconHandleInfoFUCHSIA(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* from,
+ VkMemoryGetZirconHandleInfoFUCHSIA* to);
#endif
#ifdef VK_FUCHSIA_external_semaphore
void deepcopy_VkImportSemaphoreZirconHandleInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkImportSemaphoreZirconHandleInfoFUCHSIA* from,
VkImportSemaphoreZirconHandleInfoFUCHSIA* to);
void deepcopy_VkSemaphoreGetZirconHandleInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSemaphoreGetZirconHandleInfoFUCHSIA* from,
+ Allocator* alloc, VkStructureType rootType, const VkSemaphoreGetZirconHandleInfoFUCHSIA* from,
VkSemaphoreGetZirconHandleInfoFUCHSIA* to);
#endif
#ifdef VK_FUCHSIA_buffer_collection
-void deepcopy_VkBufferCollectionCreateInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferCollectionCreateInfoFUCHSIA* from,
- VkBufferCollectionCreateInfoFUCHSIA* to);
+void deepcopy_VkBufferCollectionCreateInfoFUCHSIA(Allocator* alloc, VkStructureType rootType,
+ const VkBufferCollectionCreateInfoFUCHSIA* from,
+ VkBufferCollectionCreateInfoFUCHSIA* to);
void deepcopy_VkImportMemoryBufferCollectionFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportMemoryBufferCollectionFUCHSIA* from,
+ Allocator* alloc, VkStructureType rootType, const VkImportMemoryBufferCollectionFUCHSIA* from,
VkImportMemoryBufferCollectionFUCHSIA* to);
void deepcopy_VkBufferCollectionImageCreateInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkBufferCollectionImageCreateInfoFUCHSIA* from,
VkBufferCollectionImageCreateInfoFUCHSIA* to);
void deepcopy_VkBufferCollectionConstraintsInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkBufferCollectionConstraintsInfoFUCHSIA* from,
VkBufferCollectionConstraintsInfoFUCHSIA* to);
-void deepcopy_VkBufferConstraintsInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferConstraintsInfoFUCHSIA* from,
- VkBufferConstraintsInfoFUCHSIA* to);
+void deepcopy_VkBufferConstraintsInfoFUCHSIA(Allocator* alloc, VkStructureType rootType,
+ const VkBufferConstraintsInfoFUCHSIA* from,
+ VkBufferConstraintsInfoFUCHSIA* to);
void deepcopy_VkBufferCollectionBufferCreateInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkBufferCollectionBufferCreateInfoFUCHSIA* from,
VkBufferCollectionBufferCreateInfoFUCHSIA* to);
-void deepcopy_VkSysmemColorSpaceFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkSysmemColorSpaceFUCHSIA* from,
- VkSysmemColorSpaceFUCHSIA* to);
+void deepcopy_VkSysmemColorSpaceFUCHSIA(Allocator* alloc, VkStructureType rootType,
+ const VkSysmemColorSpaceFUCHSIA* from,
+ VkSysmemColorSpaceFUCHSIA* to);
-void deepcopy_VkBufferCollectionPropertiesFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkBufferCollectionPropertiesFUCHSIA* from,
- VkBufferCollectionPropertiesFUCHSIA* to);
+void deepcopy_VkBufferCollectionPropertiesFUCHSIA(Allocator* alloc, VkStructureType rootType,
+ const VkBufferCollectionPropertiesFUCHSIA* from,
+ VkBufferCollectionPropertiesFUCHSIA* to);
-void deepcopy_VkImageFormatConstraintsInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageFormatConstraintsInfoFUCHSIA* from,
- VkImageFormatConstraintsInfoFUCHSIA* to);
+void deepcopy_VkImageFormatConstraintsInfoFUCHSIA(Allocator* alloc, VkStructureType rootType,
+ const VkImageFormatConstraintsInfoFUCHSIA* from,
+ VkImageFormatConstraintsInfoFUCHSIA* to);
-void deepcopy_VkImageConstraintsInfoFUCHSIA(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImageConstraintsInfoFUCHSIA* from,
- VkImageConstraintsInfoFUCHSIA* to);
+void deepcopy_VkImageConstraintsInfoFUCHSIA(Allocator* alloc, VkStructureType rootType,
+ const VkImageConstraintsInfoFUCHSIA* from,
+ VkImageConstraintsInfoFUCHSIA* to);
#endif
#ifdef VK_HUAWEI_subpass_shading
void deepcopy_VkSubpassShadingPipelineCreateInfoHUAWEI(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkSubpassShadingPipelineCreateInfoHUAWEI* from,
VkSubpassShadingPipelineCreateInfoHUAWEI* to);
void deepcopy_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* from,
VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* to);
void deepcopy_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* from,
VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* to);
#endif
#ifdef VK_HUAWEI_invocation_mask
void deepcopy_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* from,
VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* to);
#endif
#ifdef VK_NV_external_memory_rdma
-void deepcopy_VkMemoryGetRemoteAddressInfoNV(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMemoryGetRemoteAddressInfoNV* from,
- VkMemoryGetRemoteAddressInfoNV* to);
+void deepcopy_VkMemoryGetRemoteAddressInfoNV(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryGetRemoteAddressInfoNV* from,
+ VkMemoryGetRemoteAddressInfoNV* to);
void deepcopy_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* from,
VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* to);
#endif
#ifdef VK_EXT_extended_dynamic_state2
void deepcopy_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* from,
VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* to);
#endif
#ifdef VK_QNX_screen_surface
-void deepcopy_VkScreenSurfaceCreateInfoQNX(
- Allocator* alloc,
- VkStructureType rootType,
- const VkScreenSurfaceCreateInfoQNX* from,
- VkScreenSurfaceCreateInfoQNX* to);
+void deepcopy_VkScreenSurfaceCreateInfoQNX(Allocator* alloc, VkStructureType rootType,
+ const VkScreenSurfaceCreateInfoQNX* from,
+ VkScreenSurfaceCreateInfoQNX* to);
#endif
#ifdef VK_EXT_color_write_enable
void deepcopy_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceColorWriteEnableFeaturesEXT* from,
VkPhysicalDeviceColorWriteEnableFeaturesEXT* to);
-void deepcopy_VkPipelineColorWriteCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPipelineColorWriteCreateInfoEXT* from,
- VkPipelineColorWriteCreateInfoEXT* to);
+void deepcopy_VkPipelineColorWriteCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkPipelineColorWriteCreateInfoEXT* from,
+ VkPipelineColorWriteCreateInfoEXT* to);
#endif
#ifdef VK_GOOGLE_gfxstream
-void deepcopy_VkImportColorBufferGOOGLE(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportColorBufferGOOGLE* from,
- VkImportColorBufferGOOGLE* to);
+void deepcopy_VkImportColorBufferGOOGLE(Allocator* alloc, VkStructureType rootType,
+ const VkImportColorBufferGOOGLE* from,
+ VkImportColorBufferGOOGLE* to);
-void deepcopy_VkImportBufferGOOGLE(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportBufferGOOGLE* from,
- VkImportBufferGOOGLE* to);
+void deepcopy_VkImportBufferGOOGLE(Allocator* alloc, VkStructureType rootType,
+ const VkImportBufferGOOGLE* from, VkImportBufferGOOGLE* to);
-void deepcopy_VkImportPhysicalAddressGOOGLE(
- Allocator* alloc,
- VkStructureType rootType,
- const VkImportPhysicalAddressGOOGLE* from,
- VkImportPhysicalAddressGOOGLE* to);
+void deepcopy_VkImportPhysicalAddressGOOGLE(Allocator* alloc, VkStructureType rootType,
+ const VkImportPhysicalAddressGOOGLE* from,
+ VkImportPhysicalAddressGOOGLE* to);
#endif
#ifdef VK_EXT_global_priority_query
void deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* from,
VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* to);
void deepcopy_VkQueueFamilyGlobalPriorityPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkQueueFamilyGlobalPriorityPropertiesEXT* from,
VkQueueFamilyGlobalPriorityPropertiesEXT* to);
#endif
#ifdef VK_EXT_multi_draw
-void deepcopy_VkPhysicalDeviceMultiDrawFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiDrawFeaturesEXT* from,
- VkPhysicalDeviceMultiDrawFeaturesEXT* to);
+void deepcopy_VkPhysicalDeviceMultiDrawFeaturesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceMultiDrawFeaturesEXT* from,
+ VkPhysicalDeviceMultiDrawFeaturesEXT* to);
void deepcopy_VkPhysicalDeviceMultiDrawPropertiesEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiDrawPropertiesEXT* from,
+ Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMultiDrawPropertiesEXT* from,
VkPhysicalDeviceMultiDrawPropertiesEXT* to);
-void deepcopy_VkMultiDrawInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMultiDrawInfoEXT* from,
- VkMultiDrawInfoEXT* to);
+void deepcopy_VkMultiDrawInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkMultiDrawInfoEXT* from, VkMultiDrawInfoEXT* to);
-void deepcopy_VkMultiDrawIndexedInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
- const VkMultiDrawIndexedInfoEXT* from,
- VkMultiDrawIndexedInfoEXT* to);
+void deepcopy_VkMultiDrawIndexedInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkMultiDrawIndexedInfoEXT* from,
+ VkMultiDrawIndexedInfoEXT* to);
#endif
#ifdef VK_EXT_load_store_op_none
#endif
#ifdef VK_EXT_border_color_swizzle
void deepcopy_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* from,
VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* to);
void deepcopy_VkSamplerBorderColorComponentMappingCreateInfoEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkSamplerBorderColorComponentMappingCreateInfoEXT* from,
VkSamplerBorderColorComponentMappingCreateInfoEXT* to);
#endif
#ifdef VK_EXT_pageable_device_local_memory
void deepcopy_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* from,
VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* to);
#endif
#ifdef VK_KHR_acceleration_structure
-void deepcopy_VkDeviceOrHostAddressKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkDeviceOrHostAddressKHR* from,
- VkDeviceOrHostAddressKHR* to);
+void deepcopy_VkDeviceOrHostAddressKHR(Allocator* alloc, VkStructureType rootType,
+ const VkDeviceOrHostAddressKHR* from,
+ VkDeviceOrHostAddressKHR* to);
void deepcopy_VkAccelerationStructureBuildRangeInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureBuildRangeInfoKHR* from,
VkAccelerationStructureBuildRangeInfoKHR* to);
void deepcopy_VkAccelerationStructureGeometryTrianglesDataKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureGeometryTrianglesDataKHR* from,
VkAccelerationStructureGeometryTrianglesDataKHR* to);
void deepcopy_VkAccelerationStructureGeometryAabbsDataKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureGeometryAabbsDataKHR* from,
VkAccelerationStructureGeometryAabbsDataKHR* to);
void deepcopy_VkAccelerationStructureGeometryInstancesDataKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureGeometryInstancesDataKHR* from,
VkAccelerationStructureGeometryInstancesDataKHR* to);
void deepcopy_VkAccelerationStructureGeometryDataKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryDataKHR* from,
+ Allocator* alloc, VkStructureType rootType, const VkAccelerationStructureGeometryDataKHR* from,
VkAccelerationStructureGeometryDataKHR* to);
-void deepcopy_VkAccelerationStructureGeometryKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryKHR* from,
- VkAccelerationStructureGeometryKHR* to);
+void deepcopy_VkAccelerationStructureGeometryKHR(Allocator* alloc, VkStructureType rootType,
+ const VkAccelerationStructureGeometryKHR* from,
+ VkAccelerationStructureGeometryKHR* to);
void deepcopy_VkAccelerationStructureBuildGeometryInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureBuildGeometryInfoKHR* from,
VkAccelerationStructureBuildGeometryInfoKHR* to);
-void deepcopy_VkAccelerationStructureCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAccelerationStructureCreateInfoKHR* from,
- VkAccelerationStructureCreateInfoKHR* to);
+void deepcopy_VkAccelerationStructureCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkAccelerationStructureCreateInfoKHR* from,
+ VkAccelerationStructureCreateInfoKHR* to);
void deepcopy_VkWriteDescriptorSetAccelerationStructureKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkWriteDescriptorSetAccelerationStructureKHR* from,
VkWriteDescriptorSetAccelerationStructureKHR* to);
void deepcopy_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceAccelerationStructureFeaturesKHR* from,
VkPhysicalDeviceAccelerationStructureFeaturesKHR* to);
void deepcopy_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceAccelerationStructurePropertiesKHR* from,
VkPhysicalDeviceAccelerationStructurePropertiesKHR* to);
void deepcopy_VkAccelerationStructureDeviceAddressInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureDeviceAddressInfoKHR* from,
VkAccelerationStructureDeviceAddressInfoKHR* to);
void deepcopy_VkAccelerationStructureVersionInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkAccelerationStructureVersionInfoKHR* from,
+ Allocator* alloc, VkStructureType rootType, const VkAccelerationStructureVersionInfoKHR* from,
VkAccelerationStructureVersionInfoKHR* to);
void deepcopy_VkCopyAccelerationStructureToMemoryInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkCopyAccelerationStructureToMemoryInfoKHR* from,
VkCopyAccelerationStructureToMemoryInfoKHR* to);
void deepcopy_VkCopyMemoryToAccelerationStructureInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkCopyMemoryToAccelerationStructureInfoKHR* from,
VkCopyMemoryToAccelerationStructureInfoKHR* to);
-void deepcopy_VkCopyAccelerationStructureInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkCopyAccelerationStructureInfoKHR* from,
- VkCopyAccelerationStructureInfoKHR* to);
+void deepcopy_VkCopyAccelerationStructureInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkCopyAccelerationStructureInfoKHR* from,
+ VkCopyAccelerationStructureInfoKHR* to);
void deepcopy_VkAccelerationStructureBuildSizesInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkAccelerationStructureBuildSizesInfoKHR* from,
VkAccelerationStructureBuildSizesInfoKHR* to);
#endif
#ifdef VK_KHR_ray_tracing_pipeline
-void deepcopy_VkRayTracingShaderGroupCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRayTracingShaderGroupCreateInfoKHR* from,
- VkRayTracingShaderGroupCreateInfoKHR* to);
+void deepcopy_VkRayTracingShaderGroupCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkRayTracingShaderGroupCreateInfoKHR* from,
+ VkRayTracingShaderGroupCreateInfoKHR* to);
void deepcopy_VkRayTracingPipelineInterfaceCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkRayTracingPipelineInterfaceCreateInfoKHR* from,
VkRayTracingPipelineInterfaceCreateInfoKHR* to);
-void deepcopy_VkRayTracingPipelineCreateInfoKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkRayTracingPipelineCreateInfoKHR* from,
- VkRayTracingPipelineCreateInfoKHR* to);
+void deepcopy_VkRayTracingPipelineCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+ const VkRayTracingPipelineCreateInfoKHR* from,
+ VkRayTracingPipelineCreateInfoKHR* to);
void deepcopy_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* from,
VkPhysicalDeviceRayTracingPipelineFeaturesKHR* to);
void deepcopy_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
- Allocator* alloc,
- VkStructureType rootType,
+ Allocator* alloc, VkStructureType rootType,
const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* from,
VkPhysicalDeviceRayTracingPipelinePropertiesKHR* to);
-void deepcopy_VkStridedDeviceAddressRegionKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkStridedDeviceAddressRegionKHR* from,
- VkStridedDeviceAddressRegionKHR* to);
+void deepcopy_VkStridedDeviceAddressRegionKHR(Allocator* alloc, VkStructureType rootType,
+ const VkStridedDeviceAddressRegionKHR* from,
+ VkStridedDeviceAddressRegionKHR* to);
-void deepcopy_VkTraceRaysIndirectCommandKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkTraceRaysIndirectCommandKHR* from,
- VkTraceRaysIndirectCommandKHR* to);
+void deepcopy_VkTraceRaysIndirectCommandKHR(Allocator* alloc, VkStructureType rootType,
+ const VkTraceRaysIndirectCommandKHR* from,
+ VkTraceRaysIndirectCommandKHR* to);
#endif
#ifdef VK_KHR_ray_query
-void deepcopy_VkPhysicalDeviceRayQueryFeaturesKHR(
- Allocator* alloc,
- VkStructureType rootType,
- const VkPhysicalDeviceRayQueryFeaturesKHR* from,
- VkPhysicalDeviceRayQueryFeaturesKHR* to);
+void deepcopy_VkPhysicalDeviceRayQueryFeaturesKHR(Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceRayQueryFeaturesKHR* from,
+ VkPhysicalDeviceRayQueryFeaturesKHR* to);
#endif
-} // namespace goldfish_vk
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp b/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
index 69215bc..d2c499f 100644
--- a/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
@@ -14,19 +14,23 @@
// limitations under the License.
// Autogenerated module goldfish_vk_extension_structs_guest
-// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal -o ../qemu/android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+//
+// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
+// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
-// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+//
+// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
+// $CEREAL_OUTPUT_DIR
+//
#include "goldfish_vk_extension_structs_guest.h"
-
-
namespace goldfish_vk {
#ifdef VK_VERSION_1_0
@@ -571,1287 +575,1009 @@
#endif
#ifdef VK_KHR_ray_query
#endif
-uint32_t goldfish_vk_struct_type(
- const void* structExtension)
-{
+uint32_t goldfish_vk_struct_type(const void* structExtension) {
const uint32_t asStructType = *(reinterpret_cast<const uint32_t*>(structExtension));
return asStructType;
}
-size_t goldfish_vk_extension_struct_size(
- VkStructureType rootType,
- const void* structExtension)
-{
- if (!structExtension)
- {
+size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* structExtension) {
+ if (!structExtension) {
return (size_t)0;
}
uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension);
- switch(structType)
- {
+ switch (structType) {
#ifdef VK_VERSION_1_1
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
return sizeof(VkPhysicalDeviceSubgroupProperties);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
return sizeof(VkPhysicalDevice16BitStorageFeatures);
}
- case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
- {
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
return sizeof(VkMemoryDedicatedRequirements);
}
- case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: {
return sizeof(VkMemoryDedicatedAllocateInfo);
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
- {
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: {
return sizeof(VkMemoryAllocateFlagsInfo);
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: {
return sizeof(VkDeviceGroupRenderPassBeginInfo);
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: {
return sizeof(VkDeviceGroupCommandBufferBeginInfo);
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: {
return sizeof(VkDeviceGroupSubmitInfo);
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: {
return sizeof(VkDeviceGroupBindSparseInfo);
}
- case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
- {
+ case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: {
return sizeof(VkBindBufferMemoryDeviceGroupInfo);
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
- {
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: {
return sizeof(VkBindImageMemoryDeviceGroupInfo);
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: {
return sizeof(VkDeviceGroupDeviceCreateInfo);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
return sizeof(VkPhysicalDeviceFeatures2);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: {
return sizeof(VkPhysicalDevicePointClippingProperties);
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: {
return sizeof(VkRenderPassInputAttachmentAspectCreateInfo);
}
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: {
return sizeof(VkImageViewUsageCreateInfo);
}
- case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: {
return sizeof(VkPipelineTessellationDomainOriginStateCreateInfo);
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: {
return sizeof(VkRenderPassMultiviewCreateInfo);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
return sizeof(VkPhysicalDeviceMultiviewFeatures);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: {
return sizeof(VkPhysicalDeviceMultiviewProperties);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
return sizeof(VkPhysicalDeviceVariablePointersFeatures);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
return sizeof(VkPhysicalDeviceProtectedMemoryFeatures);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: {
return sizeof(VkPhysicalDeviceProtectedMemoryProperties);
}
- case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
- {
+ case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: {
return sizeof(VkProtectedSubmitInfo);
}
- case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
- {
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: {
return sizeof(VkSamplerYcbcrConversionInfo);
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
- {
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: {
return sizeof(VkBindImagePlaneMemoryInfo);
}
- case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
- {
+ case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: {
return sizeof(VkImagePlaneMemoryRequirementsInfo);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
return sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures);
}
- case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: {
return sizeof(VkSamplerYcbcrConversionImageFormatProperties);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: {
return sizeof(VkPhysicalDeviceExternalImageFormatInfo);
}
- case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: {
return sizeof(VkExternalImageFormatProperties);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: {
return sizeof(VkPhysicalDeviceIDProperties);
}
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: {
return sizeof(VkExternalMemoryImageCreateInfo);
}
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: {
return sizeof(VkExternalMemoryBufferCreateInfo);
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: {
return sizeof(VkExportMemoryAllocateInfo);
}
- case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: {
return sizeof(VkExportFenceCreateInfo);
}
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: {
return sizeof(VkExportSemaphoreCreateInfo);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: {
return sizeof(VkPhysicalDeviceMaintenance3Properties);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
return sizeof(VkPhysicalDeviceShaderDrawParametersFeatures);
}
#endif
#ifdef VK_VERSION_1_2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: {
return sizeof(VkPhysicalDeviceVulkan11Features);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: {
return sizeof(VkPhysicalDeviceVulkan11Properties);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: {
return sizeof(VkPhysicalDeviceVulkan12Features);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: {
return sizeof(VkPhysicalDeviceVulkan12Properties);
}
- case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: {
return sizeof(VkImageFormatListCreateInfo);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: {
return sizeof(VkPhysicalDevice8BitStorageFeatures);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: {
return sizeof(VkPhysicalDeviceDriverProperties);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: {
return sizeof(VkPhysicalDeviceShaderAtomicInt64Features);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: {
return sizeof(VkPhysicalDeviceShaderFloat16Int8Features);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: {
return sizeof(VkPhysicalDeviceFloatControlsProperties);
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: {
return sizeof(VkDescriptorSetLayoutBindingFlagsCreateInfo);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: {
return sizeof(VkPhysicalDeviceDescriptorIndexingFeatures);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: {
return sizeof(VkPhysicalDeviceDescriptorIndexingProperties);
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: {
return sizeof(VkDescriptorSetVariableDescriptorCountAllocateInfo);
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
- {
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: {
return sizeof(VkDescriptorSetVariableDescriptorCountLayoutSupport);
}
- case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
- {
+ case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: {
return sizeof(VkSubpassDescriptionDepthStencilResolve);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: {
return sizeof(VkPhysicalDeviceDepthStencilResolveProperties);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: {
return sizeof(VkPhysicalDeviceScalarBlockLayoutFeatures);
}
- case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: {
return sizeof(VkImageStencilUsageCreateInfo);
}
- case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: {
return sizeof(VkSamplerReductionModeCreateInfo);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: {
return sizeof(VkPhysicalDeviceSamplerFilterMinmaxProperties);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: {
return sizeof(VkPhysicalDeviceVulkanMemoryModelFeatures);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: {
return sizeof(VkPhysicalDeviceImagelessFramebufferFeatures);
}
- case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: {
return sizeof(VkFramebufferAttachmentsCreateInfo);
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
- {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: {
return sizeof(VkRenderPassAttachmentBeginInfo);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: {
return sizeof(VkPhysicalDeviceUniformBufferStandardLayoutFeatures);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: {
return sizeof(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: {
return sizeof(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures);
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
- {
+ case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: {
return sizeof(VkAttachmentReferenceStencilLayout);
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
- {
+ case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: {
return sizeof(VkAttachmentDescriptionStencilLayout);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: {
return sizeof(VkPhysicalDeviceHostQueryResetFeatures);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: {
return sizeof(VkPhysicalDeviceTimelineSemaphoreFeatures);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: {
return sizeof(VkPhysicalDeviceTimelineSemaphoreProperties);
}
- case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: {
return sizeof(VkSemaphoreTypeCreateInfo);
}
- case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
- {
+ case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: {
return sizeof(VkTimelineSemaphoreSubmitInfo);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: {
return sizeof(VkPhysicalDeviceBufferDeviceAddressFeatures);
}
- case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: {
return sizeof(VkBufferOpaqueCaptureAddressCreateInfo);
}
- case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: {
return sizeof(VkMemoryOpaqueCaptureAddressAllocateInfo);
}
#endif
#ifdef VK_KHR_swapchain
- case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
return sizeof(VkImageSwapchainCreateInfoKHR);
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: {
return sizeof(VkBindImageMemorySwapchainInfoKHR);
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: {
return sizeof(VkDeviceGroupPresentInfoKHR);
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: {
return sizeof(VkDeviceGroupSwapchainCreateInfoKHR);
}
#endif
#ifdef VK_KHR_display_swapchain
- case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: {
return sizeof(VkDisplayPresentInfoKHR);
}
#endif
#ifdef VK_KHR_video_queue
- case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: {
return sizeof(VkVideoQueueFamilyProperties2KHR);
}
- case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR: {
return sizeof(VkVideoProfileKHR);
}
- case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR: {
return sizeof(VkVideoProfilesKHR);
}
#endif
#ifdef VK_KHR_dynamic_rendering
- case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: {
return sizeof(VkPipelineRenderingCreateInfoKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceDynamicRenderingFeaturesKHR);
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: {
return sizeof(VkCommandBufferInheritanceRenderingInfoKHR);
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
return sizeof(VkRenderingFragmentShadingRateAttachmentInfoKHR);
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
return sizeof(VkRenderingFragmentDensityMapAttachmentInfoEXT);
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
- {
+ case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
return sizeof(VkAttachmentSampleCountInfoAMD);
}
- case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
- {
+ case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
return sizeof(VkMultiviewPerViewAttributesInfoNVX);
}
#endif
#ifdef VK_KHR_external_memory_win32
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
return sizeof(VkImportMemoryWin32HandleInfoKHR);
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
return sizeof(VkExportMemoryWin32HandleInfoKHR);
}
#endif
#ifdef VK_KHR_external_memory_fd
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: {
return sizeof(VkImportMemoryFdInfoKHR);
}
#endif
#ifdef VK_KHR_win32_keyed_mutex
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: {
return sizeof(VkWin32KeyedMutexAcquireReleaseInfoKHR);
}
#endif
#ifdef VK_KHR_external_semaphore_win32
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: {
return sizeof(VkExportSemaphoreWin32HandleInfoKHR);
}
- case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: {
return sizeof(VkD3D12FenceSubmitInfoKHR);
}
#endif
#ifdef VK_KHR_push_descriptor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: {
return sizeof(VkPhysicalDevicePushDescriptorPropertiesKHR);
}
#endif
#ifdef VK_KHR_incremental_present
- case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
- {
+ case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: {
return sizeof(VkPresentRegionsKHR);
}
#endif
#ifdef VK_KHR_shared_presentable_image
- case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
- {
+ case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
return sizeof(VkSharedPresentSurfaceCapabilitiesKHR);
}
#endif
#ifdef VK_KHR_external_fence_win32
- case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: {
return sizeof(VkExportFenceWin32HandleInfoKHR);
}
#endif
#ifdef VK_KHR_performance_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: {
return sizeof(VkPhysicalDevicePerformanceQueryFeaturesKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: {
return sizeof(VkPhysicalDevicePerformanceQueryPropertiesKHR);
}
- case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: {
return sizeof(VkQueryPoolPerformanceCreateInfoKHR);
}
- case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: {
return sizeof(VkPerformanceQuerySubmitInfoKHR);
}
#endif
#ifdef VK_KHR_portability_subset
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
return sizeof(VkPhysicalDevicePortabilitySubsetFeaturesKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
return sizeof(VkPhysicalDevicePortabilitySubsetPropertiesKHR);
}
#endif
#ifdef VK_KHR_shader_clock
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceShaderClockFeaturesKHR);
}
#endif
#ifdef VK_KHR_shader_terminate_invocation
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR);
}
#endif
#ifdef VK_KHR_fragment_shading_rate
- case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
return sizeof(VkFragmentShadingRateAttachmentInfoKHR);
}
- case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: {
return sizeof(VkPipelineFragmentShadingRateStateCreateInfoKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceFragmentShadingRateFeaturesKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: {
return sizeof(VkPhysicalDeviceFragmentShadingRatePropertiesKHR);
}
#endif
#ifdef VK_KHR_surface_protected_capabilities
- case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
- {
+ case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: {
return sizeof(VkSurfaceProtectedCapabilitiesKHR);
}
#endif
#ifdef VK_KHR_present_wait
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: {
return sizeof(VkPhysicalDevicePresentWaitFeaturesKHR);
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: {
return sizeof(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR);
}
#endif
#ifdef VK_KHR_shader_integer_dot_product
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: {
return sizeof(VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR);
}
#endif
#ifdef VK_KHR_present_id
- case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
- {
+ case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: {
return sizeof(VkPresentIdKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: {
return sizeof(VkPhysicalDevicePresentIdFeaturesKHR);
}
#endif
#ifdef VK_KHR_video_encode_queue
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
return sizeof(VkVideoEncodeRateControlInfoKHR);
}
#endif
#ifdef VK_KHR_synchronization2
- case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR:
- {
+ case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: {
return sizeof(VkMemoryBarrier2KHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceSynchronization2FeaturesKHR);
}
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
- {
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
return sizeof(VkQueueFamilyCheckpointProperties2NV);
}
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR);
}
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR);
}
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR);
}
#endif
#ifdef VK_KHR_format_feature_flags2
- case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR:
- {
+ case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: {
return sizeof(VkFormatProperties3KHR);
}
#endif
#ifdef VK_KHR_maintenance4
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceMaintenance4FeaturesKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: {
return sizeof(VkPhysicalDeviceMaintenance4PropertiesKHR);
}
#endif
#ifdef VK_ANDROID_native_buffer
- case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
- {
+ case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
return sizeof(VkNativeBufferANDROID);
}
#endif
#ifdef VK_EXT_debug_report
- case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: {
return sizeof(VkDebugReportCallbackCreateInfoEXT);
}
#endif
#ifdef VK_AMD_rasterization_order
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: {
return sizeof(VkPipelineRasterizationStateRasterizationOrderAMD);
}
#endif
#ifdef VK_NV_dedicated_allocation
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: {
return sizeof(VkDedicatedAllocationImageCreateInfoNV);
}
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: {
return sizeof(VkDedicatedAllocationBufferCreateInfoNV);
}
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: {
return sizeof(VkDedicatedAllocationMemoryAllocateInfoNV);
}
#endif
#ifdef VK_EXT_transform_feedback
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceTransformFeedbackFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceTransformFeedbackPropertiesEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: {
return sizeof(VkPipelineRasterizationStateStreamCreateInfoEXT);
}
#endif
#ifdef VK_EXT_video_encode_h264
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
return sizeof(VkVideoEncodeH264CapabilitiesEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: {
return sizeof(VkVideoEncodeH264SessionCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
return sizeof(VkVideoEncodeH264SessionParametersAddInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
return sizeof(VkVideoEncodeH264SessionParametersCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
return sizeof(VkVideoEncodeH264VclFrameInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: {
return sizeof(VkVideoEncodeH264EmitPictureParametersEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT: {
return sizeof(VkVideoEncodeH264ProfileEXT);
}
#endif
#ifdef VK_EXT_video_encode_h265
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
return sizeof(VkVideoEncodeH265CapabilitiesEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: {
return sizeof(VkVideoEncodeH265SessionCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
return sizeof(VkVideoEncodeH265SessionParametersAddInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
return sizeof(VkVideoEncodeH265SessionParametersCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
return sizeof(VkVideoEncodeH265VclFrameInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: {
return sizeof(VkVideoEncodeH265EmitPictureParametersEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT: {
return sizeof(VkVideoEncodeH265ProfileEXT);
}
#endif
#ifdef VK_EXT_video_decode_h264
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT: {
return sizeof(VkVideoDecodeH264ProfileEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: {
return sizeof(VkVideoDecodeH264CapabilitiesEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: {
return sizeof(VkVideoDecodeH264SessionCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
return sizeof(VkVideoDecodeH264SessionParametersAddInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
return sizeof(VkVideoDecodeH264SessionParametersCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: {
return sizeof(VkVideoDecodeH264PictureInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT: {
return sizeof(VkVideoDecodeH264MvcEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: {
return sizeof(VkVideoDecodeH264DpbSlotInfoEXT);
}
#endif
#ifdef VK_AMD_texture_gather_bias_lod
- case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
- {
+ case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
return sizeof(VkTextureLODGatherFormatPropertiesAMD);
}
#endif
#ifdef VK_NV_corner_sampled_image
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: {
return sizeof(VkPhysicalDeviceCornerSampledImageFeaturesNV);
}
#endif
#ifdef VK_NV_external_memory
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: {
return sizeof(VkExternalMemoryImageCreateInfoNV);
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: {
return sizeof(VkExportMemoryAllocateInfoNV);
}
#endif
#ifdef VK_NV_external_memory_win32
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
return sizeof(VkImportMemoryWin32HandleInfoNV);
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
return sizeof(VkExportMemoryWin32HandleInfoNV);
}
#endif
#ifdef VK_NV_win32_keyed_mutex
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: {
return sizeof(VkWin32KeyedMutexAcquireReleaseInfoNV);
}
#endif
#ifdef VK_EXT_validation_flags
- case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
- {
+ case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: {
return sizeof(VkValidationFlagsEXT);
}
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT);
}
#endif
#ifdef VK_EXT_astc_decode_mode
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
- {
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
return sizeof(VkImageViewASTCDecodeModeEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceASTCDecodeFeaturesEXT);
}
#endif
#ifdef VK_EXT_conditional_rendering
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceConditionalRenderingFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: {
return sizeof(VkCommandBufferInheritanceConditionalRenderingInfoEXT);
}
#endif
#ifdef VK_NV_clip_space_w_scaling
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: {
return sizeof(VkPipelineViewportWScalingStateCreateInfoNV);
}
#endif
#ifdef VK_EXT_display_control
- case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: {
return sizeof(VkSwapchainCounterCreateInfoEXT);
}
#endif
#ifdef VK_GOOGLE_display_timing
- case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
- {
+ case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: {
return sizeof(VkPresentTimesInfoGOOGLE);
}
#endif
#ifdef VK_NVX_multiview_per_view_attributes
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: {
return sizeof(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX);
}
#endif
#ifdef VK_NV_viewport_swizzle
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: {
return sizeof(VkPipelineViewportSwizzleStateCreateInfoNV);
}
#endif
#ifdef VK_EXT_discard_rectangles
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceDiscardRectanglePropertiesEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: {
return sizeof(VkPipelineDiscardRectangleStateCreateInfoEXT);
}
#endif
#ifdef VK_EXT_conservative_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceConservativeRasterizationPropertiesEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: {
return sizeof(VkPipelineRasterizationConservativeStateCreateInfoEXT);
}
#endif
#ifdef VK_EXT_depth_clip_enable
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceDepthClipEnableFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
return sizeof(VkPipelineRasterizationDepthClipStateCreateInfoEXT);
}
#endif
#ifdef VK_EXT_debug_utils
- case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
return sizeof(VkDebugUtilsMessengerCreateInfoEXT);
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
- {
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: {
return sizeof(VkAndroidHardwareBufferUsageANDROID);
}
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
- {
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: {
return sizeof(VkAndroidHardwareBufferFormatPropertiesANDROID);
}
- case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
- {
+ case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: {
return sizeof(VkImportAndroidHardwareBufferInfoANDROID);
}
- case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
- {
+ case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: {
return sizeof(VkExternalFormatANDROID);
}
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
- {
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: {
return sizeof(VkAndroidHardwareBufferFormatProperties2ANDROID);
}
#endif
#ifdef VK_EXT_inline_uniform_block
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceInlineUniformBlockFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceInlineUniformBlockPropertiesEXT);
}
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT:
- {
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
return sizeof(VkWriteDescriptorSetInlineUniformBlockEXT);
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
return sizeof(VkDescriptorPoolInlineUniformBlockCreateInfoEXT);
}
#endif
#ifdef VK_EXT_sample_locations
- case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
return sizeof(VkSampleLocationsInfoEXT);
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: {
return sizeof(VkRenderPassSampleLocationsBeginInfoEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: {
return sizeof(VkPipelineSampleLocationsStateCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceSampleLocationsPropertiesEXT);
}
#endif
#ifdef VK_EXT_blend_operation_advanced
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: {
return sizeof(VkPipelineColorBlendAdvancedStateCreateInfoEXT);
}
#endif
#ifdef VK_NV_fragment_coverage_to_color
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: {
return sizeof(VkPipelineCoverageToColorStateCreateInfoNV);
}
#endif
#ifdef VK_NV_framebuffer_mixed_samples
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: {
return sizeof(VkPipelineCoverageModulationStateCreateInfoNV);
}
#endif
#ifdef VK_NV_shader_sm_builtins
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: {
return sizeof(VkPhysicalDeviceShaderSMBuiltinsPropertiesNV);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: {
return sizeof(VkPhysicalDeviceShaderSMBuiltinsFeaturesNV);
}
#endif
#ifdef VK_EXT_image_drm_format_modifier
- case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
- {
+ case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: {
return sizeof(VkDrmFormatModifierPropertiesListEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: {
return sizeof(VkPhysicalDeviceImageDrmFormatModifierInfoEXT);
}
- case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: {
return sizeof(VkImageDrmFormatModifierListCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: {
return sizeof(VkImageDrmFormatModifierExplicitCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
- {
+ case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: {
return sizeof(VkDrmFormatModifierPropertiesList2EXT);
}
#endif
#ifdef VK_EXT_validation_cache
- case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: {
return sizeof(VkShaderModuleValidationCacheCreateInfoEXT);
}
#endif
#ifdef VK_NV_shading_rate_image
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: {
return sizeof(VkPipelineViewportShadingRateImageStateCreateInfoNV);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: {
return sizeof(VkPhysicalDeviceShadingRateImageFeaturesNV);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: {
return sizeof(VkPhysicalDeviceShadingRateImagePropertiesNV);
}
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: {
return sizeof(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV);
}
#endif
#ifdef VK_NV_ray_tracing
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
- {
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: {
return sizeof(VkWriteDescriptorSetAccelerationStructureNV);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: {
return sizeof(VkPhysicalDeviceRayTracingPropertiesNV);
}
#endif
#ifdef VK_NV_representative_fragment_test
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: {
return sizeof(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV);
}
- case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: {
return sizeof(VkPipelineRepresentativeFragmentTestStateCreateInfoNV);
}
#endif
#ifdef VK_EXT_filter_cubic
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: {
return sizeof(VkPhysicalDeviceImageViewImageFormatInfoEXT);
}
- case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: {
return sizeof(VkFilterCubicImageViewImageFormatPropertiesEXT);
}
#endif
#ifdef VK_EXT_global_priority
- case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
return sizeof(VkDeviceQueueGlobalPriorityCreateInfoEXT);
}
#endif
#ifdef VK_EXT_external_memory_host
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
return sizeof(VkImportMemoryHostPointerInfoEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceExternalMemoryHostPropertiesEXT);
}
#endif
#ifdef VK_AMD_pipeline_compiler_control
- case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: {
return sizeof(VkPipelineCompilerControlCreateInfoAMD);
}
#endif
#ifdef VK_AMD_shader_core_properties
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: {
return sizeof(VkPhysicalDeviceShaderCorePropertiesAMD);
}
#endif
#ifdef VK_EXT_video_decode_h265
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT: {
return sizeof(VkVideoDecodeH265ProfileEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: {
return sizeof(VkVideoDecodeH265CapabilitiesEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: {
return sizeof(VkVideoDecodeH265SessionCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
return sizeof(VkVideoDecodeH265SessionParametersAddInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
return sizeof(VkVideoDecodeH265SessionParametersCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: {
return sizeof(VkVideoDecodeH265PictureInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: {
return sizeof(VkVideoDecodeH265DpbSlotInfoEXT);
}
#endif
#ifdef VK_AMD_memory_overallocation_behavior
- case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
return sizeof(VkDeviceMemoryOverallocationCreateInfoAMD);
}
#endif
#ifdef VK_EXT_vertex_attribute_divisor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: {
return sizeof(VkPipelineVertexInputDivisorStateCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT);
}
#endif
#ifdef VK_GGP_frame_token
- case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
- {
+ case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: {
return sizeof(VkPresentFrameTokenGGP);
}
#endif
#ifdef VK_EXT_pipeline_creation_feedback
- case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
return sizeof(VkPipelineCreationFeedbackCreateInfoEXT);
}
#endif
#ifdef VK_NV_compute_shader_derivatives
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
return sizeof(VkPhysicalDeviceComputeShaderDerivativesFeaturesNV);
}
#endif
#ifdef VK_NV_mesh_shader
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: {
return sizeof(VkPhysicalDeviceMeshShaderFeaturesNV);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: {
return sizeof(VkPhysicalDeviceMeshShaderPropertiesNV);
}
#endif
#ifdef VK_NV_fragment_shader_barycentric
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
return sizeof(VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV);
}
#endif
#ifdef VK_NV_shader_image_footprint
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
return sizeof(VkPhysicalDeviceShaderImageFootprintFeaturesNV);
}
#endif
#ifdef VK_NV_scissor_exclusive
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: {
return sizeof(VkPipelineViewportExclusiveScissorStateCreateInfoNV);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: {
return sizeof(VkPhysicalDeviceExclusiveScissorFeaturesNV);
}
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
- {
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: {
return sizeof(VkQueueFamilyCheckpointPropertiesNV);
}
#endif
#ifdef VK_INTEL_shader_integer_functions2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: {
return sizeof(VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL);
}
#endif
#ifdef VK_INTEL_performance_query
- case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
- {
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: {
return sizeof(VkQueryPoolPerformanceQueryCreateInfoINTEL);
}
#endif
#ifdef VK_EXT_pci_bus_info
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: {
return sizeof(VkPhysicalDevicePCIBusInfoPropertiesEXT);
}
#endif
#ifdef VK_AMD_display_native_hdr
- case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
- {
+ case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: {
return sizeof(VkDisplayNativeHdrSurfaceCapabilitiesAMD);
}
- case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
- {
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: {
return sizeof(VkSwapchainDisplayNativeHdrCreateInfoAMD);
}
#endif
#ifdef VK_EXT_fragment_density_map
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
return sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: {
return sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
return sizeof(VkImportColorBufferGOOGLE);
break;
}
- default:
- {
+ default: {
return sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT);
break;
}
}
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: {
return sizeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
return sizeof(VkImportPhysicalAddressGOOGLE);
break;
}
- default:
- {
+ default: {
return sizeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT);
break;
}
}
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: {
return sizeof(VkRenderPassFragmentDensityMapCreateInfoEXT);
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2:
- {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: {
return sizeof(VkRenderPassFragmentDensityMapCreateInfoEXT);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
return sizeof(VkImportBufferGOOGLE);
break;
}
- default:
- {
+ default: {
return sizeof(VkRenderPassFragmentDensityMapCreateInfoEXT);
break;
}
@@ -1859,1810 +1585,1431 @@
}
#endif
#ifdef VK_EXT_subgroup_size_control
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceSubgroupSizeControlFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceSubgroupSizeControlPropertiesEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: {
return sizeof(VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT);
}
#endif
#ifdef VK_AMD_shader_core_properties2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
return sizeof(VkPhysicalDeviceShaderCoreProperties2AMD);
}
#endif
#ifdef VK_AMD_device_coherent_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: {
return sizeof(VkPhysicalDeviceCoherentMemoryFeaturesAMD);
}
#endif
#ifdef VK_EXT_shader_image_atomic_int64
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT);
}
#endif
#ifdef VK_EXT_memory_budget
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceMemoryBudgetPropertiesEXT);
}
#endif
#ifdef VK_EXT_memory_priority
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceMemoryPriorityFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: {
return sizeof(VkMemoryPriorityAllocateInfoEXT);
}
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: {
return sizeof(VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV);
}
#endif
#ifdef VK_EXT_buffer_device_address
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: {
return sizeof(VkBufferDeviceAddressCreateInfoEXT);
}
#endif
#ifdef VK_EXT_validation_features
- case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: {
return sizeof(VkValidationFeaturesEXT);
}
#endif
#ifdef VK_NV_cooperative_matrix
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: {
return sizeof(VkPhysicalDeviceCooperativeMatrixFeaturesNV);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: {
return sizeof(VkPhysicalDeviceCooperativeMatrixPropertiesNV);
}
#endif
#ifdef VK_NV_coverage_reduction_mode
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: {
return sizeof(VkPhysicalDeviceCoverageReductionModeFeaturesNV);
}
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: {
return sizeof(VkPipelineCoverageReductionStateCreateInfoNV);
}
#endif
#ifdef VK_EXT_fragment_shader_interlock
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT);
}
#endif
#ifdef VK_EXT_ycbcr_image_arrays
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT);
}
#endif
#ifdef VK_EXT_provoking_vertex
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceProvokingVertexFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceProvokingVertexPropertiesEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: {
return sizeof(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT);
}
#endif
#ifdef VK_EXT_full_screen_exclusive
- case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: {
return sizeof(VkSurfaceFullScreenExclusiveInfoEXT);
}
- case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
- {
+ case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: {
return sizeof(VkSurfaceCapabilitiesFullScreenExclusiveEXT);
}
- case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: {
return sizeof(VkSurfaceFullScreenExclusiveWin32InfoEXT);
}
#endif
#ifdef VK_EXT_line_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceLineRasterizationFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceLineRasterizationPropertiesEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: {
return sizeof(VkPipelineRasterizationLineStateCreateInfoEXT);
}
#endif
#ifdef VK_EXT_shader_atomic_float
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT);
}
#endif
#ifdef VK_EXT_index_type_uint8
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceIndexTypeUint8FeaturesEXT);
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT);
}
#endif
#ifdef VK_EXT_shader_atomic_float2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT);
}
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT);
}
#endif
#ifdef VK_NV_device_generated_commands
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: {
return sizeof(VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: {
return sizeof(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV);
}
- case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: {
return sizeof(VkGraphicsPipelineShaderGroupsCreateInfoNV);
}
#endif
#ifdef VK_NV_inherited_viewport_scissor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: {
return sizeof(VkPhysicalDeviceInheritedViewportScissorFeaturesNV);
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: {
return sizeof(VkCommandBufferInheritanceViewportScissorInfoNV);
}
#endif
#ifdef VK_EXT_texel_buffer_alignment
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT);
}
#endif
#ifdef VK_QCOM_render_pass_transform
- case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
- {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
return sizeof(VkRenderPassTransformBeginInfoQCOM);
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
- {
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: {
return sizeof(VkCommandBufferInheritanceRenderPassTransformInfoQCOM);
}
#endif
#ifdef VK_EXT_device_memory_report
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: {
return sizeof(VkDeviceDeviceMemoryReportCreateInfoEXT);
}
#endif
#ifdef VK_EXT_robustness2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceRobustness2FeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceRobustness2PropertiesEXT);
}
#endif
#ifdef VK_EXT_custom_border_color
- case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: {
return sizeof(VkSamplerCustomBorderColorCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceCustomBorderColorPropertiesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceCustomBorderColorFeaturesEXT);
}
#endif
#ifdef VK_EXT_private_data
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
return sizeof(VkPhysicalDevicePrivateDataFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: {
return sizeof(VkDevicePrivateDataCreateInfoEXT);
}
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
return sizeof(VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT);
}
#endif
#ifdef VK_NV_device_diagnostics_config
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: {
return sizeof(VkPhysicalDeviceDiagnosticsConfigFeaturesNV);
}
- case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: {
return sizeof(VkDeviceDiagnosticsConfigCreateInfoNV);
}
#endif
#ifdef VK_NV_fragment_shading_rate_enums
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
return sizeof(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: {
return sizeof(VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV);
}
- case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: {
return sizeof(VkPipelineFragmentShadingRateEnumStateCreateInfoNV);
}
#endif
#ifdef VK_NV_ray_tracing_motion_blur
- case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
- {
+ case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: {
return sizeof(VkAccelerationStructureGeometryMotionTrianglesDataNV);
}
- case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: {
return sizeof(VkAccelerationStructureMotionInfoNV);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: {
return sizeof(VkPhysicalDeviceRayTracingMotionBlurFeaturesNV);
}
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT);
}
#endif
#ifdef VK_EXT_fragment_density_map2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceFragmentDensityMap2PropertiesEXT);
}
#endif
#ifdef VK_QCOM_rotated_copy_commands
- case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
- {
+ case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: {
return sizeof(VkCopyCommandTransformInfoQCOM);
}
#endif
#ifdef VK_EXT_image_robustness
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceImageRobustnessFeaturesEXT);
}
#endif
#ifdef VK_EXT_4444_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: {
return sizeof(VkPhysicalDevice4444FormatsFeaturesEXT);
}
#endif
#ifdef VK_EXT_rgba10x6_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT);
}
#endif
#ifdef VK_VALVE_mutable_descriptor_type
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: {
return sizeof(VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE);
}
- case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE:
- {
+ case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: {
return sizeof(VkMutableDescriptorTypeCreateInfoVALVE);
}
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT);
}
#endif
#ifdef VK_EXT_physical_device_drm
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceDrmPropertiesEXT);
}
#endif
#ifdef VK_EXT_primitive_topology_list_restart
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
return sizeof(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT);
}
#endif
#ifdef VK_FUCHSIA_external_memory
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
- {
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: {
return sizeof(VkImportMemoryZirconHandleInfoFUCHSIA);
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
- {
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: {
return sizeof(VkImportMemoryBufferCollectionFUCHSIA);
}
- case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
- {
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: {
return sizeof(VkBufferCollectionImageCreateInfoFUCHSIA);
}
- case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
- {
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: {
return sizeof(VkBufferCollectionBufferCreateInfoFUCHSIA);
}
#endif
#ifdef VK_HUAWEI_subpass_shading
- case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
- {
+ case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: {
return sizeof(VkSubpassShadingPipelineCreateInfoHUAWEI);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: {
return sizeof(VkPhysicalDeviceSubpassShadingFeaturesHUAWEI);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: {
return sizeof(VkPhysicalDeviceSubpassShadingPropertiesHUAWEI);
}
#endif
#ifdef VK_HUAWEI_invocation_mask
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: {
return sizeof(VkPhysicalDeviceInvocationMaskFeaturesHUAWEI);
}
#endif
#ifdef VK_NV_external_memory_rdma
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: {
return sizeof(VkPhysicalDeviceExternalMemoryRDMAFeaturesNV);
}
#endif
#ifdef VK_EXT_extended_dynamic_state2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT);
}
#endif
#ifdef VK_EXT_color_write_enable
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceColorWriteEnableFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: {
return sizeof(VkPipelineColorWriteCreateInfoEXT);
}
#endif
#ifdef VK_GOOGLE_gfxstream
- case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
- {
+ case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
return sizeof(VkImportColorBufferGOOGLE);
}
- case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
- {
+ case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE: {
return sizeof(VkImportBufferGOOGLE);
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
- {
+ case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE: {
return sizeof(VkImportPhysicalAddressGOOGLE);
}
#endif
#ifdef VK_EXT_global_priority_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: {
return sizeof(VkQueueFamilyGlobalPriorityPropertiesEXT);
}
#endif
#ifdef VK_EXT_multi_draw
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceMultiDrawFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceMultiDrawPropertiesEXT);
}
#endif
#ifdef VK_EXT_border_color_swizzle
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: {
return sizeof(VkSamplerBorderColorComponentMappingCreateInfoEXT);
}
#endif
#ifdef VK_EXT_pageable_device_local_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: {
return sizeof(VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT);
}
#endif
#ifdef VK_KHR_acceleration_structure
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
- {
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
return sizeof(VkWriteDescriptorSetAccelerationStructureKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceAccelerationStructureFeaturesKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: {
return sizeof(VkPhysicalDeviceAccelerationStructurePropertiesKHR);
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceRayTracingPipelineFeaturesKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: {
return sizeof(VkPhysicalDeviceRayTracingPipelinePropertiesKHR);
}
#endif
#ifdef VK_KHR_ray_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceRayQueryFeaturesKHR);
}
#endif
- default:
- {
+ default: {
return (size_t)0;
}
}
}
-size_t goldfish_vk_extension_struct_size_with_stream_features(
- uint32_t streamFeatures,
- VkStructureType rootType,
- const void* structExtension)
-{
- if (!structExtension)
- {
+size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFeatures,
+ VkStructureType rootType,
+ const void* structExtension) {
+ if (!structExtension) {
return (size_t)0;
}
uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension);
- switch(structType)
- {
+ switch (structType) {
#ifdef VK_VERSION_1_1
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
return sizeof(VkPhysicalDeviceSubgroupProperties);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
return sizeof(VkPhysicalDevice16BitStorageFeatures);
}
- case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
- {
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
return sizeof(VkMemoryDedicatedRequirements);
}
- case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: {
return sizeof(VkMemoryDedicatedAllocateInfo);
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
- {
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: {
return sizeof(VkMemoryAllocateFlagsInfo);
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: {
return sizeof(VkDeviceGroupRenderPassBeginInfo);
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: {
return sizeof(VkDeviceGroupCommandBufferBeginInfo);
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: {
return sizeof(VkDeviceGroupSubmitInfo);
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: {
return sizeof(VkDeviceGroupBindSparseInfo);
}
- case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
- {
+ case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: {
return sizeof(VkBindBufferMemoryDeviceGroupInfo);
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
- {
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: {
return sizeof(VkBindImageMemoryDeviceGroupInfo);
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: {
return sizeof(VkDeviceGroupDeviceCreateInfo);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
return sizeof(VkPhysicalDeviceFeatures2);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: {
return sizeof(VkPhysicalDevicePointClippingProperties);
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: {
return sizeof(VkRenderPassInputAttachmentAspectCreateInfo);
}
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: {
return sizeof(VkImageViewUsageCreateInfo);
}
- case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: {
return sizeof(VkPipelineTessellationDomainOriginStateCreateInfo);
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: {
return sizeof(VkRenderPassMultiviewCreateInfo);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
return sizeof(VkPhysicalDeviceMultiviewFeatures);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: {
return sizeof(VkPhysicalDeviceMultiviewProperties);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
return sizeof(VkPhysicalDeviceVariablePointersFeatures);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
return sizeof(VkPhysicalDeviceProtectedMemoryFeatures);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: {
return sizeof(VkPhysicalDeviceProtectedMemoryProperties);
}
- case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
- {
+ case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: {
return sizeof(VkProtectedSubmitInfo);
}
- case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
- {
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: {
return sizeof(VkSamplerYcbcrConversionInfo);
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
- {
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: {
return sizeof(VkBindImagePlaneMemoryInfo);
}
- case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
- {
+ case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: {
return sizeof(VkImagePlaneMemoryRequirementsInfo);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
return sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures);
}
- case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: {
return sizeof(VkSamplerYcbcrConversionImageFormatProperties);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: {
return sizeof(VkPhysicalDeviceExternalImageFormatInfo);
}
- case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: {
return sizeof(VkExternalImageFormatProperties);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: {
return sizeof(VkPhysicalDeviceIDProperties);
}
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: {
return sizeof(VkExternalMemoryImageCreateInfo);
}
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: {
return sizeof(VkExternalMemoryBufferCreateInfo);
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: {
return sizeof(VkExportMemoryAllocateInfo);
}
- case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: {
return sizeof(VkExportFenceCreateInfo);
}
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: {
return sizeof(VkExportSemaphoreCreateInfo);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: {
return sizeof(VkPhysicalDeviceMaintenance3Properties);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
return sizeof(VkPhysicalDeviceShaderDrawParametersFeatures);
}
#endif
#ifdef VK_VERSION_1_2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: {
return sizeof(VkPhysicalDeviceVulkan11Features);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: {
return sizeof(VkPhysicalDeviceVulkan11Properties);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: {
return sizeof(VkPhysicalDeviceVulkan12Features);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: {
return sizeof(VkPhysicalDeviceVulkan12Properties);
}
- case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: {
return sizeof(VkImageFormatListCreateInfo);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: {
return sizeof(VkPhysicalDevice8BitStorageFeatures);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: {
return sizeof(VkPhysicalDeviceDriverProperties);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: {
return sizeof(VkPhysicalDeviceShaderAtomicInt64Features);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
- {
- if (streamFeatures & VULKAN_STREAM_FEATURE_SHADER_FLOAT16_INT8_BIT)
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: {
+ if (streamFeatures & VULKAN_STREAM_FEATURE_SHADER_FLOAT16_INT8_BIT) {
return sizeof(VkPhysicalDeviceShaderFloat16Int8Features);
- }
- else
- {
+ } else {
return 0;
}
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: {
return sizeof(VkPhysicalDeviceFloatControlsProperties);
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: {
return sizeof(VkDescriptorSetLayoutBindingFlagsCreateInfo);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: {
return sizeof(VkPhysicalDeviceDescriptorIndexingFeatures);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: {
return sizeof(VkPhysicalDeviceDescriptorIndexingProperties);
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: {
return sizeof(VkDescriptorSetVariableDescriptorCountAllocateInfo);
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
- {
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: {
return sizeof(VkDescriptorSetVariableDescriptorCountLayoutSupport);
}
- case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
- {
+ case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: {
return sizeof(VkSubpassDescriptionDepthStencilResolve);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: {
return sizeof(VkPhysicalDeviceDepthStencilResolveProperties);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: {
return sizeof(VkPhysicalDeviceScalarBlockLayoutFeatures);
}
- case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: {
return sizeof(VkImageStencilUsageCreateInfo);
}
- case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: {
return sizeof(VkSamplerReductionModeCreateInfo);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: {
return sizeof(VkPhysicalDeviceSamplerFilterMinmaxProperties);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: {
return sizeof(VkPhysicalDeviceVulkanMemoryModelFeatures);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: {
return sizeof(VkPhysicalDeviceImagelessFramebufferFeatures);
}
- case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: {
return sizeof(VkFramebufferAttachmentsCreateInfo);
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
- {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: {
return sizeof(VkRenderPassAttachmentBeginInfo);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: {
return sizeof(VkPhysicalDeviceUniformBufferStandardLayoutFeatures);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: {
return sizeof(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: {
return sizeof(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures);
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
- {
+ case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: {
return sizeof(VkAttachmentReferenceStencilLayout);
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
- {
+ case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: {
return sizeof(VkAttachmentDescriptionStencilLayout);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: {
return sizeof(VkPhysicalDeviceHostQueryResetFeatures);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: {
return sizeof(VkPhysicalDeviceTimelineSemaphoreFeatures);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: {
return sizeof(VkPhysicalDeviceTimelineSemaphoreProperties);
}
- case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: {
return sizeof(VkSemaphoreTypeCreateInfo);
}
- case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
- {
+ case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: {
return sizeof(VkTimelineSemaphoreSubmitInfo);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: {
return sizeof(VkPhysicalDeviceBufferDeviceAddressFeatures);
}
- case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: {
return sizeof(VkBufferOpaqueCaptureAddressCreateInfo);
}
- case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: {
return sizeof(VkMemoryOpaqueCaptureAddressAllocateInfo);
}
#endif
#ifdef VK_KHR_swapchain
- case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
return sizeof(VkImageSwapchainCreateInfoKHR);
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: {
return sizeof(VkBindImageMemorySwapchainInfoKHR);
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: {
return sizeof(VkDeviceGroupPresentInfoKHR);
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: {
return sizeof(VkDeviceGroupSwapchainCreateInfoKHR);
}
#endif
#ifdef VK_KHR_display_swapchain
- case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: {
return sizeof(VkDisplayPresentInfoKHR);
}
#endif
#ifdef VK_KHR_video_queue
- case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: {
return sizeof(VkVideoQueueFamilyProperties2KHR);
}
- case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR: {
return sizeof(VkVideoProfileKHR);
}
- case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR: {
return sizeof(VkVideoProfilesKHR);
}
#endif
#ifdef VK_KHR_dynamic_rendering
- case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: {
return sizeof(VkPipelineRenderingCreateInfoKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceDynamicRenderingFeaturesKHR);
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: {
return sizeof(VkCommandBufferInheritanceRenderingInfoKHR);
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
return sizeof(VkRenderingFragmentShadingRateAttachmentInfoKHR);
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
return sizeof(VkRenderingFragmentDensityMapAttachmentInfoEXT);
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
- {
+ case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
return sizeof(VkAttachmentSampleCountInfoAMD);
}
- case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
- {
+ case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
return sizeof(VkMultiviewPerViewAttributesInfoNVX);
}
#endif
#ifdef VK_KHR_external_memory_win32
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
return sizeof(VkImportMemoryWin32HandleInfoKHR);
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
return sizeof(VkExportMemoryWin32HandleInfoKHR);
}
#endif
#ifdef VK_KHR_external_memory_fd
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: {
return sizeof(VkImportMemoryFdInfoKHR);
}
#endif
#ifdef VK_KHR_win32_keyed_mutex
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: {
return sizeof(VkWin32KeyedMutexAcquireReleaseInfoKHR);
}
#endif
#ifdef VK_KHR_external_semaphore_win32
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: {
return sizeof(VkExportSemaphoreWin32HandleInfoKHR);
}
- case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: {
return sizeof(VkD3D12FenceSubmitInfoKHR);
}
#endif
#ifdef VK_KHR_push_descriptor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: {
return sizeof(VkPhysicalDevicePushDescriptorPropertiesKHR);
}
#endif
#ifdef VK_KHR_incremental_present
- case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
- {
+ case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: {
return sizeof(VkPresentRegionsKHR);
}
#endif
#ifdef VK_KHR_shared_presentable_image
- case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
- {
+ case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
return sizeof(VkSharedPresentSurfaceCapabilitiesKHR);
}
#endif
#ifdef VK_KHR_external_fence_win32
- case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: {
return sizeof(VkExportFenceWin32HandleInfoKHR);
}
#endif
#ifdef VK_KHR_performance_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: {
return sizeof(VkPhysicalDevicePerformanceQueryFeaturesKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: {
return sizeof(VkPhysicalDevicePerformanceQueryPropertiesKHR);
}
- case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: {
return sizeof(VkQueryPoolPerformanceCreateInfoKHR);
}
- case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: {
return sizeof(VkPerformanceQuerySubmitInfoKHR);
}
#endif
#ifdef VK_KHR_portability_subset
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
return sizeof(VkPhysicalDevicePortabilitySubsetFeaturesKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
return sizeof(VkPhysicalDevicePortabilitySubsetPropertiesKHR);
}
#endif
#ifdef VK_KHR_shader_clock
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceShaderClockFeaturesKHR);
}
#endif
#ifdef VK_KHR_shader_terminate_invocation
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR);
}
#endif
#ifdef VK_KHR_fragment_shading_rate
- case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
return sizeof(VkFragmentShadingRateAttachmentInfoKHR);
}
- case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: {
return sizeof(VkPipelineFragmentShadingRateStateCreateInfoKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceFragmentShadingRateFeaturesKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: {
return sizeof(VkPhysicalDeviceFragmentShadingRatePropertiesKHR);
}
#endif
#ifdef VK_KHR_surface_protected_capabilities
- case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
- {
+ case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: {
return sizeof(VkSurfaceProtectedCapabilitiesKHR);
}
#endif
#ifdef VK_KHR_present_wait
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: {
return sizeof(VkPhysicalDevicePresentWaitFeaturesKHR);
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: {
return sizeof(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR);
}
#endif
#ifdef VK_KHR_shader_integer_dot_product
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: {
return sizeof(VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR);
}
#endif
#ifdef VK_KHR_present_id
- case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
- {
+ case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: {
return sizeof(VkPresentIdKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: {
return sizeof(VkPhysicalDevicePresentIdFeaturesKHR);
}
#endif
#ifdef VK_KHR_video_encode_queue
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
return sizeof(VkVideoEncodeRateControlInfoKHR);
}
#endif
#ifdef VK_KHR_synchronization2
- case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR:
- {
+ case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: {
return sizeof(VkMemoryBarrier2KHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceSynchronization2FeaturesKHR);
}
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
- {
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
return sizeof(VkQueueFamilyCheckpointProperties2NV);
}
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR);
}
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR);
}
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR);
}
#endif
#ifdef VK_KHR_format_feature_flags2
- case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR:
- {
+ case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: {
return sizeof(VkFormatProperties3KHR);
}
#endif
#ifdef VK_KHR_maintenance4
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceMaintenance4FeaturesKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: {
return sizeof(VkPhysicalDeviceMaintenance4PropertiesKHR);
}
#endif
#ifdef VK_ANDROID_native_buffer
- case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
- {
+ case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
return sizeof(VkNativeBufferANDROID);
}
#endif
#ifdef VK_EXT_debug_report
- case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: {
return sizeof(VkDebugReportCallbackCreateInfoEXT);
}
#endif
#ifdef VK_AMD_rasterization_order
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: {
return sizeof(VkPipelineRasterizationStateRasterizationOrderAMD);
}
#endif
#ifdef VK_NV_dedicated_allocation
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: {
return sizeof(VkDedicatedAllocationImageCreateInfoNV);
}
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: {
return sizeof(VkDedicatedAllocationBufferCreateInfoNV);
}
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: {
return sizeof(VkDedicatedAllocationMemoryAllocateInfoNV);
}
#endif
#ifdef VK_EXT_transform_feedback
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceTransformFeedbackFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceTransformFeedbackPropertiesEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: {
return sizeof(VkPipelineRasterizationStateStreamCreateInfoEXT);
}
#endif
#ifdef VK_EXT_video_encode_h264
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
return sizeof(VkVideoEncodeH264CapabilitiesEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: {
return sizeof(VkVideoEncodeH264SessionCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
return sizeof(VkVideoEncodeH264SessionParametersAddInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
return sizeof(VkVideoEncodeH264SessionParametersCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
return sizeof(VkVideoEncodeH264VclFrameInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: {
return sizeof(VkVideoEncodeH264EmitPictureParametersEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT: {
return sizeof(VkVideoEncodeH264ProfileEXT);
}
#endif
#ifdef VK_EXT_video_encode_h265
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
return sizeof(VkVideoEncodeH265CapabilitiesEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: {
return sizeof(VkVideoEncodeH265SessionCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
return sizeof(VkVideoEncodeH265SessionParametersAddInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
return sizeof(VkVideoEncodeH265SessionParametersCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
return sizeof(VkVideoEncodeH265VclFrameInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: {
return sizeof(VkVideoEncodeH265EmitPictureParametersEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT: {
return sizeof(VkVideoEncodeH265ProfileEXT);
}
#endif
#ifdef VK_EXT_video_decode_h264
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT: {
return sizeof(VkVideoDecodeH264ProfileEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: {
return sizeof(VkVideoDecodeH264CapabilitiesEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: {
return sizeof(VkVideoDecodeH264SessionCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
return sizeof(VkVideoDecodeH264SessionParametersAddInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
return sizeof(VkVideoDecodeH264SessionParametersCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: {
return sizeof(VkVideoDecodeH264PictureInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT: {
return sizeof(VkVideoDecodeH264MvcEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: {
return sizeof(VkVideoDecodeH264DpbSlotInfoEXT);
}
#endif
#ifdef VK_AMD_texture_gather_bias_lod
- case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
- {
+ case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
return sizeof(VkTextureLODGatherFormatPropertiesAMD);
}
#endif
#ifdef VK_NV_corner_sampled_image
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: {
return sizeof(VkPhysicalDeviceCornerSampledImageFeaturesNV);
}
#endif
#ifdef VK_NV_external_memory
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: {
return sizeof(VkExternalMemoryImageCreateInfoNV);
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: {
return sizeof(VkExportMemoryAllocateInfoNV);
}
#endif
#ifdef VK_NV_external_memory_win32
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
return sizeof(VkImportMemoryWin32HandleInfoNV);
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
return sizeof(VkExportMemoryWin32HandleInfoNV);
}
#endif
#ifdef VK_NV_win32_keyed_mutex
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: {
return sizeof(VkWin32KeyedMutexAcquireReleaseInfoNV);
}
#endif
#ifdef VK_EXT_validation_flags
- case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
- {
+ case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: {
return sizeof(VkValidationFlagsEXT);
}
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT);
}
#endif
#ifdef VK_EXT_astc_decode_mode
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
- {
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
return sizeof(VkImageViewASTCDecodeModeEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceASTCDecodeFeaturesEXT);
}
#endif
#ifdef VK_EXT_conditional_rendering
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceConditionalRenderingFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: {
return sizeof(VkCommandBufferInheritanceConditionalRenderingInfoEXT);
}
#endif
#ifdef VK_NV_clip_space_w_scaling
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: {
return sizeof(VkPipelineViewportWScalingStateCreateInfoNV);
}
#endif
#ifdef VK_EXT_display_control
- case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: {
return sizeof(VkSwapchainCounterCreateInfoEXT);
}
#endif
#ifdef VK_GOOGLE_display_timing
- case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
- {
+ case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: {
return sizeof(VkPresentTimesInfoGOOGLE);
}
#endif
#ifdef VK_NVX_multiview_per_view_attributes
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: {
return sizeof(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX);
}
#endif
#ifdef VK_NV_viewport_swizzle
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: {
return sizeof(VkPipelineViewportSwizzleStateCreateInfoNV);
}
#endif
#ifdef VK_EXT_discard_rectangles
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceDiscardRectanglePropertiesEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: {
return sizeof(VkPipelineDiscardRectangleStateCreateInfoEXT);
}
#endif
#ifdef VK_EXT_conservative_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceConservativeRasterizationPropertiesEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: {
return sizeof(VkPipelineRasterizationConservativeStateCreateInfoEXT);
}
#endif
#ifdef VK_EXT_depth_clip_enable
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceDepthClipEnableFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
return sizeof(VkPipelineRasterizationDepthClipStateCreateInfoEXT);
}
#endif
#ifdef VK_EXT_debug_utils
- case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
return sizeof(VkDebugUtilsMessengerCreateInfoEXT);
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
- {
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: {
return sizeof(VkAndroidHardwareBufferUsageANDROID);
}
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
- {
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: {
return sizeof(VkAndroidHardwareBufferFormatPropertiesANDROID);
}
- case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
- {
+ case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: {
return sizeof(VkImportAndroidHardwareBufferInfoANDROID);
}
- case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
- {
+ case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: {
return sizeof(VkExternalFormatANDROID);
}
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
- {
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: {
return sizeof(VkAndroidHardwareBufferFormatProperties2ANDROID);
}
#endif
#ifdef VK_EXT_inline_uniform_block
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceInlineUniformBlockFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceInlineUniformBlockPropertiesEXT);
}
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT:
- {
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
return sizeof(VkWriteDescriptorSetInlineUniformBlockEXT);
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
return sizeof(VkDescriptorPoolInlineUniformBlockCreateInfoEXT);
}
#endif
#ifdef VK_EXT_sample_locations
- case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
return sizeof(VkSampleLocationsInfoEXT);
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: {
return sizeof(VkRenderPassSampleLocationsBeginInfoEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: {
return sizeof(VkPipelineSampleLocationsStateCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceSampleLocationsPropertiesEXT);
}
#endif
#ifdef VK_EXT_blend_operation_advanced
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: {
return sizeof(VkPipelineColorBlendAdvancedStateCreateInfoEXT);
}
#endif
#ifdef VK_NV_fragment_coverage_to_color
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: {
return sizeof(VkPipelineCoverageToColorStateCreateInfoNV);
}
#endif
#ifdef VK_NV_framebuffer_mixed_samples
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: {
return sizeof(VkPipelineCoverageModulationStateCreateInfoNV);
}
#endif
#ifdef VK_NV_shader_sm_builtins
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: {
return sizeof(VkPhysicalDeviceShaderSMBuiltinsPropertiesNV);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: {
return sizeof(VkPhysicalDeviceShaderSMBuiltinsFeaturesNV);
}
#endif
#ifdef VK_EXT_image_drm_format_modifier
- case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
- {
+ case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: {
return sizeof(VkDrmFormatModifierPropertiesListEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: {
return sizeof(VkPhysicalDeviceImageDrmFormatModifierInfoEXT);
}
- case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: {
return sizeof(VkImageDrmFormatModifierListCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: {
return sizeof(VkImageDrmFormatModifierExplicitCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
- {
+ case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: {
return sizeof(VkDrmFormatModifierPropertiesList2EXT);
}
#endif
#ifdef VK_EXT_validation_cache
- case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: {
return sizeof(VkShaderModuleValidationCacheCreateInfoEXT);
}
#endif
#ifdef VK_NV_shading_rate_image
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: {
return sizeof(VkPipelineViewportShadingRateImageStateCreateInfoNV);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: {
return sizeof(VkPhysicalDeviceShadingRateImageFeaturesNV);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: {
return sizeof(VkPhysicalDeviceShadingRateImagePropertiesNV);
}
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: {
return sizeof(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV);
}
#endif
#ifdef VK_NV_ray_tracing
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
- {
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: {
return sizeof(VkWriteDescriptorSetAccelerationStructureNV);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: {
return sizeof(VkPhysicalDeviceRayTracingPropertiesNV);
}
#endif
#ifdef VK_NV_representative_fragment_test
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: {
return sizeof(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV);
}
- case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: {
return sizeof(VkPipelineRepresentativeFragmentTestStateCreateInfoNV);
}
#endif
#ifdef VK_EXT_filter_cubic
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: {
return sizeof(VkPhysicalDeviceImageViewImageFormatInfoEXT);
}
- case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: {
return sizeof(VkFilterCubicImageViewImageFormatPropertiesEXT);
}
#endif
#ifdef VK_EXT_global_priority
- case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
return sizeof(VkDeviceQueueGlobalPriorityCreateInfoEXT);
}
#endif
#ifdef VK_EXT_external_memory_host
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
return sizeof(VkImportMemoryHostPointerInfoEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceExternalMemoryHostPropertiesEXT);
}
#endif
#ifdef VK_AMD_pipeline_compiler_control
- case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: {
return sizeof(VkPipelineCompilerControlCreateInfoAMD);
}
#endif
#ifdef VK_AMD_shader_core_properties
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: {
return sizeof(VkPhysicalDeviceShaderCorePropertiesAMD);
}
#endif
#ifdef VK_EXT_video_decode_h265
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT: {
return sizeof(VkVideoDecodeH265ProfileEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: {
return sizeof(VkVideoDecodeH265CapabilitiesEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: {
return sizeof(VkVideoDecodeH265SessionCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
return sizeof(VkVideoDecodeH265SessionParametersAddInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
return sizeof(VkVideoDecodeH265SessionParametersCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: {
return sizeof(VkVideoDecodeH265PictureInfoEXT);
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: {
return sizeof(VkVideoDecodeH265DpbSlotInfoEXT);
}
#endif
#ifdef VK_AMD_memory_overallocation_behavior
- case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
return sizeof(VkDeviceMemoryOverallocationCreateInfoAMD);
}
#endif
#ifdef VK_EXT_vertex_attribute_divisor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: {
return sizeof(VkPipelineVertexInputDivisorStateCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT);
}
#endif
#ifdef VK_GGP_frame_token
- case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
- {
+ case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: {
return sizeof(VkPresentFrameTokenGGP);
}
#endif
#ifdef VK_EXT_pipeline_creation_feedback
- case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
return sizeof(VkPipelineCreationFeedbackCreateInfoEXT);
}
#endif
#ifdef VK_NV_compute_shader_derivatives
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
return sizeof(VkPhysicalDeviceComputeShaderDerivativesFeaturesNV);
}
#endif
#ifdef VK_NV_mesh_shader
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: {
return sizeof(VkPhysicalDeviceMeshShaderFeaturesNV);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: {
return sizeof(VkPhysicalDeviceMeshShaderPropertiesNV);
}
#endif
#ifdef VK_NV_fragment_shader_barycentric
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
return sizeof(VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV);
}
#endif
#ifdef VK_NV_shader_image_footprint
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
return sizeof(VkPhysicalDeviceShaderImageFootprintFeaturesNV);
}
#endif
#ifdef VK_NV_scissor_exclusive
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: {
return sizeof(VkPipelineViewportExclusiveScissorStateCreateInfoNV);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: {
return sizeof(VkPhysicalDeviceExclusiveScissorFeaturesNV);
}
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
- {
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: {
return sizeof(VkQueueFamilyCheckpointPropertiesNV);
}
#endif
#ifdef VK_INTEL_shader_integer_functions2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: {
return sizeof(VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL);
}
#endif
#ifdef VK_INTEL_performance_query
- case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
- {
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: {
return sizeof(VkQueryPoolPerformanceQueryCreateInfoINTEL);
}
#endif
#ifdef VK_EXT_pci_bus_info
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: {
return sizeof(VkPhysicalDevicePCIBusInfoPropertiesEXT);
}
#endif
#ifdef VK_AMD_display_native_hdr
- case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
- {
+ case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: {
return sizeof(VkDisplayNativeHdrSurfaceCapabilitiesAMD);
}
- case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
- {
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: {
return sizeof(VkSwapchainDisplayNativeHdrCreateInfoAMD);
}
#endif
#ifdef VK_EXT_fragment_density_map
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
return sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: {
return sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
return sizeof(VkImportColorBufferGOOGLE);
break;
}
- default:
- {
+ default: {
return sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT);
break;
}
}
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: {
return sizeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
return sizeof(VkImportPhysicalAddressGOOGLE);
break;
}
- default:
- {
+ default: {
return sizeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT);
break;
}
}
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: {
return sizeof(VkRenderPassFragmentDensityMapCreateInfoEXT);
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2:
- {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: {
return sizeof(VkRenderPassFragmentDensityMapCreateInfoEXT);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
return sizeof(VkImportBufferGOOGLE);
break;
}
- default:
- {
+ default: {
return sizeof(VkRenderPassFragmentDensityMapCreateInfoEXT);
break;
}
@@ -3670,527 +3017,425 @@
}
#endif
#ifdef VK_EXT_subgroup_size_control
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceSubgroupSizeControlFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceSubgroupSizeControlPropertiesEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: {
return sizeof(VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT);
}
#endif
#ifdef VK_AMD_shader_core_properties2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
return sizeof(VkPhysicalDeviceShaderCoreProperties2AMD);
}
#endif
#ifdef VK_AMD_device_coherent_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: {
return sizeof(VkPhysicalDeviceCoherentMemoryFeaturesAMD);
}
#endif
#ifdef VK_EXT_shader_image_atomic_int64
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT);
}
#endif
#ifdef VK_EXT_memory_budget
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceMemoryBudgetPropertiesEXT);
}
#endif
#ifdef VK_EXT_memory_priority
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceMemoryPriorityFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: {
return sizeof(VkMemoryPriorityAllocateInfoEXT);
}
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: {
return sizeof(VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV);
}
#endif
#ifdef VK_EXT_buffer_device_address
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: {
return sizeof(VkBufferDeviceAddressCreateInfoEXT);
}
#endif
#ifdef VK_EXT_validation_features
- case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: {
return sizeof(VkValidationFeaturesEXT);
}
#endif
#ifdef VK_NV_cooperative_matrix
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: {
return sizeof(VkPhysicalDeviceCooperativeMatrixFeaturesNV);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: {
return sizeof(VkPhysicalDeviceCooperativeMatrixPropertiesNV);
}
#endif
#ifdef VK_NV_coverage_reduction_mode
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: {
return sizeof(VkPhysicalDeviceCoverageReductionModeFeaturesNV);
}
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: {
return sizeof(VkPipelineCoverageReductionStateCreateInfoNV);
}
#endif
#ifdef VK_EXT_fragment_shader_interlock
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT);
}
#endif
#ifdef VK_EXT_ycbcr_image_arrays
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT);
}
#endif
#ifdef VK_EXT_provoking_vertex
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceProvokingVertexFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceProvokingVertexPropertiesEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: {
return sizeof(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT);
}
#endif
#ifdef VK_EXT_full_screen_exclusive
- case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: {
return sizeof(VkSurfaceFullScreenExclusiveInfoEXT);
}
- case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
- {
+ case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: {
return sizeof(VkSurfaceCapabilitiesFullScreenExclusiveEXT);
}
- case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: {
return sizeof(VkSurfaceFullScreenExclusiveWin32InfoEXT);
}
#endif
#ifdef VK_EXT_line_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceLineRasterizationFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceLineRasterizationPropertiesEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: {
return sizeof(VkPipelineRasterizationLineStateCreateInfoEXT);
}
#endif
#ifdef VK_EXT_shader_atomic_float
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT);
}
#endif
#ifdef VK_EXT_index_type_uint8
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceIndexTypeUint8FeaturesEXT);
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT);
}
#endif
#ifdef VK_EXT_shader_atomic_float2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT);
}
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT);
}
#endif
#ifdef VK_NV_device_generated_commands
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: {
return sizeof(VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: {
return sizeof(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV);
}
- case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: {
return sizeof(VkGraphicsPipelineShaderGroupsCreateInfoNV);
}
#endif
#ifdef VK_NV_inherited_viewport_scissor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: {
return sizeof(VkPhysicalDeviceInheritedViewportScissorFeaturesNV);
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: {
return sizeof(VkCommandBufferInheritanceViewportScissorInfoNV);
}
#endif
#ifdef VK_EXT_texel_buffer_alignment
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT);
}
#endif
#ifdef VK_QCOM_render_pass_transform
- case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
- {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
return sizeof(VkRenderPassTransformBeginInfoQCOM);
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
- {
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: {
return sizeof(VkCommandBufferInheritanceRenderPassTransformInfoQCOM);
}
#endif
#ifdef VK_EXT_device_memory_report
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: {
return sizeof(VkDeviceDeviceMemoryReportCreateInfoEXT);
}
#endif
#ifdef VK_EXT_robustness2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceRobustness2FeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceRobustness2PropertiesEXT);
}
#endif
#ifdef VK_EXT_custom_border_color
- case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: {
return sizeof(VkSamplerCustomBorderColorCreateInfoEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceCustomBorderColorPropertiesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceCustomBorderColorFeaturesEXT);
}
#endif
#ifdef VK_EXT_private_data
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
return sizeof(VkPhysicalDevicePrivateDataFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: {
return sizeof(VkDevicePrivateDataCreateInfoEXT);
}
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
return sizeof(VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT);
}
#endif
#ifdef VK_NV_device_diagnostics_config
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: {
return sizeof(VkPhysicalDeviceDiagnosticsConfigFeaturesNV);
}
- case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: {
return sizeof(VkDeviceDiagnosticsConfigCreateInfoNV);
}
#endif
#ifdef VK_NV_fragment_shading_rate_enums
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
return sizeof(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: {
return sizeof(VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV);
}
- case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: {
return sizeof(VkPipelineFragmentShadingRateEnumStateCreateInfoNV);
}
#endif
#ifdef VK_NV_ray_tracing_motion_blur
- case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
- {
+ case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: {
return sizeof(VkAccelerationStructureGeometryMotionTrianglesDataNV);
}
- case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
- {
+ case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: {
return sizeof(VkAccelerationStructureMotionInfoNV);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: {
return sizeof(VkPhysicalDeviceRayTracingMotionBlurFeaturesNV);
}
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT);
}
#endif
#ifdef VK_EXT_fragment_density_map2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceFragmentDensityMap2PropertiesEXT);
}
#endif
#ifdef VK_QCOM_rotated_copy_commands
- case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
- {
+ case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: {
return sizeof(VkCopyCommandTransformInfoQCOM);
}
#endif
#ifdef VK_EXT_image_robustness
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceImageRobustnessFeaturesEXT);
}
#endif
#ifdef VK_EXT_4444_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: {
return sizeof(VkPhysicalDevice4444FormatsFeaturesEXT);
}
#endif
#ifdef VK_EXT_rgba10x6_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT);
}
#endif
#ifdef VK_VALVE_mutable_descriptor_type
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: {
return sizeof(VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE);
}
- case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE:
- {
+ case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: {
return sizeof(VkMutableDescriptorTypeCreateInfoVALVE);
}
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT);
}
#endif
#ifdef VK_EXT_physical_device_drm
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceDrmPropertiesEXT);
}
#endif
#ifdef VK_EXT_primitive_topology_list_restart
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
return sizeof(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT);
}
#endif
#ifdef VK_FUCHSIA_external_memory
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
- {
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: {
return sizeof(VkImportMemoryZirconHandleInfoFUCHSIA);
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
- {
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: {
return sizeof(VkImportMemoryBufferCollectionFUCHSIA);
}
- case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
- {
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: {
return sizeof(VkBufferCollectionImageCreateInfoFUCHSIA);
}
- case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
- {
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: {
return sizeof(VkBufferCollectionBufferCreateInfoFUCHSIA);
}
#endif
#ifdef VK_HUAWEI_subpass_shading
- case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
- {
+ case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: {
return sizeof(VkSubpassShadingPipelineCreateInfoHUAWEI);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: {
return sizeof(VkPhysicalDeviceSubpassShadingFeaturesHUAWEI);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: {
return sizeof(VkPhysicalDeviceSubpassShadingPropertiesHUAWEI);
}
#endif
#ifdef VK_HUAWEI_invocation_mask
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: {
return sizeof(VkPhysicalDeviceInvocationMaskFeaturesHUAWEI);
}
#endif
#ifdef VK_NV_external_memory_rdma
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: {
return sizeof(VkPhysicalDeviceExternalMemoryRDMAFeaturesNV);
}
#endif
#ifdef VK_EXT_extended_dynamic_state2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT);
}
#endif
#ifdef VK_EXT_color_write_enable
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceColorWriteEnableFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: {
return sizeof(VkPipelineColorWriteCreateInfoEXT);
}
#endif
#ifdef VK_GOOGLE_gfxstream
- case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
- {
+ case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
return sizeof(VkImportColorBufferGOOGLE);
}
- case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
- {
+ case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE: {
return sizeof(VkImportBufferGOOGLE);
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
- {
+ case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE: {
return sizeof(VkImportPhysicalAddressGOOGLE);
}
#endif
#ifdef VK_EXT_global_priority_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: {
return sizeof(VkQueueFamilyGlobalPriorityPropertiesEXT);
}
#endif
#ifdef VK_EXT_multi_draw
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceMultiDrawFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceMultiDrawPropertiesEXT);
}
#endif
#ifdef VK_EXT_border_color_swizzle
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
return sizeof(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT);
}
- case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
- {
+ case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: {
return sizeof(VkSamplerBorderColorComponentMappingCreateInfoEXT);
}
#endif
#ifdef VK_EXT_pageable_device_local_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: {
return sizeof(VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT);
}
#endif
#ifdef VK_KHR_acceleration_structure
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
- {
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
return sizeof(VkWriteDescriptorSetAccelerationStructureKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceAccelerationStructureFeaturesKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: {
return sizeof(VkPhysicalDeviceAccelerationStructurePropertiesKHR);
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceRayTracingPipelineFeaturesKHR);
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: {
return sizeof(VkPhysicalDeviceRayTracingPipelinePropertiesKHR);
}
#endif
#ifdef VK_KHR_ray_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
- {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: {
return sizeof(VkPhysicalDeviceRayQueryFeaturesKHR);
}
#endif
- default:
- {
+ default: {
return (size_t)0;
}
}
}
-
-} // namespace goldfish_vk
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_extension_structs_guest.h b/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
index 4bf48b0..ae0e5df 100644
--- a/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
+++ b/system/vulkan_enc/goldfish_vk_extension_structs_guest.h
@@ -14,22 +14,26 @@
// limitations under the License.
// Autogenerated module goldfish_vk_extension_structs_guest
-// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal -o ../qemu/android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+//
+// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
+// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
-// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
-
+//
+// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
+// $CEREAL_OUTPUT_DIR
+//
#pragma once
-
#include <vulkan/vulkan.h>
-
-#include "vk_platform_compat.h"
#include "goldfish_vk_private_defs.h"
+#include "vk_platform_compat.h"
+#include "vulkan_gfxstream.h"
// Stuff we are not going to use but if included,
// will cause compile errors. These are Android Vulkan
// required extensions, but the approach will be to
@@ -37,20 +41,14 @@
#undef VK_KHR_android_surface
#undef VK_ANDROID_external_memory_android_hardware_buffer
-
namespace goldfish_vk {
+uint32_t goldfish_vk_struct_type(const void* structExtension);
-uint32_t goldfish_vk_struct_type(
- const void* structExtension);
+size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* structExtension);
-size_t goldfish_vk_extension_struct_size(
- VkStructureType rootType,
- const void* structExtension);
-
-size_t goldfish_vk_extension_struct_size_with_stream_features(
- uint32_t streamFeatures,
- VkStructureType rootType,
- const void* structExtension);
+size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFeatures,
+ VkStructureType rootType,
+ const void* structExtension);
#ifdef VK_VERSION_1_0
#endif
@@ -595,4 +593,4 @@
#ifdef VK_KHR_ray_query
#endif
-} // namespace goldfish_vk
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp b/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
index 53af9ac..2759863 100644
--- a/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp
@@ -14,474 +14,347 @@
// limitations under the License.
// Autogenerated module goldfish_vk_handlemap_guest
-// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal -o ../qemu/android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+//
+// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
+// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
-// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+//
+// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
+// $CEREAL_OUTPUT_DIR
+//
#include "goldfish_vk_handlemap_guest.h"
+#include <cstring>
#include "goldfish_vk_extension_structs_guest.h"
#include "goldfish_vk_private_defs.h"
-#include <cstring>
-
-
namespace goldfish_vk {
-void handlemap_extension_struct(
- VulkanHandleMapping* handlemap,
- void* structExtension_out);
+void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExtension_out);
#ifdef VK_VERSION_1_0
-void handlemap_VkExtent2D(
- VulkanHandleMapping* handlemap,
- VkExtent2D* toMap)
-{
+void handlemap_VkExtent2D(VulkanHandleMapping* handlemap, VkExtent2D* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkExtent3D(
- VulkanHandleMapping* handlemap,
- VkExtent3D* toMap)
-{
+void handlemap_VkExtent3D(VulkanHandleMapping* handlemap, VkExtent3D* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkOffset2D(
- VulkanHandleMapping* handlemap,
- VkOffset2D* toMap)
-{
+void handlemap_VkOffset2D(VulkanHandleMapping* handlemap, VkOffset2D* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkOffset3D(
- VulkanHandleMapping* handlemap,
- VkOffset3D* toMap)
-{
+void handlemap_VkOffset3D(VulkanHandleMapping* handlemap, VkOffset3D* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkRect2D(
- VulkanHandleMapping* handlemap,
- VkRect2D* toMap)
-{
+void handlemap_VkRect2D(VulkanHandleMapping* handlemap, VkRect2D* toMap) {
(void)handlemap;
(void)toMap;
handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->offset));
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->extent));
}
-void handlemap_VkBaseInStructure(
- VulkanHandleMapping* handlemap,
- VkBaseInStructure* toMap)
-{
+void handlemap_VkBaseInStructure(VulkanHandleMapping* handlemap, VkBaseInStructure* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkBaseOutStructure(
- VulkanHandleMapping* handlemap,
- VkBaseOutStructure* toMap)
-{
+void handlemap_VkBaseOutStructure(VulkanHandleMapping* handlemap, VkBaseOutStructure* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkBufferMemoryBarrier(
- VulkanHandleMapping* handlemap,
- VkBufferMemoryBarrier* toMap)
-{
+void handlemap_VkBufferMemoryBarrier(VulkanHandleMapping* handlemap, VkBufferMemoryBarrier* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
}
-void handlemap_VkDispatchIndirectCommand(
- VulkanHandleMapping* handlemap,
- VkDispatchIndirectCommand* toMap)
-{
+void handlemap_VkDispatchIndirectCommand(VulkanHandleMapping* handlemap,
+ VkDispatchIndirectCommand* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkDrawIndexedIndirectCommand(
- VulkanHandleMapping* handlemap,
- VkDrawIndexedIndirectCommand* toMap)
-{
+void handlemap_VkDrawIndexedIndirectCommand(VulkanHandleMapping* handlemap,
+ VkDrawIndexedIndirectCommand* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkDrawIndirectCommand(
- VulkanHandleMapping* handlemap,
- VkDrawIndirectCommand* toMap)
-{
+void handlemap_VkDrawIndirectCommand(VulkanHandleMapping* handlemap, VkDrawIndirectCommand* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkImageSubresourceRange(
- VulkanHandleMapping* handlemap,
- VkImageSubresourceRange* toMap)
-{
+void handlemap_VkImageSubresourceRange(VulkanHandleMapping* handlemap,
+ VkImageSubresourceRange* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkImageMemoryBarrier(
- VulkanHandleMapping* handlemap,
- VkImageMemoryBarrier* toMap)
-{
+void handlemap_VkImageMemoryBarrier(VulkanHandleMapping* handlemap, VkImageMemoryBarrier* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
- handlemap_VkImageSubresourceRange(handlemap, (VkImageSubresourceRange*)(&toMap->subresourceRange));
+ handlemap_VkImageSubresourceRange(handlemap,
+ (VkImageSubresourceRange*)(&toMap->subresourceRange));
}
-void handlemap_VkMemoryBarrier(
- VulkanHandleMapping* handlemap,
- VkMemoryBarrier* toMap)
-{
+void handlemap_VkMemoryBarrier(VulkanHandleMapping* handlemap, VkMemoryBarrier* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPipelineCacheHeaderVersionOne(
- VulkanHandleMapping* handlemap,
- VkPipelineCacheHeaderVersionOne* toMap)
-{
+void handlemap_VkPipelineCacheHeaderVersionOne(VulkanHandleMapping* handlemap,
+ VkPipelineCacheHeaderVersionOne* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkAllocationCallbacks(
- VulkanHandleMapping* handlemap,
- VkAllocationCallbacks* toMap)
-{
+void handlemap_VkAllocationCallbacks(VulkanHandleMapping* handlemap, VkAllocationCallbacks* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkApplicationInfo(
- VulkanHandleMapping* handlemap,
- VkApplicationInfo* toMap)
-{
+void handlemap_VkApplicationInfo(VulkanHandleMapping* handlemap, VkApplicationInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkFormatProperties(
- VulkanHandleMapping* handlemap,
- VkFormatProperties* toMap)
-{
+void handlemap_VkFormatProperties(VulkanHandleMapping* handlemap, VkFormatProperties* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkImageFormatProperties(
- VulkanHandleMapping* handlemap,
- VkImageFormatProperties* toMap)
-{
+void handlemap_VkImageFormatProperties(VulkanHandleMapping* handlemap,
+ VkImageFormatProperties* toMap) {
(void)handlemap;
(void)toMap;
handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->maxExtent));
}
-void handlemap_VkInstanceCreateInfo(
- VulkanHandleMapping* handlemap,
- VkInstanceCreateInfo* toMap)
-{
+void handlemap_VkInstanceCreateInfo(VulkanHandleMapping* handlemap, VkInstanceCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pApplicationInfo)
- {
+ if (toMap->pApplicationInfo) {
handlemap_VkApplicationInfo(handlemap, (VkApplicationInfo*)(toMap->pApplicationInfo));
}
}
-void handlemap_VkMemoryHeap(
- VulkanHandleMapping* handlemap,
- VkMemoryHeap* toMap)
-{
+void handlemap_VkMemoryHeap(VulkanHandleMapping* handlemap, VkMemoryHeap* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkMemoryType(
- VulkanHandleMapping* handlemap,
- VkMemoryType* toMap)
-{
+void handlemap_VkMemoryType(VulkanHandleMapping* handlemap, VkMemoryType* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkPhysicalDeviceFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFeatures* toMap)
-{
+void handlemap_VkPhysicalDeviceFeatures(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceFeatures* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkPhysicalDeviceLimits(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceLimits* toMap)
-{
+void handlemap_VkPhysicalDeviceLimits(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceLimits* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkPhysicalDeviceMemoryProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMemoryProperties* toMap)
-{
+void handlemap_VkPhysicalDeviceMemoryProperties(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMemoryProperties* toMap) {
(void)handlemap;
(void)toMap;
- for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i)
- {
+ for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i) {
handlemap_VkMemoryType(handlemap, (VkMemoryType*)(toMap->memoryTypes + i));
}
- for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i)
- {
+ for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i) {
handlemap_VkMemoryHeap(handlemap, (VkMemoryHeap*)(toMap->memoryHeaps + i));
}
}
-void handlemap_VkPhysicalDeviceSparseProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSparseProperties* toMap)
-{
+void handlemap_VkPhysicalDeviceSparseProperties(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceSparseProperties* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkPhysicalDeviceProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceProperties* toMap)
-{
+void handlemap_VkPhysicalDeviceProperties(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceProperties* toMap) {
(void)handlemap;
(void)toMap;
handlemap_VkPhysicalDeviceLimits(handlemap, (VkPhysicalDeviceLimits*)(&toMap->limits));
- handlemap_VkPhysicalDeviceSparseProperties(handlemap, (VkPhysicalDeviceSparseProperties*)(&toMap->sparseProperties));
+ handlemap_VkPhysicalDeviceSparseProperties(
+ handlemap, (VkPhysicalDeviceSparseProperties*)(&toMap->sparseProperties));
}
-void handlemap_VkQueueFamilyProperties(
- VulkanHandleMapping* handlemap,
- VkQueueFamilyProperties* toMap)
-{
+void handlemap_VkQueueFamilyProperties(VulkanHandleMapping* handlemap,
+ VkQueueFamilyProperties* toMap) {
(void)handlemap;
(void)toMap;
handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->minImageTransferGranularity));
}
-void handlemap_VkDeviceQueueCreateInfo(
- VulkanHandleMapping* handlemap,
- VkDeviceQueueCreateInfo* toMap)
-{
+void handlemap_VkDeviceQueueCreateInfo(VulkanHandleMapping* handlemap,
+ VkDeviceQueueCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDeviceCreateInfo(
- VulkanHandleMapping* handlemap,
- VkDeviceCreateInfo* toMap)
-{
+void handlemap_VkDeviceCreateInfo(VulkanHandleMapping* handlemap, VkDeviceCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pQueueCreateInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->queueCreateInfoCount; ++i)
- {
- handlemap_VkDeviceQueueCreateInfo(handlemap, (VkDeviceQueueCreateInfo*)(toMap->pQueueCreateInfos + i));
+ if (toMap) {
+ if (toMap->pQueueCreateInfos) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->queueCreateInfoCount; ++i) {
+ handlemap_VkDeviceQueueCreateInfo(
+ handlemap, (VkDeviceQueueCreateInfo*)(toMap->pQueueCreateInfos + i));
}
}
}
- if (toMap->pEnabledFeatures)
- {
- handlemap_VkPhysicalDeviceFeatures(handlemap, (VkPhysicalDeviceFeatures*)(toMap->pEnabledFeatures));
+ if (toMap->pEnabledFeatures) {
+ handlemap_VkPhysicalDeviceFeatures(handlemap,
+ (VkPhysicalDeviceFeatures*)(toMap->pEnabledFeatures));
}
}
-void handlemap_VkExtensionProperties(
- VulkanHandleMapping* handlemap,
- VkExtensionProperties* toMap)
-{
+void handlemap_VkExtensionProperties(VulkanHandleMapping* handlemap, VkExtensionProperties* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkLayerProperties(
- VulkanHandleMapping* handlemap,
- VkLayerProperties* toMap)
-{
+void handlemap_VkLayerProperties(VulkanHandleMapping* handlemap, VkLayerProperties* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkSubmitInfo(
- VulkanHandleMapping* handlemap,
- VkSubmitInfo* toMap)
-{
+void handlemap_VkSubmitInfo(VulkanHandleMapping* handlemap, VkSubmitInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pWaitSemaphores)
- {
- handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pWaitSemaphores, toMap->waitSemaphoreCount);
+ if (toMap->pWaitSemaphores) {
+ handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pWaitSemaphores,
+ toMap->waitSemaphoreCount);
}
- if (toMap->pCommandBuffers)
- {
- handlemap->mapHandles_VkCommandBuffer((VkCommandBuffer*)toMap->pCommandBuffers, toMap->commandBufferCount);
+ if (toMap->pCommandBuffers) {
+ handlemap->mapHandles_VkCommandBuffer((VkCommandBuffer*)toMap->pCommandBuffers,
+ toMap->commandBufferCount);
}
- if (toMap->pSignalSemaphores)
- {
- handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pSignalSemaphores, toMap->signalSemaphoreCount);
+ if (toMap->pSignalSemaphores) {
+ handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pSignalSemaphores,
+ toMap->signalSemaphoreCount);
}
}
-void handlemap_VkMappedMemoryRange(
- VulkanHandleMapping* handlemap,
- VkMappedMemoryRange* toMap)
-{
+void handlemap_VkMappedMemoryRange(VulkanHandleMapping* handlemap, VkMappedMemoryRange* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
}
-void handlemap_VkMemoryAllocateInfo(
- VulkanHandleMapping* handlemap,
- VkMemoryAllocateInfo* toMap)
-{
+void handlemap_VkMemoryAllocateInfo(VulkanHandleMapping* handlemap, VkMemoryAllocateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkMemoryRequirements(
- VulkanHandleMapping* handlemap,
- VkMemoryRequirements* toMap)
-{
+void handlemap_VkMemoryRequirements(VulkanHandleMapping* handlemap, VkMemoryRequirements* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkSparseMemoryBind(
- VulkanHandleMapping* handlemap,
- VkSparseMemoryBind* toMap)
-{
+void handlemap_VkSparseMemoryBind(VulkanHandleMapping* handlemap, VkSparseMemoryBind* toMap) {
(void)handlemap;
(void)toMap;
handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
}
-void handlemap_VkSparseBufferMemoryBindInfo(
- VulkanHandleMapping* handlemap,
- VkSparseBufferMemoryBindInfo* toMap)
-{
+void handlemap_VkSparseBufferMemoryBindInfo(VulkanHandleMapping* handlemap,
+ VkSparseBufferMemoryBindInfo* toMap) {
(void)handlemap;
(void)toMap;
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
- if (toMap)
- {
- if (toMap->pBinds)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->bindCount; ++i)
- {
+ if (toMap) {
+ if (toMap->pBinds) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->bindCount; ++i) {
handlemap_VkSparseMemoryBind(handlemap, (VkSparseMemoryBind*)(toMap->pBinds + i));
}
}
}
}
-void handlemap_VkSparseImageOpaqueMemoryBindInfo(
- VulkanHandleMapping* handlemap,
- VkSparseImageOpaqueMemoryBindInfo* toMap)
-{
+void handlemap_VkSparseImageOpaqueMemoryBindInfo(VulkanHandleMapping* handlemap,
+ VkSparseImageOpaqueMemoryBindInfo* toMap) {
(void)handlemap;
(void)toMap;
handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
- if (toMap)
- {
- if (toMap->pBinds)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->bindCount; ++i)
- {
+ if (toMap) {
+ if (toMap->pBinds) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->bindCount; ++i) {
handlemap_VkSparseMemoryBind(handlemap, (VkSparseMemoryBind*)(toMap->pBinds + i));
}
}
}
}
-void handlemap_VkImageSubresource(
- VulkanHandleMapping* handlemap,
- VkImageSubresource* toMap)
-{
+void handlemap_VkImageSubresource(VulkanHandleMapping* handlemap, VkImageSubresource* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkSparseImageMemoryBind(
- VulkanHandleMapping* handlemap,
- VkSparseImageMemoryBind* toMap)
-{
+void handlemap_VkSparseImageMemoryBind(VulkanHandleMapping* handlemap,
+ VkSparseImageMemoryBind* toMap) {
(void)handlemap;
(void)toMap;
handlemap_VkImageSubresource(handlemap, (VkImageSubresource*)(&toMap->subresource));
@@ -490,398 +363,300 @@
handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
}
-void handlemap_VkSparseImageMemoryBindInfo(
- VulkanHandleMapping* handlemap,
- VkSparseImageMemoryBindInfo* toMap)
-{
+void handlemap_VkSparseImageMemoryBindInfo(VulkanHandleMapping* handlemap,
+ VkSparseImageMemoryBindInfo* toMap) {
(void)handlemap;
(void)toMap;
handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
- if (toMap)
- {
- if (toMap->pBinds)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->bindCount; ++i)
- {
- handlemap_VkSparseImageMemoryBind(handlemap, (VkSparseImageMemoryBind*)(toMap->pBinds + i));
+ if (toMap) {
+ if (toMap->pBinds) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->bindCount; ++i) {
+ handlemap_VkSparseImageMemoryBind(handlemap,
+ (VkSparseImageMemoryBind*)(toMap->pBinds + i));
}
}
}
}
-void handlemap_VkBindSparseInfo(
- VulkanHandleMapping* handlemap,
- VkBindSparseInfo* toMap)
-{
+void handlemap_VkBindSparseInfo(VulkanHandleMapping* handlemap, VkBindSparseInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pWaitSemaphores)
- {
- handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pWaitSemaphores, toMap->waitSemaphoreCount);
+ if (toMap->pWaitSemaphores) {
+ handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pWaitSemaphores,
+ toMap->waitSemaphoreCount);
}
- if (toMap)
- {
- if (toMap->pBufferBinds)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->bufferBindCount; ++i)
- {
- handlemap_VkSparseBufferMemoryBindInfo(handlemap, (VkSparseBufferMemoryBindInfo*)(toMap->pBufferBinds + i));
+ if (toMap) {
+ if (toMap->pBufferBinds) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->bufferBindCount; ++i) {
+ handlemap_VkSparseBufferMemoryBindInfo(
+ handlemap, (VkSparseBufferMemoryBindInfo*)(toMap->pBufferBinds + i));
}
}
}
- if (toMap)
- {
- if (toMap->pImageOpaqueBinds)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->imageOpaqueBindCount; ++i)
- {
- handlemap_VkSparseImageOpaqueMemoryBindInfo(handlemap, (VkSparseImageOpaqueMemoryBindInfo*)(toMap->pImageOpaqueBinds + i));
+ if (toMap) {
+ if (toMap->pImageOpaqueBinds) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->imageOpaqueBindCount; ++i) {
+ handlemap_VkSparseImageOpaqueMemoryBindInfo(
+ handlemap, (VkSparseImageOpaqueMemoryBindInfo*)(toMap->pImageOpaqueBinds + i));
}
}
}
- if (toMap)
- {
- if (toMap->pImageBinds)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->imageBindCount; ++i)
- {
- handlemap_VkSparseImageMemoryBindInfo(handlemap, (VkSparseImageMemoryBindInfo*)(toMap->pImageBinds + i));
+ if (toMap) {
+ if (toMap->pImageBinds) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->imageBindCount; ++i) {
+ handlemap_VkSparseImageMemoryBindInfo(
+ handlemap, (VkSparseImageMemoryBindInfo*)(toMap->pImageBinds + i));
}
}
}
- if (toMap->pSignalSemaphores)
- {
- handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pSignalSemaphores, toMap->signalSemaphoreCount);
+ if (toMap->pSignalSemaphores) {
+ handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pSignalSemaphores,
+ toMap->signalSemaphoreCount);
}
}
-void handlemap_VkSparseImageFormatProperties(
- VulkanHandleMapping* handlemap,
- VkSparseImageFormatProperties* toMap)
-{
+void handlemap_VkSparseImageFormatProperties(VulkanHandleMapping* handlemap,
+ VkSparseImageFormatProperties* toMap) {
(void)handlemap;
(void)toMap;
handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->imageGranularity));
}
-void handlemap_VkSparseImageMemoryRequirements(
- VulkanHandleMapping* handlemap,
- VkSparseImageMemoryRequirements* toMap)
-{
+void handlemap_VkSparseImageMemoryRequirements(VulkanHandleMapping* handlemap,
+ VkSparseImageMemoryRequirements* toMap) {
(void)handlemap;
(void)toMap;
- handlemap_VkSparseImageFormatProperties(handlemap, (VkSparseImageFormatProperties*)(&toMap->formatProperties));
+ handlemap_VkSparseImageFormatProperties(
+ handlemap, (VkSparseImageFormatProperties*)(&toMap->formatProperties));
}
-void handlemap_VkFenceCreateInfo(
- VulkanHandleMapping* handlemap,
- VkFenceCreateInfo* toMap)
-{
+void handlemap_VkFenceCreateInfo(VulkanHandleMapping* handlemap, VkFenceCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkSemaphoreCreateInfo(
- VulkanHandleMapping* handlemap,
- VkSemaphoreCreateInfo* toMap)
-{
+void handlemap_VkSemaphoreCreateInfo(VulkanHandleMapping* handlemap, VkSemaphoreCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkEventCreateInfo(
- VulkanHandleMapping* handlemap,
- VkEventCreateInfo* toMap)
-{
+void handlemap_VkEventCreateInfo(VulkanHandleMapping* handlemap, VkEventCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkQueryPoolCreateInfo(
- VulkanHandleMapping* handlemap,
- VkQueryPoolCreateInfo* toMap)
-{
+void handlemap_VkQueryPoolCreateInfo(VulkanHandleMapping* handlemap, VkQueryPoolCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkBufferCreateInfo(
- VulkanHandleMapping* handlemap,
- VkBufferCreateInfo* toMap)
-{
+void handlemap_VkBufferCreateInfo(VulkanHandleMapping* handlemap, VkBufferCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkBufferViewCreateInfo(
- VulkanHandleMapping* handlemap,
- VkBufferViewCreateInfo* toMap)
-{
+void handlemap_VkBufferViewCreateInfo(VulkanHandleMapping* handlemap,
+ VkBufferViewCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
}
-void handlemap_VkImageCreateInfo(
- VulkanHandleMapping* handlemap,
- VkImageCreateInfo* toMap)
-{
+void handlemap_VkImageCreateInfo(VulkanHandleMapping* handlemap, VkImageCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
}
-void handlemap_VkSubresourceLayout(
- VulkanHandleMapping* handlemap,
- VkSubresourceLayout* toMap)
-{
+void handlemap_VkSubresourceLayout(VulkanHandleMapping* handlemap, VkSubresourceLayout* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkComponentMapping(
- VulkanHandleMapping* handlemap,
- VkComponentMapping* toMap)
-{
+void handlemap_VkComponentMapping(VulkanHandleMapping* handlemap, VkComponentMapping* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkImageViewCreateInfo(
- VulkanHandleMapping* handlemap,
- VkImageViewCreateInfo* toMap)
-{
+void handlemap_VkImageViewCreateInfo(VulkanHandleMapping* handlemap, VkImageViewCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
handlemap_VkComponentMapping(handlemap, (VkComponentMapping*)(&toMap->components));
- handlemap_VkImageSubresourceRange(handlemap, (VkImageSubresourceRange*)(&toMap->subresourceRange));
+ handlemap_VkImageSubresourceRange(handlemap,
+ (VkImageSubresourceRange*)(&toMap->subresourceRange));
}
-void handlemap_VkShaderModuleCreateInfo(
- VulkanHandleMapping* handlemap,
- VkShaderModuleCreateInfo* toMap)
-{
+void handlemap_VkShaderModuleCreateInfo(VulkanHandleMapping* handlemap,
+ VkShaderModuleCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPipelineCacheCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineCacheCreateInfo* toMap)
-{
+void handlemap_VkPipelineCacheCreateInfo(VulkanHandleMapping* handlemap,
+ VkPipelineCacheCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkSpecializationMapEntry(
- VulkanHandleMapping* handlemap,
- VkSpecializationMapEntry* toMap)
-{
+void handlemap_VkSpecializationMapEntry(VulkanHandleMapping* handlemap,
+ VkSpecializationMapEntry* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkSpecializationInfo(
- VulkanHandleMapping* handlemap,
- VkSpecializationInfo* toMap)
-{
+void handlemap_VkSpecializationInfo(VulkanHandleMapping* handlemap, VkSpecializationInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap)
- {
- if (toMap->pMapEntries)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->mapEntryCount; ++i)
- {
- handlemap_VkSpecializationMapEntry(handlemap, (VkSpecializationMapEntry*)(toMap->pMapEntries + i));
+ if (toMap) {
+ if (toMap->pMapEntries) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->mapEntryCount; ++i) {
+ handlemap_VkSpecializationMapEntry(
+ handlemap, (VkSpecializationMapEntry*)(toMap->pMapEntries + i));
}
}
}
}
-void handlemap_VkPipelineShaderStageCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineShaderStageCreateInfo* toMap)
-{
+void handlemap_VkPipelineShaderStageCreateInfo(VulkanHandleMapping* handlemap,
+ VkPipelineShaderStageCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkShaderModule((VkShaderModule*)&toMap->module);
- if (toMap->pSpecializationInfo)
- {
- handlemap_VkSpecializationInfo(handlemap, (VkSpecializationInfo*)(toMap->pSpecializationInfo));
+ if (toMap->pSpecializationInfo) {
+ handlemap_VkSpecializationInfo(handlemap,
+ (VkSpecializationInfo*)(toMap->pSpecializationInfo));
}
}
-void handlemap_VkComputePipelineCreateInfo(
- VulkanHandleMapping* handlemap,
- VkComputePipelineCreateInfo* toMap)
-{
+void handlemap_VkComputePipelineCreateInfo(VulkanHandleMapping* handlemap,
+ VkComputePipelineCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkPipelineShaderStageCreateInfo(handlemap, (VkPipelineShaderStageCreateInfo*)(&toMap->stage));
+ handlemap_VkPipelineShaderStageCreateInfo(handlemap,
+ (VkPipelineShaderStageCreateInfo*)(&toMap->stage));
handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->layout);
handlemap->mapHandles_VkPipeline((VkPipeline*)&toMap->basePipelineHandle);
}
-void handlemap_VkVertexInputBindingDescription(
- VulkanHandleMapping* handlemap,
- VkVertexInputBindingDescription* toMap)
-{
+void handlemap_VkVertexInputBindingDescription(VulkanHandleMapping* handlemap,
+ VkVertexInputBindingDescription* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkVertexInputAttributeDescription(
- VulkanHandleMapping* handlemap,
- VkVertexInputAttributeDescription* toMap)
-{
+void handlemap_VkVertexInputAttributeDescription(VulkanHandleMapping* handlemap,
+ VkVertexInputAttributeDescription* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkPipelineVertexInputStateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineVertexInputStateCreateInfo* toMap)
-{
+void handlemap_VkPipelineVertexInputStateCreateInfo(VulkanHandleMapping* handlemap,
+ VkPipelineVertexInputStateCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pVertexBindingDescriptions)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->vertexBindingDescriptionCount; ++i)
- {
- handlemap_VkVertexInputBindingDescription(handlemap, (VkVertexInputBindingDescription*)(toMap->pVertexBindingDescriptions + i));
+ if (toMap) {
+ if (toMap->pVertexBindingDescriptions) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->vertexBindingDescriptionCount; ++i) {
+ handlemap_VkVertexInputBindingDescription(
+ handlemap,
+ (VkVertexInputBindingDescription*)(toMap->pVertexBindingDescriptions + i));
}
}
}
- if (toMap)
- {
- if (toMap->pVertexAttributeDescriptions)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->vertexAttributeDescriptionCount; ++i)
- {
- handlemap_VkVertexInputAttributeDescription(handlemap, (VkVertexInputAttributeDescription*)(toMap->pVertexAttributeDescriptions + i));
+ if (toMap) {
+ if (toMap->pVertexAttributeDescriptions) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->vertexAttributeDescriptionCount; ++i) {
+ handlemap_VkVertexInputAttributeDescription(
+ handlemap,
+ (VkVertexInputAttributeDescription*)(toMap->pVertexAttributeDescriptions + i));
}
}
}
}
void handlemap_VkPipelineInputAssemblyStateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineInputAssemblyStateCreateInfo* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineInputAssemblyStateCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPipelineTessellationStateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineTessellationStateCreateInfo* toMap)
-{
+void handlemap_VkPipelineTessellationStateCreateInfo(VulkanHandleMapping* handlemap,
+ VkPipelineTessellationStateCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkViewport(
- VulkanHandleMapping* handlemap,
- VkViewport* toMap)
-{
+void handlemap_VkViewport(VulkanHandleMapping* handlemap, VkViewport* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkPipelineViewportStateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineViewportStateCreateInfo* toMap)
-{
+void handlemap_VkPipelineViewportStateCreateInfo(VulkanHandleMapping* handlemap,
+ VkPipelineViewportStateCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pViewports)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->viewportCount; ++i)
- {
+ if (toMap) {
+ if (toMap->pViewports) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->viewportCount; ++i) {
handlemap_VkViewport(handlemap, (VkViewport*)(toMap->pViewports + i));
}
}
}
- if (toMap)
- {
- if (toMap->pScissors)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->scissorCount; ++i)
- {
+ if (toMap) {
+ if (toMap->pScissors) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->scissorCount; ++i) {
handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pScissors + i));
}
}
@@ -889,665 +664,518 @@
}
void handlemap_VkPipelineRasterizationStateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineRasterizationStateCreateInfo* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineRasterizationStateCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPipelineMultisampleStateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineMultisampleStateCreateInfo* toMap)
-{
+void handlemap_VkPipelineMultisampleStateCreateInfo(VulkanHandleMapping* handlemap,
+ VkPipelineMultisampleStateCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkStencilOpState(
- VulkanHandleMapping* handlemap,
- VkStencilOpState* toMap)
-{
+void handlemap_VkStencilOpState(VulkanHandleMapping* handlemap, VkStencilOpState* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkPipelineDepthStencilStateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineDepthStencilStateCreateInfo* toMap)
-{
+void handlemap_VkPipelineDepthStencilStateCreateInfo(VulkanHandleMapping* handlemap,
+ VkPipelineDepthStencilStateCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkStencilOpState(handlemap, (VkStencilOpState*)(&toMap->front));
handlemap_VkStencilOpState(handlemap, (VkStencilOpState*)(&toMap->back));
}
-void handlemap_VkPipelineColorBlendAttachmentState(
- VulkanHandleMapping* handlemap,
- VkPipelineColorBlendAttachmentState* toMap)
-{
+void handlemap_VkPipelineColorBlendAttachmentState(VulkanHandleMapping* handlemap,
+ VkPipelineColorBlendAttachmentState* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkPipelineColorBlendStateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineColorBlendStateCreateInfo* toMap)
-{
+void handlemap_VkPipelineColorBlendStateCreateInfo(VulkanHandleMapping* handlemap,
+ VkPipelineColorBlendStateCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->attachmentCount; ++i)
- {
- handlemap_VkPipelineColorBlendAttachmentState(handlemap, (VkPipelineColorBlendAttachmentState*)(toMap->pAttachments + i));
+ if (toMap) {
+ if (toMap->pAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->attachmentCount; ++i) {
+ handlemap_VkPipelineColorBlendAttachmentState(
+ handlemap, (VkPipelineColorBlendAttachmentState*)(toMap->pAttachments + i));
}
}
}
}
-void handlemap_VkPipelineDynamicStateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineDynamicStateCreateInfo* toMap)
-{
+void handlemap_VkPipelineDynamicStateCreateInfo(VulkanHandleMapping* handlemap,
+ VkPipelineDynamicStateCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkGraphicsPipelineCreateInfo(
- VulkanHandleMapping* handlemap,
- VkGraphicsPipelineCreateInfo* toMap)
-{
+void handlemap_VkGraphicsPipelineCreateInfo(VulkanHandleMapping* handlemap,
+ VkGraphicsPipelineCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pStages)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->stageCount; ++i)
- {
- handlemap_VkPipelineShaderStageCreateInfo(handlemap, (VkPipelineShaderStageCreateInfo*)(toMap->pStages + i));
+ if (toMap) {
+ if (toMap->pStages) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->stageCount; ++i) {
+ handlemap_VkPipelineShaderStageCreateInfo(
+ handlemap, (VkPipelineShaderStageCreateInfo*)(toMap->pStages + i));
}
}
}
- if (toMap->pVertexInputState)
- {
- handlemap_VkPipelineVertexInputStateCreateInfo(handlemap, (VkPipelineVertexInputStateCreateInfo*)(toMap->pVertexInputState));
+ if (toMap->pVertexInputState) {
+ handlemap_VkPipelineVertexInputStateCreateInfo(
+ handlemap, (VkPipelineVertexInputStateCreateInfo*)(toMap->pVertexInputState));
}
- if (toMap->pInputAssemblyState)
- {
- handlemap_VkPipelineInputAssemblyStateCreateInfo(handlemap, (VkPipelineInputAssemblyStateCreateInfo*)(toMap->pInputAssemblyState));
+ if (toMap->pInputAssemblyState) {
+ handlemap_VkPipelineInputAssemblyStateCreateInfo(
+ handlemap, (VkPipelineInputAssemblyStateCreateInfo*)(toMap->pInputAssemblyState));
}
- if (toMap->pTessellationState)
- {
- handlemap_VkPipelineTessellationStateCreateInfo(handlemap, (VkPipelineTessellationStateCreateInfo*)(toMap->pTessellationState));
+ if (toMap->pTessellationState) {
+ handlemap_VkPipelineTessellationStateCreateInfo(
+ handlemap, (VkPipelineTessellationStateCreateInfo*)(toMap->pTessellationState));
}
- if (toMap->pViewportState)
- {
- handlemap_VkPipelineViewportStateCreateInfo(handlemap, (VkPipelineViewportStateCreateInfo*)(toMap->pViewportState));
+ if (toMap->pViewportState) {
+ handlemap_VkPipelineViewportStateCreateInfo(
+ handlemap, (VkPipelineViewportStateCreateInfo*)(toMap->pViewportState));
}
- if (toMap->pRasterizationState)
- {
- handlemap_VkPipelineRasterizationStateCreateInfo(handlemap, (VkPipelineRasterizationStateCreateInfo*)(toMap->pRasterizationState));
+ if (toMap->pRasterizationState) {
+ handlemap_VkPipelineRasterizationStateCreateInfo(
+ handlemap, (VkPipelineRasterizationStateCreateInfo*)(toMap->pRasterizationState));
}
- if (toMap->pMultisampleState)
- {
- handlemap_VkPipelineMultisampleStateCreateInfo(handlemap, (VkPipelineMultisampleStateCreateInfo*)(toMap->pMultisampleState));
+ if (toMap->pMultisampleState) {
+ handlemap_VkPipelineMultisampleStateCreateInfo(
+ handlemap, (VkPipelineMultisampleStateCreateInfo*)(toMap->pMultisampleState));
}
- if (toMap->pDepthStencilState)
- {
- handlemap_VkPipelineDepthStencilStateCreateInfo(handlemap, (VkPipelineDepthStencilStateCreateInfo*)(toMap->pDepthStencilState));
+ if (toMap->pDepthStencilState) {
+ handlemap_VkPipelineDepthStencilStateCreateInfo(
+ handlemap, (VkPipelineDepthStencilStateCreateInfo*)(toMap->pDepthStencilState));
}
- if (toMap->pColorBlendState)
- {
- handlemap_VkPipelineColorBlendStateCreateInfo(handlemap, (VkPipelineColorBlendStateCreateInfo*)(toMap->pColorBlendState));
+ if (toMap->pColorBlendState) {
+ handlemap_VkPipelineColorBlendStateCreateInfo(
+ handlemap, (VkPipelineColorBlendStateCreateInfo*)(toMap->pColorBlendState));
}
- if (toMap->pDynamicState)
- {
- handlemap_VkPipelineDynamicStateCreateInfo(handlemap, (VkPipelineDynamicStateCreateInfo*)(toMap->pDynamicState));
+ if (toMap->pDynamicState) {
+ handlemap_VkPipelineDynamicStateCreateInfo(
+ handlemap, (VkPipelineDynamicStateCreateInfo*)(toMap->pDynamicState));
}
handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->layout);
handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
handlemap->mapHandles_VkPipeline((VkPipeline*)&toMap->basePipelineHandle);
}
-void handlemap_VkPushConstantRange(
- VulkanHandleMapping* handlemap,
- VkPushConstantRange* toMap)
-{
+void handlemap_VkPushConstantRange(VulkanHandleMapping* handlemap, VkPushConstantRange* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkPipelineLayoutCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineLayoutCreateInfo* toMap)
-{
+void handlemap_VkPipelineLayoutCreateInfo(VulkanHandleMapping* handlemap,
+ VkPipelineLayoutCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pSetLayouts)
- {
- handlemap->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)toMap->pSetLayouts, toMap->setLayoutCount);
+ if (toMap->pSetLayouts) {
+ handlemap->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)toMap->pSetLayouts,
+ toMap->setLayoutCount);
}
- if (toMap)
- {
- if (toMap->pPushConstantRanges)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->pushConstantRangeCount; ++i)
- {
- handlemap_VkPushConstantRange(handlemap, (VkPushConstantRange*)(toMap->pPushConstantRanges + i));
+ if (toMap) {
+ if (toMap->pPushConstantRanges) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->pushConstantRangeCount; ++i) {
+ handlemap_VkPushConstantRange(
+ handlemap, (VkPushConstantRange*)(toMap->pPushConstantRanges + i));
}
}
}
}
-void handlemap_VkSamplerCreateInfo(
- VulkanHandleMapping* handlemap,
- VkSamplerCreateInfo* toMap)
-{
+void handlemap_VkSamplerCreateInfo(VulkanHandleMapping* handlemap, VkSamplerCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkCopyDescriptorSet(
- VulkanHandleMapping* handlemap,
- VkCopyDescriptorSet* toMap)
-{
+void handlemap_VkCopyDescriptorSet(VulkanHandleMapping* handlemap, VkCopyDescriptorSet* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkDescriptorSet((VkDescriptorSet*)&toMap->srcSet);
handlemap->mapHandles_VkDescriptorSet((VkDescriptorSet*)&toMap->dstSet);
}
-void handlemap_VkDescriptorBufferInfo(
- VulkanHandleMapping* handlemap,
- VkDescriptorBufferInfo* toMap)
-{
+void handlemap_VkDescriptorBufferInfo(VulkanHandleMapping* handlemap,
+ VkDescriptorBufferInfo* toMap) {
(void)handlemap;
(void)toMap;
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
}
-void handlemap_VkDescriptorImageInfo(
- VulkanHandleMapping* handlemap,
- VkDescriptorImageInfo* toMap)
-{
+void handlemap_VkDescriptorImageInfo(VulkanHandleMapping* handlemap, VkDescriptorImageInfo* toMap) {
(void)handlemap;
(void)toMap;
handlemap->mapHandles_VkSampler((VkSampler*)&toMap->sampler);
handlemap->mapHandles_VkImageView((VkImageView*)&toMap->imageView);
}
-void handlemap_VkDescriptorPoolSize(
- VulkanHandleMapping* handlemap,
- VkDescriptorPoolSize* toMap)
-{
+void handlemap_VkDescriptorPoolSize(VulkanHandleMapping* handlemap, VkDescriptorPoolSize* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkDescriptorPoolCreateInfo(
- VulkanHandleMapping* handlemap,
- VkDescriptorPoolCreateInfo* toMap)
-{
+void handlemap_VkDescriptorPoolCreateInfo(VulkanHandleMapping* handlemap,
+ VkDescriptorPoolCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pPoolSizes)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->poolSizeCount; ++i)
- {
- handlemap_VkDescriptorPoolSize(handlemap, (VkDescriptorPoolSize*)(toMap->pPoolSizes + i));
+ if (toMap) {
+ if (toMap->pPoolSizes) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->poolSizeCount; ++i) {
+ handlemap_VkDescriptorPoolSize(handlemap,
+ (VkDescriptorPoolSize*)(toMap->pPoolSizes + i));
}
}
}
}
-void handlemap_VkDescriptorSetAllocateInfo(
- VulkanHandleMapping* handlemap,
- VkDescriptorSetAllocateInfo* toMap)
-{
+void handlemap_VkDescriptorSetAllocateInfo(VulkanHandleMapping* handlemap,
+ VkDescriptorSetAllocateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkDescriptorPool((VkDescriptorPool*)&toMap->descriptorPool);
- if (toMap->pSetLayouts)
- {
- handlemap->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)toMap->pSetLayouts, toMap->descriptorSetCount);
+ if (toMap->pSetLayouts) {
+ handlemap->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)toMap->pSetLayouts,
+ toMap->descriptorSetCount);
}
}
-void handlemap_VkDescriptorSetLayoutBinding(
- VulkanHandleMapping* handlemap,
- VkDescriptorSetLayoutBinding* toMap)
-{
+void handlemap_VkDescriptorSetLayoutBinding(VulkanHandleMapping* handlemap,
+ VkDescriptorSetLayoutBinding* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pImmutableSamplers)
- {
- handlemap->mapHandles_VkSampler((VkSampler*)toMap->pImmutableSamplers, toMap->descriptorCount);
+ if (toMap->pImmutableSamplers) {
+ handlemap->mapHandles_VkSampler((VkSampler*)toMap->pImmutableSamplers,
+ toMap->descriptorCount);
}
}
-void handlemap_VkDescriptorSetLayoutCreateInfo(
- VulkanHandleMapping* handlemap,
- VkDescriptorSetLayoutCreateInfo* toMap)
-{
+void handlemap_VkDescriptorSetLayoutCreateInfo(VulkanHandleMapping* handlemap,
+ VkDescriptorSetLayoutCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pBindings)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->bindingCount; ++i)
- {
- handlemap_VkDescriptorSetLayoutBinding(handlemap, (VkDescriptorSetLayoutBinding*)(toMap->pBindings + i));
+ if (toMap) {
+ if (toMap->pBindings) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->bindingCount; ++i) {
+ handlemap_VkDescriptorSetLayoutBinding(
+ handlemap, (VkDescriptorSetLayoutBinding*)(toMap->pBindings + i));
}
}
}
}
-void handlemap_VkWriteDescriptorSet(
- VulkanHandleMapping* handlemap,
- VkWriteDescriptorSet* toMap)
-{
+void handlemap_VkWriteDescriptorSet(VulkanHandleMapping* handlemap, VkWriteDescriptorSet* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkDescriptorSet((VkDescriptorSet*)&toMap->dstSet);
- if (toMap)
- {
- if (toMap->pImageInfo)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->descriptorCount; ++i)
- {
- handlemap_VkDescriptorImageInfo(handlemap, (VkDescriptorImageInfo*)(toMap->pImageInfo + i));
+ if (toMap) {
+ if (toMap->pImageInfo) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->descriptorCount; ++i) {
+ handlemap_VkDescriptorImageInfo(handlemap,
+ (VkDescriptorImageInfo*)(toMap->pImageInfo + i));
}
}
}
- if (toMap)
- {
- if (toMap->pBufferInfo)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->descriptorCount; ++i)
- {
- handlemap_VkDescriptorBufferInfo(handlemap, (VkDescriptorBufferInfo*)(toMap->pBufferInfo + i));
+ if (toMap) {
+ if (toMap->pBufferInfo) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->descriptorCount; ++i) {
+ handlemap_VkDescriptorBufferInfo(handlemap,
+ (VkDescriptorBufferInfo*)(toMap->pBufferInfo + i));
}
}
}
- if (toMap->pTexelBufferView)
- {
- handlemap->mapHandles_VkBufferView((VkBufferView*)toMap->pTexelBufferView, toMap->descriptorCount);
+ if (toMap->pTexelBufferView) {
+ handlemap->mapHandles_VkBufferView((VkBufferView*)toMap->pTexelBufferView,
+ toMap->descriptorCount);
}
}
-void handlemap_VkAttachmentDescription(
- VulkanHandleMapping* handlemap,
- VkAttachmentDescription* toMap)
-{
+void handlemap_VkAttachmentDescription(VulkanHandleMapping* handlemap,
+ VkAttachmentDescription* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkAttachmentReference(
- VulkanHandleMapping* handlemap,
- VkAttachmentReference* toMap)
-{
+void handlemap_VkAttachmentReference(VulkanHandleMapping* handlemap, VkAttachmentReference* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkFramebufferCreateInfo(
- VulkanHandleMapping* handlemap,
- VkFramebufferCreateInfo* toMap)
-{
+void handlemap_VkFramebufferCreateInfo(VulkanHandleMapping* handlemap,
+ VkFramebufferCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
- if (toMap->pAttachments)
- {
- handlemap->mapHandles_VkImageView((VkImageView*)toMap->pAttachments, toMap->attachmentCount);
+ if (toMap->pAttachments) {
+ handlemap->mapHandles_VkImageView((VkImageView*)toMap->pAttachments,
+ toMap->attachmentCount);
}
}
-void handlemap_VkSubpassDescription(
- VulkanHandleMapping* handlemap,
- VkSubpassDescription* toMap)
-{
+void handlemap_VkSubpassDescription(VulkanHandleMapping* handlemap, VkSubpassDescription* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap)
- {
- if (toMap->pInputAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->inputAttachmentCount; ++i)
- {
- handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(toMap->pInputAttachments + i));
+ if (toMap) {
+ if (toMap->pInputAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->inputAttachmentCount; ++i) {
+ handlemap_VkAttachmentReference(
+ handlemap, (VkAttachmentReference*)(toMap->pInputAttachments + i));
}
}
}
- if (toMap)
- {
- if (toMap->pColorAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i)
- {
- handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(toMap->pColorAttachments + i));
+ if (toMap) {
+ if (toMap->pColorAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i) {
+ handlemap_VkAttachmentReference(
+ handlemap, (VkAttachmentReference*)(toMap->pColorAttachments + i));
}
}
}
- if (toMap)
- {
- if (toMap->pResolveAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i)
- {
- handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(toMap->pResolveAttachments + i));
+ if (toMap) {
+ if (toMap->pResolveAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i) {
+ handlemap_VkAttachmentReference(
+ handlemap, (VkAttachmentReference*)(toMap->pResolveAttachments + i));
}
}
}
- if (toMap->pDepthStencilAttachment)
- {
- handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(toMap->pDepthStencilAttachment));
+ if (toMap->pDepthStencilAttachment) {
+ handlemap_VkAttachmentReference(handlemap,
+ (VkAttachmentReference*)(toMap->pDepthStencilAttachment));
}
}
-void handlemap_VkSubpassDependency(
- VulkanHandleMapping* handlemap,
- VkSubpassDependency* toMap)
-{
+void handlemap_VkSubpassDependency(VulkanHandleMapping* handlemap, VkSubpassDependency* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkRenderPassCreateInfo(
- VulkanHandleMapping* handlemap,
- VkRenderPassCreateInfo* toMap)
-{
+void handlemap_VkRenderPassCreateInfo(VulkanHandleMapping* handlemap,
+ VkRenderPassCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->attachmentCount; ++i)
- {
- handlemap_VkAttachmentDescription(handlemap, (VkAttachmentDescription*)(toMap->pAttachments + i));
+ if (toMap) {
+ if (toMap->pAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->attachmentCount; ++i) {
+ handlemap_VkAttachmentDescription(
+ handlemap, (VkAttachmentDescription*)(toMap->pAttachments + i));
}
}
}
- if (toMap)
- {
- if (toMap->pSubpasses)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->subpassCount; ++i)
- {
- handlemap_VkSubpassDescription(handlemap, (VkSubpassDescription*)(toMap->pSubpasses + i));
+ if (toMap) {
+ if (toMap->pSubpasses) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->subpassCount; ++i) {
+ handlemap_VkSubpassDescription(handlemap,
+ (VkSubpassDescription*)(toMap->pSubpasses + i));
}
}
}
- if (toMap)
- {
- if (toMap->pDependencies)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->dependencyCount; ++i)
- {
- handlemap_VkSubpassDependency(handlemap, (VkSubpassDependency*)(toMap->pDependencies + i));
+ if (toMap) {
+ if (toMap->pDependencies) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->dependencyCount; ++i) {
+ handlemap_VkSubpassDependency(handlemap,
+ (VkSubpassDependency*)(toMap->pDependencies + i));
}
}
}
}
-void handlemap_VkCommandPoolCreateInfo(
- VulkanHandleMapping* handlemap,
- VkCommandPoolCreateInfo* toMap)
-{
+void handlemap_VkCommandPoolCreateInfo(VulkanHandleMapping* handlemap,
+ VkCommandPoolCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkCommandBufferAllocateInfo(
- VulkanHandleMapping* handlemap,
- VkCommandBufferAllocateInfo* toMap)
-{
+void handlemap_VkCommandBufferAllocateInfo(VulkanHandleMapping* handlemap,
+ VkCommandBufferAllocateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkCommandPool((VkCommandPool*)&toMap->commandPool);
}
-void handlemap_VkCommandBufferInheritanceInfo(
- VulkanHandleMapping* handlemap,
- VkCommandBufferInheritanceInfo* toMap)
-{
+void handlemap_VkCommandBufferInheritanceInfo(VulkanHandleMapping* handlemap,
+ VkCommandBufferInheritanceInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
handlemap->mapHandles_VkFramebuffer((VkFramebuffer*)&toMap->framebuffer);
}
-void handlemap_VkCommandBufferBeginInfo(
- VulkanHandleMapping* handlemap,
- VkCommandBufferBeginInfo* toMap)
-{
+void handlemap_VkCommandBufferBeginInfo(VulkanHandleMapping* handlemap,
+ VkCommandBufferBeginInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pInheritanceInfo)
- {
- handlemap_VkCommandBufferInheritanceInfo(handlemap, (VkCommandBufferInheritanceInfo*)(toMap->pInheritanceInfo));
+ if (toMap->pInheritanceInfo) {
+ handlemap_VkCommandBufferInheritanceInfo(
+ handlemap, (VkCommandBufferInheritanceInfo*)(toMap->pInheritanceInfo));
}
}
-void handlemap_VkBufferCopy(
- VulkanHandleMapping* handlemap,
- VkBufferCopy* toMap)
-{
+void handlemap_VkBufferCopy(VulkanHandleMapping* handlemap, VkBufferCopy* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkImageSubresourceLayers(
- VulkanHandleMapping* handlemap,
- VkImageSubresourceLayers* toMap)
-{
+void handlemap_VkImageSubresourceLayers(VulkanHandleMapping* handlemap,
+ VkImageSubresourceLayers* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkBufferImageCopy(
- VulkanHandleMapping* handlemap,
- VkBufferImageCopy* toMap)
-{
+void handlemap_VkBufferImageCopy(VulkanHandleMapping* handlemap, VkBufferImageCopy* toMap) {
(void)handlemap;
(void)toMap;
- handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->imageSubresource));
+ handlemap_VkImageSubresourceLayers(handlemap,
+ (VkImageSubresourceLayers*)(&toMap->imageSubresource));
handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->imageOffset));
handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->imageExtent));
}
-void handlemap_VkClearColorValue(
- VulkanHandleMapping* handlemap,
- VkClearColorValue* toMap)
-{
+void handlemap_VkClearColorValue(VulkanHandleMapping* handlemap, VkClearColorValue* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkClearDepthStencilValue(
- VulkanHandleMapping* handlemap,
- VkClearDepthStencilValue* toMap)
-{
+void handlemap_VkClearDepthStencilValue(VulkanHandleMapping* handlemap,
+ VkClearDepthStencilValue* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkClearValue(
- VulkanHandleMapping* handlemap,
- VkClearValue* toMap)
-{
+void handlemap_VkClearValue(VulkanHandleMapping* handlemap, VkClearValue* toMap) {
(void)handlemap;
(void)toMap;
handlemap_VkClearColorValue(handlemap, (VkClearColorValue*)(&toMap->color));
- handlemap_VkClearDepthStencilValue(handlemap, (VkClearDepthStencilValue*)(&toMap->depthStencil));
+ handlemap_VkClearDepthStencilValue(handlemap,
+ (VkClearDepthStencilValue*)(&toMap->depthStencil));
}
-void handlemap_VkClearAttachment(
- VulkanHandleMapping* handlemap,
- VkClearAttachment* toMap)
-{
+void handlemap_VkClearAttachment(VulkanHandleMapping* handlemap, VkClearAttachment* toMap) {
(void)handlemap;
(void)toMap;
handlemap_VkClearValue(handlemap, (VkClearValue*)(&toMap->clearValue));
}
-void handlemap_VkClearRect(
- VulkanHandleMapping* handlemap,
- VkClearRect* toMap)
-{
+void handlemap_VkClearRect(VulkanHandleMapping* handlemap, VkClearRect* toMap) {
(void)handlemap;
(void)toMap;
handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->rect));
}
-void handlemap_VkImageBlit(
- VulkanHandleMapping* handlemap,
- VkImageBlit* toMap)
-{
+void handlemap_VkImageBlit(VulkanHandleMapping* handlemap, VkImageBlit* toMap) {
(void)handlemap;
(void)toMap;
- handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->srcSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ handlemap_VkImageSubresourceLayers(handlemap,
+ (VkImageSubresourceLayers*)(&toMap->srcSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
handlemap_VkOffset3D(handlemap, (VkOffset3D*)(toMap->srcOffsets + i));
}
- handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->dstSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ handlemap_VkImageSubresourceLayers(handlemap,
+ (VkImageSubresourceLayers*)(&toMap->dstSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
handlemap_VkOffset3D(handlemap, (VkOffset3D*)(toMap->dstOffsets + i));
}
}
-void handlemap_VkImageCopy(
- VulkanHandleMapping* handlemap,
- VkImageCopy* toMap)
-{
+void handlemap_VkImageCopy(VulkanHandleMapping* handlemap, VkImageCopy* toMap) {
(void)handlemap;
(void)toMap;
- handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->srcSubresource));
+ handlemap_VkImageSubresourceLayers(handlemap,
+ (VkImageSubresourceLayers*)(&toMap->srcSubresource));
handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->srcOffset));
- handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->dstSubresource));
+ handlemap_VkImageSubresourceLayers(handlemap,
+ (VkImageSubresourceLayers*)(&toMap->dstSubresource));
handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->dstOffset));
handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
}
-void handlemap_VkImageResolve(
- VulkanHandleMapping* handlemap,
- VkImageResolve* toMap)
-{
+void handlemap_VkImageResolve(VulkanHandleMapping* handlemap, VkImageResolve* toMap) {
(void)handlemap;
(void)toMap;
- handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->srcSubresource));
+ handlemap_VkImageSubresourceLayers(handlemap,
+ (VkImageSubresourceLayers*)(&toMap->srcSubresource));
handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->srcOffset));
- handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->dstSubresource));
+ handlemap_VkImageSubresourceLayers(handlemap,
+ (VkImageSubresourceLayers*)(&toMap->dstSubresource));
handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->dstOffset));
handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
}
-void handlemap_VkRenderPassBeginInfo(
- VulkanHandleMapping* handlemap,
- VkRenderPassBeginInfo* toMap)
-{
+void handlemap_VkRenderPassBeginInfo(VulkanHandleMapping* handlemap, VkRenderPassBeginInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
handlemap->mapHandles_VkFramebuffer((VkFramebuffer*)&toMap->framebuffer);
handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->renderArea));
- if (toMap)
- {
- if (toMap->pClearValues)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->clearValueCount; ++i)
- {
+ if (toMap) {
+ if (toMap->pClearValues) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->clearValueCount; ++i) {
handlemap_VkClearValue(handlemap, (VkClearValue*)(toMap->pClearValues + i));
}
}
@@ -1556,1575 +1184,1197 @@
#endif
#ifdef VK_VERSION_1_1
-void handlemap_VkPhysicalDeviceSubgroupProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSubgroupProperties* toMap)
-{
+void handlemap_VkPhysicalDeviceSubgroupProperties(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceSubgroupProperties* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkBindBufferMemoryInfo(
- VulkanHandleMapping* handlemap,
- VkBindBufferMemoryInfo* toMap)
-{
+void handlemap_VkBindBufferMemoryInfo(VulkanHandleMapping* handlemap,
+ VkBindBufferMemoryInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
}
-void handlemap_VkBindImageMemoryInfo(
- VulkanHandleMapping* handlemap,
- VkBindImageMemoryInfo* toMap)
-{
+void handlemap_VkBindImageMemoryInfo(VulkanHandleMapping* handlemap, VkBindImageMemoryInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
}
-void handlemap_VkPhysicalDevice16BitStorageFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevice16BitStorageFeatures* toMap)
-{
+void handlemap_VkPhysicalDevice16BitStorageFeatures(VulkanHandleMapping* handlemap,
+ VkPhysicalDevice16BitStorageFeatures* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkMemoryDedicatedRequirements(
- VulkanHandleMapping* handlemap,
- VkMemoryDedicatedRequirements* toMap)
-{
+void handlemap_VkMemoryDedicatedRequirements(VulkanHandleMapping* handlemap,
+ VkMemoryDedicatedRequirements* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkMemoryDedicatedAllocateInfo(
- VulkanHandleMapping* handlemap,
- VkMemoryDedicatedAllocateInfo* toMap)
-{
+void handlemap_VkMemoryDedicatedAllocateInfo(VulkanHandleMapping* handlemap,
+ VkMemoryDedicatedAllocateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
}
-void handlemap_VkMemoryAllocateFlagsInfo(
- VulkanHandleMapping* handlemap,
- VkMemoryAllocateFlagsInfo* toMap)
-{
+void handlemap_VkMemoryAllocateFlagsInfo(VulkanHandleMapping* handlemap,
+ VkMemoryAllocateFlagsInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDeviceGroupRenderPassBeginInfo(
- VulkanHandleMapping* handlemap,
- VkDeviceGroupRenderPassBeginInfo* toMap)
-{
+void handlemap_VkDeviceGroupRenderPassBeginInfo(VulkanHandleMapping* handlemap,
+ VkDeviceGroupRenderPassBeginInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pDeviceRenderAreas)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->deviceRenderAreaCount; ++i)
- {
+ if (toMap) {
+ if (toMap->pDeviceRenderAreas) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->deviceRenderAreaCount; ++i) {
handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pDeviceRenderAreas + i));
}
}
}
}
-void handlemap_VkDeviceGroupCommandBufferBeginInfo(
- VulkanHandleMapping* handlemap,
- VkDeviceGroupCommandBufferBeginInfo* toMap)
-{
+void handlemap_VkDeviceGroupCommandBufferBeginInfo(VulkanHandleMapping* handlemap,
+ VkDeviceGroupCommandBufferBeginInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDeviceGroupSubmitInfo(
- VulkanHandleMapping* handlemap,
- VkDeviceGroupSubmitInfo* toMap)
-{
+void handlemap_VkDeviceGroupSubmitInfo(VulkanHandleMapping* handlemap,
+ VkDeviceGroupSubmitInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDeviceGroupBindSparseInfo(
- VulkanHandleMapping* handlemap,
- VkDeviceGroupBindSparseInfo* toMap)
-{
+void handlemap_VkDeviceGroupBindSparseInfo(VulkanHandleMapping* handlemap,
+ VkDeviceGroupBindSparseInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkBindBufferMemoryDeviceGroupInfo(
- VulkanHandleMapping* handlemap,
- VkBindBufferMemoryDeviceGroupInfo* toMap)
-{
+void handlemap_VkBindBufferMemoryDeviceGroupInfo(VulkanHandleMapping* handlemap,
+ VkBindBufferMemoryDeviceGroupInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkBindImageMemoryDeviceGroupInfo(
- VulkanHandleMapping* handlemap,
- VkBindImageMemoryDeviceGroupInfo* toMap)
-{
+void handlemap_VkBindImageMemoryDeviceGroupInfo(VulkanHandleMapping* handlemap,
+ VkBindImageMemoryDeviceGroupInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pSplitInstanceBindRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->splitInstanceBindRegionCount; ++i)
- {
+ if (toMap) {
+ if (toMap->pSplitInstanceBindRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->splitInstanceBindRegionCount; ++i) {
handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pSplitInstanceBindRegions + i));
}
}
}
}
-void handlemap_VkPhysicalDeviceGroupProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceGroupProperties* toMap)
-{
+void handlemap_VkPhysicalDeviceGroupProperties(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceGroupProperties* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap->mapHandles_VkPhysicalDevice((VkPhysicalDevice*)toMap->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE);
+ handlemap->mapHandles_VkPhysicalDevice((VkPhysicalDevice*)toMap->physicalDevices,
+ VK_MAX_DEVICE_GROUP_SIZE);
}
-void handlemap_VkDeviceGroupDeviceCreateInfo(
- VulkanHandleMapping* handlemap,
- VkDeviceGroupDeviceCreateInfo* toMap)
-{
+void handlemap_VkDeviceGroupDeviceCreateInfo(VulkanHandleMapping* handlemap,
+ VkDeviceGroupDeviceCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pPhysicalDevices)
- {
- handlemap->mapHandles_VkPhysicalDevice((VkPhysicalDevice*)toMap->pPhysicalDevices, toMap->physicalDeviceCount);
+ if (toMap->pPhysicalDevices) {
+ handlemap->mapHandles_VkPhysicalDevice((VkPhysicalDevice*)toMap->pPhysicalDevices,
+ toMap->physicalDeviceCount);
}
}
-void handlemap_VkBufferMemoryRequirementsInfo2(
- VulkanHandleMapping* handlemap,
- VkBufferMemoryRequirementsInfo2* toMap)
-{
+void handlemap_VkBufferMemoryRequirementsInfo2(VulkanHandleMapping* handlemap,
+ VkBufferMemoryRequirementsInfo2* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
}
-void handlemap_VkImageMemoryRequirementsInfo2(
- VulkanHandleMapping* handlemap,
- VkImageMemoryRequirementsInfo2* toMap)
-{
+void handlemap_VkImageMemoryRequirementsInfo2(VulkanHandleMapping* handlemap,
+ VkImageMemoryRequirementsInfo2* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
}
-void handlemap_VkImageSparseMemoryRequirementsInfo2(
- VulkanHandleMapping* handlemap,
- VkImageSparseMemoryRequirementsInfo2* toMap)
-{
+void handlemap_VkImageSparseMemoryRequirementsInfo2(VulkanHandleMapping* handlemap,
+ VkImageSparseMemoryRequirementsInfo2* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
}
-void handlemap_VkMemoryRequirements2(
- VulkanHandleMapping* handlemap,
- VkMemoryRequirements2* toMap)
-{
+void handlemap_VkMemoryRequirements2(VulkanHandleMapping* handlemap, VkMemoryRequirements2* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkMemoryRequirements(handlemap, (VkMemoryRequirements*)(&toMap->memoryRequirements));
}
-void handlemap_VkSparseImageMemoryRequirements2(
- VulkanHandleMapping* handlemap,
- VkSparseImageMemoryRequirements2* toMap)
-{
+void handlemap_VkSparseImageMemoryRequirements2(VulkanHandleMapping* handlemap,
+ VkSparseImageMemoryRequirements2* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkSparseImageMemoryRequirements(handlemap, (VkSparseImageMemoryRequirements*)(&toMap->memoryRequirements));
+ handlemap_VkSparseImageMemoryRequirements(
+ handlemap, (VkSparseImageMemoryRequirements*)(&toMap->memoryRequirements));
}
-void handlemap_VkPhysicalDeviceFeatures2(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFeatures2* toMap)
-{
+void handlemap_VkPhysicalDeviceFeatures2(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceFeatures2* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkPhysicalDeviceFeatures(handlemap, (VkPhysicalDeviceFeatures*)(&toMap->features));
}
-void handlemap_VkPhysicalDeviceProperties2(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceProperties2* toMap)
-{
+void handlemap_VkPhysicalDeviceProperties2(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceProperties2* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkPhysicalDeviceProperties(handlemap, (VkPhysicalDeviceProperties*)(&toMap->properties));
+ handlemap_VkPhysicalDeviceProperties(handlemap,
+ (VkPhysicalDeviceProperties*)(&toMap->properties));
}
-void handlemap_VkFormatProperties2(
- VulkanHandleMapping* handlemap,
- VkFormatProperties2* toMap)
-{
+void handlemap_VkFormatProperties2(VulkanHandleMapping* handlemap, VkFormatProperties2* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkFormatProperties(handlemap, (VkFormatProperties*)(&toMap->formatProperties));
}
-void handlemap_VkImageFormatProperties2(
- VulkanHandleMapping* handlemap,
- VkImageFormatProperties2* toMap)
-{
+void handlemap_VkImageFormatProperties2(VulkanHandleMapping* handlemap,
+ VkImageFormatProperties2* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkImageFormatProperties(handlemap, (VkImageFormatProperties*)(&toMap->imageFormatProperties));
+ handlemap_VkImageFormatProperties(handlemap,
+ (VkImageFormatProperties*)(&toMap->imageFormatProperties));
}
-void handlemap_VkPhysicalDeviceImageFormatInfo2(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceImageFormatInfo2* toMap)
-{
+void handlemap_VkPhysicalDeviceImageFormatInfo2(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceImageFormatInfo2* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkQueueFamilyProperties2(
- VulkanHandleMapping* handlemap,
- VkQueueFamilyProperties2* toMap)
-{
+void handlemap_VkQueueFamilyProperties2(VulkanHandleMapping* handlemap,
+ VkQueueFamilyProperties2* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkQueueFamilyProperties(handlemap, (VkQueueFamilyProperties*)(&toMap->queueFamilyProperties));
+ handlemap_VkQueueFamilyProperties(handlemap,
+ (VkQueueFamilyProperties*)(&toMap->queueFamilyProperties));
}
-void handlemap_VkPhysicalDeviceMemoryProperties2(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMemoryProperties2* toMap)
-{
+void handlemap_VkPhysicalDeviceMemoryProperties2(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMemoryProperties2* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkPhysicalDeviceMemoryProperties(handlemap, (VkPhysicalDeviceMemoryProperties*)(&toMap->memoryProperties));
+ handlemap_VkPhysicalDeviceMemoryProperties(
+ handlemap, (VkPhysicalDeviceMemoryProperties*)(&toMap->memoryProperties));
}
-void handlemap_VkSparseImageFormatProperties2(
- VulkanHandleMapping* handlemap,
- VkSparseImageFormatProperties2* toMap)
-{
+void handlemap_VkSparseImageFormatProperties2(VulkanHandleMapping* handlemap,
+ VkSparseImageFormatProperties2* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkSparseImageFormatProperties(handlemap, (VkSparseImageFormatProperties*)(&toMap->properties));
+ handlemap_VkSparseImageFormatProperties(handlemap,
+ (VkSparseImageFormatProperties*)(&toMap->properties));
}
void handlemap_VkPhysicalDeviceSparseImageFormatInfo2(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSparseImageFormatInfo2* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceSparseImageFormatInfo2* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDevicePointClippingProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePointClippingProperties* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePointClippingProperties* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkInputAttachmentAspectReference(
- VulkanHandleMapping* handlemap,
- VkInputAttachmentAspectReference* toMap)
-{
+void handlemap_VkInputAttachmentAspectReference(VulkanHandleMapping* handlemap,
+ VkInputAttachmentAspectReference* toMap) {
(void)handlemap;
(void)toMap;
}
void handlemap_VkRenderPassInputAttachmentAspectCreateInfo(
- VulkanHandleMapping* handlemap,
- VkRenderPassInputAttachmentAspectCreateInfo* toMap)
-{
+ VulkanHandleMapping* handlemap, VkRenderPassInputAttachmentAspectCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pAspectReferences)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->aspectReferenceCount; ++i)
- {
- handlemap_VkInputAttachmentAspectReference(handlemap, (VkInputAttachmentAspectReference*)(toMap->pAspectReferences + i));
+ if (toMap) {
+ if (toMap->pAspectReferences) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->aspectReferenceCount; ++i) {
+ handlemap_VkInputAttachmentAspectReference(
+ handlemap, (VkInputAttachmentAspectReference*)(toMap->pAspectReferences + i));
}
}
}
}
-void handlemap_VkImageViewUsageCreateInfo(
- VulkanHandleMapping* handlemap,
- VkImageViewUsageCreateInfo* toMap)
-{
+void handlemap_VkImageViewUsageCreateInfo(VulkanHandleMapping* handlemap,
+ VkImageViewUsageCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPipelineTessellationDomainOriginStateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineTessellationDomainOriginStateCreateInfo* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineTessellationDomainOriginStateCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkRenderPassMultiviewCreateInfo(
- VulkanHandleMapping* handlemap,
- VkRenderPassMultiviewCreateInfo* toMap)
-{
+void handlemap_VkRenderPassMultiviewCreateInfo(VulkanHandleMapping* handlemap,
+ VkRenderPassMultiviewCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPhysicalDeviceMultiviewFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMultiviewFeatures* toMap)
-{
+void handlemap_VkPhysicalDeviceMultiviewFeatures(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMultiviewFeatures* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPhysicalDeviceMultiviewProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMultiviewProperties* toMap)
-{
+void handlemap_VkPhysicalDeviceMultiviewProperties(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMultiviewProperties* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceVariablePointersFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceVariablePointersFeatures* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceVariablePointersFeatures* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceProtectedMemoryFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceProtectedMemoryFeatures* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceProtectedMemoryFeatures* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceProtectedMemoryProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceProtectedMemoryProperties* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceProtectedMemoryProperties* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDeviceQueueInfo2(
- VulkanHandleMapping* handlemap,
- VkDeviceQueueInfo2* toMap)
-{
+void handlemap_VkDeviceQueueInfo2(VulkanHandleMapping* handlemap, VkDeviceQueueInfo2* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkProtectedSubmitInfo(
- VulkanHandleMapping* handlemap,
- VkProtectedSubmitInfo* toMap)
-{
+void handlemap_VkProtectedSubmitInfo(VulkanHandleMapping* handlemap, VkProtectedSubmitInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkSamplerYcbcrConversionCreateInfo(
- VulkanHandleMapping* handlemap,
- VkSamplerYcbcrConversionCreateInfo* toMap)
-{
+void handlemap_VkSamplerYcbcrConversionCreateInfo(VulkanHandleMapping* handlemap,
+ VkSamplerYcbcrConversionCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkComponentMapping(handlemap, (VkComponentMapping*)(&toMap->components));
}
-void handlemap_VkSamplerYcbcrConversionInfo(
- VulkanHandleMapping* handlemap,
- VkSamplerYcbcrConversionInfo* toMap)
-{
+void handlemap_VkSamplerYcbcrConversionInfo(VulkanHandleMapping* handlemap,
+ VkSamplerYcbcrConversionInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkSamplerYcbcrConversion((VkSamplerYcbcrConversion*)&toMap->conversion);
}
-void handlemap_VkBindImagePlaneMemoryInfo(
- VulkanHandleMapping* handlemap,
- VkBindImagePlaneMemoryInfo* toMap)
-{
+void handlemap_VkBindImagePlaneMemoryInfo(VulkanHandleMapping* handlemap,
+ VkBindImagePlaneMemoryInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkImagePlaneMemoryRequirementsInfo(
- VulkanHandleMapping* handlemap,
- VkImagePlaneMemoryRequirementsInfo* toMap)
-{
+void handlemap_VkImagePlaneMemoryRequirementsInfo(VulkanHandleMapping* handlemap,
+ VkImagePlaneMemoryRequirementsInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSamplerYcbcrConversionFeatures* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceSamplerYcbcrConversionFeatures* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkSamplerYcbcrConversionImageFormatProperties(
- VulkanHandleMapping* handlemap,
- VkSamplerYcbcrConversionImageFormatProperties* toMap)
-{
+ VulkanHandleMapping* handlemap, VkSamplerYcbcrConversionImageFormatProperties* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDescriptorUpdateTemplateEntry(
- VulkanHandleMapping* handlemap,
- VkDescriptorUpdateTemplateEntry* toMap)
-{
+void handlemap_VkDescriptorUpdateTemplateEntry(VulkanHandleMapping* handlemap,
+ VkDescriptorUpdateTemplateEntry* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkDescriptorUpdateTemplateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkDescriptorUpdateTemplateCreateInfo* toMap)
-{
+void handlemap_VkDescriptorUpdateTemplateCreateInfo(VulkanHandleMapping* handlemap,
+ VkDescriptorUpdateTemplateCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pDescriptorUpdateEntries)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->descriptorUpdateEntryCount; ++i)
- {
- handlemap_VkDescriptorUpdateTemplateEntry(handlemap, (VkDescriptorUpdateTemplateEntry*)(toMap->pDescriptorUpdateEntries + i));
+ if (toMap) {
+ if (toMap->pDescriptorUpdateEntries) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->descriptorUpdateEntryCount; ++i) {
+ handlemap_VkDescriptorUpdateTemplateEntry(
+ handlemap,
+ (VkDescriptorUpdateTemplateEntry*)(toMap->pDescriptorUpdateEntries + i));
}
}
}
- handlemap->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)&toMap->descriptorSetLayout);
+ handlemap->mapHandles_VkDescriptorSetLayout(
+ (VkDescriptorSetLayout*)&toMap->descriptorSetLayout);
handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->pipelineLayout);
}
-void handlemap_VkExternalMemoryProperties(
- VulkanHandleMapping* handlemap,
- VkExternalMemoryProperties* toMap)
-{
+void handlemap_VkExternalMemoryProperties(VulkanHandleMapping* handlemap,
+ VkExternalMemoryProperties* toMap) {
(void)handlemap;
(void)toMap;
}
void handlemap_VkPhysicalDeviceExternalImageFormatInfo(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceExternalImageFormatInfo* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceExternalImageFormatInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkExternalImageFormatProperties(
- VulkanHandleMapping* handlemap,
- VkExternalImageFormatProperties* toMap)
-{
+void handlemap_VkExternalImageFormatProperties(VulkanHandleMapping* handlemap,
+ VkExternalImageFormatProperties* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkExternalMemoryProperties(handlemap, (VkExternalMemoryProperties*)(&toMap->externalMemoryProperties));
+ handlemap_VkExternalMemoryProperties(
+ handlemap, (VkExternalMemoryProperties*)(&toMap->externalMemoryProperties));
}
-void handlemap_VkPhysicalDeviceExternalBufferInfo(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceExternalBufferInfo* toMap)
-{
+void handlemap_VkPhysicalDeviceExternalBufferInfo(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceExternalBufferInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkExternalBufferProperties(
- VulkanHandleMapping* handlemap,
- VkExternalBufferProperties* toMap)
-{
+void handlemap_VkExternalBufferProperties(VulkanHandleMapping* handlemap,
+ VkExternalBufferProperties* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkExternalMemoryProperties(handlemap, (VkExternalMemoryProperties*)(&toMap->externalMemoryProperties));
+ handlemap_VkExternalMemoryProperties(
+ handlemap, (VkExternalMemoryProperties*)(&toMap->externalMemoryProperties));
}
-void handlemap_VkPhysicalDeviceIDProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceIDProperties* toMap)
-{
+void handlemap_VkPhysicalDeviceIDProperties(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceIDProperties* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkExternalMemoryImageCreateInfo(
- VulkanHandleMapping* handlemap,
- VkExternalMemoryImageCreateInfo* toMap)
-{
+void handlemap_VkExternalMemoryImageCreateInfo(VulkanHandleMapping* handlemap,
+ VkExternalMemoryImageCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkExternalMemoryBufferCreateInfo(
- VulkanHandleMapping* handlemap,
- VkExternalMemoryBufferCreateInfo* toMap)
-{
+void handlemap_VkExternalMemoryBufferCreateInfo(VulkanHandleMapping* handlemap,
+ VkExternalMemoryBufferCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkExportMemoryAllocateInfo(
- VulkanHandleMapping* handlemap,
- VkExportMemoryAllocateInfo* toMap)
-{
+void handlemap_VkExportMemoryAllocateInfo(VulkanHandleMapping* handlemap,
+ VkExportMemoryAllocateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPhysicalDeviceExternalFenceInfo(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceExternalFenceInfo* toMap)
-{
+void handlemap_VkPhysicalDeviceExternalFenceInfo(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceExternalFenceInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkExternalFenceProperties(
- VulkanHandleMapping* handlemap,
- VkExternalFenceProperties* toMap)
-{
+void handlemap_VkExternalFenceProperties(VulkanHandleMapping* handlemap,
+ VkExternalFenceProperties* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkExportFenceCreateInfo(
- VulkanHandleMapping* handlemap,
- VkExportFenceCreateInfo* toMap)
-{
+void handlemap_VkExportFenceCreateInfo(VulkanHandleMapping* handlemap,
+ VkExportFenceCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkExportSemaphoreCreateInfo(
- VulkanHandleMapping* handlemap,
- VkExportSemaphoreCreateInfo* toMap)
-{
+void handlemap_VkExportSemaphoreCreateInfo(VulkanHandleMapping* handlemap,
+ VkExportSemaphoreCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPhysicalDeviceExternalSemaphoreInfo(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceExternalSemaphoreInfo* toMap)
-{
+void handlemap_VkPhysicalDeviceExternalSemaphoreInfo(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceExternalSemaphoreInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkExternalSemaphoreProperties(
- VulkanHandleMapping* handlemap,
- VkExternalSemaphoreProperties* toMap)
-{
+void handlemap_VkExternalSemaphoreProperties(VulkanHandleMapping* handlemap,
+ VkExternalSemaphoreProperties* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceMaintenance3Properties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMaintenance3Properties* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceMaintenance3Properties* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDescriptorSetLayoutSupport(
- VulkanHandleMapping* handlemap,
- VkDescriptorSetLayoutSupport* toMap)
-{
+void handlemap_VkDescriptorSetLayoutSupport(VulkanHandleMapping* handlemap,
+ VkDescriptorSetLayoutSupport* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceShaderDrawParametersFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderDrawParametersFeatures* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderDrawParametersFeatures* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_VERSION_1_2
-void handlemap_VkPhysicalDeviceVulkan11Features(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceVulkan11Features* toMap)
-{
+void handlemap_VkPhysicalDeviceVulkan11Features(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceVulkan11Features* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPhysicalDeviceVulkan11Properties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceVulkan11Properties* toMap)
-{
+void handlemap_VkPhysicalDeviceVulkan11Properties(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceVulkan11Properties* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPhysicalDeviceVulkan12Features(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceVulkan12Features* toMap)
-{
+void handlemap_VkPhysicalDeviceVulkan12Features(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceVulkan12Features* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkConformanceVersion(
- VulkanHandleMapping* handlemap,
- VkConformanceVersion* toMap)
-{
+void handlemap_VkConformanceVersion(VulkanHandleMapping* handlemap, VkConformanceVersion* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkPhysicalDeviceVulkan12Properties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceVulkan12Properties* toMap)
-{
+void handlemap_VkPhysicalDeviceVulkan12Properties(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceVulkan12Properties* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkConformanceVersion(handlemap, (VkConformanceVersion*)(&toMap->conformanceVersion));
}
-void handlemap_VkImageFormatListCreateInfo(
- VulkanHandleMapping* handlemap,
- VkImageFormatListCreateInfo* toMap)
-{
+void handlemap_VkImageFormatListCreateInfo(VulkanHandleMapping* handlemap,
+ VkImageFormatListCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkAttachmentDescription2(
- VulkanHandleMapping* handlemap,
- VkAttachmentDescription2* toMap)
-{
+void handlemap_VkAttachmentDescription2(VulkanHandleMapping* handlemap,
+ VkAttachmentDescription2* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkAttachmentReference2(
- VulkanHandleMapping* handlemap,
- VkAttachmentReference2* toMap)
-{
+void handlemap_VkAttachmentReference2(VulkanHandleMapping* handlemap,
+ VkAttachmentReference2* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkSubpassDescription2(
- VulkanHandleMapping* handlemap,
- VkSubpassDescription2* toMap)
-{
+void handlemap_VkSubpassDescription2(VulkanHandleMapping* handlemap, VkSubpassDescription2* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pInputAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->inputAttachmentCount; ++i)
- {
- handlemap_VkAttachmentReference2(handlemap, (VkAttachmentReference2*)(toMap->pInputAttachments + i));
+ if (toMap) {
+ if (toMap->pInputAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->inputAttachmentCount; ++i) {
+ handlemap_VkAttachmentReference2(
+ handlemap, (VkAttachmentReference2*)(toMap->pInputAttachments + i));
}
}
}
- if (toMap)
- {
- if (toMap->pColorAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i)
- {
- handlemap_VkAttachmentReference2(handlemap, (VkAttachmentReference2*)(toMap->pColorAttachments + i));
+ if (toMap) {
+ if (toMap->pColorAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i) {
+ handlemap_VkAttachmentReference2(
+ handlemap, (VkAttachmentReference2*)(toMap->pColorAttachments + i));
}
}
}
- if (toMap)
- {
- if (toMap->pResolveAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i)
- {
- handlemap_VkAttachmentReference2(handlemap, (VkAttachmentReference2*)(toMap->pResolveAttachments + i));
+ if (toMap) {
+ if (toMap->pResolveAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i) {
+ handlemap_VkAttachmentReference2(
+ handlemap, (VkAttachmentReference2*)(toMap->pResolveAttachments + i));
}
}
}
- if (toMap->pDepthStencilAttachment)
- {
- handlemap_VkAttachmentReference2(handlemap, (VkAttachmentReference2*)(toMap->pDepthStencilAttachment));
+ if (toMap->pDepthStencilAttachment) {
+ handlemap_VkAttachmentReference2(handlemap,
+ (VkAttachmentReference2*)(toMap->pDepthStencilAttachment));
}
}
-void handlemap_VkSubpassDependency2(
- VulkanHandleMapping* handlemap,
- VkSubpassDependency2* toMap)
-{
+void handlemap_VkSubpassDependency2(VulkanHandleMapping* handlemap, VkSubpassDependency2* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkRenderPassCreateInfo2(
- VulkanHandleMapping* handlemap,
- VkRenderPassCreateInfo2* toMap)
-{
+void handlemap_VkRenderPassCreateInfo2(VulkanHandleMapping* handlemap,
+ VkRenderPassCreateInfo2* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->attachmentCount; ++i)
- {
- handlemap_VkAttachmentDescription2(handlemap, (VkAttachmentDescription2*)(toMap->pAttachments + i));
+ if (toMap) {
+ if (toMap->pAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->attachmentCount; ++i) {
+ handlemap_VkAttachmentDescription2(
+ handlemap, (VkAttachmentDescription2*)(toMap->pAttachments + i));
}
}
}
- if (toMap)
- {
- if (toMap->pSubpasses)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->subpassCount; ++i)
- {
- handlemap_VkSubpassDescription2(handlemap, (VkSubpassDescription2*)(toMap->pSubpasses + i));
+ if (toMap) {
+ if (toMap->pSubpasses) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->subpassCount; ++i) {
+ handlemap_VkSubpassDescription2(handlemap,
+ (VkSubpassDescription2*)(toMap->pSubpasses + i));
}
}
}
- if (toMap)
- {
- if (toMap->pDependencies)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->dependencyCount; ++i)
- {
- handlemap_VkSubpassDependency2(handlemap, (VkSubpassDependency2*)(toMap->pDependencies + i));
+ if (toMap) {
+ if (toMap->pDependencies) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->dependencyCount; ++i) {
+ handlemap_VkSubpassDependency2(handlemap,
+ (VkSubpassDependency2*)(toMap->pDependencies + i));
}
}
}
}
-void handlemap_VkSubpassBeginInfo(
- VulkanHandleMapping* handlemap,
- VkSubpassBeginInfo* toMap)
-{
+void handlemap_VkSubpassBeginInfo(VulkanHandleMapping* handlemap, VkSubpassBeginInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkSubpassEndInfo(
- VulkanHandleMapping* handlemap,
- VkSubpassEndInfo* toMap)
-{
+void handlemap_VkSubpassEndInfo(VulkanHandleMapping* handlemap, VkSubpassEndInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPhysicalDevice8BitStorageFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevice8BitStorageFeatures* toMap)
-{
+void handlemap_VkPhysicalDevice8BitStorageFeatures(VulkanHandleMapping* handlemap,
+ VkPhysicalDevice8BitStorageFeatures* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPhysicalDeviceDriverProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDriverProperties* toMap)
-{
+void handlemap_VkPhysicalDeviceDriverProperties(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceDriverProperties* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkConformanceVersion(handlemap, (VkConformanceVersion*)(&toMap->conformanceVersion));
}
void handlemap_VkPhysicalDeviceShaderAtomicInt64Features(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderAtomicInt64Features* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderAtomicInt64Features* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceShaderFloat16Int8Features(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderFloat16Int8Features* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderFloat16Int8Features* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceFloatControlsProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFloatControlsProperties* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFloatControlsProperties* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfo(
- VulkanHandleMapping* handlemap,
- VkDescriptorSetLayoutBindingFlagsCreateInfo* toMap)
-{
+ VulkanHandleMapping* handlemap, VkDescriptorSetLayoutBindingFlagsCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceDescriptorIndexingFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDescriptorIndexingFeatures* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDescriptorIndexingFeatures* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceDescriptorIndexingProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDescriptorIndexingProperties* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDescriptorIndexingProperties* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfo(
- VulkanHandleMapping* handlemap,
- VkDescriptorSetVariableDescriptorCountAllocateInfo* toMap)
-{
+ VulkanHandleMapping* handlemap, VkDescriptorSetVariableDescriptorCountAllocateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupport(
- VulkanHandleMapping* handlemap,
- VkDescriptorSetVariableDescriptorCountLayoutSupport* toMap)
-{
+ VulkanHandleMapping* handlemap, VkDescriptorSetVariableDescriptorCountLayoutSupport* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkSubpassDescriptionDepthStencilResolve(
- VulkanHandleMapping* handlemap,
- VkSubpassDescriptionDepthStencilResolve* toMap)
-{
+ VulkanHandleMapping* handlemap, VkSubpassDescriptionDepthStencilResolve* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pDepthStencilResolveAttachment)
- {
- handlemap_VkAttachmentReference2(handlemap, (VkAttachmentReference2*)(toMap->pDepthStencilResolveAttachment));
+ if (toMap->pDepthStencilResolveAttachment) {
+ handlemap_VkAttachmentReference2(
+ handlemap, (VkAttachmentReference2*)(toMap->pDepthStencilResolveAttachment));
}
}
void handlemap_VkPhysicalDeviceDepthStencilResolveProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDepthStencilResolveProperties* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDepthStencilResolveProperties* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceScalarBlockLayoutFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceScalarBlockLayoutFeatures* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceScalarBlockLayoutFeatures* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkImageStencilUsageCreateInfo(
- VulkanHandleMapping* handlemap,
- VkImageStencilUsageCreateInfo* toMap)
-{
+void handlemap_VkImageStencilUsageCreateInfo(VulkanHandleMapping* handlemap,
+ VkImageStencilUsageCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkSamplerReductionModeCreateInfo(
- VulkanHandleMapping* handlemap,
- VkSamplerReductionModeCreateInfo* toMap)
-{
+void handlemap_VkSamplerReductionModeCreateInfo(VulkanHandleMapping* handlemap,
+ VkSamplerReductionModeCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceSamplerFilterMinmaxProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSamplerFilterMinmaxProperties* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceSamplerFilterMinmaxProperties* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceVulkanMemoryModelFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceVulkanMemoryModelFeatures* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceVulkanMemoryModelFeatures* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceImagelessFramebufferFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceImagelessFramebufferFeatures* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceImagelessFramebufferFeatures* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkFramebufferAttachmentImageInfo(
- VulkanHandleMapping* handlemap,
- VkFramebufferAttachmentImageInfo* toMap)
-{
+void handlemap_VkFramebufferAttachmentImageInfo(VulkanHandleMapping* handlemap,
+ VkFramebufferAttachmentImageInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkFramebufferAttachmentsCreateInfo(
- VulkanHandleMapping* handlemap,
- VkFramebufferAttachmentsCreateInfo* toMap)
-{
+void handlemap_VkFramebufferAttachmentsCreateInfo(VulkanHandleMapping* handlemap,
+ VkFramebufferAttachmentsCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pAttachmentImageInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->attachmentImageInfoCount; ++i)
- {
- handlemap_VkFramebufferAttachmentImageInfo(handlemap, (VkFramebufferAttachmentImageInfo*)(toMap->pAttachmentImageInfos + i));
+ if (toMap) {
+ if (toMap->pAttachmentImageInfos) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->attachmentImageInfoCount; ++i) {
+ handlemap_VkFramebufferAttachmentImageInfo(
+ handlemap,
+ (VkFramebufferAttachmentImageInfo*)(toMap->pAttachmentImageInfos + i));
}
}
}
}
-void handlemap_VkRenderPassAttachmentBeginInfo(
- VulkanHandleMapping* handlemap,
- VkRenderPassAttachmentBeginInfo* toMap)
-{
+void handlemap_VkRenderPassAttachmentBeginInfo(VulkanHandleMapping* handlemap,
+ VkRenderPassAttachmentBeginInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pAttachments)
- {
- handlemap->mapHandles_VkImageView((VkImageView*)toMap->pAttachments, toMap->attachmentCount);
+ if (toMap->pAttachments) {
+ handlemap->mapHandles_VkImageView((VkImageView*)toMap->pAttachments,
+ toMap->attachmentCount);
}
}
void handlemap_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceUniformBufferStandardLayoutFeatures* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceUniformBufferStandardLayoutFeatures* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkAttachmentReferenceStencilLayout(
- VulkanHandleMapping* handlemap,
- VkAttachmentReferenceStencilLayout* toMap)
-{
+void handlemap_VkAttachmentReferenceStencilLayout(VulkanHandleMapping* handlemap,
+ VkAttachmentReferenceStencilLayout* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkAttachmentDescriptionStencilLayout(
- VulkanHandleMapping* handlemap,
- VkAttachmentDescriptionStencilLayout* toMap)
-{
+void handlemap_VkAttachmentDescriptionStencilLayout(VulkanHandleMapping* handlemap,
+ VkAttachmentDescriptionStencilLayout* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceHostQueryResetFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceHostQueryResetFeatures* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceHostQueryResetFeatures* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceTimelineSemaphoreFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceTimelineSemaphoreFeatures* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceTimelineSemaphoreFeatures* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceTimelineSemaphoreProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceTimelineSemaphoreProperties* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceTimelineSemaphoreProperties* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkSemaphoreTypeCreateInfo(
- VulkanHandleMapping* handlemap,
- VkSemaphoreTypeCreateInfo* toMap)
-{
+void handlemap_VkSemaphoreTypeCreateInfo(VulkanHandleMapping* handlemap,
+ VkSemaphoreTypeCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkTimelineSemaphoreSubmitInfo(
- VulkanHandleMapping* handlemap,
- VkTimelineSemaphoreSubmitInfo* toMap)
-{
+void handlemap_VkTimelineSemaphoreSubmitInfo(VulkanHandleMapping* handlemap,
+ VkTimelineSemaphoreSubmitInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkSemaphoreWaitInfo(
- VulkanHandleMapping* handlemap,
- VkSemaphoreWaitInfo* toMap)
-{
+void handlemap_VkSemaphoreWaitInfo(VulkanHandleMapping* handlemap, VkSemaphoreWaitInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pSemaphores)
- {
+ if (toMap->pSemaphores) {
handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pSemaphores, toMap->semaphoreCount);
}
}
-void handlemap_VkSemaphoreSignalInfo(
- VulkanHandleMapping* handlemap,
- VkSemaphoreSignalInfo* toMap)
-{
+void handlemap_VkSemaphoreSignalInfo(VulkanHandleMapping* handlemap, VkSemaphoreSignalInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
}
void handlemap_VkPhysicalDeviceBufferDeviceAddressFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceBufferDeviceAddressFeatures* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceBufferDeviceAddressFeatures* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkBufferDeviceAddressInfo(
- VulkanHandleMapping* handlemap,
- VkBufferDeviceAddressInfo* toMap)
-{
+void handlemap_VkBufferDeviceAddressInfo(VulkanHandleMapping* handlemap,
+ VkBufferDeviceAddressInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
}
void handlemap_VkBufferOpaqueCaptureAddressCreateInfo(
- VulkanHandleMapping* handlemap,
- VkBufferOpaqueCaptureAddressCreateInfo* toMap)
-{
+ VulkanHandleMapping* handlemap, VkBufferOpaqueCaptureAddressCreateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkMemoryOpaqueCaptureAddressAllocateInfo(
- VulkanHandleMapping* handlemap,
- VkMemoryOpaqueCaptureAddressAllocateInfo* toMap)
-{
+ VulkanHandleMapping* handlemap, VkMemoryOpaqueCaptureAddressAllocateInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkDeviceMemoryOpaqueCaptureAddressInfo(
- VulkanHandleMapping* handlemap,
- VkDeviceMemoryOpaqueCaptureAddressInfo* toMap)
-{
+ VulkanHandleMapping* handlemap, VkDeviceMemoryOpaqueCaptureAddressInfo* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
@@ -3132,10 +2382,8 @@
#endif
#ifdef VK_KHR_surface
-void handlemap_VkSurfaceCapabilitiesKHR(
- VulkanHandleMapping* handlemap,
- VkSurfaceCapabilitiesKHR* toMap)
-{
+void handlemap_VkSurfaceCapabilitiesKHR(VulkanHandleMapping* handlemap,
+ VkSurfaceCapabilitiesKHR* toMap) {
(void)handlemap;
(void)toMap;
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->currentExtent));
@@ -3143,24 +2391,18 @@
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxImageExtent));
}
-void handlemap_VkSurfaceFormatKHR(
- VulkanHandleMapping* handlemap,
- VkSurfaceFormatKHR* toMap)
-{
+void handlemap_VkSurfaceFormatKHR(VulkanHandleMapping* handlemap, VkSurfaceFormatKHR* toMap) {
(void)handlemap;
(void)toMap;
}
#endif
#ifdef VK_KHR_swapchain
-void handlemap_VkSwapchainCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkSwapchainCreateInfoKHR* toMap)
-{
+void handlemap_VkSwapchainCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkSwapchainCreateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkSurfaceKHR((VkSurfaceKHR*)&toMap->surface);
@@ -3168,60 +2410,47 @@
handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->oldSwapchain);
}
-void handlemap_VkPresentInfoKHR(
- VulkanHandleMapping* handlemap,
- VkPresentInfoKHR* toMap)
-{
+void handlemap_VkPresentInfoKHR(VulkanHandleMapping* handlemap, VkPresentInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pWaitSemaphores)
- {
- handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pWaitSemaphores, toMap->waitSemaphoreCount);
+ if (toMap->pWaitSemaphores) {
+ handlemap->mapHandles_VkSemaphore((VkSemaphore*)toMap->pWaitSemaphores,
+ toMap->waitSemaphoreCount);
}
- if (toMap->pSwapchains)
- {
- handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)toMap->pSwapchains, toMap->swapchainCount);
+ if (toMap->pSwapchains) {
+ handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)toMap->pSwapchains,
+ toMap->swapchainCount);
}
}
-void handlemap_VkImageSwapchainCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkImageSwapchainCreateInfoKHR* toMap)
-{
+void handlemap_VkImageSwapchainCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkImageSwapchainCreateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->swapchain);
}
-void handlemap_VkBindImageMemorySwapchainInfoKHR(
- VulkanHandleMapping* handlemap,
- VkBindImageMemorySwapchainInfoKHR* toMap)
-{
+void handlemap_VkBindImageMemorySwapchainInfoKHR(VulkanHandleMapping* handlemap,
+ VkBindImageMemorySwapchainInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->swapchain);
}
-void handlemap_VkAcquireNextImageInfoKHR(
- VulkanHandleMapping* handlemap,
- VkAcquireNextImageInfoKHR* toMap)
-{
+void handlemap_VkAcquireNextImageInfoKHR(VulkanHandleMapping* handlemap,
+ VkAcquireNextImageInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->swapchain);
@@ -3229,80 +2458,64 @@
handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
}
-void handlemap_VkDeviceGroupPresentCapabilitiesKHR(
- VulkanHandleMapping* handlemap,
- VkDeviceGroupPresentCapabilitiesKHR* toMap)
-{
+void handlemap_VkDeviceGroupPresentCapabilitiesKHR(VulkanHandleMapping* handlemap,
+ VkDeviceGroupPresentCapabilitiesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDeviceGroupPresentInfoKHR(
- VulkanHandleMapping* handlemap,
- VkDeviceGroupPresentInfoKHR* toMap)
-{
+void handlemap_VkDeviceGroupPresentInfoKHR(VulkanHandleMapping* handlemap,
+ VkDeviceGroupPresentInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDeviceGroupSwapchainCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkDeviceGroupSwapchainCreateInfoKHR* toMap)
-{
+void handlemap_VkDeviceGroupSwapchainCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkDeviceGroupSwapchainCreateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_KHR_display
-void handlemap_VkDisplayModeParametersKHR(
- VulkanHandleMapping* handlemap,
- VkDisplayModeParametersKHR* toMap)
-{
+void handlemap_VkDisplayModeParametersKHR(VulkanHandleMapping* handlemap,
+ VkDisplayModeParametersKHR* toMap) {
(void)handlemap;
(void)toMap;
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->visibleRegion));
}
-void handlemap_VkDisplayModeCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkDisplayModeCreateInfoKHR* toMap)
-{
+void handlemap_VkDisplayModeCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkDisplayModeCreateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkDisplayModeParametersKHR(handlemap, (VkDisplayModeParametersKHR*)(&toMap->parameters));
+ handlemap_VkDisplayModeParametersKHR(handlemap,
+ (VkDisplayModeParametersKHR*)(&toMap->parameters));
}
-void handlemap_VkDisplayModePropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkDisplayModePropertiesKHR* toMap)
-{
+void handlemap_VkDisplayModePropertiesKHR(VulkanHandleMapping* handlemap,
+ VkDisplayModePropertiesKHR* toMap) {
(void)handlemap;
(void)toMap;
handlemap->mapHandles_VkDisplayModeKHR((VkDisplayModeKHR*)&toMap->displayMode);
- handlemap_VkDisplayModeParametersKHR(handlemap, (VkDisplayModeParametersKHR*)(&toMap->parameters));
+ handlemap_VkDisplayModeParametersKHR(handlemap,
+ (VkDisplayModeParametersKHR*)(&toMap->parameters));
}
-void handlemap_VkDisplayPlaneCapabilitiesKHR(
- VulkanHandleMapping* handlemap,
- VkDisplayPlaneCapabilitiesKHR* toMap)
-{
+void handlemap_VkDisplayPlaneCapabilitiesKHR(VulkanHandleMapping* handlemap,
+ VkDisplayPlaneCapabilitiesKHR* toMap) {
(void)handlemap;
(void)toMap;
handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->minSrcPosition));
@@ -3315,19 +2528,15 @@
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxDstExtent));
}
-void handlemap_VkDisplayPlanePropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkDisplayPlanePropertiesKHR* toMap)
-{
+void handlemap_VkDisplayPlanePropertiesKHR(VulkanHandleMapping* handlemap,
+ VkDisplayPlanePropertiesKHR* toMap) {
(void)handlemap;
(void)toMap;
handlemap->mapHandles_VkDisplayKHR((VkDisplayKHR*)&toMap->currentDisplay);
}
-void handlemap_VkDisplayPropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkDisplayPropertiesKHR* toMap)
-{
+void handlemap_VkDisplayPropertiesKHR(VulkanHandleMapping* handlemap,
+ VkDisplayPropertiesKHR* toMap) {
(void)handlemap;
(void)toMap;
handlemap->mapHandles_VkDisplayKHR((VkDisplayKHR*)&toMap->display);
@@ -3335,14 +2544,11 @@
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->physicalResolution));
}
-void handlemap_VkDisplaySurfaceCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkDisplaySurfaceCreateInfoKHR* toMap)
-{
+void handlemap_VkDisplaySurfaceCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkDisplaySurfaceCreateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkDisplayModeKHR((VkDisplayModeKHR*)&toMap->displayMode);
@@ -3351,14 +2557,11 @@
#endif
#ifdef VK_KHR_display_swapchain
-void handlemap_VkDisplayPresentInfoKHR(
- VulkanHandleMapping* handlemap,
- VkDisplayPresentInfoKHR* toMap)
-{
+void handlemap_VkDisplayPresentInfoKHR(VulkanHandleMapping* handlemap,
+ VkDisplayPresentInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->srcRect));
@@ -3367,70 +2570,55 @@
#endif
#ifdef VK_KHR_xlib_surface
-void handlemap_VkXlibSurfaceCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkXlibSurfaceCreateInfoKHR* toMap)
-{
+void handlemap_VkXlibSurfaceCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkXlibSurfaceCreateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_KHR_xcb_surface
-void handlemap_VkXcbSurfaceCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkXcbSurfaceCreateInfoKHR* toMap)
-{
+void handlemap_VkXcbSurfaceCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkXcbSurfaceCreateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_KHR_wayland_surface
-void handlemap_VkWaylandSurfaceCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkWaylandSurfaceCreateInfoKHR* toMap)
-{
+void handlemap_VkWaylandSurfaceCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkWaylandSurfaceCreateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_KHR_android_surface
-void handlemap_VkAndroidSurfaceCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkAndroidSurfaceCreateInfoKHR* toMap)
-{
+void handlemap_VkAndroidSurfaceCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkAndroidSurfaceCreateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_KHR_win32_surface
-void handlemap_VkWin32SurfaceCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkWin32SurfaceCreateInfoKHR* toMap)
-{
+void handlemap_VkWin32SurfaceCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkWin32SurfaceCreateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -3439,54 +2627,39 @@
#ifdef VK_KHR_sampler_mirror_clamp_to_edge
#endif
#ifdef VK_KHR_video_queue
-void handlemap_VkVideoQueueFamilyProperties2KHR(
- VulkanHandleMapping* handlemap,
- VkVideoQueueFamilyProperties2KHR* toMap)
-{
+void handlemap_VkVideoQueueFamilyProperties2KHR(VulkanHandleMapping* handlemap,
+ VkVideoQueueFamilyProperties2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkVideoProfileKHR(
- VulkanHandleMapping* handlemap,
- VkVideoProfileKHR* toMap)
-{
+void handlemap_VkVideoProfileKHR(VulkanHandleMapping* handlemap, VkVideoProfileKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkVideoProfilesKHR(
- VulkanHandleMapping* handlemap,
- VkVideoProfilesKHR* toMap)
-{
+void handlemap_VkVideoProfilesKHR(VulkanHandleMapping* handlemap, VkVideoProfilesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pProfiles)
- {
+ if (toMap->pProfiles) {
handlemap_VkVideoProfileKHR(handlemap, (VkVideoProfileKHR*)(toMap->pProfiles));
}
}
-void handlemap_VkVideoCapabilitiesKHR(
- VulkanHandleMapping* handlemap,
- VkVideoCapabilitiesKHR* toMap)
-{
+void handlemap_VkVideoCapabilitiesKHR(VulkanHandleMapping* handlemap,
+ VkVideoCapabilitiesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->videoPictureExtentGranularity));
@@ -3494,42 +2667,32 @@
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxExtent));
}
-void handlemap_VkPhysicalDeviceVideoFormatInfoKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceVideoFormatInfoKHR* toMap)
-{
+void handlemap_VkPhysicalDeviceVideoFormatInfoKHR(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceVideoFormatInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pVideoProfiles)
- {
+ if (toMap->pVideoProfiles) {
handlemap_VkVideoProfilesKHR(handlemap, (VkVideoProfilesKHR*)(toMap->pVideoProfiles));
}
}
-void handlemap_VkVideoFormatPropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkVideoFormatPropertiesKHR* toMap)
-{
+void handlemap_VkVideoFormatPropertiesKHR(VulkanHandleMapping* handlemap,
+ VkVideoFormatPropertiesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkVideoPictureResourceKHR(
- VulkanHandleMapping* handlemap,
- VkVideoPictureResourceKHR* toMap)
-{
+void handlemap_VkVideoPictureResourceKHR(VulkanHandleMapping* handlemap,
+ VkVideoPictureResourceKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->codedOffset));
@@ -3537,169 +2700,135 @@
handlemap->mapHandles_VkImageView((VkImageView*)&toMap->imageViewBinding);
}
-void handlemap_VkVideoReferenceSlotKHR(
- VulkanHandleMapping* handlemap,
- VkVideoReferenceSlotKHR* toMap)
-{
+void handlemap_VkVideoReferenceSlotKHR(VulkanHandleMapping* handlemap,
+ VkVideoReferenceSlotKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pPictureResource)
- {
- handlemap_VkVideoPictureResourceKHR(handlemap, (VkVideoPictureResourceKHR*)(toMap->pPictureResource));
+ if (toMap->pPictureResource) {
+ handlemap_VkVideoPictureResourceKHR(handlemap,
+ (VkVideoPictureResourceKHR*)(toMap->pPictureResource));
}
}
-void handlemap_VkVideoGetMemoryPropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkVideoGetMemoryPropertiesKHR* toMap)
-{
+void handlemap_VkVideoGetMemoryPropertiesKHR(VulkanHandleMapping* handlemap,
+ VkVideoGetMemoryPropertiesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pMemoryRequirements)
- {
- handlemap_VkMemoryRequirements2(handlemap, (VkMemoryRequirements2*)(toMap->pMemoryRequirements));
+ if (toMap->pMemoryRequirements) {
+ handlemap_VkMemoryRequirements2(handlemap,
+ (VkMemoryRequirements2*)(toMap->pMemoryRequirements));
}
}
-void handlemap_VkVideoBindMemoryKHR(
- VulkanHandleMapping* handlemap,
- VkVideoBindMemoryKHR* toMap)
-{
+void handlemap_VkVideoBindMemoryKHR(VulkanHandleMapping* handlemap, VkVideoBindMemoryKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
}
-void handlemap_VkVideoSessionCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkVideoSessionCreateInfoKHR* toMap)
-{
+void handlemap_VkVideoSessionCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkVideoSessionCreateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pVideoProfile)
- {
+ if (toMap->pVideoProfile) {
handlemap_VkVideoProfileKHR(handlemap, (VkVideoProfileKHR*)(toMap->pVideoProfile));
}
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxCodedExtent));
}
-void handlemap_VkVideoSessionParametersCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkVideoSessionParametersCreateInfoKHR* toMap)
-{
+void handlemap_VkVideoSessionParametersCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkVideoSessionParametersCreateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap->mapHandles_VkVideoSessionParametersKHR((VkVideoSessionParametersKHR*)&toMap->videoSessionParametersTemplate);
+ handlemap->mapHandles_VkVideoSessionParametersKHR(
+ (VkVideoSessionParametersKHR*)&toMap->videoSessionParametersTemplate);
handlemap->mapHandles_VkVideoSessionKHR((VkVideoSessionKHR*)&toMap->videoSession);
}
-void handlemap_VkVideoSessionParametersUpdateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkVideoSessionParametersUpdateInfoKHR* toMap)
-{
+void handlemap_VkVideoSessionParametersUpdateInfoKHR(VulkanHandleMapping* handlemap,
+ VkVideoSessionParametersUpdateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkVideoBeginCodingInfoKHR(
- VulkanHandleMapping* handlemap,
- VkVideoBeginCodingInfoKHR* toMap)
-{
+void handlemap_VkVideoBeginCodingInfoKHR(VulkanHandleMapping* handlemap,
+ VkVideoBeginCodingInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkVideoSessionKHR((VkVideoSessionKHR*)&toMap->videoSession);
- handlemap->mapHandles_VkVideoSessionParametersKHR((VkVideoSessionParametersKHR*)&toMap->videoSessionParameters);
- if (toMap)
- {
- if (toMap->pReferenceSlots)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->referenceSlotCount; ++i)
- {
- handlemap_VkVideoReferenceSlotKHR(handlemap, (VkVideoReferenceSlotKHR*)(toMap->pReferenceSlots + i));
+ handlemap->mapHandles_VkVideoSessionParametersKHR(
+ (VkVideoSessionParametersKHR*)&toMap->videoSessionParameters);
+ if (toMap) {
+ if (toMap->pReferenceSlots) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->referenceSlotCount; ++i) {
+ handlemap_VkVideoReferenceSlotKHR(
+ handlemap, (VkVideoReferenceSlotKHR*)(toMap->pReferenceSlots + i));
}
}
}
}
-void handlemap_VkVideoEndCodingInfoKHR(
- VulkanHandleMapping* handlemap,
- VkVideoEndCodingInfoKHR* toMap)
-{
+void handlemap_VkVideoEndCodingInfoKHR(VulkanHandleMapping* handlemap,
+ VkVideoEndCodingInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkVideoCodingControlInfoKHR(
- VulkanHandleMapping* handlemap,
- VkVideoCodingControlInfoKHR* toMap)
-{
+void handlemap_VkVideoCodingControlInfoKHR(VulkanHandleMapping* handlemap,
+ VkVideoCodingControlInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_KHR_video_decode_queue
-void handlemap_VkVideoDecodeInfoKHR(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeInfoKHR* toMap)
-{
+void handlemap_VkVideoDecodeInfoKHR(VulkanHandleMapping* handlemap, VkVideoDecodeInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->codedOffset));
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->codedExtent));
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->srcBuffer);
- handlemap_VkVideoPictureResourceKHR(handlemap, (VkVideoPictureResourceKHR*)(&toMap->dstPictureResource));
- if (toMap->pSetupReferenceSlot)
- {
- handlemap_VkVideoReferenceSlotKHR(handlemap, (VkVideoReferenceSlotKHR*)(toMap->pSetupReferenceSlot));
+ handlemap_VkVideoPictureResourceKHR(handlemap,
+ (VkVideoPictureResourceKHR*)(&toMap->dstPictureResource));
+ if (toMap->pSetupReferenceSlot) {
+ handlemap_VkVideoReferenceSlotKHR(handlemap,
+ (VkVideoReferenceSlotKHR*)(toMap->pSetupReferenceSlot));
}
- if (toMap)
- {
- if (toMap->pReferenceSlots)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->referenceSlotCount; ++i)
- {
- handlemap_VkVideoReferenceSlotKHR(handlemap, (VkVideoReferenceSlotKHR*)(toMap->pReferenceSlots + i));
+ if (toMap) {
+ if (toMap->pReferenceSlots) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->referenceSlotCount; ++i) {
+ handlemap_VkVideoReferenceSlotKHR(
+ handlemap, (VkVideoReferenceSlotKHR*)(toMap->pReferenceSlots + i));
}
}
}
@@ -3707,14 +2836,11 @@
#endif
#ifdef VK_KHR_dynamic_rendering
-void handlemap_VkRenderingAttachmentInfoKHR(
- VulkanHandleMapping* handlemap,
- VkRenderingAttachmentInfoKHR* toMap)
-{
+void handlemap_VkRenderingAttachmentInfoKHR(VulkanHandleMapping* handlemap,
+ VkRenderingAttachmentInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkImageView((VkImageView*)&toMap->imageView);
@@ -3722,81 +2848,63 @@
handlemap_VkClearValue(handlemap, (VkClearValue*)(&toMap->clearValue));
}
-void handlemap_VkRenderingInfoKHR(
- VulkanHandleMapping* handlemap,
- VkRenderingInfoKHR* toMap)
-{
+void handlemap_VkRenderingInfoKHR(VulkanHandleMapping* handlemap, VkRenderingInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->renderArea));
- if (toMap)
- {
- if (toMap->pColorAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i)
- {
- handlemap_VkRenderingAttachmentInfoKHR(handlemap, (VkRenderingAttachmentInfoKHR*)(toMap->pColorAttachments + i));
+ if (toMap) {
+ if (toMap->pColorAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i) {
+ handlemap_VkRenderingAttachmentInfoKHR(
+ handlemap, (VkRenderingAttachmentInfoKHR*)(toMap->pColorAttachments + i));
}
}
}
- if (toMap->pDepthAttachment)
- {
- handlemap_VkRenderingAttachmentInfoKHR(handlemap, (VkRenderingAttachmentInfoKHR*)(toMap->pDepthAttachment));
+ if (toMap->pDepthAttachment) {
+ handlemap_VkRenderingAttachmentInfoKHR(
+ handlemap, (VkRenderingAttachmentInfoKHR*)(toMap->pDepthAttachment));
}
- if (toMap->pStencilAttachment)
- {
- handlemap_VkRenderingAttachmentInfoKHR(handlemap, (VkRenderingAttachmentInfoKHR*)(toMap->pStencilAttachment));
+ if (toMap->pStencilAttachment) {
+ handlemap_VkRenderingAttachmentInfoKHR(
+ handlemap, (VkRenderingAttachmentInfoKHR*)(toMap->pStencilAttachment));
}
}
-void handlemap_VkPipelineRenderingCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkPipelineRenderingCreateInfoKHR* toMap)
-{
+void handlemap_VkPipelineRenderingCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkPipelineRenderingCreateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDynamicRenderingFeaturesKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDynamicRenderingFeaturesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkCommandBufferInheritanceRenderingInfoKHR(
- VulkanHandleMapping* handlemap,
- VkCommandBufferInheritanceRenderingInfoKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkCommandBufferInheritanceRenderingInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- VulkanHandleMapping* handlemap,
- VkRenderingFragmentShadingRateAttachmentInfoKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkRenderingFragmentShadingRateAttachmentInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkImageView((VkImageView*)&toMap->imageView);
@@ -3804,38 +2912,29 @@
}
void handlemap_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- VulkanHandleMapping* handlemap,
- VkRenderingFragmentDensityMapAttachmentInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkRenderingFragmentDensityMapAttachmentInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkImageView((VkImageView*)&toMap->imageView);
}
-void handlemap_VkAttachmentSampleCountInfoAMD(
- VulkanHandleMapping* handlemap,
- VkAttachmentSampleCountInfoAMD* toMap)
-{
+void handlemap_VkAttachmentSampleCountInfoAMD(VulkanHandleMapping* handlemap,
+ VkAttachmentSampleCountInfoAMD* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkMultiviewPerViewAttributesInfoNVX(
- VulkanHandleMapping* handlemap,
- VkMultiviewPerViewAttributesInfoNVX* toMap)
-{
+void handlemap_VkMultiviewPerViewAttributesInfoNVX(VulkanHandleMapping* handlemap,
+ VkMultiviewPerViewAttributesInfoNVX* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -3858,50 +2957,38 @@
#ifdef VK_KHR_external_memory
#endif
#ifdef VK_KHR_external_memory_win32
-void handlemap_VkImportMemoryWin32HandleInfoKHR(
- VulkanHandleMapping* handlemap,
- VkImportMemoryWin32HandleInfoKHR* toMap)
-{
+void handlemap_VkImportMemoryWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
+ VkImportMemoryWin32HandleInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkExportMemoryWin32HandleInfoKHR(
- VulkanHandleMapping* handlemap,
- VkExportMemoryWin32HandleInfoKHR* toMap)
-{
+void handlemap_VkExportMemoryWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
+ VkExportMemoryWin32HandleInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkMemoryWin32HandlePropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkMemoryWin32HandlePropertiesKHR* toMap)
-{
+void handlemap_VkMemoryWin32HandlePropertiesKHR(VulkanHandleMapping* handlemap,
+ VkMemoryWin32HandlePropertiesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkMemoryGetWin32HandleInfoKHR(
- VulkanHandleMapping* handlemap,
- VkMemoryGetWin32HandleInfoKHR* toMap)
-{
+void handlemap_VkMemoryGetWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
+ VkMemoryGetWin32HandleInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
@@ -3909,38 +2996,28 @@
#endif
#ifdef VK_KHR_external_memory_fd
-void handlemap_VkImportMemoryFdInfoKHR(
- VulkanHandleMapping* handlemap,
- VkImportMemoryFdInfoKHR* toMap)
-{
+void handlemap_VkImportMemoryFdInfoKHR(VulkanHandleMapping* handlemap,
+ VkImportMemoryFdInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkMemoryFdPropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkMemoryFdPropertiesKHR* toMap)
-{
+void handlemap_VkMemoryFdPropertiesKHR(VulkanHandleMapping* handlemap,
+ VkMemoryFdPropertiesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkMemoryGetFdInfoKHR(
- VulkanHandleMapping* handlemap,
- VkMemoryGetFdInfoKHR* toMap)
-{
+void handlemap_VkMemoryGetFdInfoKHR(VulkanHandleMapping* handlemap, VkMemoryGetFdInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
@@ -3949,22 +3026,19 @@
#endif
#ifdef VK_KHR_win32_keyed_mutex
void handlemap_VkWin32KeyedMutexAcquireReleaseInfoKHR(
- VulkanHandleMapping* handlemap,
- VkWin32KeyedMutexAcquireReleaseInfoKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkWin32KeyedMutexAcquireReleaseInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pAcquireSyncs)
- {
- handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pAcquireSyncs, toMap->acquireCount);
+ if (toMap->pAcquireSyncs) {
+ handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pAcquireSyncs,
+ toMap->acquireCount);
}
- if (toMap->pReleaseSyncs)
- {
- handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pReleaseSyncs, toMap->releaseCount);
+ if (toMap->pReleaseSyncs) {
+ handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pReleaseSyncs,
+ toMap->releaseCount);
}
}
@@ -3974,51 +3048,39 @@
#ifdef VK_KHR_external_semaphore
#endif
#ifdef VK_KHR_external_semaphore_win32
-void handlemap_VkImportSemaphoreWin32HandleInfoKHR(
- VulkanHandleMapping* handlemap,
- VkImportSemaphoreWin32HandleInfoKHR* toMap)
-{
+void handlemap_VkImportSemaphoreWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
+ VkImportSemaphoreWin32HandleInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
}
-void handlemap_VkExportSemaphoreWin32HandleInfoKHR(
- VulkanHandleMapping* handlemap,
- VkExportSemaphoreWin32HandleInfoKHR* toMap)
-{
+void handlemap_VkExportSemaphoreWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
+ VkExportSemaphoreWin32HandleInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkD3D12FenceSubmitInfoKHR(
- VulkanHandleMapping* handlemap,
- VkD3D12FenceSubmitInfoKHR* toMap)
-{
+void handlemap_VkD3D12FenceSubmitInfoKHR(VulkanHandleMapping* handlemap,
+ VkD3D12FenceSubmitInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkSemaphoreGetWin32HandleInfoKHR(
- VulkanHandleMapping* handlemap,
- VkSemaphoreGetWin32HandleInfoKHR* toMap)
-{
+void handlemap_VkSemaphoreGetWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
+ VkSemaphoreGetWin32HandleInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
@@ -4026,27 +3088,21 @@
#endif
#ifdef VK_KHR_external_semaphore_fd
-void handlemap_VkImportSemaphoreFdInfoKHR(
- VulkanHandleMapping* handlemap,
- VkImportSemaphoreFdInfoKHR* toMap)
-{
+void handlemap_VkImportSemaphoreFdInfoKHR(VulkanHandleMapping* handlemap,
+ VkImportSemaphoreFdInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
}
-void handlemap_VkSemaphoreGetFdInfoKHR(
- VulkanHandleMapping* handlemap,
- VkSemaphoreGetFdInfoKHR* toMap)
-{
+void handlemap_VkSemaphoreGetFdInfoKHR(VulkanHandleMapping* handlemap,
+ VkSemaphoreGetFdInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
@@ -4055,13 +3111,10 @@
#endif
#ifdef VK_KHR_push_descriptor
void handlemap_VkPhysicalDevicePushDescriptorPropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePushDescriptorPropertiesKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePushDescriptorPropertiesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -4072,50 +3125,34 @@
#ifdef VK_KHR_16bit_storage
#endif
#ifdef VK_KHR_incremental_present
-void handlemap_VkRectLayerKHR(
- VulkanHandleMapping* handlemap,
- VkRectLayerKHR* toMap)
-{
+void handlemap_VkRectLayerKHR(VulkanHandleMapping* handlemap, VkRectLayerKHR* toMap) {
(void)handlemap;
(void)toMap;
handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->offset));
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->extent));
}
-void handlemap_VkPresentRegionKHR(
- VulkanHandleMapping* handlemap,
- VkPresentRegionKHR* toMap)
-{
+void handlemap_VkPresentRegionKHR(VulkanHandleMapping* handlemap, VkPresentRegionKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap)
- {
- if (toMap->pRectangles)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->rectangleCount; ++i)
- {
+ if (toMap) {
+ if (toMap->pRectangles) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->rectangleCount; ++i) {
handlemap_VkRectLayerKHR(handlemap, (VkRectLayerKHR*)(toMap->pRectangles + i));
}
}
}
}
-void handlemap_VkPresentRegionsKHR(
- VulkanHandleMapping* handlemap,
- VkPresentRegionsKHR* toMap)
-{
+void handlemap_VkPresentRegionsKHR(VulkanHandleMapping* handlemap, VkPresentRegionsKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->swapchainCount; ++i)
- {
+ if (toMap) {
+ if (toMap->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->swapchainCount; ++i) {
handlemap_VkPresentRegionKHR(handlemap, (VkPresentRegionKHR*)(toMap->pRegions + i));
}
}
@@ -4130,14 +3167,11 @@
#ifdef VK_KHR_create_renderpass2
#endif
#ifdef VK_KHR_shared_presentable_image
-void handlemap_VkSharedPresentSurfaceCapabilitiesKHR(
- VulkanHandleMapping* handlemap,
- VkSharedPresentSurfaceCapabilitiesKHR* toMap)
-{
+void handlemap_VkSharedPresentSurfaceCapabilitiesKHR(VulkanHandleMapping* handlemap,
+ VkSharedPresentSurfaceCapabilitiesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -4148,39 +3182,30 @@
#ifdef VK_KHR_external_fence
#endif
#ifdef VK_KHR_external_fence_win32
-void handlemap_VkImportFenceWin32HandleInfoKHR(
- VulkanHandleMapping* handlemap,
- VkImportFenceWin32HandleInfoKHR* toMap)
-{
+void handlemap_VkImportFenceWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
+ VkImportFenceWin32HandleInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
}
-void handlemap_VkExportFenceWin32HandleInfoKHR(
- VulkanHandleMapping* handlemap,
- VkExportFenceWin32HandleInfoKHR* toMap)
-{
+void handlemap_VkExportFenceWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
+ VkExportFenceWin32HandleInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkFenceGetWin32HandleInfoKHR(
- VulkanHandleMapping* handlemap,
- VkFenceGetWin32HandleInfoKHR* toMap)
-{
+void handlemap_VkFenceGetWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
+ VkFenceGetWin32HandleInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
@@ -4188,27 +3213,20 @@
#endif
#ifdef VK_KHR_external_fence_fd
-void handlemap_VkImportFenceFdInfoKHR(
- VulkanHandleMapping* handlemap,
- VkImportFenceFdInfoKHR* toMap)
-{
+void handlemap_VkImportFenceFdInfoKHR(VulkanHandleMapping* handlemap,
+ VkImportFenceFdInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
}
-void handlemap_VkFenceGetFdInfoKHR(
- VulkanHandleMapping* handlemap,
- VkFenceGetFdInfoKHR* toMap)
-{
+void handlemap_VkFenceGetFdInfoKHR(VulkanHandleMapping* handlemap, VkFenceGetFdInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkFence((VkFence*)&toMap->fence);
@@ -4217,93 +3235,70 @@
#endif
#ifdef VK_KHR_performance_query
void handlemap_VkPhysicalDevicePerformanceQueryFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePerformanceQueryFeaturesKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePerformanceQueryFeaturesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDevicePerformanceQueryPropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePerformanceQueryPropertiesKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePerformanceQueryPropertiesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPerformanceCounterKHR(
- VulkanHandleMapping* handlemap,
- VkPerformanceCounterKHR* toMap)
-{
+void handlemap_VkPerformanceCounterKHR(VulkanHandleMapping* handlemap,
+ VkPerformanceCounterKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPerformanceCounterDescriptionKHR(
- VulkanHandleMapping* handlemap,
- VkPerformanceCounterDescriptionKHR* toMap)
-{
+void handlemap_VkPerformanceCounterDescriptionKHR(VulkanHandleMapping* handlemap,
+ VkPerformanceCounterDescriptionKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkQueryPoolPerformanceCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkQueryPoolPerformanceCreateInfoKHR* toMap)
-{
+void handlemap_VkQueryPoolPerformanceCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkQueryPoolPerformanceCreateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPerformanceCounterResultKHR(
- VulkanHandleMapping* handlemap,
- VkPerformanceCounterResultKHR* toMap)
-{
+void handlemap_VkPerformanceCounterResultKHR(VulkanHandleMapping* handlemap,
+ VkPerformanceCounterResultKHR* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkAcquireProfilingLockInfoKHR(
- VulkanHandleMapping* handlemap,
- VkAcquireProfilingLockInfoKHR* toMap)
-{
+void handlemap_VkAcquireProfilingLockInfoKHR(VulkanHandleMapping* handlemap,
+ VkAcquireProfilingLockInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPerformanceQuerySubmitInfoKHR(
- VulkanHandleMapping* handlemap,
- VkPerformanceQuerySubmitInfoKHR* toMap)
-{
+void handlemap_VkPerformanceQuerySubmitInfoKHR(VulkanHandleMapping* handlemap,
+ VkPerformanceQuerySubmitInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -4312,40 +3307,31 @@
#ifdef VK_KHR_maintenance2
#endif
#ifdef VK_KHR_get_surface_capabilities2
-void handlemap_VkPhysicalDeviceSurfaceInfo2KHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSurfaceInfo2KHR* toMap)
-{
+void handlemap_VkPhysicalDeviceSurfaceInfo2KHR(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceSurfaceInfo2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkSurfaceKHR((VkSurfaceKHR*)&toMap->surface);
}
-void handlemap_VkSurfaceCapabilities2KHR(
- VulkanHandleMapping* handlemap,
- VkSurfaceCapabilities2KHR* toMap)
-{
+void handlemap_VkSurfaceCapabilities2KHR(VulkanHandleMapping* handlemap,
+ VkSurfaceCapabilities2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkSurfaceCapabilitiesKHR(handlemap, (VkSurfaceCapabilitiesKHR*)(&toMap->surfaceCapabilities));
+ handlemap_VkSurfaceCapabilitiesKHR(handlemap,
+ (VkSurfaceCapabilitiesKHR*)(&toMap->surfaceCapabilities));
}
-void handlemap_VkSurfaceFormat2KHR(
- VulkanHandleMapping* handlemap,
- VkSurfaceFormat2KHR* toMap)
-{
+void handlemap_VkSurfaceFormat2KHR(VulkanHandleMapping* handlemap, VkSurfaceFormat2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkSurfaceFormatKHR(handlemap, (VkSurfaceFormatKHR*)(&toMap->surfaceFormat));
@@ -4355,69 +3341,58 @@
#ifdef VK_KHR_variable_pointers
#endif
#ifdef VK_KHR_get_display_properties2
-void handlemap_VkDisplayProperties2KHR(
- VulkanHandleMapping* handlemap,
- VkDisplayProperties2KHR* toMap)
-{
+void handlemap_VkDisplayProperties2KHR(VulkanHandleMapping* handlemap,
+ VkDisplayProperties2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkDisplayPropertiesKHR(handlemap, (VkDisplayPropertiesKHR*)(&toMap->displayProperties));
+ handlemap_VkDisplayPropertiesKHR(handlemap,
+ (VkDisplayPropertiesKHR*)(&toMap->displayProperties));
}
-void handlemap_VkDisplayPlaneProperties2KHR(
- VulkanHandleMapping* handlemap,
- VkDisplayPlaneProperties2KHR* toMap)
-{
+void handlemap_VkDisplayPlaneProperties2KHR(VulkanHandleMapping* handlemap,
+ VkDisplayPlaneProperties2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkDisplayPlanePropertiesKHR(handlemap, (VkDisplayPlanePropertiesKHR*)(&toMap->displayPlaneProperties));
+ handlemap_VkDisplayPlanePropertiesKHR(
+ handlemap, (VkDisplayPlanePropertiesKHR*)(&toMap->displayPlaneProperties));
}
-void handlemap_VkDisplayModeProperties2KHR(
- VulkanHandleMapping* handlemap,
- VkDisplayModeProperties2KHR* toMap)
-{
+void handlemap_VkDisplayModeProperties2KHR(VulkanHandleMapping* handlemap,
+ VkDisplayModeProperties2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkDisplayModePropertiesKHR(handlemap, (VkDisplayModePropertiesKHR*)(&toMap->displayModeProperties));
+ handlemap_VkDisplayModePropertiesKHR(
+ handlemap, (VkDisplayModePropertiesKHR*)(&toMap->displayModeProperties));
}
-void handlemap_VkDisplayPlaneInfo2KHR(
- VulkanHandleMapping* handlemap,
- VkDisplayPlaneInfo2KHR* toMap)
-{
+void handlemap_VkDisplayPlaneInfo2KHR(VulkanHandleMapping* handlemap,
+ VkDisplayPlaneInfo2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkDisplayModeKHR((VkDisplayModeKHR*)&toMap->mode);
}
-void handlemap_VkDisplayPlaneCapabilities2KHR(
- VulkanHandleMapping* handlemap,
- VkDisplayPlaneCapabilities2KHR* toMap)
-{
+void handlemap_VkDisplayPlaneCapabilities2KHR(VulkanHandleMapping* handlemap,
+ VkDisplayPlaneCapabilities2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkDisplayPlaneCapabilitiesKHR(handlemap, (VkDisplayPlaneCapabilitiesKHR*)(&toMap->capabilities));
+ handlemap_VkDisplayPlaneCapabilitiesKHR(handlemap,
+ (VkDisplayPlaneCapabilitiesKHR*)(&toMap->capabilities));
}
#endif
@@ -4437,25 +3412,19 @@
#endif
#ifdef VK_KHR_portability_subset
void handlemap_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePortabilitySubsetFeaturesKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePortabilitySubsetFeaturesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePortabilitySubsetPropertiesKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePortabilitySubsetPropertiesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -4473,13 +3442,10 @@
#endif
#ifdef VK_KHR_shader_clock
void handlemap_VkPhysicalDeviceShaderClockFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderClockFeaturesKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderClockFeaturesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -4499,13 +3465,10 @@
#endif
#ifdef VK_KHR_shader_terminate_invocation
void handlemap_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -4513,70 +3476,57 @@
#endif
#ifdef VK_KHR_fragment_shading_rate
void handlemap_VkFragmentShadingRateAttachmentInfoKHR(
- VulkanHandleMapping* handlemap,
- VkFragmentShadingRateAttachmentInfoKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkFragmentShadingRateAttachmentInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pFragmentShadingRateAttachment)
- {
- handlemap_VkAttachmentReference2(handlemap, (VkAttachmentReference2*)(toMap->pFragmentShadingRateAttachment));
+ if (toMap->pFragmentShadingRateAttachment) {
+ handlemap_VkAttachmentReference2(
+ handlemap, (VkAttachmentReference2*)(toMap->pFragmentShadingRateAttachment));
}
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->shadingRateAttachmentTexelSize));
}
void handlemap_VkPipelineFragmentShadingRateStateCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkPipelineFragmentShadingRateStateCreateInfoKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineFragmentShadingRateStateCreateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->fragmentSize));
}
void handlemap_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentShadingRateFeaturesKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShadingRateFeaturesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentShadingRatePropertiesKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShadingRatePropertiesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minFragmentShadingRateAttachmentTexelSize));
- handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxFragmentShadingRateAttachmentTexelSize));
+ handlemap_VkExtent2D(handlemap,
+ (VkExtent2D*)(&toMap->minFragmentShadingRateAttachmentTexelSize));
+ handlemap_VkExtent2D(handlemap,
+ (VkExtent2D*)(&toMap->maxFragmentShadingRateAttachmentTexelSize));
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxFragmentSize));
}
void handlemap_VkPhysicalDeviceFragmentShadingRateKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentShadingRateKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShadingRateKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->fragmentSize));
@@ -4586,14 +3536,11 @@
#ifdef VK_KHR_spirv_1_4
#endif
#ifdef VK_KHR_surface_protected_capabilities
-void handlemap_VkSurfaceProtectedCapabilitiesKHR(
- VulkanHandleMapping* handlemap,
- VkSurfaceProtectedCapabilitiesKHR* toMap)
-{
+void handlemap_VkSurfaceProtectedCapabilitiesKHR(VulkanHandleMapping* handlemap,
+ VkSurfaceProtectedCapabilitiesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -4603,13 +3550,10 @@
#endif
#ifdef VK_KHR_present_wait
void handlemap_VkPhysicalDevicePresentWaitFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePresentWaitFeaturesKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePresentWaitFeaturesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -4624,83 +3568,64 @@
#ifdef VK_KHR_pipeline_executable_properties
void handlemap_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
VulkanHandleMapping* handlemap,
- VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* toMap)
-{
+ VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPipelineInfoKHR(
- VulkanHandleMapping* handlemap,
- VkPipelineInfoKHR* toMap)
-{
+void handlemap_VkPipelineInfoKHR(VulkanHandleMapping* handlemap, VkPipelineInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkPipeline((VkPipeline*)&toMap->pipeline);
}
-void handlemap_VkPipelineExecutablePropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkPipelineExecutablePropertiesKHR* toMap)
-{
+void handlemap_VkPipelineExecutablePropertiesKHR(VulkanHandleMapping* handlemap,
+ VkPipelineExecutablePropertiesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPipelineExecutableInfoKHR(
- VulkanHandleMapping* handlemap,
- VkPipelineExecutableInfoKHR* toMap)
-{
+void handlemap_VkPipelineExecutableInfoKHR(VulkanHandleMapping* handlemap,
+ VkPipelineExecutableInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkPipeline((VkPipeline*)&toMap->pipeline);
}
-void handlemap_VkPipelineExecutableStatisticValueKHR(
- VulkanHandleMapping* handlemap,
- VkPipelineExecutableStatisticValueKHR* toMap)
-{
+void handlemap_VkPipelineExecutableStatisticValueKHR(VulkanHandleMapping* handlemap,
+ VkPipelineExecutableStatisticValueKHR* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkPipelineExecutableStatisticKHR(
- VulkanHandleMapping* handlemap,
- VkPipelineExecutableStatisticKHR* toMap)
-{
+void handlemap_VkPipelineExecutableStatisticKHR(VulkanHandleMapping* handlemap,
+ VkPipelineExecutableStatisticKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkPipelineExecutableStatisticValueKHR(handlemap, (VkPipelineExecutableStatisticValueKHR*)(&toMap->value));
+ handlemap_VkPipelineExecutableStatisticValueKHR(
+ handlemap, (VkPipelineExecutableStatisticValueKHR*)(&toMap->value));
}
void handlemap_VkPipelineExecutableInternalRepresentationKHR(
- VulkanHandleMapping* handlemap,
- VkPipelineExecutableInternalRepresentationKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineExecutableInternalRepresentationKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -4708,43 +3633,33 @@
#endif
#ifdef VK_KHR_shader_integer_dot_product
void handlemap_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_KHR_pipeline_library
-void handlemap_VkPipelineLibraryCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkPipelineLibraryCreateInfoKHR* toMap)
-{
+void handlemap_VkPipelineLibraryCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkPipelineLibraryCreateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pLibraries)
- {
+ if (toMap->pLibraries) {
handlemap->mapHandles_VkPipeline((VkPipeline*)toMap->pLibraries, toMap->libraryCount);
}
}
@@ -4753,256 +3668,196 @@
#ifdef VK_KHR_shader_non_semantic_info
#endif
#ifdef VK_KHR_present_id
-void handlemap_VkPresentIdKHR(
- VulkanHandleMapping* handlemap,
- VkPresentIdKHR* toMap)
-{
+void handlemap_VkPresentIdKHR(VulkanHandleMapping* handlemap, VkPresentIdKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPhysicalDevicePresentIdFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePresentIdFeaturesKHR* toMap)
-{
+void handlemap_VkPhysicalDevicePresentIdFeaturesKHR(VulkanHandleMapping* handlemap,
+ VkPhysicalDevicePresentIdFeaturesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_KHR_video_encode_queue
-void handlemap_VkVideoEncodeInfoKHR(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeInfoKHR* toMap)
-{
+void handlemap_VkVideoEncodeInfoKHR(VulkanHandleMapping* handlemap, VkVideoEncodeInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->codedExtent));
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->dstBitstreamBuffer);
- handlemap_VkVideoPictureResourceKHR(handlemap, (VkVideoPictureResourceKHR*)(&toMap->srcPictureResource));
- if (toMap->pSetupReferenceSlot)
- {
- handlemap_VkVideoReferenceSlotKHR(handlemap, (VkVideoReferenceSlotKHR*)(toMap->pSetupReferenceSlot));
+ handlemap_VkVideoPictureResourceKHR(handlemap,
+ (VkVideoPictureResourceKHR*)(&toMap->srcPictureResource));
+ if (toMap->pSetupReferenceSlot) {
+ handlemap_VkVideoReferenceSlotKHR(handlemap,
+ (VkVideoReferenceSlotKHR*)(toMap->pSetupReferenceSlot));
}
- if (toMap)
- {
- if (toMap->pReferenceSlots)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->referenceSlotCount; ++i)
- {
- handlemap_VkVideoReferenceSlotKHR(handlemap, (VkVideoReferenceSlotKHR*)(toMap->pReferenceSlots + i));
+ if (toMap) {
+ if (toMap->pReferenceSlots) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->referenceSlotCount; ++i) {
+ handlemap_VkVideoReferenceSlotKHR(
+ handlemap, (VkVideoReferenceSlotKHR*)(toMap->pReferenceSlots + i));
}
}
}
}
-void handlemap_VkVideoEncodeRateControlInfoKHR(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeRateControlInfoKHR* toMap)
-{
+void handlemap_VkVideoEncodeRateControlInfoKHR(VulkanHandleMapping* handlemap,
+ VkVideoEncodeRateControlInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_KHR_synchronization2
-void handlemap_VkMemoryBarrier2KHR(
- VulkanHandleMapping* handlemap,
- VkMemoryBarrier2KHR* toMap)
-{
+void handlemap_VkMemoryBarrier2KHR(VulkanHandleMapping* handlemap, VkMemoryBarrier2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkBufferMemoryBarrier2KHR(
- VulkanHandleMapping* handlemap,
- VkBufferMemoryBarrier2KHR* toMap)
-{
+void handlemap_VkBufferMemoryBarrier2KHR(VulkanHandleMapping* handlemap,
+ VkBufferMemoryBarrier2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
}
-void handlemap_VkImageMemoryBarrier2KHR(
- VulkanHandleMapping* handlemap,
- VkImageMemoryBarrier2KHR* toMap)
-{
+void handlemap_VkImageMemoryBarrier2KHR(VulkanHandleMapping* handlemap,
+ VkImageMemoryBarrier2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
- handlemap_VkImageSubresourceRange(handlemap, (VkImageSubresourceRange*)(&toMap->subresourceRange));
+ handlemap_VkImageSubresourceRange(handlemap,
+ (VkImageSubresourceRange*)(&toMap->subresourceRange));
}
-void handlemap_VkDependencyInfoKHR(
- VulkanHandleMapping* handlemap,
- VkDependencyInfoKHR* toMap)
-{
+void handlemap_VkDependencyInfoKHR(VulkanHandleMapping* handlemap, VkDependencyInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pMemoryBarriers)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->memoryBarrierCount; ++i)
- {
- handlemap_VkMemoryBarrier2KHR(handlemap, (VkMemoryBarrier2KHR*)(toMap->pMemoryBarriers + i));
+ if (toMap) {
+ if (toMap->pMemoryBarriers) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->memoryBarrierCount; ++i) {
+ handlemap_VkMemoryBarrier2KHR(handlemap,
+ (VkMemoryBarrier2KHR*)(toMap->pMemoryBarriers + i));
}
}
}
- if (toMap)
- {
- if (toMap->pBufferMemoryBarriers)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->bufferMemoryBarrierCount; ++i)
- {
- handlemap_VkBufferMemoryBarrier2KHR(handlemap, (VkBufferMemoryBarrier2KHR*)(toMap->pBufferMemoryBarriers + i));
+ if (toMap) {
+ if (toMap->pBufferMemoryBarriers) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->bufferMemoryBarrierCount; ++i) {
+ handlemap_VkBufferMemoryBarrier2KHR(
+ handlemap, (VkBufferMemoryBarrier2KHR*)(toMap->pBufferMemoryBarriers + i));
}
}
}
- if (toMap)
- {
- if (toMap->pImageMemoryBarriers)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->imageMemoryBarrierCount; ++i)
- {
- handlemap_VkImageMemoryBarrier2KHR(handlemap, (VkImageMemoryBarrier2KHR*)(toMap->pImageMemoryBarriers + i));
+ if (toMap) {
+ if (toMap->pImageMemoryBarriers) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->imageMemoryBarrierCount; ++i) {
+ handlemap_VkImageMemoryBarrier2KHR(
+ handlemap, (VkImageMemoryBarrier2KHR*)(toMap->pImageMemoryBarriers + i));
}
}
}
}
-void handlemap_VkSemaphoreSubmitInfoKHR(
- VulkanHandleMapping* handlemap,
- VkSemaphoreSubmitInfoKHR* toMap)
-{
+void handlemap_VkSemaphoreSubmitInfoKHR(VulkanHandleMapping* handlemap,
+ VkSemaphoreSubmitInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
}
-void handlemap_VkCommandBufferSubmitInfoKHR(
- VulkanHandleMapping* handlemap,
- VkCommandBufferSubmitInfoKHR* toMap)
-{
+void handlemap_VkCommandBufferSubmitInfoKHR(VulkanHandleMapping* handlemap,
+ VkCommandBufferSubmitInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkCommandBuffer((VkCommandBuffer*)&toMap->commandBuffer);
}
-void handlemap_VkSubmitInfo2KHR(
- VulkanHandleMapping* handlemap,
- VkSubmitInfo2KHR* toMap)
-{
+void handlemap_VkSubmitInfo2KHR(VulkanHandleMapping* handlemap, VkSubmitInfo2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pWaitSemaphoreInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->waitSemaphoreInfoCount; ++i)
- {
- handlemap_VkSemaphoreSubmitInfoKHR(handlemap, (VkSemaphoreSubmitInfoKHR*)(toMap->pWaitSemaphoreInfos + i));
+ if (toMap) {
+ if (toMap->pWaitSemaphoreInfos) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->waitSemaphoreInfoCount; ++i) {
+ handlemap_VkSemaphoreSubmitInfoKHR(
+ handlemap, (VkSemaphoreSubmitInfoKHR*)(toMap->pWaitSemaphoreInfos + i));
}
}
}
- if (toMap)
- {
- if (toMap->pCommandBufferInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->commandBufferInfoCount; ++i)
- {
- handlemap_VkCommandBufferSubmitInfoKHR(handlemap, (VkCommandBufferSubmitInfoKHR*)(toMap->pCommandBufferInfos + i));
+ if (toMap) {
+ if (toMap->pCommandBufferInfos) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->commandBufferInfoCount; ++i) {
+ handlemap_VkCommandBufferSubmitInfoKHR(
+ handlemap, (VkCommandBufferSubmitInfoKHR*)(toMap->pCommandBufferInfos + i));
}
}
}
- if (toMap)
- {
- if (toMap->pSignalSemaphoreInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->signalSemaphoreInfoCount; ++i)
- {
- handlemap_VkSemaphoreSubmitInfoKHR(handlemap, (VkSemaphoreSubmitInfoKHR*)(toMap->pSignalSemaphoreInfos + i));
+ if (toMap) {
+ if (toMap->pSignalSemaphoreInfos) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->signalSemaphoreInfoCount; ++i) {
+ handlemap_VkSemaphoreSubmitInfoKHR(
+ handlemap, (VkSemaphoreSubmitInfoKHR*)(toMap->pSignalSemaphoreInfos + i));
}
}
}
}
void handlemap_VkPhysicalDeviceSynchronization2FeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSynchronization2FeaturesKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceSynchronization2FeaturesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkQueueFamilyCheckpointProperties2NV(
- VulkanHandleMapping* handlemap,
- VkQueueFamilyCheckpointProperties2NV* toMap)
-{
+void handlemap_VkQueueFamilyCheckpointProperties2NV(VulkanHandleMapping* handlemap,
+ VkQueueFamilyCheckpointProperties2NV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkCheckpointData2NV(
- VulkanHandleMapping* handlemap,
- VkCheckpointData2NV* toMap)
-{
+void handlemap_VkCheckpointData2NV(VulkanHandleMapping* handlemap, VkCheckpointData2NV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -5011,12 +3866,10 @@
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
void handlemap_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* toMap)
-{
+ VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -5025,12 +3878,10 @@
#ifdef VK_KHR_zero_initialize_workgroup_memory
void handlemap_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
VulkanHandleMapping* handlemap,
- VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* toMap)
-{
+ VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -5039,239 +3890,185 @@
#ifdef VK_KHR_workgroup_memory_explicit_layout
void handlemap_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
VulkanHandleMapping* handlemap,
- VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* toMap)
-{
+ VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_KHR_copy_commands2
-void handlemap_VkBufferCopy2KHR(
- VulkanHandleMapping* handlemap,
- VkBufferCopy2KHR* toMap)
-{
+void handlemap_VkBufferCopy2KHR(VulkanHandleMapping* handlemap, VkBufferCopy2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkCopyBufferInfo2KHR(
- VulkanHandleMapping* handlemap,
- VkCopyBufferInfo2KHR* toMap)
-{
+void handlemap_VkCopyBufferInfo2KHR(VulkanHandleMapping* handlemap, VkCopyBufferInfo2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->srcBuffer);
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->dstBuffer);
- if (toMap)
- {
- if (toMap->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i)
- {
+ if (toMap) {
+ if (toMap->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
handlemap_VkBufferCopy2KHR(handlemap, (VkBufferCopy2KHR*)(toMap->pRegions + i));
}
}
}
}
-void handlemap_VkImageCopy2KHR(
- VulkanHandleMapping* handlemap,
- VkImageCopy2KHR* toMap)
-{
+void handlemap_VkImageCopy2KHR(VulkanHandleMapping* handlemap, VkImageCopy2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->srcSubresource));
+ handlemap_VkImageSubresourceLayers(handlemap,
+ (VkImageSubresourceLayers*)(&toMap->srcSubresource));
handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->srcOffset));
- handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->dstSubresource));
+ handlemap_VkImageSubresourceLayers(handlemap,
+ (VkImageSubresourceLayers*)(&toMap->dstSubresource));
handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->dstOffset));
handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
}
-void handlemap_VkCopyImageInfo2KHR(
- VulkanHandleMapping* handlemap,
- VkCopyImageInfo2KHR* toMap)
-{
+void handlemap_VkCopyImageInfo2KHR(VulkanHandleMapping* handlemap, VkCopyImageInfo2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkImage((VkImage*)&toMap->srcImage);
handlemap->mapHandles_VkImage((VkImage*)&toMap->dstImage);
- if (toMap)
- {
- if (toMap->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i)
- {
+ if (toMap) {
+ if (toMap->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
handlemap_VkImageCopy2KHR(handlemap, (VkImageCopy2KHR*)(toMap->pRegions + i));
}
}
}
}
-void handlemap_VkBufferImageCopy2KHR(
- VulkanHandleMapping* handlemap,
- VkBufferImageCopy2KHR* toMap)
-{
+void handlemap_VkBufferImageCopy2KHR(VulkanHandleMapping* handlemap, VkBufferImageCopy2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->imageSubresource));
+ handlemap_VkImageSubresourceLayers(handlemap,
+ (VkImageSubresourceLayers*)(&toMap->imageSubresource));
handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->imageOffset));
handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->imageExtent));
}
-void handlemap_VkCopyBufferToImageInfo2KHR(
- VulkanHandleMapping* handlemap,
- VkCopyBufferToImageInfo2KHR* toMap)
-{
+void handlemap_VkCopyBufferToImageInfo2KHR(VulkanHandleMapping* handlemap,
+ VkCopyBufferToImageInfo2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->srcBuffer);
handlemap->mapHandles_VkImage((VkImage*)&toMap->dstImage);
- if (toMap)
- {
- if (toMap->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i)
- {
- handlemap_VkBufferImageCopy2KHR(handlemap, (VkBufferImageCopy2KHR*)(toMap->pRegions + i));
+ if (toMap) {
+ if (toMap->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
+ handlemap_VkBufferImageCopy2KHR(handlemap,
+ (VkBufferImageCopy2KHR*)(toMap->pRegions + i));
}
}
}
}
-void handlemap_VkCopyImageToBufferInfo2KHR(
- VulkanHandleMapping* handlemap,
- VkCopyImageToBufferInfo2KHR* toMap)
-{
+void handlemap_VkCopyImageToBufferInfo2KHR(VulkanHandleMapping* handlemap,
+ VkCopyImageToBufferInfo2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkImage((VkImage*)&toMap->srcImage);
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->dstBuffer);
- if (toMap)
- {
- if (toMap->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i)
- {
- handlemap_VkBufferImageCopy2KHR(handlemap, (VkBufferImageCopy2KHR*)(toMap->pRegions + i));
+ if (toMap) {
+ if (toMap->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
+ handlemap_VkBufferImageCopy2KHR(handlemap,
+ (VkBufferImageCopy2KHR*)(toMap->pRegions + i));
}
}
}
}
-void handlemap_VkImageBlit2KHR(
- VulkanHandleMapping* handlemap,
- VkImageBlit2KHR* toMap)
-{
+void handlemap_VkImageBlit2KHR(VulkanHandleMapping* handlemap, VkImageBlit2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->srcSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ handlemap_VkImageSubresourceLayers(handlemap,
+ (VkImageSubresourceLayers*)(&toMap->srcSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
handlemap_VkOffset3D(handlemap, (VkOffset3D*)(toMap->srcOffsets + i));
}
- handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->dstSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ handlemap_VkImageSubresourceLayers(handlemap,
+ (VkImageSubresourceLayers*)(&toMap->dstSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
handlemap_VkOffset3D(handlemap, (VkOffset3D*)(toMap->dstOffsets + i));
}
}
-void handlemap_VkBlitImageInfo2KHR(
- VulkanHandleMapping* handlemap,
- VkBlitImageInfo2KHR* toMap)
-{
+void handlemap_VkBlitImageInfo2KHR(VulkanHandleMapping* handlemap, VkBlitImageInfo2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkImage((VkImage*)&toMap->srcImage);
handlemap->mapHandles_VkImage((VkImage*)&toMap->dstImage);
- if (toMap)
- {
- if (toMap->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i)
- {
+ if (toMap) {
+ if (toMap->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
handlemap_VkImageBlit2KHR(handlemap, (VkImageBlit2KHR*)(toMap->pRegions + i));
}
}
}
}
-void handlemap_VkImageResolve2KHR(
- VulkanHandleMapping* handlemap,
- VkImageResolve2KHR* toMap)
-{
+void handlemap_VkImageResolve2KHR(VulkanHandleMapping* handlemap, VkImageResolve2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->srcSubresource));
+ handlemap_VkImageSubresourceLayers(handlemap,
+ (VkImageSubresourceLayers*)(&toMap->srcSubresource));
handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->srcOffset));
- handlemap_VkImageSubresourceLayers(handlemap, (VkImageSubresourceLayers*)(&toMap->dstSubresource));
+ handlemap_VkImageSubresourceLayers(handlemap,
+ (VkImageSubresourceLayers*)(&toMap->dstSubresource));
handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->dstOffset));
handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
}
-void handlemap_VkResolveImageInfo2KHR(
- VulkanHandleMapping* handlemap,
- VkResolveImageInfo2KHR* toMap)
-{
+void handlemap_VkResolveImageInfo2KHR(VulkanHandleMapping* handlemap,
+ VkResolveImageInfo2KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkImage((VkImage*)&toMap->srcImage);
handlemap->mapHandles_VkImage((VkImage*)&toMap->dstImage);
- if (toMap)
- {
- if (toMap->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i)
- {
+ if (toMap) {
+ if (toMap->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
handlemap_VkImageResolve2KHR(handlemap, (VkImageResolve2KHR*)(toMap->pRegions + i));
}
}
@@ -5280,14 +4077,11 @@
#endif
#ifdef VK_KHR_format_feature_flags2
-void handlemap_VkFormatProperties3KHR(
- VulkanHandleMapping* handlemap,
- VkFormatProperties3KHR* toMap)
-{
+void handlemap_VkFormatProperties3KHR(VulkanHandleMapping* handlemap,
+ VkFormatProperties3KHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -5295,85 +4089,64 @@
#endif
#ifdef VK_KHR_maintenance4
void handlemap_VkPhysicalDeviceMaintenance4FeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMaintenance4FeaturesKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceMaintenance4FeaturesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceMaintenance4PropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMaintenance4PropertiesKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceMaintenance4PropertiesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDeviceBufferMemoryRequirementsKHR(
- VulkanHandleMapping* handlemap,
- VkDeviceBufferMemoryRequirementsKHR* toMap)
-{
+void handlemap_VkDeviceBufferMemoryRequirementsKHR(VulkanHandleMapping* handlemap,
+ VkDeviceBufferMemoryRequirementsKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pCreateInfo)
- {
+ if (toMap->pCreateInfo) {
handlemap_VkBufferCreateInfo(handlemap, (VkBufferCreateInfo*)(toMap->pCreateInfo));
}
}
-void handlemap_VkDeviceImageMemoryRequirementsKHR(
- VulkanHandleMapping* handlemap,
- VkDeviceImageMemoryRequirementsKHR* toMap)
-{
+void handlemap_VkDeviceImageMemoryRequirementsKHR(VulkanHandleMapping* handlemap,
+ VkDeviceImageMemoryRequirementsKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pCreateInfo)
- {
+ if (toMap->pCreateInfo) {
handlemap_VkImageCreateInfo(handlemap, (VkImageCreateInfo*)(toMap->pCreateInfo));
}
}
#endif
#ifdef VK_ANDROID_native_buffer
-void handlemap_VkNativeBufferANDROID(
- VulkanHandleMapping* handlemap,
- VkNativeBufferANDROID* toMap)
-{
+void handlemap_VkNativeBufferANDROID(VulkanHandleMapping* handlemap, VkNativeBufferANDROID* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_EXT_debug_report
-void handlemap_VkDebugReportCallbackCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDebugReportCallbackCreateInfoEXT* toMap)
-{
+void handlemap_VkDebugReportCallbackCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkDebugReportCallbackCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -5387,13 +4160,10 @@
#endif
#ifdef VK_AMD_rasterization_order
void handlemap_VkPipelineRasterizationStateRasterizationOrderAMD(
- VulkanHandleMapping* handlemap,
- VkPipelineRasterizationStateRasterizationOrderAMD* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineRasterizationStateRasterizationOrderAMD* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -5404,38 +4174,29 @@
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
-void handlemap_VkDebugMarkerObjectNameInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDebugMarkerObjectNameInfoEXT* toMap)
-{
+void handlemap_VkDebugMarkerObjectNameInfoEXT(VulkanHandleMapping* handlemap,
+ VkDebugMarkerObjectNameInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDebugMarkerObjectTagInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDebugMarkerObjectTagInfoEXT* toMap)
-{
+void handlemap_VkDebugMarkerObjectTagInfoEXT(VulkanHandleMapping* handlemap,
+ VkDebugMarkerObjectTagInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDebugMarkerMarkerInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDebugMarkerMarkerInfoEXT* toMap)
-{
+void handlemap_VkDebugMarkerMarkerInfoEXT(VulkanHandleMapping* handlemap,
+ VkDebugMarkerMarkerInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -5445,37 +4206,28 @@
#endif
#ifdef VK_NV_dedicated_allocation
void handlemap_VkDedicatedAllocationImageCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkDedicatedAllocationImageCreateInfoNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkDedicatedAllocationImageCreateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkDedicatedAllocationBufferCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkDedicatedAllocationBufferCreateInfoNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkDedicatedAllocationBufferCreateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkDedicatedAllocationMemoryAllocateInfoNV(
- VulkanHandleMapping* handlemap,
- VkDedicatedAllocationMemoryAllocateInfoNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkDedicatedAllocationMemoryAllocateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
@@ -5485,76 +4237,57 @@
#endif
#ifdef VK_EXT_transform_feedback
void handlemap_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceTransformFeedbackFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceTransformFeedbackFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceTransformFeedbackPropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceTransformFeedbackPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPipelineRasterizationStateStreamCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineRasterizationStateStreamCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineRasterizationStateStreamCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_NVX_binary_import
-void handlemap_VkCuModuleCreateInfoNVX(
- VulkanHandleMapping* handlemap,
- VkCuModuleCreateInfoNVX* toMap)
-{
+void handlemap_VkCuModuleCreateInfoNVX(VulkanHandleMapping* handlemap,
+ VkCuModuleCreateInfoNVX* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkCuFunctionCreateInfoNVX(
- VulkanHandleMapping* handlemap,
- VkCuFunctionCreateInfoNVX* toMap)
-{
+void handlemap_VkCuFunctionCreateInfoNVX(VulkanHandleMapping* handlemap,
+ VkCuFunctionCreateInfoNVX* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkCuModuleNVX((VkCuModuleNVX*)&toMap->module);
}
-void handlemap_VkCuLaunchInfoNVX(
- VulkanHandleMapping* handlemap,
- VkCuLaunchInfoNVX* toMap)
-{
+void handlemap_VkCuLaunchInfoNVX(VulkanHandleMapping* handlemap, VkCuLaunchInfoNVX* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkCuFunctionNVX((VkCuFunctionNVX*)&toMap->function);
@@ -5562,28 +4295,22 @@
#endif
#ifdef VK_NVX_image_view_handle
-void handlemap_VkImageViewHandleInfoNVX(
- VulkanHandleMapping* handlemap,
- VkImageViewHandleInfoNVX* toMap)
-{
+void handlemap_VkImageViewHandleInfoNVX(VulkanHandleMapping* handlemap,
+ VkImageViewHandleInfoNVX* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkImageView((VkImageView*)&toMap->imageView);
handlemap->mapHandles_VkSampler((VkSampler*)&toMap->sampler);
}
-void handlemap_VkImageViewAddressPropertiesNVX(
- VulkanHandleMapping* handlemap,
- VkImageViewAddressPropertiesNVX* toMap)
-{
+void handlemap_VkImageViewAddressPropertiesNVX(VulkanHandleMapping* handlemap,
+ VkImageViewAddressPropertiesNVX* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -5598,490 +4325,396 @@
#ifdef VK_AMD_shader_ballot
#endif
#ifdef VK_EXT_video_encode_h264
-void handlemap_VkVideoEncodeH264CapabilitiesEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH264CapabilitiesEXT* toMap)
-{
+void handlemap_VkVideoEncodeH264CapabilitiesEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH264CapabilitiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minPictureSizeInMbs));
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxPictureSizeInMbs));
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->inputImageDataAlignment));
- handlemap_VkExtensionProperties(handlemap, (VkExtensionProperties*)(&toMap->stdExtensionVersion));
+ handlemap_VkExtensionProperties(handlemap,
+ (VkExtensionProperties*)(&toMap->stdExtensionVersion));
}
-void handlemap_VkVideoEncodeH264SessionCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH264SessionCreateInfoEXT* toMap)
-{
+void handlemap_VkVideoEncodeH264SessionCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH264SessionCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxPictureSizeInMbs));
- if (toMap->pStdExtensionVersion)
- {
- handlemap_VkExtensionProperties(handlemap, (VkExtensionProperties*)(toMap->pStdExtensionVersion));
+ if (toMap->pStdExtensionVersion) {
+ handlemap_VkExtensionProperties(handlemap,
+ (VkExtensionProperties*)(toMap->pStdExtensionVersion));
}
}
void handlemap_VkVideoEncodeH264SessionParametersAddInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH264SessionParametersAddInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkVideoEncodeH264SessionParametersAddInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkVideoEncodeH264SessionParametersCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH264SessionParametersCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkVideoEncodeH264SessionParametersCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pParametersAddInfo)
- {
- handlemap_VkVideoEncodeH264SessionParametersAddInfoEXT(handlemap, (VkVideoEncodeH264SessionParametersAddInfoEXT*)(toMap->pParametersAddInfo));
+ if (toMap->pParametersAddInfo) {
+ handlemap_VkVideoEncodeH264SessionParametersAddInfoEXT(
+ handlemap, (VkVideoEncodeH264SessionParametersAddInfoEXT*)(toMap->pParametersAddInfo));
}
}
-void handlemap_VkVideoEncodeH264DpbSlotInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH264DpbSlotInfoEXT* toMap)
-{
+void handlemap_VkVideoEncodeH264DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH264DpbSlotInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkVideoEncodeH264NaluSliceEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH264NaluSliceEXT* toMap)
-{
+void handlemap_VkVideoEncodeH264NaluSliceEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH264NaluSliceEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pRefFinalList0Entries)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->refFinalList0EntryCount; ++i)
- {
- handlemap_VkVideoEncodeH264DpbSlotInfoEXT(handlemap, (VkVideoEncodeH264DpbSlotInfoEXT*)(toMap->pRefFinalList0Entries + i));
+ if (toMap) {
+ if (toMap->pRefFinalList0Entries) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->refFinalList0EntryCount; ++i) {
+ handlemap_VkVideoEncodeH264DpbSlotInfoEXT(
+ handlemap,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(toMap->pRefFinalList0Entries + i));
}
}
}
- if (toMap)
- {
- if (toMap->pRefFinalList1Entries)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->refFinalList1EntryCount; ++i)
- {
- handlemap_VkVideoEncodeH264DpbSlotInfoEXT(handlemap, (VkVideoEncodeH264DpbSlotInfoEXT*)(toMap->pRefFinalList1Entries + i));
+ if (toMap) {
+ if (toMap->pRefFinalList1Entries) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->refFinalList1EntryCount; ++i) {
+ handlemap_VkVideoEncodeH264DpbSlotInfoEXT(
+ handlemap,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(toMap->pRefFinalList1Entries + i));
}
}
}
}
-void handlemap_VkVideoEncodeH264VclFrameInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH264VclFrameInfoEXT* toMap)
-{
+void handlemap_VkVideoEncodeH264VclFrameInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH264VclFrameInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pRefDefaultFinalList0Entries)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->refDefaultFinalList0EntryCount; ++i)
- {
- handlemap_VkVideoEncodeH264DpbSlotInfoEXT(handlemap, (VkVideoEncodeH264DpbSlotInfoEXT*)(toMap->pRefDefaultFinalList0Entries + i));
+ if (toMap) {
+ if (toMap->pRefDefaultFinalList0Entries) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->refDefaultFinalList0EntryCount; ++i) {
+ handlemap_VkVideoEncodeH264DpbSlotInfoEXT(
+ handlemap,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(toMap->pRefDefaultFinalList0Entries + i));
}
}
}
- if (toMap)
- {
- if (toMap->pRefDefaultFinalList1Entries)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->refDefaultFinalList1EntryCount; ++i)
- {
- handlemap_VkVideoEncodeH264DpbSlotInfoEXT(handlemap, (VkVideoEncodeH264DpbSlotInfoEXT*)(toMap->pRefDefaultFinalList1Entries + i));
+ if (toMap) {
+ if (toMap->pRefDefaultFinalList1Entries) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->refDefaultFinalList1EntryCount; ++i) {
+ handlemap_VkVideoEncodeH264DpbSlotInfoEXT(
+ handlemap,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(toMap->pRefDefaultFinalList1Entries + i));
}
}
}
- if (toMap)
- {
- if (toMap->pNaluSliceEntries)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->naluSliceEntryCount; ++i)
- {
- handlemap_VkVideoEncodeH264NaluSliceEXT(handlemap, (VkVideoEncodeH264NaluSliceEXT*)(toMap->pNaluSliceEntries + i));
+ if (toMap) {
+ if (toMap->pNaluSliceEntries) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->naluSliceEntryCount; ++i) {
+ handlemap_VkVideoEncodeH264NaluSliceEXT(
+ handlemap, (VkVideoEncodeH264NaluSliceEXT*)(toMap->pNaluSliceEntries + i));
}
}
}
- if (toMap->pCurrentPictureInfo)
- {
- handlemap_VkVideoEncodeH264DpbSlotInfoEXT(handlemap, (VkVideoEncodeH264DpbSlotInfoEXT*)(toMap->pCurrentPictureInfo));
+ if (toMap->pCurrentPictureInfo) {
+ handlemap_VkVideoEncodeH264DpbSlotInfoEXT(
+ handlemap, (VkVideoEncodeH264DpbSlotInfoEXT*)(toMap->pCurrentPictureInfo));
}
}
void handlemap_VkVideoEncodeH264EmitPictureParametersEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH264EmitPictureParametersEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkVideoEncodeH264EmitPictureParametersEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkVideoEncodeH264ProfileEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH264ProfileEXT* toMap)
-{
+void handlemap_VkVideoEncodeH264ProfileEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH264ProfileEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_EXT_video_encode_h265
-void handlemap_VkVideoEncodeH265CapabilitiesEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH265CapabilitiesEXT* toMap)
-{
+void handlemap_VkVideoEncodeH265CapabilitiesEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH265CapabilitiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->inputImageDataAlignment));
- handlemap_VkExtensionProperties(handlemap, (VkExtensionProperties*)(&toMap->stdExtensionVersion));
+ handlemap_VkExtensionProperties(handlemap,
+ (VkExtensionProperties*)(&toMap->stdExtensionVersion));
}
-void handlemap_VkVideoEncodeH265SessionCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH265SessionCreateInfoEXT* toMap)
-{
+void handlemap_VkVideoEncodeH265SessionCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH265SessionCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pStdExtensionVersion)
- {
- handlemap_VkExtensionProperties(handlemap, (VkExtensionProperties*)(toMap->pStdExtensionVersion));
+ if (toMap->pStdExtensionVersion) {
+ handlemap_VkExtensionProperties(handlemap,
+ (VkExtensionProperties*)(toMap->pStdExtensionVersion));
}
}
void handlemap_VkVideoEncodeH265SessionParametersAddInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH265SessionParametersAddInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkVideoEncodeH265SessionParametersAddInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkVideoEncodeH265SessionParametersCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH265SessionParametersCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkVideoEncodeH265SessionParametersCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pParametersAddInfo)
- {
- handlemap_VkVideoEncodeH265SessionParametersAddInfoEXT(handlemap, (VkVideoEncodeH265SessionParametersAddInfoEXT*)(toMap->pParametersAddInfo));
+ if (toMap->pParametersAddInfo) {
+ handlemap_VkVideoEncodeH265SessionParametersAddInfoEXT(
+ handlemap, (VkVideoEncodeH265SessionParametersAddInfoEXT*)(toMap->pParametersAddInfo));
}
}
-void handlemap_VkVideoEncodeH265DpbSlotInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH265DpbSlotInfoEXT* toMap)
-{
+void handlemap_VkVideoEncodeH265DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH265DpbSlotInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkVideoEncodeH265ReferenceListsEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH265ReferenceListsEXT* toMap)
-{
+void handlemap_VkVideoEncodeH265ReferenceListsEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH265ReferenceListsEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pReferenceList0Entries)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->referenceList0EntryCount; ++i)
- {
- handlemap_VkVideoEncodeH265DpbSlotInfoEXT(handlemap, (VkVideoEncodeH265DpbSlotInfoEXT*)(toMap->pReferenceList0Entries + i));
+ if (toMap) {
+ if (toMap->pReferenceList0Entries) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->referenceList0EntryCount; ++i) {
+ handlemap_VkVideoEncodeH265DpbSlotInfoEXT(
+ handlemap,
+ (VkVideoEncodeH265DpbSlotInfoEXT*)(toMap->pReferenceList0Entries + i));
}
}
}
- if (toMap)
- {
- if (toMap->pReferenceList1Entries)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->referenceList1EntryCount; ++i)
- {
- handlemap_VkVideoEncodeH265DpbSlotInfoEXT(handlemap, (VkVideoEncodeH265DpbSlotInfoEXT*)(toMap->pReferenceList1Entries + i));
+ if (toMap) {
+ if (toMap->pReferenceList1Entries) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->referenceList1EntryCount; ++i) {
+ handlemap_VkVideoEncodeH265DpbSlotInfoEXT(
+ handlemap,
+ (VkVideoEncodeH265DpbSlotInfoEXT*)(toMap->pReferenceList1Entries + i));
}
}
}
}
-void handlemap_VkVideoEncodeH265NaluSliceEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH265NaluSliceEXT* toMap)
-{
+void handlemap_VkVideoEncodeH265NaluSliceEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH265NaluSliceEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pReferenceFinalLists)
- {
- handlemap_VkVideoEncodeH265ReferenceListsEXT(handlemap, (VkVideoEncodeH265ReferenceListsEXT*)(toMap->pReferenceFinalLists));
+ if (toMap->pReferenceFinalLists) {
+ handlemap_VkVideoEncodeH265ReferenceListsEXT(
+ handlemap, (VkVideoEncodeH265ReferenceListsEXT*)(toMap->pReferenceFinalLists));
}
}
-void handlemap_VkVideoEncodeH265VclFrameInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH265VclFrameInfoEXT* toMap)
-{
+void handlemap_VkVideoEncodeH265VclFrameInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH265VclFrameInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pReferenceFinalLists)
- {
- handlemap_VkVideoEncodeH265ReferenceListsEXT(handlemap, (VkVideoEncodeH265ReferenceListsEXT*)(toMap->pReferenceFinalLists));
+ if (toMap->pReferenceFinalLists) {
+ handlemap_VkVideoEncodeH265ReferenceListsEXT(
+ handlemap, (VkVideoEncodeH265ReferenceListsEXT*)(toMap->pReferenceFinalLists));
}
- if (toMap)
- {
- if (toMap->pNaluSliceEntries)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->naluSliceEntryCount; ++i)
- {
- handlemap_VkVideoEncodeH265NaluSliceEXT(handlemap, (VkVideoEncodeH265NaluSliceEXT*)(toMap->pNaluSliceEntries + i));
+ if (toMap) {
+ if (toMap->pNaluSliceEntries) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->naluSliceEntryCount; ++i) {
+ handlemap_VkVideoEncodeH265NaluSliceEXT(
+ handlemap, (VkVideoEncodeH265NaluSliceEXT*)(toMap->pNaluSliceEntries + i));
}
}
}
}
void handlemap_VkVideoEncodeH265EmitPictureParametersEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH265EmitPictureParametersEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkVideoEncodeH265EmitPictureParametersEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkVideoEncodeH265ProfileEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH265ProfileEXT* toMap)
-{
+void handlemap_VkVideoEncodeH265ProfileEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH265ProfileEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_EXT_video_decode_h264
-void handlemap_VkVideoDecodeH264ProfileEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH264ProfileEXT* toMap)
-{
+void handlemap_VkVideoDecodeH264ProfileEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH264ProfileEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkVideoDecodeH264CapabilitiesEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH264CapabilitiesEXT* toMap)
-{
+void handlemap_VkVideoDecodeH264CapabilitiesEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH264CapabilitiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->fieldOffsetGranularity));
- handlemap_VkExtensionProperties(handlemap, (VkExtensionProperties*)(&toMap->stdExtensionVersion));
+ handlemap_VkExtensionProperties(handlemap,
+ (VkExtensionProperties*)(&toMap->stdExtensionVersion));
}
-void handlemap_VkVideoDecodeH264SessionCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH264SessionCreateInfoEXT* toMap)
-{
+void handlemap_VkVideoDecodeH264SessionCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH264SessionCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pStdExtensionVersion)
- {
- handlemap_VkExtensionProperties(handlemap, (VkExtensionProperties*)(toMap->pStdExtensionVersion));
+ if (toMap->pStdExtensionVersion) {
+ handlemap_VkExtensionProperties(handlemap,
+ (VkExtensionProperties*)(toMap->pStdExtensionVersion));
}
}
void handlemap_VkVideoDecodeH264SessionParametersAddInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH264SessionParametersAddInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkVideoDecodeH264SessionParametersAddInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkVideoDecodeH264SessionParametersCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH264SessionParametersCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkVideoDecodeH264SessionParametersCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pParametersAddInfo)
- {
- handlemap_VkVideoDecodeH264SessionParametersAddInfoEXT(handlemap, (VkVideoDecodeH264SessionParametersAddInfoEXT*)(toMap->pParametersAddInfo));
+ if (toMap->pParametersAddInfo) {
+ handlemap_VkVideoDecodeH264SessionParametersAddInfoEXT(
+ handlemap, (VkVideoDecodeH264SessionParametersAddInfoEXT*)(toMap->pParametersAddInfo));
}
}
-void handlemap_VkVideoDecodeH264PictureInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH264PictureInfoEXT* toMap)
-{
+void handlemap_VkVideoDecodeH264PictureInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH264PictureInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkVideoDecodeH264MvcEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH264MvcEXT* toMap)
-{
+void handlemap_VkVideoDecodeH264MvcEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH264MvcEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkVideoDecodeH264DpbSlotInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH264DpbSlotInfoEXT* toMap)
-{
+void handlemap_VkVideoDecodeH264DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH264DpbSlotInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_AMD_texture_gather_bias_lod
-void handlemap_VkTextureLODGatherFormatPropertiesAMD(
- VulkanHandleMapping* handlemap,
- VkTextureLODGatherFormatPropertiesAMD* toMap)
-{
+void handlemap_VkTextureLODGatherFormatPropertiesAMD(VulkanHandleMapping* handlemap,
+ VkTextureLODGatherFormatPropertiesAMD* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_AMD_shader_info
-void handlemap_VkShaderResourceUsageAMD(
- VulkanHandleMapping* handlemap,
- VkShaderResourceUsageAMD* toMap)
-{
+void handlemap_VkShaderResourceUsageAMD(VulkanHandleMapping* handlemap,
+ VkShaderResourceUsageAMD* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkShaderStatisticsInfoAMD(
- VulkanHandleMapping* handlemap,
- VkShaderStatisticsInfoAMD* toMap)
-{
+void handlemap_VkShaderStatisticsInfoAMD(VulkanHandleMapping* handlemap,
+ VkShaderStatisticsInfoAMD* toMap) {
(void)handlemap;
(void)toMap;
- handlemap_VkShaderResourceUsageAMD(handlemap, (VkShaderResourceUsageAMD*)(&toMap->resourceUsage));
+ handlemap_VkShaderResourceUsageAMD(handlemap,
+ (VkShaderResourceUsageAMD*)(&toMap->resourceUsage));
}
#endif
@@ -6089,13 +4722,10 @@
#endif
#ifdef VK_GGP_stream_descriptor_surface
void handlemap_VkStreamDescriptorSurfaceCreateInfoGGP(
- VulkanHandleMapping* handlemap,
- VkStreamDescriptorSurfaceCreateInfoGGP* toMap)
-{
+ VulkanHandleMapping* handlemap, VkStreamDescriptorSurfaceCreateInfoGGP* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -6103,13 +4733,10 @@
#endif
#ifdef VK_NV_corner_sampled_image
void handlemap_VkPhysicalDeviceCornerSampledImageFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceCornerSampledImageFeaturesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceCornerSampledImageFeaturesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -6118,113 +4745,90 @@
#ifdef VK_IMG_format_pvrtc
#endif
#ifdef VK_NV_external_memory_capabilities
-void handlemap_VkExternalImageFormatPropertiesNV(
- VulkanHandleMapping* handlemap,
- VkExternalImageFormatPropertiesNV* toMap)
-{
+void handlemap_VkExternalImageFormatPropertiesNV(VulkanHandleMapping* handlemap,
+ VkExternalImageFormatPropertiesNV* toMap) {
(void)handlemap;
(void)toMap;
- handlemap_VkImageFormatProperties(handlemap, (VkImageFormatProperties*)(&toMap->imageFormatProperties));
+ handlemap_VkImageFormatProperties(handlemap,
+ (VkImageFormatProperties*)(&toMap->imageFormatProperties));
}
#endif
#ifdef VK_NV_external_memory
-void handlemap_VkExternalMemoryImageCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkExternalMemoryImageCreateInfoNV* toMap)
-{
+void handlemap_VkExternalMemoryImageCreateInfoNV(VulkanHandleMapping* handlemap,
+ VkExternalMemoryImageCreateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkExportMemoryAllocateInfoNV(
- VulkanHandleMapping* handlemap,
- VkExportMemoryAllocateInfoNV* toMap)
-{
+void handlemap_VkExportMemoryAllocateInfoNV(VulkanHandleMapping* handlemap,
+ VkExportMemoryAllocateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_NV_external_memory_win32
-void handlemap_VkImportMemoryWin32HandleInfoNV(
- VulkanHandleMapping* handlemap,
- VkImportMemoryWin32HandleInfoNV* toMap)
-{
+void handlemap_VkImportMemoryWin32HandleInfoNV(VulkanHandleMapping* handlemap,
+ VkImportMemoryWin32HandleInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkExportMemoryWin32HandleInfoNV(
- VulkanHandleMapping* handlemap,
- VkExportMemoryWin32HandleInfoNV* toMap)
-{
+void handlemap_VkExportMemoryWin32HandleInfoNV(VulkanHandleMapping* handlemap,
+ VkExportMemoryWin32HandleInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_NV_win32_keyed_mutex
-void handlemap_VkWin32KeyedMutexAcquireReleaseInfoNV(
- VulkanHandleMapping* handlemap,
- VkWin32KeyedMutexAcquireReleaseInfoNV* toMap)
-{
+void handlemap_VkWin32KeyedMutexAcquireReleaseInfoNV(VulkanHandleMapping* handlemap,
+ VkWin32KeyedMutexAcquireReleaseInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pAcquireSyncs)
- {
- handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pAcquireSyncs, toMap->acquireCount);
+ if (toMap->pAcquireSyncs) {
+ handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pAcquireSyncs,
+ toMap->acquireCount);
}
- if (toMap->pReleaseSyncs)
- {
- handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pReleaseSyncs, toMap->releaseCount);
+ if (toMap->pReleaseSyncs) {
+ handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)toMap->pReleaseSyncs,
+ toMap->releaseCount);
}
}
#endif
#ifdef VK_EXT_validation_flags
-void handlemap_VkValidationFlagsEXT(
- VulkanHandleMapping* handlemap,
- VkValidationFlagsEXT* toMap)
-{
+void handlemap_VkValidationFlagsEXT(VulkanHandleMapping* handlemap, VkValidationFlagsEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_NN_vi_surface
-void handlemap_VkViSurfaceCreateInfoNN(
- VulkanHandleMapping* handlemap,
- VkViSurfaceCreateInfoNN* toMap)
-{
+void handlemap_VkViSurfaceCreateInfoNN(VulkanHandleMapping* handlemap,
+ VkViSurfaceCreateInfoNN* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -6236,109 +4840,83 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
void handlemap_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_EXT_astc_decode_mode
-void handlemap_VkImageViewASTCDecodeModeEXT(
- VulkanHandleMapping* handlemap,
- VkImageViewASTCDecodeModeEXT* toMap)
-{
+void handlemap_VkImageViewASTCDecodeModeEXT(VulkanHandleMapping* handlemap,
+ VkImageViewASTCDecodeModeEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPhysicalDeviceASTCDecodeFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceASTCDecodeFeaturesEXT* toMap)
-{
+void handlemap_VkPhysicalDeviceASTCDecodeFeaturesEXT(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceASTCDecodeFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_EXT_conditional_rendering
-void handlemap_VkConditionalRenderingBeginInfoEXT(
- VulkanHandleMapping* handlemap,
- VkConditionalRenderingBeginInfoEXT* toMap)
-{
+void handlemap_VkConditionalRenderingBeginInfoEXT(VulkanHandleMapping* handlemap,
+ VkConditionalRenderingBeginInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
}
void handlemap_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceConditionalRenderingFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceConditionalRenderingFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
- VulkanHandleMapping* handlemap,
- VkCommandBufferInheritanceConditionalRenderingInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkCommandBufferInheritanceConditionalRenderingInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_NV_clip_space_w_scaling
-void handlemap_VkViewportWScalingNV(
- VulkanHandleMapping* handlemap,
- VkViewportWScalingNV* toMap)
-{
+void handlemap_VkViewportWScalingNV(VulkanHandleMapping* handlemap, VkViewportWScalingNV* toMap) {
(void)handlemap;
(void)toMap;
}
void handlemap_VkPipelineViewportWScalingStateCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkPipelineViewportWScalingStateCreateInfoNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineViewportWScalingStateCreateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pViewportWScalings)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->viewportCount; ++i)
- {
- handlemap_VkViewportWScalingNV(handlemap, (VkViewportWScalingNV*)(toMap->pViewportWScalings + i));
+ if (toMap) {
+ if (toMap->pViewportWScalings) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->viewportCount; ++i) {
+ handlemap_VkViewportWScalingNV(
+ handlemap, (VkViewportWScalingNV*)(toMap->pViewportWScalings + i));
}
}
}
@@ -6350,14 +4928,11 @@
#ifdef VK_EXT_acquire_xlib_display
#endif
#ifdef VK_EXT_display_surface_counter
-void handlemap_VkSurfaceCapabilities2EXT(
- VulkanHandleMapping* handlemap,
- VkSurfaceCapabilities2EXT* toMap)
-{
+void handlemap_VkSurfaceCapabilities2EXT(VulkanHandleMapping* handlemap,
+ VkSurfaceCapabilities2EXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->currentExtent));
@@ -6367,96 +4942,68 @@
#endif
#ifdef VK_EXT_display_control
-void handlemap_VkDisplayPowerInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDisplayPowerInfoEXT* toMap)
-{
+void handlemap_VkDisplayPowerInfoEXT(VulkanHandleMapping* handlemap, VkDisplayPowerInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDeviceEventInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDeviceEventInfoEXT* toMap)
-{
+void handlemap_VkDeviceEventInfoEXT(VulkanHandleMapping* handlemap, VkDeviceEventInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDisplayEventInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDisplayEventInfoEXT* toMap)
-{
+void handlemap_VkDisplayEventInfoEXT(VulkanHandleMapping* handlemap, VkDisplayEventInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkSwapchainCounterCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkSwapchainCounterCreateInfoEXT* toMap)
-{
+void handlemap_VkSwapchainCounterCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkSwapchainCounterCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_GOOGLE_display_timing
-void handlemap_VkRefreshCycleDurationGOOGLE(
- VulkanHandleMapping* handlemap,
- VkRefreshCycleDurationGOOGLE* toMap)
-{
+void handlemap_VkRefreshCycleDurationGOOGLE(VulkanHandleMapping* handlemap,
+ VkRefreshCycleDurationGOOGLE* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkPastPresentationTimingGOOGLE(
- VulkanHandleMapping* handlemap,
- VkPastPresentationTimingGOOGLE* toMap)
-{
+void handlemap_VkPastPresentationTimingGOOGLE(VulkanHandleMapping* handlemap,
+ VkPastPresentationTimingGOOGLE* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkPresentTimeGOOGLE(
- VulkanHandleMapping* handlemap,
- VkPresentTimeGOOGLE* toMap)
-{
+void handlemap_VkPresentTimeGOOGLE(VulkanHandleMapping* handlemap, VkPresentTimeGOOGLE* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkPresentTimesInfoGOOGLE(
- VulkanHandleMapping* handlemap,
- VkPresentTimesInfoGOOGLE* toMap)
-{
+void handlemap_VkPresentTimesInfoGOOGLE(VulkanHandleMapping* handlemap,
+ VkPresentTimesInfoGOOGLE* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pTimes)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->swapchainCount; ++i)
- {
+ if (toMap) {
+ if (toMap->pTimes) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->swapchainCount; ++i) {
handlemap_VkPresentTimeGOOGLE(handlemap, (VkPresentTimeGOOGLE*)(toMap->pTimes + i));
}
}
@@ -6473,43 +5020,33 @@
#ifdef VK_NVX_multiview_per_view_attributes
void handlemap_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toMap)
-{
+ VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_NV_viewport_swizzle
-void handlemap_VkViewportSwizzleNV(
- VulkanHandleMapping* handlemap,
- VkViewportSwizzleNV* toMap)
-{
+void handlemap_VkViewportSwizzleNV(VulkanHandleMapping* handlemap, VkViewportSwizzleNV* toMap) {
(void)handlemap;
(void)toMap;
}
void handlemap_VkPipelineViewportSwizzleStateCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkPipelineViewportSwizzleStateCreateInfoNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineViewportSwizzleStateCreateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pViewportSwizzles)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->viewportCount; ++i)
- {
- handlemap_VkViewportSwizzleNV(handlemap, (VkViewportSwizzleNV*)(toMap->pViewportSwizzles + i));
+ if (toMap) {
+ if (toMap->pViewportSwizzles) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->viewportCount; ++i) {
+ handlemap_VkViewportSwizzleNV(handlemap,
+ (VkViewportSwizzleNV*)(toMap->pViewportSwizzles + i));
}
}
}
@@ -6518,33 +5055,24 @@
#endif
#ifdef VK_EXT_discard_rectangles
void handlemap_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDiscardRectanglePropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDiscardRectanglePropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPipelineDiscardRectangleStateCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineDiscardRectangleStateCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineDiscardRectangleStateCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pDiscardRectangles)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->discardRectangleCount; ++i)
- {
+ if (toMap) {
+ if (toMap->pDiscardRectangles) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->discardRectangleCount; ++i) {
handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pDiscardRectangles + i));
}
}
@@ -6554,25 +5082,19 @@
#endif
#ifdef VK_EXT_conservative_rasterization
void handlemap_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceConservativeRasterizationPropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceConservativeRasterizationPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPipelineRasterizationConservativeStateCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineRasterizationConservativeStateCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineRasterizationConservativeStateCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -6580,25 +5102,19 @@
#endif
#ifdef VK_EXT_depth_clip_enable
void handlemap_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDepthClipEnableFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDepthClipEnableFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineRasterizationDepthClipStateCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineRasterizationDepthClipStateCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -6607,22 +5123,15 @@
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
-void handlemap_VkXYColorEXT(
- VulkanHandleMapping* handlemap,
- VkXYColorEXT* toMap)
-{
+void handlemap_VkXYColorEXT(VulkanHandleMapping* handlemap, VkXYColorEXT* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkHdrMetadataEXT(
- VulkanHandleMapping* handlemap,
- VkHdrMetadataEXT* toMap)
-{
+void handlemap_VkHdrMetadataEXT(VulkanHandleMapping* handlemap, VkHdrMetadataEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkXYColorEXT(handlemap, (VkXYColorEXT*)(&toMap->displayPrimaryRed));
@@ -6633,28 +5142,22 @@
#endif
#ifdef VK_MVK_ios_surface
-void handlemap_VkIOSSurfaceCreateInfoMVK(
- VulkanHandleMapping* handlemap,
- VkIOSSurfaceCreateInfoMVK* toMap)
-{
+void handlemap_VkIOSSurfaceCreateInfoMVK(VulkanHandleMapping* handlemap,
+ VkIOSSurfaceCreateInfoMVK* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_MVK_macos_surface
-void handlemap_VkMacOSSurfaceCreateInfoMVK(
- VulkanHandleMapping* handlemap,
- VkMacOSSurfaceCreateInfoMVK* toMap)
-{
+void handlemap_VkMacOSSurfaceCreateInfoMVK(VulkanHandleMapping* handlemap,
+ VkMacOSSurfaceCreateInfoMVK* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -6667,183 +5170,142 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
-void handlemap_VkDebugUtilsLabelEXT(
- VulkanHandleMapping* handlemap,
- VkDebugUtilsLabelEXT* toMap)
-{
+void handlemap_VkDebugUtilsLabelEXT(VulkanHandleMapping* handlemap, VkDebugUtilsLabelEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDebugUtilsObjectNameInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDebugUtilsObjectNameInfoEXT* toMap)
-{
+void handlemap_VkDebugUtilsObjectNameInfoEXT(VulkanHandleMapping* handlemap,
+ VkDebugUtilsObjectNameInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDebugUtilsMessengerCallbackDataEXT(
- VulkanHandleMapping* handlemap,
- VkDebugUtilsMessengerCallbackDataEXT* toMap)
-{
+void handlemap_VkDebugUtilsMessengerCallbackDataEXT(VulkanHandleMapping* handlemap,
+ VkDebugUtilsMessengerCallbackDataEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pQueueLabels)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->queueLabelCount; ++i)
- {
- handlemap_VkDebugUtilsLabelEXT(handlemap, (VkDebugUtilsLabelEXT*)(toMap->pQueueLabels + i));
+ if (toMap) {
+ if (toMap->pQueueLabels) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->queueLabelCount; ++i) {
+ handlemap_VkDebugUtilsLabelEXT(handlemap,
+ (VkDebugUtilsLabelEXT*)(toMap->pQueueLabels + i));
}
}
}
- if (toMap)
- {
- if (toMap->pCmdBufLabels)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->cmdBufLabelCount; ++i)
- {
- handlemap_VkDebugUtilsLabelEXT(handlemap, (VkDebugUtilsLabelEXT*)(toMap->pCmdBufLabels + i));
+ if (toMap) {
+ if (toMap->pCmdBufLabels) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->cmdBufLabelCount; ++i) {
+ handlemap_VkDebugUtilsLabelEXT(handlemap,
+ (VkDebugUtilsLabelEXT*)(toMap->pCmdBufLabels + i));
}
}
}
- if (toMap)
- {
- if (toMap->pObjects)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->objectCount; ++i)
- {
- handlemap_VkDebugUtilsObjectNameInfoEXT(handlemap, (VkDebugUtilsObjectNameInfoEXT*)(toMap->pObjects + i));
+ if (toMap) {
+ if (toMap->pObjects) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->objectCount; ++i) {
+ handlemap_VkDebugUtilsObjectNameInfoEXT(
+ handlemap, (VkDebugUtilsObjectNameInfoEXT*)(toMap->pObjects + i));
}
}
}
}
-void handlemap_VkDebugUtilsMessengerCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDebugUtilsMessengerCreateInfoEXT* toMap)
-{
+void handlemap_VkDebugUtilsMessengerCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkDebugUtilsMessengerCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDebugUtilsObjectTagInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDebugUtilsObjectTagInfoEXT* toMap)
-{
+void handlemap_VkDebugUtilsObjectTagInfoEXT(VulkanHandleMapping* handlemap,
+ VkDebugUtilsObjectTagInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
-void handlemap_VkAndroidHardwareBufferUsageANDROID(
- VulkanHandleMapping* handlemap,
- VkAndroidHardwareBufferUsageANDROID* toMap)
-{
+void handlemap_VkAndroidHardwareBufferUsageANDROID(VulkanHandleMapping* handlemap,
+ VkAndroidHardwareBufferUsageANDROID* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkAndroidHardwareBufferPropertiesANDROID(
- VulkanHandleMapping* handlemap,
- VkAndroidHardwareBufferPropertiesANDROID* toMap)
-{
+ VulkanHandleMapping* handlemap, VkAndroidHardwareBufferPropertiesANDROID* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkAndroidHardwareBufferFormatPropertiesANDROID(
- VulkanHandleMapping* handlemap,
- VkAndroidHardwareBufferFormatPropertiesANDROID* toMap)
-{
+ VulkanHandleMapping* handlemap, VkAndroidHardwareBufferFormatPropertiesANDROID* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkComponentMapping(handlemap, (VkComponentMapping*)(&toMap->samplerYcbcrConversionComponents));
+ handlemap_VkComponentMapping(handlemap,
+ (VkComponentMapping*)(&toMap->samplerYcbcrConversionComponents));
}
void handlemap_VkImportAndroidHardwareBufferInfoANDROID(
- VulkanHandleMapping* handlemap,
- VkImportAndroidHardwareBufferInfoANDROID* toMap)
-{
+ VulkanHandleMapping* handlemap, VkImportAndroidHardwareBufferInfoANDROID* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkMemoryGetAndroidHardwareBufferInfoANDROID(
- VulkanHandleMapping* handlemap,
- VkMemoryGetAndroidHardwareBufferInfoANDROID* toMap)
-{
+ VulkanHandleMapping* handlemap, VkMemoryGetAndroidHardwareBufferInfoANDROID* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
}
-void handlemap_VkExternalFormatANDROID(
- VulkanHandleMapping* handlemap,
- VkExternalFormatANDROID* toMap)
-{
+void handlemap_VkExternalFormatANDROID(VulkanHandleMapping* handlemap,
+ VkExternalFormatANDROID* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkAndroidHardwareBufferFormatProperties2ANDROID(
- VulkanHandleMapping* handlemap,
- VkAndroidHardwareBufferFormatProperties2ANDROID* toMap)
-{
+ VulkanHandleMapping* handlemap, VkAndroidHardwareBufferFormatProperties2ANDROID* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkComponentMapping(handlemap, (VkComponentMapping*)(&toMap->samplerYcbcrConversionComponents));
+ handlemap_VkComponentMapping(handlemap,
+ (VkComponentMapping*)(&toMap->samplerYcbcrConversionComponents));
}
#endif
@@ -6857,49 +5319,37 @@
#endif
#ifdef VK_EXT_inline_uniform_block
void handlemap_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkWriteDescriptorSetInlineUniformBlockEXT(
- VulkanHandleMapping* handlemap,
- VkWriteDescriptorSetInlineUniformBlockEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkWriteDescriptorSetInlineUniformBlockEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -6908,121 +5358,99 @@
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
-void handlemap_VkSampleLocationEXT(
- VulkanHandleMapping* handlemap,
- VkSampleLocationEXT* toMap)
-{
+void handlemap_VkSampleLocationEXT(VulkanHandleMapping* handlemap, VkSampleLocationEXT* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkSampleLocationsInfoEXT(
- VulkanHandleMapping* handlemap,
- VkSampleLocationsInfoEXT* toMap)
-{
+void handlemap_VkSampleLocationsInfoEXT(VulkanHandleMapping* handlemap,
+ VkSampleLocationsInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->sampleLocationGridSize));
- if (toMap)
- {
- if (toMap->pSampleLocations)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->sampleLocationsCount; ++i)
- {
- handlemap_VkSampleLocationEXT(handlemap, (VkSampleLocationEXT*)(toMap->pSampleLocations + i));
+ if (toMap) {
+ if (toMap->pSampleLocations) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->sampleLocationsCount; ++i) {
+ handlemap_VkSampleLocationEXT(handlemap,
+ (VkSampleLocationEXT*)(toMap->pSampleLocations + i));
}
}
}
}
-void handlemap_VkAttachmentSampleLocationsEXT(
- VulkanHandleMapping* handlemap,
- VkAttachmentSampleLocationsEXT* toMap)
-{
+void handlemap_VkAttachmentSampleLocationsEXT(VulkanHandleMapping* handlemap,
+ VkAttachmentSampleLocationsEXT* toMap) {
(void)handlemap;
(void)toMap;
- handlemap_VkSampleLocationsInfoEXT(handlemap, (VkSampleLocationsInfoEXT*)(&toMap->sampleLocationsInfo));
+ handlemap_VkSampleLocationsInfoEXT(handlemap,
+ (VkSampleLocationsInfoEXT*)(&toMap->sampleLocationsInfo));
}
-void handlemap_VkSubpassSampleLocationsEXT(
- VulkanHandleMapping* handlemap,
- VkSubpassSampleLocationsEXT* toMap)
-{
+void handlemap_VkSubpassSampleLocationsEXT(VulkanHandleMapping* handlemap,
+ VkSubpassSampleLocationsEXT* toMap) {
(void)handlemap;
(void)toMap;
- handlemap_VkSampleLocationsInfoEXT(handlemap, (VkSampleLocationsInfoEXT*)(&toMap->sampleLocationsInfo));
+ handlemap_VkSampleLocationsInfoEXT(handlemap,
+ (VkSampleLocationsInfoEXT*)(&toMap->sampleLocationsInfo));
}
void handlemap_VkRenderPassSampleLocationsBeginInfoEXT(
- VulkanHandleMapping* handlemap,
- VkRenderPassSampleLocationsBeginInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkRenderPassSampleLocationsBeginInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pAttachmentInitialSampleLocations)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->attachmentInitialSampleLocationsCount; ++i)
- {
- handlemap_VkAttachmentSampleLocationsEXT(handlemap, (VkAttachmentSampleLocationsEXT*)(toMap->pAttachmentInitialSampleLocations + i));
+ if (toMap) {
+ if (toMap->pAttachmentInitialSampleLocations) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->attachmentInitialSampleLocationsCount; ++i) {
+ handlemap_VkAttachmentSampleLocationsEXT(
+ handlemap,
+ (VkAttachmentSampleLocationsEXT*)(toMap->pAttachmentInitialSampleLocations +
+ i));
}
}
}
- if (toMap)
- {
- if (toMap->pPostSubpassSampleLocations)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->postSubpassSampleLocationsCount; ++i)
- {
- handlemap_VkSubpassSampleLocationsEXT(handlemap, (VkSubpassSampleLocationsEXT*)(toMap->pPostSubpassSampleLocations + i));
+ if (toMap) {
+ if (toMap->pPostSubpassSampleLocations) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->postSubpassSampleLocationsCount; ++i) {
+ handlemap_VkSubpassSampleLocationsEXT(
+ handlemap,
+ (VkSubpassSampleLocationsEXT*)(toMap->pPostSubpassSampleLocations + i));
}
}
}
}
void handlemap_VkPipelineSampleLocationsStateCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineSampleLocationsStateCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineSampleLocationsStateCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkSampleLocationsInfoEXT(handlemap, (VkSampleLocationsInfoEXT*)(&toMap->sampleLocationsInfo));
+ handlemap_VkSampleLocationsInfoEXT(handlemap,
+ (VkSampleLocationsInfoEXT*)(&toMap->sampleLocationsInfo));
}
void handlemap_VkPhysicalDeviceSampleLocationsPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSampleLocationsPropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceSampleLocationsPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxSampleLocationGridSize));
}
-void handlemap_VkMultisamplePropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkMultisamplePropertiesEXT* toMap)
-{
+void handlemap_VkMultisamplePropertiesEXT(VulkanHandleMapping* handlemap,
+ VkMultisamplePropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxSampleLocationGridSize));
@@ -7031,37 +5459,28 @@
#endif
#ifdef VK_EXT_blend_operation_advanced
void handlemap_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineColorBlendAdvancedStateCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineColorBlendAdvancedStateCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -7069,13 +5488,10 @@
#endif
#ifdef VK_NV_fragment_coverage_to_color
void handlemap_VkPipelineCoverageToColorStateCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkPipelineCoverageToColorStateCreateInfoNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineCoverageToColorStateCreateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -7083,13 +5499,10 @@
#endif
#ifdef VK_NV_framebuffer_mixed_samples
void handlemap_VkPipelineCoverageModulationStateCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkPipelineCoverageModulationStateCreateInfoNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineCoverageModulationStateCreateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -7099,25 +5512,19 @@
#endif
#ifdef VK_NV_shader_sm_builtins
void handlemap_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -7126,119 +5533,93 @@
#ifdef VK_EXT_post_depth_coverage
#endif
#ifdef VK_EXT_image_drm_format_modifier
-void handlemap_VkDrmFormatModifierPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkDrmFormatModifierPropertiesEXT* toMap)
-{
+void handlemap_VkDrmFormatModifierPropertiesEXT(VulkanHandleMapping* handlemap,
+ VkDrmFormatModifierPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkDrmFormatModifierPropertiesListEXT(
- VulkanHandleMapping* handlemap,
- VkDrmFormatModifierPropertiesListEXT* toMap)
-{
+void handlemap_VkDrmFormatModifierPropertiesListEXT(VulkanHandleMapping* handlemap,
+ VkDrmFormatModifierPropertiesListEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pDrmFormatModifierProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->drmFormatModifierCount; ++i)
- {
- handlemap_VkDrmFormatModifierPropertiesEXT(handlemap, (VkDrmFormatModifierPropertiesEXT*)(toMap->pDrmFormatModifierProperties + i));
+ if (toMap) {
+ if (toMap->pDrmFormatModifierProperties) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->drmFormatModifierCount; ++i) {
+ handlemap_VkDrmFormatModifierPropertiesEXT(
+ handlemap,
+ (VkDrmFormatModifierPropertiesEXT*)(toMap->pDrmFormatModifierProperties + i));
}
}
}
}
void handlemap_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceImageDrmFormatModifierInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceImageDrmFormatModifierInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkImageDrmFormatModifierListCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkImageDrmFormatModifierListCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkImageDrmFormatModifierListCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkImageDrmFormatModifierExplicitCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkImageDrmFormatModifierExplicitCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkImageDrmFormatModifierExplicitCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pPlaneLayouts)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->drmFormatModifierPlaneCount; ++i)
- {
- handlemap_VkSubresourceLayout(handlemap, (VkSubresourceLayout*)(toMap->pPlaneLayouts + i));
+ if (toMap) {
+ if (toMap->pPlaneLayouts) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->drmFormatModifierPlaneCount; ++i) {
+ handlemap_VkSubresourceLayout(handlemap,
+ (VkSubresourceLayout*)(toMap->pPlaneLayouts + i));
}
}
}
}
-void handlemap_VkImageDrmFormatModifierPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkImageDrmFormatModifierPropertiesEXT* toMap)
-{
+void handlemap_VkImageDrmFormatModifierPropertiesEXT(VulkanHandleMapping* handlemap,
+ VkImageDrmFormatModifierPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDrmFormatModifierProperties2EXT(
- VulkanHandleMapping* handlemap,
- VkDrmFormatModifierProperties2EXT* toMap)
-{
+void handlemap_VkDrmFormatModifierProperties2EXT(VulkanHandleMapping* handlemap,
+ VkDrmFormatModifierProperties2EXT* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkDrmFormatModifierPropertiesList2EXT(
- VulkanHandleMapping* handlemap,
- VkDrmFormatModifierPropertiesList2EXT* toMap)
-{
+void handlemap_VkDrmFormatModifierPropertiesList2EXT(VulkanHandleMapping* handlemap,
+ VkDrmFormatModifierPropertiesList2EXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pDrmFormatModifierProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->drmFormatModifierCount; ++i)
- {
- handlemap_VkDrmFormatModifierProperties2EXT(handlemap, (VkDrmFormatModifierProperties2EXT*)(toMap->pDrmFormatModifierProperties + i));
+ if (toMap) {
+ if (toMap->pDrmFormatModifierProperties) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->drmFormatModifierCount; ++i) {
+ handlemap_VkDrmFormatModifierProperties2EXT(
+ handlemap,
+ (VkDrmFormatModifierProperties2EXT*)(toMap->pDrmFormatModifierProperties + i));
}
}
}
@@ -7246,26 +5627,20 @@
#endif
#ifdef VK_EXT_validation_cache
-void handlemap_VkValidationCacheCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkValidationCacheCreateInfoEXT* toMap)
-{
+void handlemap_VkValidationCacheCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkValidationCacheCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkShaderModuleValidationCacheCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkShaderModuleValidationCacheCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkShaderModuleValidationCacheCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkValidationCacheEXT((VkValidationCacheEXT*)&toMap->validationCache);
@@ -7277,104 +5652,80 @@
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_NV_shading_rate_image
-void handlemap_VkShadingRatePaletteNV(
- VulkanHandleMapping* handlemap,
- VkShadingRatePaletteNV* toMap)
-{
+void handlemap_VkShadingRatePaletteNV(VulkanHandleMapping* handlemap,
+ VkShadingRatePaletteNV* toMap) {
(void)handlemap;
(void)toMap;
}
void handlemap_VkPipelineViewportShadingRateImageStateCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkPipelineViewportShadingRateImageStateCreateInfoNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineViewportShadingRateImageStateCreateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pShadingRatePalettes)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->viewportCount; ++i)
- {
- handlemap_VkShadingRatePaletteNV(handlemap, (VkShadingRatePaletteNV*)(toMap->pShadingRatePalettes + i));
+ if (toMap) {
+ if (toMap->pShadingRatePalettes) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->viewportCount; ++i) {
+ handlemap_VkShadingRatePaletteNV(
+ handlemap, (VkShadingRatePaletteNV*)(toMap->pShadingRatePalettes + i));
}
}
}
}
void handlemap_VkPhysicalDeviceShadingRateImageFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShadingRateImageFeaturesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShadingRateImageFeaturesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceShadingRateImagePropertiesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShadingRateImagePropertiesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShadingRateImagePropertiesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->shadingRateTexelSize));
}
-void handlemap_VkCoarseSampleLocationNV(
- VulkanHandleMapping* handlemap,
- VkCoarseSampleLocationNV* toMap)
-{
+void handlemap_VkCoarseSampleLocationNV(VulkanHandleMapping* handlemap,
+ VkCoarseSampleLocationNV* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkCoarseSampleOrderCustomNV(
- VulkanHandleMapping* handlemap,
- VkCoarseSampleOrderCustomNV* toMap)
-{
+void handlemap_VkCoarseSampleOrderCustomNV(VulkanHandleMapping* handlemap,
+ VkCoarseSampleOrderCustomNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap)
- {
- if (toMap->pSampleLocations)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->sampleLocationCount; ++i)
- {
- handlemap_VkCoarseSampleLocationNV(handlemap, (VkCoarseSampleLocationNV*)(toMap->pSampleLocations + i));
+ if (toMap) {
+ if (toMap->pSampleLocations) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->sampleLocationCount; ++i) {
+ handlemap_VkCoarseSampleLocationNV(
+ handlemap, (VkCoarseSampleLocationNV*)(toMap->pSampleLocations + i));
}
}
}
}
void handlemap_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pCustomSampleOrders)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->customSampleOrderCount; ++i)
- {
- handlemap_VkCoarseSampleOrderCustomNV(handlemap, (VkCoarseSampleOrderCustomNV*)(toMap->pCustomSampleOrders + i));
+ if (toMap) {
+ if (toMap->pCustomSampleOrders) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->customSampleOrderCount; ++i) {
+ handlemap_VkCoarseSampleOrderCustomNV(
+ handlemap, (VkCoarseSampleOrderCustomNV*)(toMap->pCustomSampleOrders + i));
}
}
}
@@ -7382,45 +5733,35 @@
#endif
#ifdef VK_NV_ray_tracing
-void handlemap_VkRayTracingShaderGroupCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkRayTracingShaderGroupCreateInfoNV* toMap)
-{
+void handlemap_VkRayTracingShaderGroupCreateInfoNV(VulkanHandleMapping* handlemap,
+ VkRayTracingShaderGroupCreateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkRayTracingPipelineCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkRayTracingPipelineCreateInfoNV* toMap)
-{
+void handlemap_VkRayTracingPipelineCreateInfoNV(VulkanHandleMapping* handlemap,
+ VkRayTracingPipelineCreateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pStages)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->stageCount; ++i)
- {
- handlemap_VkPipelineShaderStageCreateInfo(handlemap, (VkPipelineShaderStageCreateInfo*)(toMap->pStages + i));
+ if (toMap) {
+ if (toMap->pStages) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->stageCount; ++i) {
+ handlemap_VkPipelineShaderStageCreateInfo(
+ handlemap, (VkPipelineShaderStageCreateInfo*)(toMap->pStages + i));
}
}
}
- if (toMap)
- {
- if (toMap->pGroups)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->groupCount; ++i)
- {
- handlemap_VkRayTracingShaderGroupCreateInfoNV(handlemap, (VkRayTracingShaderGroupCreateInfoNV*)(toMap->pGroups + i));
+ if (toMap) {
+ if (toMap->pGroups) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->groupCount; ++i) {
+ handlemap_VkRayTracingShaderGroupCreateInfoNV(
+ handlemap, (VkRayTracingShaderGroupCreateInfoNV*)(toMap->pGroups + i));
}
}
}
@@ -7428,14 +5769,10 @@
handlemap->mapHandles_VkPipeline((VkPipeline*)&toMap->basePipelineHandle);
}
-void handlemap_VkGeometryTrianglesNV(
- VulkanHandleMapping* handlemap,
- VkGeometryTrianglesNV* toMap)
-{
+void handlemap_VkGeometryTrianglesNV(VulkanHandleMapping* handlemap, VkGeometryTrianglesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->vertexData);
@@ -7443,152 +5780,116 @@
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->transformData);
}
-void handlemap_VkGeometryAABBNV(
- VulkanHandleMapping* handlemap,
- VkGeometryAABBNV* toMap)
-{
+void handlemap_VkGeometryAABBNV(VulkanHandleMapping* handlemap, VkGeometryAABBNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->aabbData);
}
-void handlemap_VkGeometryDataNV(
- VulkanHandleMapping* handlemap,
- VkGeometryDataNV* toMap)
-{
+void handlemap_VkGeometryDataNV(VulkanHandleMapping* handlemap, VkGeometryDataNV* toMap) {
(void)handlemap;
(void)toMap;
handlemap_VkGeometryTrianglesNV(handlemap, (VkGeometryTrianglesNV*)(&toMap->triangles));
handlemap_VkGeometryAABBNV(handlemap, (VkGeometryAABBNV*)(&toMap->aabbs));
}
-void handlemap_VkGeometryNV(
- VulkanHandleMapping* handlemap,
- VkGeometryNV* toMap)
-{
+void handlemap_VkGeometryNV(VulkanHandleMapping* handlemap, VkGeometryNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkGeometryDataNV(handlemap, (VkGeometryDataNV*)(&toMap->geometry));
}
-void handlemap_VkAccelerationStructureInfoNV(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureInfoNV* toMap)
-{
+void handlemap_VkAccelerationStructureInfoNV(VulkanHandleMapping* handlemap,
+ VkAccelerationStructureInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pGeometries)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->geometryCount; ++i)
- {
+ if (toMap) {
+ if (toMap->pGeometries) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->geometryCount; ++i) {
handlemap_VkGeometryNV(handlemap, (VkGeometryNV*)(toMap->pGeometries + i));
}
}
}
}
-void handlemap_VkAccelerationStructureCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureCreateInfoNV* toMap)
-{
+void handlemap_VkAccelerationStructureCreateInfoNV(VulkanHandleMapping* handlemap,
+ VkAccelerationStructureCreateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkAccelerationStructureInfoNV(handlemap, (VkAccelerationStructureInfoNV*)(&toMap->info));
+ handlemap_VkAccelerationStructureInfoNV(handlemap,
+ (VkAccelerationStructureInfoNV*)(&toMap->info));
}
void handlemap_VkBindAccelerationStructureMemoryInfoNV(
- VulkanHandleMapping* handlemap,
- VkBindAccelerationStructureMemoryInfoNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkBindAccelerationStructureMemoryInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap->mapHandles_VkAccelerationStructureNV((VkAccelerationStructureNV*)&toMap->accelerationStructure);
+ handlemap->mapHandles_VkAccelerationStructureNV(
+ (VkAccelerationStructureNV*)&toMap->accelerationStructure);
handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
}
void handlemap_VkWriteDescriptorSetAccelerationStructureNV(
- VulkanHandleMapping* handlemap,
- VkWriteDescriptorSetAccelerationStructureNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkWriteDescriptorSetAccelerationStructureNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pAccelerationStructures)
- {
- handlemap->mapHandles_VkAccelerationStructureNV((VkAccelerationStructureNV*)toMap->pAccelerationStructures, toMap->accelerationStructureCount);
+ if (toMap->pAccelerationStructures) {
+ handlemap->mapHandles_VkAccelerationStructureNV(
+ (VkAccelerationStructureNV*)toMap->pAccelerationStructures,
+ toMap->accelerationStructureCount);
}
}
void handlemap_VkAccelerationStructureMemoryRequirementsInfoNV(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureMemoryRequirementsInfoNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkAccelerationStructureMemoryRequirementsInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap->mapHandles_VkAccelerationStructureNV((VkAccelerationStructureNV*)&toMap->accelerationStructure);
+ handlemap->mapHandles_VkAccelerationStructureNV(
+ (VkAccelerationStructureNV*)&toMap->accelerationStructure);
}
void handlemap_VkPhysicalDeviceRayTracingPropertiesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceRayTracingPropertiesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingPropertiesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkTransformMatrixKHR(
- VulkanHandleMapping* handlemap,
- VkTransformMatrixKHR* toMap)
-{
+void handlemap_VkTransformMatrixKHR(VulkanHandleMapping* handlemap, VkTransformMatrixKHR* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkAabbPositionsKHR(
- VulkanHandleMapping* handlemap,
- VkAabbPositionsKHR* toMap)
-{
+void handlemap_VkAabbPositionsKHR(VulkanHandleMapping* handlemap, VkAabbPositionsKHR* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkAccelerationStructureInstanceKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureInstanceKHR* toMap)
-{
+void handlemap_VkAccelerationStructureInstanceKHR(VulkanHandleMapping* handlemap,
+ VkAccelerationStructureInstanceKHR* toMap) {
(void)handlemap;
(void)toMap;
handlemap_VkTransformMatrixKHR(handlemap, (VkTransformMatrixKHR*)(&toMap->transform));
@@ -7597,25 +5898,19 @@
#endif
#ifdef VK_NV_representative_fragment_test
void handlemap_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkPipelineRepresentativeFragmentTestStateCreateInfoNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineRepresentativeFragmentTestStateCreateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -7623,25 +5918,19 @@
#endif
#ifdef VK_EXT_filter_cubic
void handlemap_VkPhysicalDeviceImageViewImageFormatInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceImageViewImageFormatInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceImageViewImageFormatInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkFilterCubicImageViewImageFormatPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkFilterCubicImageViewImageFormatPropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkFilterCubicImageViewImageFormatPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -7651,51 +5940,39 @@
#endif
#ifdef VK_EXT_global_priority
void handlemap_VkDeviceQueueGlobalPriorityCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDeviceQueueGlobalPriorityCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkDeviceQueueGlobalPriorityCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_EXT_external_memory_host
-void handlemap_VkImportMemoryHostPointerInfoEXT(
- VulkanHandleMapping* handlemap,
- VkImportMemoryHostPointerInfoEXT* toMap)
-{
+void handlemap_VkImportMemoryHostPointerInfoEXT(VulkanHandleMapping* handlemap,
+ VkImportMemoryHostPointerInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkMemoryHostPointerPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkMemoryHostPointerPropertiesEXT* toMap)
-{
+void handlemap_VkMemoryHostPointerPropertiesEXT(VulkanHandleMapping* handlemap,
+ VkMemoryHostPointerPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -7705,27 +5982,21 @@
#endif
#ifdef VK_AMD_pipeline_compiler_control
void handlemap_VkPipelineCompilerControlCreateInfoAMD(
- VulkanHandleMapping* handlemap,
- VkPipelineCompilerControlCreateInfoAMD* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineCompilerControlCreateInfoAMD* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_EXT_calibrated_timestamps
-void handlemap_VkCalibratedTimestampInfoEXT(
- VulkanHandleMapping* handlemap,
- VkCalibratedTimestampInfoEXT* toMap)
-{
+void handlemap_VkCalibratedTimestampInfoEXT(VulkanHandleMapping* handlemap,
+ VkCalibratedTimestampInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -7733,108 +6004,85 @@
#endif
#ifdef VK_AMD_shader_core_properties
void handlemap_VkPhysicalDeviceShaderCorePropertiesAMD(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderCorePropertiesAMD* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderCorePropertiesAMD* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_EXT_video_decode_h265
-void handlemap_VkVideoDecodeH265ProfileEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH265ProfileEXT* toMap)
-{
+void handlemap_VkVideoDecodeH265ProfileEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH265ProfileEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkVideoDecodeH265CapabilitiesEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH265CapabilitiesEXT* toMap)
-{
+void handlemap_VkVideoDecodeH265CapabilitiesEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH265CapabilitiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkExtensionProperties(handlemap, (VkExtensionProperties*)(&toMap->stdExtensionVersion));
+ handlemap_VkExtensionProperties(handlemap,
+ (VkExtensionProperties*)(&toMap->stdExtensionVersion));
}
-void handlemap_VkVideoDecodeH265SessionCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH265SessionCreateInfoEXT* toMap)
-{
+void handlemap_VkVideoDecodeH265SessionCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH265SessionCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pStdExtensionVersion)
- {
- handlemap_VkExtensionProperties(handlemap, (VkExtensionProperties*)(toMap->pStdExtensionVersion));
+ if (toMap->pStdExtensionVersion) {
+ handlemap_VkExtensionProperties(handlemap,
+ (VkExtensionProperties*)(toMap->pStdExtensionVersion));
}
}
void handlemap_VkVideoDecodeH265SessionParametersAddInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH265SessionParametersAddInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkVideoDecodeH265SessionParametersAddInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkVideoDecodeH265SessionParametersCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH265SessionParametersCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkVideoDecodeH265SessionParametersCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pParametersAddInfo)
- {
- handlemap_VkVideoDecodeH265SessionParametersAddInfoEXT(handlemap, (VkVideoDecodeH265SessionParametersAddInfoEXT*)(toMap->pParametersAddInfo));
+ if (toMap->pParametersAddInfo) {
+ handlemap_VkVideoDecodeH265SessionParametersAddInfoEXT(
+ handlemap, (VkVideoDecodeH265SessionParametersAddInfoEXT*)(toMap->pParametersAddInfo));
}
}
-void handlemap_VkVideoDecodeH265PictureInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH265PictureInfoEXT* toMap)
-{
+void handlemap_VkVideoDecodeH265PictureInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH265PictureInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkVideoDecodeH265DpbSlotInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH265DpbSlotInfoEXT* toMap)
-{
+void handlemap_VkVideoDecodeH265DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH265DpbSlotInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -7842,13 +6090,10 @@
#endif
#ifdef VK_AMD_memory_overallocation_behavior
void handlemap_VkDeviceMemoryOverallocationCreateInfoAMD(
- VulkanHandleMapping* handlemap,
- VkDeviceMemoryOverallocationCreateInfoAMD* toMap)
-{
+ VulkanHandleMapping* handlemap, VkDeviceMemoryOverallocationCreateInfoAMD* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -7856,104 +6101,84 @@
#endif
#ifdef VK_EXT_vertex_attribute_divisor
void handlemap_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkVertexInputBindingDivisorDescriptionEXT(
- VulkanHandleMapping* handlemap,
- VkVertexInputBindingDivisorDescriptionEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkVertexInputBindingDivisorDescriptionEXT* toMap) {
(void)handlemap;
(void)toMap;
}
void handlemap_VkPipelineVertexInputDivisorStateCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineVertexInputDivisorStateCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineVertexInputDivisorStateCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pVertexBindingDivisors)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->vertexBindingDivisorCount; ++i)
- {
- handlemap_VkVertexInputBindingDivisorDescriptionEXT(handlemap, (VkVertexInputBindingDivisorDescriptionEXT*)(toMap->pVertexBindingDivisors + i));
+ if (toMap) {
+ if (toMap->pVertexBindingDivisors) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->vertexBindingDivisorCount; ++i) {
+ handlemap_VkVertexInputBindingDivisorDescriptionEXT(
+ handlemap,
+ (VkVertexInputBindingDivisorDescriptionEXT*)(toMap->pVertexBindingDivisors +
+ i));
}
}
}
}
void handlemap_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_GGP_frame_token
-void handlemap_VkPresentFrameTokenGGP(
- VulkanHandleMapping* handlemap,
- VkPresentFrameTokenGGP* toMap)
-{
+void handlemap_VkPresentFrameTokenGGP(VulkanHandleMapping* handlemap,
+ VkPresentFrameTokenGGP* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_EXT_pipeline_creation_feedback
-void handlemap_VkPipelineCreationFeedbackEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineCreationFeedbackEXT* toMap)
-{
+void handlemap_VkPipelineCreationFeedbackEXT(VulkanHandleMapping* handlemap,
+ VkPipelineCreationFeedbackEXT* toMap) {
(void)handlemap;
(void)toMap;
}
void handlemap_VkPipelineCreationFeedbackCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineCreationFeedbackCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineCreationFeedbackCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pPipelineCreationFeedback)
- {
- handlemap_VkPipelineCreationFeedbackEXT(handlemap, (VkPipelineCreationFeedbackEXT*)(toMap->pPipelineCreationFeedback));
+ if (toMap->pPipelineCreationFeedback) {
+ handlemap_VkPipelineCreationFeedbackEXT(
+ handlemap, (VkPipelineCreationFeedbackEXT*)(toMap->pPipelineCreationFeedback));
}
- if (toMap)
- {
- if (toMap->pPipelineStageCreationFeedbacks)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->pipelineStageCreationFeedbackCount; ++i)
- {
- handlemap_VkPipelineCreationFeedbackEXT(handlemap, (VkPipelineCreationFeedbackEXT*)(toMap->pPipelineStageCreationFeedbacks + i));
+ if (toMap) {
+ if (toMap->pPipelineStageCreationFeedbacks) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->pipelineStageCreationFeedbackCount; ++i) {
+ handlemap_VkPipelineCreationFeedbackEXT(
+ handlemap,
+ (VkPipelineCreationFeedbackEXT*)(toMap->pPipelineStageCreationFeedbacks + i));
}
}
}
@@ -7964,47 +6189,36 @@
#endif
#ifdef VK_NV_compute_shader_derivatives
void handlemap_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_NV_mesh_shader
-void handlemap_VkPhysicalDeviceMeshShaderFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMeshShaderFeaturesNV* toMap)
-{
+void handlemap_VkPhysicalDeviceMeshShaderFeaturesNV(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMeshShaderFeaturesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceMeshShaderPropertiesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMeshShaderPropertiesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceMeshShaderPropertiesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDrawMeshTasksIndirectCommandNV(
- VulkanHandleMapping* handlemap,
- VkDrawMeshTasksIndirectCommandNV* toMap)
-{
+void handlemap_VkDrawMeshTasksIndirectCommandNV(VulkanHandleMapping* handlemap,
+ VkDrawMeshTasksIndirectCommandNV* toMap) {
(void)handlemap;
(void)toMap;
}
@@ -8012,13 +6226,10 @@
#endif
#ifdef VK_NV_fragment_shader_barycentric
void handlemap_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8026,13 +6237,10 @@
#endif
#ifdef VK_NV_shader_image_footprint
void handlemap_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderImageFootprintFeaturesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderImageFootprintFeaturesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8040,21 +6248,15 @@
#endif
#ifdef VK_NV_scissor_exclusive
void handlemap_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkPipelineViewportExclusiveScissorStateCreateInfoNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineViewportExclusiveScissorStateCreateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pExclusiveScissors)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->exclusiveScissorCount; ++i)
- {
+ if (toMap) {
+ if (toMap->pExclusiveScissors) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->exclusiveScissorCount; ++i) {
handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pExclusiveScissors + i));
}
}
@@ -8062,39 +6264,29 @@
}
void handlemap_VkPhysicalDeviceExclusiveScissorFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceExclusiveScissorFeaturesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceExclusiveScissorFeaturesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
-void handlemap_VkQueueFamilyCheckpointPropertiesNV(
- VulkanHandleMapping* handlemap,
- VkQueueFamilyCheckpointPropertiesNV* toMap)
-{
+void handlemap_VkQueueFamilyCheckpointPropertiesNV(VulkanHandleMapping* handlemap,
+ VkQueueFamilyCheckpointPropertiesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkCheckpointDataNV(
- VulkanHandleMapping* handlemap,
- VkCheckpointDataNV* toMap)
-{
+void handlemap_VkCheckpointDataNV(VulkanHandleMapping* handlemap, VkCheckpointDataNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8102,104 +6294,79 @@
#endif
#ifdef VK_INTEL_shader_integer_functions2
void handlemap_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_INTEL_performance_query
-void handlemap_VkPerformanceValueDataINTEL(
- VulkanHandleMapping* handlemap,
- VkPerformanceValueDataINTEL* toMap)
-{
+void handlemap_VkPerformanceValueDataINTEL(VulkanHandleMapping* handlemap,
+ VkPerformanceValueDataINTEL* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkPerformanceValueINTEL(
- VulkanHandleMapping* handlemap,
- VkPerformanceValueINTEL* toMap)
-{
+void handlemap_VkPerformanceValueINTEL(VulkanHandleMapping* handlemap,
+ VkPerformanceValueINTEL* toMap) {
(void)handlemap;
(void)toMap;
handlemap_VkPerformanceValueDataINTEL(handlemap, (VkPerformanceValueDataINTEL*)(&toMap->data));
}
-void handlemap_VkInitializePerformanceApiInfoINTEL(
- VulkanHandleMapping* handlemap,
- VkInitializePerformanceApiInfoINTEL* toMap)
-{
+void handlemap_VkInitializePerformanceApiInfoINTEL(VulkanHandleMapping* handlemap,
+ VkInitializePerformanceApiInfoINTEL* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkQueryPoolPerformanceQueryCreateInfoINTEL(
- VulkanHandleMapping* handlemap,
- VkQueryPoolPerformanceQueryCreateInfoINTEL* toMap)
-{
+ VulkanHandleMapping* handlemap, VkQueryPoolPerformanceQueryCreateInfoINTEL* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPerformanceMarkerInfoINTEL(
- VulkanHandleMapping* handlemap,
- VkPerformanceMarkerInfoINTEL* toMap)
-{
+void handlemap_VkPerformanceMarkerInfoINTEL(VulkanHandleMapping* handlemap,
+ VkPerformanceMarkerInfoINTEL* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPerformanceStreamMarkerInfoINTEL(
- VulkanHandleMapping* handlemap,
- VkPerformanceStreamMarkerInfoINTEL* toMap)
-{
+void handlemap_VkPerformanceStreamMarkerInfoINTEL(VulkanHandleMapping* handlemap,
+ VkPerformanceStreamMarkerInfoINTEL* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPerformanceOverrideInfoINTEL(
- VulkanHandleMapping* handlemap,
- VkPerformanceOverrideInfoINTEL* toMap)
-{
+void handlemap_VkPerformanceOverrideInfoINTEL(VulkanHandleMapping* handlemap,
+ VkPerformanceOverrideInfoINTEL* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPerformanceConfigurationAcquireInfoINTEL(
- VulkanHandleMapping* handlemap,
- VkPerformanceConfigurationAcquireInfoINTEL* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPerformanceConfigurationAcquireInfoINTEL* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8207,13 +6374,10 @@
#endif
#ifdef VK_EXT_pci_bus_info
void handlemap_VkPhysicalDevicePCIBusInfoPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePCIBusInfoPropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePCIBusInfoPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8221,53 +6385,41 @@
#endif
#ifdef VK_AMD_display_native_hdr
void handlemap_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
- VulkanHandleMapping* handlemap,
- VkDisplayNativeHdrSurfaceCapabilitiesAMD* toMap)
-{
+ VulkanHandleMapping* handlemap, VkDisplayNativeHdrSurfaceCapabilitiesAMD* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkSwapchainDisplayNativeHdrCreateInfoAMD(
- VulkanHandleMapping* handlemap,
- VkSwapchainDisplayNativeHdrCreateInfoAMD* toMap)
-{
+ VulkanHandleMapping* handlemap, VkSwapchainDisplayNativeHdrCreateInfoAMD* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
-void handlemap_VkImagePipeSurfaceCreateInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkImagePipeSurfaceCreateInfoFUCHSIA* toMap)
-{
+void handlemap_VkImagePipeSurfaceCreateInfoFUCHSIA(VulkanHandleMapping* handlemap,
+ VkImagePipeSurfaceCreateInfoFUCHSIA* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_EXT_metal_surface
-void handlemap_VkMetalSurfaceCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkMetalSurfaceCreateInfoEXT* toMap)
-{
+void handlemap_VkMetalSurfaceCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkMetalSurfaceCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8275,25 +6427,19 @@
#endif
#ifdef VK_EXT_fragment_density_map
void handlemap_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minFragmentDensityTexelSize));
@@ -8301,16 +6447,14 @@
}
void handlemap_VkRenderPassFragmentDensityMapCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkRenderPassFragmentDensityMapCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkRenderPassFragmentDensityMapCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkAttachmentReference(handlemap, (VkAttachmentReference*)(&toMap->fragmentDensityMapAttachment));
+ handlemap_VkAttachmentReference(handlemap,
+ (VkAttachmentReference*)(&toMap->fragmentDensityMapAttachment));
}
#endif
@@ -8322,37 +6466,28 @@
#endif
#ifdef VK_EXT_subgroup_size_control
void handlemap_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8360,13 +6495,10 @@
#endif
#ifdef VK_AMD_shader_core_properties2
void handlemap_VkPhysicalDeviceShaderCoreProperties2AMD(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderCoreProperties2AMD* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderCoreProperties2AMD* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8374,13 +6506,10 @@
#endif
#ifdef VK_AMD_device_coherent_memory
void handlemap_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceCoherentMemoryFeaturesAMD* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceCoherentMemoryFeaturesAMD* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8388,13 +6517,10 @@
#endif
#ifdef VK_EXT_shader_image_atomic_int64
void handlemap_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8402,13 +6528,10 @@
#endif
#ifdef VK_EXT_memory_budget
void handlemap_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMemoryBudgetPropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceMemoryBudgetPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8416,25 +6539,19 @@
#endif
#ifdef VK_EXT_memory_priority
void handlemap_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMemoryPriorityFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceMemoryPriorityFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkMemoryPriorityAllocateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkMemoryPriorityAllocateInfoEXT* toMap)
-{
+void handlemap_VkMemoryPriorityAllocateInfoEXT(VulkanHandleMapping* handlemap,
+ VkMemoryPriorityAllocateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8443,12 +6560,10 @@
#ifdef VK_NV_dedicated_allocation_image_aliasing
void handlemap_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* toMap)
-{
+ VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8456,39 +6571,30 @@
#endif
#ifdef VK_EXT_buffer_device_address
void handlemap_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkBufferDeviceAddressCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkBufferDeviceAddressCreateInfoEXT* toMap)
-{
+void handlemap_VkBufferDeviceAddressCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkBufferDeviceAddressCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_EXT_tooling_info
-void handlemap_VkPhysicalDeviceToolPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceToolPropertiesEXT* toMap)
-{
+void handlemap_VkPhysicalDeviceToolPropertiesEXT(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceToolPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8497,52 +6603,40 @@
#ifdef VK_EXT_separate_stencil_usage
#endif
#ifdef VK_EXT_validation_features
-void handlemap_VkValidationFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkValidationFeaturesEXT* toMap)
-{
+void handlemap_VkValidationFeaturesEXT(VulkanHandleMapping* handlemap,
+ VkValidationFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_NV_cooperative_matrix
-void handlemap_VkCooperativeMatrixPropertiesNV(
- VulkanHandleMapping* handlemap,
- VkCooperativeMatrixPropertiesNV* toMap)
-{
+void handlemap_VkCooperativeMatrixPropertiesNV(VulkanHandleMapping* handlemap,
+ VkCooperativeMatrixPropertiesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceCooperativeMatrixFeaturesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceCooperativeMatrixFeaturesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceCooperativeMatrixPropertiesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceCooperativeMatrixPropertiesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8550,37 +6644,28 @@
#endif
#ifdef VK_NV_coverage_reduction_mode
void handlemap_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceCoverageReductionModeFeaturesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceCoverageReductionModeFeaturesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPipelineCoverageReductionStateCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkPipelineCoverageReductionStateCreateInfoNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineCoverageReductionStateCreateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkFramebufferMixedSamplesCombinationNV(
- VulkanHandleMapping* handlemap,
- VkFramebufferMixedSamplesCombinationNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkFramebufferMixedSamplesCombinationNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8588,13 +6673,10 @@
#endif
#ifdef VK_EXT_fragment_shader_interlock
void handlemap_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8602,13 +6684,10 @@
#endif
#ifdef VK_EXT_ycbcr_image_arrays
void handlemap_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8616,89 +6695,69 @@
#endif
#ifdef VK_EXT_provoking_vertex
void handlemap_VkPhysicalDeviceProvokingVertexFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceProvokingVertexFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceProvokingVertexFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceProvokingVertexPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceProvokingVertexPropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceProvokingVertexPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
VulkanHandleMapping* handlemap,
- VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* toMap)
-{
+ VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_EXT_full_screen_exclusive
-void handlemap_VkSurfaceFullScreenExclusiveInfoEXT(
- VulkanHandleMapping* handlemap,
- VkSurfaceFullScreenExclusiveInfoEXT* toMap)
-{
+void handlemap_VkSurfaceFullScreenExclusiveInfoEXT(VulkanHandleMapping* handlemap,
+ VkSurfaceFullScreenExclusiveInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
- VulkanHandleMapping* handlemap,
- VkSurfaceCapabilitiesFullScreenExclusiveEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkSurfaceCapabilitiesFullScreenExclusiveEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkSurfaceFullScreenExclusiveWin32InfoEXT(
- VulkanHandleMapping* handlemap,
- VkSurfaceFullScreenExclusiveWin32InfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkSurfaceFullScreenExclusiveWin32InfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_EXT_headless_surface
-void handlemap_VkHeadlessSurfaceCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkHeadlessSurfaceCreateInfoEXT* toMap)
-{
+void handlemap_VkHeadlessSurfaceCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkHeadlessSurfaceCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8706,37 +6765,28 @@
#endif
#ifdef VK_EXT_line_rasterization
void handlemap_VkPhysicalDeviceLineRasterizationFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceLineRasterizationFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceLineRasterizationFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceLineRasterizationPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceLineRasterizationPropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceLineRasterizationPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPipelineRasterizationLineStateCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineRasterizationLineStateCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineRasterizationLineStateCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8744,13 +6794,10 @@
#endif
#ifdef VK_EXT_shader_atomic_float
void handlemap_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8760,13 +6807,10 @@
#endif
#ifdef VK_EXT_index_type_uint8
void handlemap_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceIndexTypeUint8FeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceIndexTypeUint8FeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8774,13 +6818,10 @@
#endif
#ifdef VK_EXT_extended_dynamic_state
void handlemap_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8788,13 +6829,10 @@
#endif
#ifdef VK_EXT_shader_atomic_float2
void handlemap_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8803,12 +6841,10 @@
#ifdef VK_EXT_shader_demote_to_helper_invocation
void handlemap_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* toMap)
-{
+ VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -8816,180 +6852,141 @@
#endif
#ifdef VK_NV_device_generated_commands
void handlemap_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkGraphicsShaderGroupCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkGraphicsShaderGroupCreateInfoNV* toMap)
-{
+void handlemap_VkGraphicsShaderGroupCreateInfoNV(VulkanHandleMapping* handlemap,
+ VkGraphicsShaderGroupCreateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pStages)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->stageCount; ++i)
- {
- handlemap_VkPipelineShaderStageCreateInfo(handlemap, (VkPipelineShaderStageCreateInfo*)(toMap->pStages + i));
+ if (toMap) {
+ if (toMap->pStages) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->stageCount; ++i) {
+ handlemap_VkPipelineShaderStageCreateInfo(
+ handlemap, (VkPipelineShaderStageCreateInfo*)(toMap->pStages + i));
}
}
}
- if (toMap->pVertexInputState)
- {
- handlemap_VkPipelineVertexInputStateCreateInfo(handlemap, (VkPipelineVertexInputStateCreateInfo*)(toMap->pVertexInputState));
+ if (toMap->pVertexInputState) {
+ handlemap_VkPipelineVertexInputStateCreateInfo(
+ handlemap, (VkPipelineVertexInputStateCreateInfo*)(toMap->pVertexInputState));
}
- if (toMap->pTessellationState)
- {
- handlemap_VkPipelineTessellationStateCreateInfo(handlemap, (VkPipelineTessellationStateCreateInfo*)(toMap->pTessellationState));
+ if (toMap->pTessellationState) {
+ handlemap_VkPipelineTessellationStateCreateInfo(
+ handlemap, (VkPipelineTessellationStateCreateInfo*)(toMap->pTessellationState));
}
}
void handlemap_VkGraphicsPipelineShaderGroupsCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkGraphicsPipelineShaderGroupsCreateInfoNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkGraphicsPipelineShaderGroupsCreateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pGroups)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->groupCount; ++i)
- {
- handlemap_VkGraphicsShaderGroupCreateInfoNV(handlemap, (VkGraphicsShaderGroupCreateInfoNV*)(toMap->pGroups + i));
+ if (toMap) {
+ if (toMap->pGroups) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->groupCount; ++i) {
+ handlemap_VkGraphicsShaderGroupCreateInfoNV(
+ handlemap, (VkGraphicsShaderGroupCreateInfoNV*)(toMap->pGroups + i));
}
}
}
- if (toMap->pPipelines)
- {
+ if (toMap->pPipelines) {
handlemap->mapHandles_VkPipeline((VkPipeline*)toMap->pPipelines, toMap->pipelineCount);
}
}
-void handlemap_VkBindShaderGroupIndirectCommandNV(
- VulkanHandleMapping* handlemap,
- VkBindShaderGroupIndirectCommandNV* toMap)
-{
+void handlemap_VkBindShaderGroupIndirectCommandNV(VulkanHandleMapping* handlemap,
+ VkBindShaderGroupIndirectCommandNV* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkBindIndexBufferIndirectCommandNV(
- VulkanHandleMapping* handlemap,
- VkBindIndexBufferIndirectCommandNV* toMap)
-{
+void handlemap_VkBindIndexBufferIndirectCommandNV(VulkanHandleMapping* handlemap,
+ VkBindIndexBufferIndirectCommandNV* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkBindVertexBufferIndirectCommandNV(
- VulkanHandleMapping* handlemap,
- VkBindVertexBufferIndirectCommandNV* toMap)
-{
+void handlemap_VkBindVertexBufferIndirectCommandNV(VulkanHandleMapping* handlemap,
+ VkBindVertexBufferIndirectCommandNV* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkSetStateFlagsIndirectCommandNV(
- VulkanHandleMapping* handlemap,
- VkSetStateFlagsIndirectCommandNV* toMap)
-{
+void handlemap_VkSetStateFlagsIndirectCommandNV(VulkanHandleMapping* handlemap,
+ VkSetStateFlagsIndirectCommandNV* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkIndirectCommandsStreamNV(
- VulkanHandleMapping* handlemap,
- VkIndirectCommandsStreamNV* toMap)
-{
+void handlemap_VkIndirectCommandsStreamNV(VulkanHandleMapping* handlemap,
+ VkIndirectCommandsStreamNV* toMap) {
(void)handlemap;
(void)toMap;
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
}
-void handlemap_VkIndirectCommandsLayoutTokenNV(
- VulkanHandleMapping* handlemap,
- VkIndirectCommandsLayoutTokenNV* toMap)
-{
+void handlemap_VkIndirectCommandsLayoutTokenNV(VulkanHandleMapping* handlemap,
+ VkIndirectCommandsLayoutTokenNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->pushconstantPipelineLayout);
}
-void handlemap_VkIndirectCommandsLayoutCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkIndirectCommandsLayoutCreateInfoNV* toMap)
-{
+void handlemap_VkIndirectCommandsLayoutCreateInfoNV(VulkanHandleMapping* handlemap,
+ VkIndirectCommandsLayoutCreateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pTokens)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->tokenCount; ++i)
- {
- handlemap_VkIndirectCommandsLayoutTokenNV(handlemap, (VkIndirectCommandsLayoutTokenNV*)(toMap->pTokens + i));
+ if (toMap) {
+ if (toMap->pTokens) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->tokenCount; ++i) {
+ handlemap_VkIndirectCommandsLayoutTokenNV(
+ handlemap, (VkIndirectCommandsLayoutTokenNV*)(toMap->pTokens + i));
}
}
}
}
-void handlemap_VkGeneratedCommandsInfoNV(
- VulkanHandleMapping* handlemap,
- VkGeneratedCommandsInfoNV* toMap)
-{
+void handlemap_VkGeneratedCommandsInfoNV(VulkanHandleMapping* handlemap,
+ VkGeneratedCommandsInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkPipeline((VkPipeline*)&toMap->pipeline);
- handlemap->mapHandles_VkIndirectCommandsLayoutNV((VkIndirectCommandsLayoutNV*)&toMap->indirectCommandsLayout);
- if (toMap)
- {
- if (toMap->pStreams)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->streamCount; ++i)
- {
- handlemap_VkIndirectCommandsStreamNV(handlemap, (VkIndirectCommandsStreamNV*)(toMap->pStreams + i));
+ handlemap->mapHandles_VkIndirectCommandsLayoutNV(
+ (VkIndirectCommandsLayoutNV*)&toMap->indirectCommandsLayout);
+ if (toMap) {
+ if (toMap->pStreams) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->streamCount; ++i) {
+ handlemap_VkIndirectCommandsStreamNV(
+ handlemap, (VkIndirectCommandsStreamNV*)(toMap->pStreams + i));
}
}
}
@@ -8999,45 +6996,36 @@
}
void handlemap_VkGeneratedCommandsMemoryRequirementsInfoNV(
- VulkanHandleMapping* handlemap,
- VkGeneratedCommandsMemoryRequirementsInfoNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkGeneratedCommandsMemoryRequirementsInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkPipeline((VkPipeline*)&toMap->pipeline);
- handlemap->mapHandles_VkIndirectCommandsLayoutNV((VkIndirectCommandsLayoutNV*)&toMap->indirectCommandsLayout);
+ handlemap->mapHandles_VkIndirectCommandsLayoutNV(
+ (VkIndirectCommandsLayoutNV*)&toMap->indirectCommandsLayout);
}
#endif
#ifdef VK_NV_inherited_viewport_scissor
void handlemap_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceInheritedViewportScissorFeaturesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceInheritedViewportScissorFeaturesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkCommandBufferInheritanceViewportScissorInfoNV(
- VulkanHandleMapping* handlemap,
- VkCommandBufferInheritanceViewportScissorInfoNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkCommandBufferInheritanceViewportScissorInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pViewportDepths)
- {
+ if (toMap->pViewportDepths) {
handlemap_VkViewport(handlemap, (VkViewport*)(toMap->pViewportDepths));
}
}
@@ -9045,51 +7033,39 @@
#endif
#ifdef VK_EXT_texel_buffer_alignment
void handlemap_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_QCOM_render_pass_transform
-void handlemap_VkRenderPassTransformBeginInfoQCOM(
- VulkanHandleMapping* handlemap,
- VkRenderPassTransformBeginInfoQCOM* toMap)
-{
+void handlemap_VkRenderPassTransformBeginInfoQCOM(VulkanHandleMapping* handlemap,
+ VkRenderPassTransformBeginInfoQCOM* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
- VulkanHandleMapping* handlemap,
- VkCommandBufferInheritanceRenderPassTransformInfoQCOM* toMap)
-{
+ VulkanHandleMapping* handlemap, VkCommandBufferInheritanceRenderPassTransformInfoQCOM* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->renderArea));
@@ -9098,37 +7074,28 @@
#endif
#ifdef VK_EXT_device_memory_report
void handlemap_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDeviceMemoryReportCallbackDataEXT(
- VulkanHandleMapping* handlemap,
- VkDeviceMemoryReportCallbackDataEXT* toMap)
-{
+void handlemap_VkDeviceMemoryReportCallbackDataEXT(VulkanHandleMapping* handlemap,
+ VkDeviceMemoryReportCallbackDataEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkDeviceDeviceMemoryReportCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDeviceDeviceMemoryReportCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkDeviceDeviceMemoryReportCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -9138,25 +7105,19 @@
#endif
#ifdef VK_EXT_robustness2
void handlemap_VkPhysicalDeviceRobustness2FeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceRobustness2FeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceRobustness2FeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceRobustness2PropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceRobustness2PropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceRobustness2PropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -9164,38 +7125,29 @@
#endif
#ifdef VK_EXT_custom_border_color
void handlemap_VkSamplerCustomBorderColorCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkSamplerCustomBorderColorCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkSamplerCustomBorderColorCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkClearColorValue(handlemap, (VkClearColorValue*)(&toMap->customBorderColor));
}
void handlemap_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceCustomBorderColorPropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceCustomBorderColorPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceCustomBorderColorFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceCustomBorderColorFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -9205,37 +7157,28 @@
#endif
#ifdef VK_EXT_private_data
void handlemap_VkPhysicalDevicePrivateDataFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePrivateDataFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePrivateDataFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDevicePrivateDataCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDevicePrivateDataCreateInfoEXT* toMap)
-{
+void handlemap_VkDevicePrivateDataCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkDevicePrivateDataCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPrivateDataSlotCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPrivateDataSlotCreateInfoEXT* toMap)
-{
+void handlemap_VkPrivateDataSlotCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkPrivateDataSlotCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -9244,12 +7187,10 @@
#ifdef VK_EXT_pipeline_creation_cache_control
void handlemap_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
VulkanHandleMapping* handlemap,
- VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toMap)
-{
+ VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -9257,25 +7198,19 @@
#endif
#ifdef VK_NV_device_diagnostics_config
void handlemap_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkDeviceDiagnosticsConfigCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkDeviceDiagnosticsConfigCreateInfoNV* toMap)
-{
+void handlemap_VkDeviceDiagnosticsConfigCreateInfoNV(VulkanHandleMapping* handlemap,
+ VkDeviceDiagnosticsConfigCreateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -9285,98 +7220,75 @@
#endif
#ifdef VK_NV_fragment_shading_rate_enums
void handlemap_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkPipelineFragmentShadingRateEnumStateCreateInfoNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPipelineFragmentShadingRateEnumStateCreateInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_NV_ray_tracing_motion_blur
-void handlemap_VkDeviceOrHostAddressConstKHR(
- VulkanHandleMapping* handlemap,
- VkDeviceOrHostAddressConstKHR* toMap)
-{
+void handlemap_VkDeviceOrHostAddressConstKHR(VulkanHandleMapping* handlemap,
+ VkDeviceOrHostAddressConstKHR* toMap) {
(void)handlemap;
(void)toMap;
}
void handlemap_VkAccelerationStructureGeometryMotionTrianglesDataNV(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureGeometryMotionTrianglesDataNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkAccelerationStructureGeometryMotionTrianglesDataNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkDeviceOrHostAddressConstKHR(handlemap, (VkDeviceOrHostAddressConstKHR*)(&toMap->vertexData));
+ handlemap_VkDeviceOrHostAddressConstKHR(handlemap,
+ (VkDeviceOrHostAddressConstKHR*)(&toMap->vertexData));
}
-void handlemap_VkAccelerationStructureMotionInfoNV(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureMotionInfoNV* toMap)
-{
+void handlemap_VkAccelerationStructureMotionInfoNV(VulkanHandleMapping* handlemap,
+ VkAccelerationStructureMotionInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkAccelerationStructureMatrixMotionInstanceNV(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureMatrixMotionInstanceNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkAccelerationStructureMatrixMotionInstanceNV* toMap) {
(void)handlemap;
(void)toMap;
handlemap_VkTransformMatrixKHR(handlemap, (VkTransformMatrixKHR*)(&toMap->transformT0));
handlemap_VkTransformMatrixKHR(handlemap, (VkTransformMatrixKHR*)(&toMap->transformT1));
}
-void handlemap_VkSRTDataNV(
- VulkanHandleMapping* handlemap,
- VkSRTDataNV* toMap)
-{
+void handlemap_VkSRTDataNV(VulkanHandleMapping* handlemap, VkSRTDataNV* toMap) {
(void)handlemap;
(void)toMap;
}
void handlemap_VkAccelerationStructureSRTMotionInstanceNV(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureSRTMotionInstanceNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkAccelerationStructureSRTMotionInstanceNV* toMap) {
(void)handlemap;
(void)toMap;
handlemap_VkSRTDataNV(handlemap, (VkSRTDataNV*)(&toMap->transformT0));
@@ -9384,33 +7296,30 @@
}
void handlemap_VkAccelerationStructureMotionInstanceDataNV(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureMotionInstanceDataNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkAccelerationStructureMotionInstanceDataNV* toMap) {
(void)handlemap;
(void)toMap;
- handlemap_VkAccelerationStructureInstanceKHR(handlemap, (VkAccelerationStructureInstanceKHR*)(&toMap->staticInstance));
- handlemap_VkAccelerationStructureMatrixMotionInstanceNV(handlemap, (VkAccelerationStructureMatrixMotionInstanceNV*)(&toMap->matrixMotionInstance));
- handlemap_VkAccelerationStructureSRTMotionInstanceNV(handlemap, (VkAccelerationStructureSRTMotionInstanceNV*)(&toMap->srtMotionInstance));
+ handlemap_VkAccelerationStructureInstanceKHR(
+ handlemap, (VkAccelerationStructureInstanceKHR*)(&toMap->staticInstance));
+ handlemap_VkAccelerationStructureMatrixMotionInstanceNV(
+ handlemap, (VkAccelerationStructureMatrixMotionInstanceNV*)(&toMap->matrixMotionInstance));
+ handlemap_VkAccelerationStructureSRTMotionInstanceNV(
+ handlemap, (VkAccelerationStructureSRTMotionInstanceNV*)(&toMap->srtMotionInstance));
}
void handlemap_VkAccelerationStructureMotionInstanceNV(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureMotionInstanceNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkAccelerationStructureMotionInstanceNV* toMap) {
(void)handlemap;
(void)toMap;
- handlemap_VkAccelerationStructureMotionInstanceDataNV(handlemap, (VkAccelerationStructureMotionInstanceDataNV*)(&toMap->data));
+ handlemap_VkAccelerationStructureMotionInstanceDataNV(
+ handlemap, (VkAccelerationStructureMotionInstanceDataNV*)(&toMap->data));
}
void handlemap_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -9418,13 +7327,10 @@
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
void handlemap_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -9432,39 +7338,30 @@
#endif
#ifdef VK_EXT_fragment_density_map2
void handlemap_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_QCOM_rotated_copy_commands
-void handlemap_VkCopyCommandTransformInfoQCOM(
- VulkanHandleMapping* handlemap,
- VkCopyCommandTransformInfoQCOM* toMap)
-{
+void handlemap_VkCopyCommandTransformInfoQCOM(VulkanHandleMapping* handlemap,
+ VkCopyCommandTransformInfoQCOM* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -9472,13 +7369,10 @@
#endif
#ifdef VK_EXT_image_robustness
void handlemap_VkPhysicalDeviceImageRobustnessFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceImageRobustnessFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceImageRobustnessFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -9486,13 +7380,10 @@
#endif
#ifdef VK_EXT_4444_formats
void handlemap_VkPhysicalDevice4444FormatsFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevice4444FormatsFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDevice4444FormatsFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -9500,13 +7391,10 @@
#endif
#ifdef VK_EXT_rgba10x6_formats
void handlemap_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -9515,14 +7403,11 @@
#ifdef VK_NV_acquire_winrt_display
#endif
#ifdef VK_EXT_directfb_surface
-void handlemap_VkDirectFBSurfaceCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDirectFBSurfaceCreateInfoEXT* toMap)
-{
+void handlemap_VkDirectFBSurfaceCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkDirectFBSurfaceCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -9530,42 +7415,33 @@
#endif
#ifdef VK_VALVE_mutable_descriptor_type
void handlemap_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkMutableDescriptorTypeListVALVE(
- VulkanHandleMapping* handlemap,
- VkMutableDescriptorTypeListVALVE* toMap)
-{
+void handlemap_VkMutableDescriptorTypeListVALVE(VulkanHandleMapping* handlemap,
+ VkMutableDescriptorTypeListVALVE* toMap) {
(void)handlemap;
(void)toMap;
}
void handlemap_VkMutableDescriptorTypeCreateInfoVALVE(
- VulkanHandleMapping* handlemap,
- VkMutableDescriptorTypeCreateInfoVALVE* toMap)
-{
+ VulkanHandleMapping* handlemap, VkMutableDescriptorTypeCreateInfoVALVE* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pMutableDescriptorTypeLists)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->mutableDescriptorTypeListCount; ++i)
- {
- handlemap_VkMutableDescriptorTypeListVALVE(handlemap, (VkMutableDescriptorTypeListVALVE*)(toMap->pMutableDescriptorTypeLists + i));
+ if (toMap) {
+ if (toMap->pMutableDescriptorTypeLists) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->mutableDescriptorTypeListCount; ++i) {
+ handlemap_VkMutableDescriptorTypeListVALVE(
+ handlemap,
+ (VkMutableDescriptorTypeListVALVE*)(toMap->pMutableDescriptorTypeLists + i));
}
}
}
@@ -9574,51 +7450,39 @@
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
void handlemap_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkVertexInputBindingDescription2EXT(
- VulkanHandleMapping* handlemap,
- VkVertexInputBindingDescription2EXT* toMap)
-{
+void handlemap_VkVertexInputBindingDescription2EXT(VulkanHandleMapping* handlemap,
+ VkVertexInputBindingDescription2EXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkVertexInputAttributeDescription2EXT(
- VulkanHandleMapping* handlemap,
- VkVertexInputAttributeDescription2EXT* toMap)
-{
+void handlemap_VkVertexInputAttributeDescription2EXT(VulkanHandleMapping* handlemap,
+ VkVertexInputAttributeDescription2EXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_EXT_physical_device_drm
-void handlemap_VkPhysicalDeviceDrmPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDrmPropertiesEXT* toMap)
-{
+void handlemap_VkPhysicalDeviceDrmPropertiesEXT(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceDrmPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -9627,50 +7491,39 @@
#ifdef VK_EXT_primitive_topology_list_restart
void handlemap_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
VulkanHandleMapping* handlemap,
- VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* toMap)
-{
+ VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_FUCHSIA_external_memory
-void handlemap_VkImportMemoryZirconHandleInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkImportMemoryZirconHandleInfoFUCHSIA* toMap)
-{
+void handlemap_VkImportMemoryZirconHandleInfoFUCHSIA(VulkanHandleMapping* handlemap,
+ VkImportMemoryZirconHandleInfoFUCHSIA* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkMemoryZirconHandlePropertiesFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkMemoryZirconHandlePropertiesFUCHSIA* toMap)
-{
+void handlemap_VkMemoryZirconHandlePropertiesFUCHSIA(VulkanHandleMapping* handlemap,
+ VkMemoryZirconHandlePropertiesFUCHSIA* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkMemoryGetZirconHandleInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkMemoryGetZirconHandleInfoFUCHSIA* toMap)
-{
+void handlemap_VkMemoryGetZirconHandleInfoFUCHSIA(VulkanHandleMapping* handlemap,
+ VkMemoryGetZirconHandleInfoFUCHSIA* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
@@ -9679,26 +7532,20 @@
#endif
#ifdef VK_FUCHSIA_external_semaphore
void handlemap_VkImportSemaphoreZirconHandleInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkImportSemaphoreZirconHandleInfoFUCHSIA* toMap)
-{
+ VulkanHandleMapping* handlemap, VkImportSemaphoreZirconHandleInfoFUCHSIA* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
}
-void handlemap_VkSemaphoreGetZirconHandleInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkSemaphoreGetZirconHandleInfoFUCHSIA* toMap)
-{
+void handlemap_VkSemaphoreGetZirconHandleInfoFUCHSIA(VulkanHandleMapping* handlemap,
+ VkSemaphoreGetZirconHandleInfoFUCHSIA* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
@@ -9706,184 +7553,150 @@
#endif
#ifdef VK_FUCHSIA_buffer_collection
-void handlemap_VkBufferCollectionCreateInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkBufferCollectionCreateInfoFUCHSIA* toMap)
-{
+void handlemap_VkBufferCollectionCreateInfoFUCHSIA(VulkanHandleMapping* handlemap,
+ VkBufferCollectionCreateInfoFUCHSIA* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkImportMemoryBufferCollectionFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkImportMemoryBufferCollectionFUCHSIA* toMap)
-{
+void handlemap_VkImportMemoryBufferCollectionFUCHSIA(VulkanHandleMapping* handlemap,
+ VkImportMemoryBufferCollectionFUCHSIA* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkBufferCollectionFUCHSIA((VkBufferCollectionFUCHSIA*)&toMap->collection);
}
void handlemap_VkBufferCollectionImageCreateInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkBufferCollectionImageCreateInfoFUCHSIA* toMap)
-{
+ VulkanHandleMapping* handlemap, VkBufferCollectionImageCreateInfoFUCHSIA* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkBufferCollectionFUCHSIA((VkBufferCollectionFUCHSIA*)&toMap->collection);
}
void handlemap_VkBufferCollectionConstraintsInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkBufferCollectionConstraintsInfoFUCHSIA* toMap)
-{
+ VulkanHandleMapping* handlemap, VkBufferCollectionConstraintsInfoFUCHSIA* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkBufferConstraintsInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkBufferConstraintsInfoFUCHSIA* toMap)
-{
+void handlemap_VkBufferConstraintsInfoFUCHSIA(VulkanHandleMapping* handlemap,
+ VkBufferConstraintsInfoFUCHSIA* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkBufferCreateInfo(handlemap, (VkBufferCreateInfo*)(&toMap->createInfo));
- handlemap_VkBufferCollectionConstraintsInfoFUCHSIA(handlemap, (VkBufferCollectionConstraintsInfoFUCHSIA*)(&toMap->bufferCollectionConstraints));
+ handlemap_VkBufferCollectionConstraintsInfoFUCHSIA(
+ handlemap,
+ (VkBufferCollectionConstraintsInfoFUCHSIA*)(&toMap->bufferCollectionConstraints));
}
void handlemap_VkBufferCollectionBufferCreateInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkBufferCollectionBufferCreateInfoFUCHSIA* toMap)
-{
+ VulkanHandleMapping* handlemap, VkBufferCollectionBufferCreateInfoFUCHSIA* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkBufferCollectionFUCHSIA((VkBufferCollectionFUCHSIA*)&toMap->collection);
}
-void handlemap_VkSysmemColorSpaceFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkSysmemColorSpaceFUCHSIA* toMap)
-{
+void handlemap_VkSysmemColorSpaceFUCHSIA(VulkanHandleMapping* handlemap,
+ VkSysmemColorSpaceFUCHSIA* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkBufferCollectionPropertiesFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkBufferCollectionPropertiesFUCHSIA* toMap)
-{
+void handlemap_VkBufferCollectionPropertiesFUCHSIA(VulkanHandleMapping* handlemap,
+ VkBufferCollectionPropertiesFUCHSIA* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkSysmemColorSpaceFUCHSIA(handlemap, (VkSysmemColorSpaceFUCHSIA*)(&toMap->sysmemColorSpaceIndex));
- handlemap_VkComponentMapping(handlemap, (VkComponentMapping*)(&toMap->samplerYcbcrConversionComponents));
+ handlemap_VkSysmemColorSpaceFUCHSIA(
+ handlemap, (VkSysmemColorSpaceFUCHSIA*)(&toMap->sysmemColorSpaceIndex));
+ handlemap_VkComponentMapping(handlemap,
+ (VkComponentMapping*)(&toMap->samplerYcbcrConversionComponents));
}
-void handlemap_VkImageFormatConstraintsInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkImageFormatConstraintsInfoFUCHSIA* toMap)
-{
+void handlemap_VkImageFormatConstraintsInfoFUCHSIA(VulkanHandleMapping* handlemap,
+ VkImageFormatConstraintsInfoFUCHSIA* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkImageCreateInfo(handlemap, (VkImageCreateInfo*)(&toMap->imageCreateInfo));
- if (toMap->pColorSpaces)
- {
- handlemap_VkSysmemColorSpaceFUCHSIA(handlemap, (VkSysmemColorSpaceFUCHSIA*)(toMap->pColorSpaces));
+ if (toMap->pColorSpaces) {
+ handlemap_VkSysmemColorSpaceFUCHSIA(handlemap,
+ (VkSysmemColorSpaceFUCHSIA*)(toMap->pColorSpaces));
}
}
-void handlemap_VkImageConstraintsInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkImageConstraintsInfoFUCHSIA* toMap)
-{
+void handlemap_VkImageConstraintsInfoFUCHSIA(VulkanHandleMapping* handlemap,
+ VkImageConstraintsInfoFUCHSIA* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pFormatConstraints)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->formatConstraintsCount; ++i)
- {
- handlemap_VkImageFormatConstraintsInfoFUCHSIA(handlemap, (VkImageFormatConstraintsInfoFUCHSIA*)(toMap->pFormatConstraints + i));
+ if (toMap) {
+ if (toMap->pFormatConstraints) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->formatConstraintsCount; ++i) {
+ handlemap_VkImageFormatConstraintsInfoFUCHSIA(
+ handlemap,
+ (VkImageFormatConstraintsInfoFUCHSIA*)(toMap->pFormatConstraints + i));
}
}
}
- handlemap_VkBufferCollectionConstraintsInfoFUCHSIA(handlemap, (VkBufferCollectionConstraintsInfoFUCHSIA*)(&toMap->bufferCollectionConstraints));
+ handlemap_VkBufferCollectionConstraintsInfoFUCHSIA(
+ handlemap,
+ (VkBufferCollectionConstraintsInfoFUCHSIA*)(&toMap->bufferCollectionConstraints));
}
#endif
#ifdef VK_HUAWEI_subpass_shading
void handlemap_VkSubpassShadingPipelineCreateInfoHUAWEI(
- VulkanHandleMapping* handlemap,
- VkSubpassShadingPipelineCreateInfoHUAWEI* toMap)
-{
+ VulkanHandleMapping* handlemap, VkSubpassShadingPipelineCreateInfoHUAWEI* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkRenderPass((VkRenderPass*)&toMap->renderPass);
}
void handlemap_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -9891,40 +7704,31 @@
#endif
#ifdef VK_HUAWEI_invocation_mask
void handlemap_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_NV_external_memory_rdma
-void handlemap_VkMemoryGetRemoteAddressInfoNV(
- VulkanHandleMapping* handlemap,
- VkMemoryGetRemoteAddressInfoNV* toMap)
-{
+void handlemap_VkMemoryGetRemoteAddressInfoNV(VulkanHandleMapping* handlemap,
+ VkMemoryGetRemoteAddressInfoNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
}
void handlemap_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -9932,27 +7736,21 @@
#endif
#ifdef VK_EXT_extended_dynamic_state2
void handlemap_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_QNX_screen_surface
-void handlemap_VkScreenSurfaceCreateInfoQNX(
- VulkanHandleMapping* handlemap,
- VkScreenSurfaceCreateInfoQNX* toMap)
-{
+void handlemap_VkScreenSurfaceCreateInfoQNX(VulkanHandleMapping* handlemap,
+ VkScreenSurfaceCreateInfoQNX* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -9960,63 +7758,47 @@
#endif
#ifdef VK_EXT_color_write_enable
void handlemap_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceColorWriteEnableFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceColorWriteEnableFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkPipelineColorWriteCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineColorWriteCreateInfoEXT* toMap)
-{
+void handlemap_VkPipelineColorWriteCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkPipelineColorWriteCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_GOOGLE_gfxstream
-void handlemap_VkImportColorBufferGOOGLE(
- VulkanHandleMapping* handlemap,
- VkImportColorBufferGOOGLE* toMap)
-{
+void handlemap_VkImportColorBufferGOOGLE(VulkanHandleMapping* handlemap,
+ VkImportColorBufferGOOGLE* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkImportBufferGOOGLE(
- VulkanHandleMapping* handlemap,
- VkImportBufferGOOGLE* toMap)
-{
+void handlemap_VkImportBufferGOOGLE(VulkanHandleMapping* handlemap, VkImportBufferGOOGLE* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkImportPhysicalAddressGOOGLE(
- VulkanHandleMapping* handlemap,
- VkImportPhysicalAddressGOOGLE* toMap)
-{
+void handlemap_VkImportPhysicalAddressGOOGLE(VulkanHandleMapping* handlemap,
+ VkImportPhysicalAddressGOOGLE* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
@@ -10024,67 +7806,50 @@
#endif
#ifdef VK_EXT_global_priority_query
void handlemap_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkQueueFamilyGlobalPriorityPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkQueueFamilyGlobalPriorityPropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkQueueFamilyGlobalPriorityPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_EXT_multi_draw
-void handlemap_VkPhysicalDeviceMultiDrawFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMultiDrawFeaturesEXT* toMap)
-{
+void handlemap_VkPhysicalDeviceMultiDrawFeaturesEXT(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMultiDrawFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceMultiDrawPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMultiDrawPropertiesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceMultiDrawPropertiesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkMultiDrawInfoEXT(
- VulkanHandleMapping* handlemap,
- VkMultiDrawInfoEXT* toMap)
-{
+void handlemap_VkMultiDrawInfoEXT(VulkanHandleMapping* handlemap, VkMultiDrawInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkMultiDrawIndexedInfoEXT(
- VulkanHandleMapping* handlemap,
- VkMultiDrawIndexedInfoEXT* toMap)
-{
+void handlemap_VkMultiDrawIndexedInfoEXT(VulkanHandleMapping* handlemap,
+ VkMultiDrawIndexedInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
}
@@ -10094,25 +7859,19 @@
#endif
#ifdef VK_EXT_border_color_swizzle
void handlemap_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkSamplerBorderColorComponentMappingCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkSamplerBorderColorComponentMappingCreateInfoEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkSamplerBorderColorComponentMappingCreateInfoEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap_VkComponentMapping(handlemap, (VkComponentMapping*)(&toMap->components));
@@ -10121,211 +7880,177 @@
#endif
#ifdef VK_EXT_pageable_device_local_memory
void handlemap_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_KHR_acceleration_structure
-void handlemap_VkDeviceOrHostAddressKHR(
- VulkanHandleMapping* handlemap,
- VkDeviceOrHostAddressKHR* toMap)
-{
+void handlemap_VkDeviceOrHostAddressKHR(VulkanHandleMapping* handlemap,
+ VkDeviceOrHostAddressKHR* toMap) {
(void)handlemap;
(void)toMap;
}
void handlemap_VkAccelerationStructureBuildRangeInfoKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureBuildRangeInfoKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkAccelerationStructureBuildRangeInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
}
void handlemap_VkAccelerationStructureGeometryTrianglesDataKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureGeometryTrianglesDataKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkAccelerationStructureGeometryTrianglesDataKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkDeviceOrHostAddressConstKHR(handlemap, (VkDeviceOrHostAddressConstKHR*)(&toMap->vertexData));
- handlemap_VkDeviceOrHostAddressConstKHR(handlemap, (VkDeviceOrHostAddressConstKHR*)(&toMap->indexData));
- handlemap_VkDeviceOrHostAddressConstKHR(handlemap, (VkDeviceOrHostAddressConstKHR*)(&toMap->transformData));
+ handlemap_VkDeviceOrHostAddressConstKHR(handlemap,
+ (VkDeviceOrHostAddressConstKHR*)(&toMap->vertexData));
+ handlemap_VkDeviceOrHostAddressConstKHR(handlemap,
+ (VkDeviceOrHostAddressConstKHR*)(&toMap->indexData));
+ handlemap_VkDeviceOrHostAddressConstKHR(
+ handlemap, (VkDeviceOrHostAddressConstKHR*)(&toMap->transformData));
}
void handlemap_VkAccelerationStructureGeometryAabbsDataKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureGeometryAabbsDataKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkAccelerationStructureGeometryAabbsDataKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkDeviceOrHostAddressConstKHR(handlemap, (VkDeviceOrHostAddressConstKHR*)(&toMap->data));
+ handlemap_VkDeviceOrHostAddressConstKHR(handlemap,
+ (VkDeviceOrHostAddressConstKHR*)(&toMap->data));
}
void handlemap_VkAccelerationStructureGeometryInstancesDataKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureGeometryInstancesDataKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkAccelerationStructureGeometryInstancesDataKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkDeviceOrHostAddressConstKHR(handlemap, (VkDeviceOrHostAddressConstKHR*)(&toMap->data));
+ handlemap_VkDeviceOrHostAddressConstKHR(handlemap,
+ (VkDeviceOrHostAddressConstKHR*)(&toMap->data));
}
void handlemap_VkAccelerationStructureGeometryDataKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureGeometryDataKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkAccelerationStructureGeometryDataKHR* toMap) {
(void)handlemap;
(void)toMap;
- handlemap_VkAccelerationStructureGeometryTrianglesDataKHR(handlemap, (VkAccelerationStructureGeometryTrianglesDataKHR*)(&toMap->triangles));
- handlemap_VkAccelerationStructureGeometryAabbsDataKHR(handlemap, (VkAccelerationStructureGeometryAabbsDataKHR*)(&toMap->aabbs));
- handlemap_VkAccelerationStructureGeometryInstancesDataKHR(handlemap, (VkAccelerationStructureGeometryInstancesDataKHR*)(&toMap->instances));
+ handlemap_VkAccelerationStructureGeometryTrianglesDataKHR(
+ handlemap, (VkAccelerationStructureGeometryTrianglesDataKHR*)(&toMap->triangles));
+ handlemap_VkAccelerationStructureGeometryAabbsDataKHR(
+ handlemap, (VkAccelerationStructureGeometryAabbsDataKHR*)(&toMap->aabbs));
+ handlemap_VkAccelerationStructureGeometryInstancesDataKHR(
+ handlemap, (VkAccelerationStructureGeometryInstancesDataKHR*)(&toMap->instances));
}
-void handlemap_VkAccelerationStructureGeometryKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureGeometryKHR* toMap)
-{
+void handlemap_VkAccelerationStructureGeometryKHR(VulkanHandleMapping* handlemap,
+ VkAccelerationStructureGeometryKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkAccelerationStructureGeometryDataKHR(handlemap, (VkAccelerationStructureGeometryDataKHR*)(&toMap->geometry));
+ handlemap_VkAccelerationStructureGeometryDataKHR(
+ handlemap, (VkAccelerationStructureGeometryDataKHR*)(&toMap->geometry));
}
void handlemap_VkAccelerationStructureBuildGeometryInfoKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureBuildGeometryInfoKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkAccelerationStructureBuildGeometryInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap->mapHandles_VkAccelerationStructureKHR((VkAccelerationStructureKHR*)&toMap->srcAccelerationStructure);
- handlemap->mapHandles_VkAccelerationStructureKHR((VkAccelerationStructureKHR*)&toMap->dstAccelerationStructure);
- if (toMap)
- {
- if (toMap->pGeometries)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->geometryCount; ++i)
- {
- handlemap_VkAccelerationStructureGeometryKHR(handlemap, (VkAccelerationStructureGeometryKHR*)(toMap->pGeometries + i));
+ handlemap->mapHandles_VkAccelerationStructureKHR(
+ (VkAccelerationStructureKHR*)&toMap->srcAccelerationStructure);
+ handlemap->mapHandles_VkAccelerationStructureKHR(
+ (VkAccelerationStructureKHR*)&toMap->dstAccelerationStructure);
+ if (toMap) {
+ if (toMap->pGeometries) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->geometryCount; ++i) {
+ handlemap_VkAccelerationStructureGeometryKHR(
+ handlemap, (VkAccelerationStructureGeometryKHR*)(toMap->pGeometries + i));
}
}
}
handlemap_VkDeviceOrHostAddressKHR(handlemap, (VkDeviceOrHostAddressKHR*)(&toMap->scratchData));
}
-void handlemap_VkAccelerationStructureCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureCreateInfoKHR* toMap)
-{
+void handlemap_VkAccelerationStructureCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkAccelerationStructureCreateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
}
void handlemap_VkWriteDescriptorSetAccelerationStructureKHR(
- VulkanHandleMapping* handlemap,
- VkWriteDescriptorSetAccelerationStructureKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkWriteDescriptorSetAccelerationStructureKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap->pAccelerationStructures)
- {
- handlemap->mapHandles_VkAccelerationStructureKHR((VkAccelerationStructureKHR*)toMap->pAccelerationStructures, toMap->accelerationStructureCount);
+ if (toMap->pAccelerationStructures) {
+ handlemap->mapHandles_VkAccelerationStructureKHR(
+ (VkAccelerationStructureKHR*)toMap->pAccelerationStructures,
+ toMap->accelerationStructureCount);
}
}
void handlemap_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceAccelerationStructureFeaturesKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceAccelerationStructureFeaturesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceAccelerationStructurePropertiesKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceAccelerationStructurePropertiesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkAccelerationStructureDeviceAddressInfoKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureDeviceAddressInfoKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkAccelerationStructureDeviceAddressInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap->mapHandles_VkAccelerationStructureKHR((VkAccelerationStructureKHR*)&toMap->accelerationStructure);
+ handlemap->mapHandles_VkAccelerationStructureKHR(
+ (VkAccelerationStructureKHR*)&toMap->accelerationStructure);
}
-void handlemap_VkAccelerationStructureVersionInfoKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureVersionInfoKHR* toMap)
-{
+void handlemap_VkAccelerationStructureVersionInfoKHR(VulkanHandleMapping* handlemap,
+ VkAccelerationStructureVersionInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkCopyAccelerationStructureToMemoryInfoKHR(
- VulkanHandleMapping* handlemap,
- VkCopyAccelerationStructureToMemoryInfoKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkCopyAccelerationStructureToMemoryInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkAccelerationStructureKHR((VkAccelerationStructureKHR*)&toMap->src);
@@ -10333,27 +8058,22 @@
}
void handlemap_VkCopyMemoryToAccelerationStructureInfoKHR(
- VulkanHandleMapping* handlemap,
- VkCopyMemoryToAccelerationStructureInfoKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkCopyMemoryToAccelerationStructureInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- handlemap_VkDeviceOrHostAddressConstKHR(handlemap, (VkDeviceOrHostAddressConstKHR*)(&toMap->src));
+ handlemap_VkDeviceOrHostAddressConstKHR(handlemap,
+ (VkDeviceOrHostAddressConstKHR*)(&toMap->src));
handlemap->mapHandles_VkAccelerationStructureKHR((VkAccelerationStructureKHR*)&toMap->dst);
}
-void handlemap_VkCopyAccelerationStructureInfoKHR(
- VulkanHandleMapping* handlemap,
- VkCopyAccelerationStructureInfoKHR* toMap)
-{
+void handlemap_VkCopyAccelerationStructureInfoKHR(VulkanHandleMapping* handlemap,
+ VkCopyAccelerationStructureInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
handlemap->mapHandles_VkAccelerationStructureKHR((VkAccelerationStructureKHR*)&toMap->src);
@@ -10361,2242 +8081,2511 @@
}
void handlemap_VkAccelerationStructureBuildSizesInfoKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureBuildSizesInfoKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkAccelerationStructureBuildSizesInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
-void handlemap_VkRayTracingShaderGroupCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkRayTracingShaderGroupCreateInfoKHR* toMap)
-{
+void handlemap_VkRayTracingShaderGroupCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkRayTracingShaderGroupCreateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkRayTracingPipelineInterfaceCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkRayTracingPipelineInterfaceCreateInfoKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkRayTracingPipelineInterfaceCreateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkRayTracingPipelineCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkRayTracingPipelineCreateInfoKHR* toMap)
-{
+void handlemap_VkRayTracingPipelineCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkRayTracingPipelineCreateInfoKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
- if (toMap)
- {
- if (toMap->pStages)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->stageCount; ++i)
- {
- handlemap_VkPipelineShaderStageCreateInfo(handlemap, (VkPipelineShaderStageCreateInfo*)(toMap->pStages + i));
+ if (toMap) {
+ if (toMap->pStages) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->stageCount; ++i) {
+ handlemap_VkPipelineShaderStageCreateInfo(
+ handlemap, (VkPipelineShaderStageCreateInfo*)(toMap->pStages + i));
}
}
}
- if (toMap)
- {
- if (toMap->pGroups)
- {
- for (uint32_t i = 0; i < (uint32_t)toMap->groupCount; ++i)
- {
- handlemap_VkRayTracingShaderGroupCreateInfoKHR(handlemap, (VkRayTracingShaderGroupCreateInfoKHR*)(toMap->pGroups + i));
+ if (toMap) {
+ if (toMap->pGroups) {
+ for (uint32_t i = 0; i < (uint32_t)toMap->groupCount; ++i) {
+ handlemap_VkRayTracingShaderGroupCreateInfoKHR(
+ handlemap, (VkRayTracingShaderGroupCreateInfoKHR*)(toMap->pGroups + i));
}
}
}
- if (toMap->pLibraryInfo)
- {
- handlemap_VkPipelineLibraryCreateInfoKHR(handlemap, (VkPipelineLibraryCreateInfoKHR*)(toMap->pLibraryInfo));
+ if (toMap->pLibraryInfo) {
+ handlemap_VkPipelineLibraryCreateInfoKHR(
+ handlemap, (VkPipelineLibraryCreateInfoKHR*)(toMap->pLibraryInfo));
}
- if (toMap->pLibraryInterface)
- {
- handlemap_VkRayTracingPipelineInterfaceCreateInfoKHR(handlemap, (VkRayTracingPipelineInterfaceCreateInfoKHR*)(toMap->pLibraryInterface));
+ if (toMap->pLibraryInterface) {
+ handlemap_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ handlemap, (VkRayTracingPipelineInterfaceCreateInfoKHR*)(toMap->pLibraryInterface));
}
- if (toMap->pDynamicState)
- {
- handlemap_VkPipelineDynamicStateCreateInfo(handlemap, (VkPipelineDynamicStateCreateInfo*)(toMap->pDynamicState));
+ if (toMap->pDynamicState) {
+ handlemap_VkPipelineDynamicStateCreateInfo(
+ handlemap, (VkPipelineDynamicStateCreateInfo*)(toMap->pDynamicState));
}
handlemap->mapHandles_VkPipelineLayout((VkPipelineLayout*)&toMap->layout);
handlemap->mapHandles_VkPipeline((VkPipeline*)&toMap->basePipelineHandle);
}
void handlemap_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
void handlemap_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toMap)
-{
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
-void handlemap_VkStridedDeviceAddressRegionKHR(
- VulkanHandleMapping* handlemap,
- VkStridedDeviceAddressRegionKHR* toMap)
-{
+void handlemap_VkStridedDeviceAddressRegionKHR(VulkanHandleMapping* handlemap,
+ VkStridedDeviceAddressRegionKHR* toMap) {
(void)handlemap;
(void)toMap;
}
-void handlemap_VkTraceRaysIndirectCommandKHR(
- VulkanHandleMapping* handlemap,
- VkTraceRaysIndirectCommandKHR* toMap)
-{
+void handlemap_VkTraceRaysIndirectCommandKHR(VulkanHandleMapping* handlemap,
+ VkTraceRaysIndirectCommandKHR* toMap) {
(void)handlemap;
(void)toMap;
}
#endif
#ifdef VK_KHR_ray_query
-void handlemap_VkPhysicalDeviceRayQueryFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceRayQueryFeaturesKHR* toMap)
-{
+void handlemap_VkPhysicalDeviceRayQueryFeaturesKHR(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceRayQueryFeaturesKHR* toMap) {
(void)handlemap;
(void)toMap;
- if (toMap->pNext)
- {
+ if (toMap->pNext) {
handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
}
}
#endif
-void handlemap_extension_struct(
- VulkanHandleMapping* handlemap,
- void* structExtension_out)
-{
- if (!structExtension_out)
- {
+void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExtension_out) {
+ if (!structExtension_out) {
return;
}
uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension_out);
- switch(structType)
- {
+ switch (structType) {
#ifdef VK_VERSION_1_1
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
- {
- handlemap_VkPhysicalDeviceSubgroupProperties(handlemap, reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
+ handlemap_VkPhysicalDeviceSubgroupProperties(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
- {
- handlemap_VkPhysicalDevice16BitStorageFeatures(handlemap, reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
+ handlemap_VkPhysicalDevice16BitStorageFeatures(
+ handlemap,
+ reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
- {
- handlemap_VkMemoryDedicatedRequirements(handlemap, reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
+ handlemap_VkMemoryDedicatedRequirements(
+ handlemap, reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
- {
- handlemap_VkMemoryDedicatedAllocateInfo(handlemap, reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: {
+ handlemap_VkMemoryDedicatedAllocateInfo(
+ handlemap, reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
- {
- handlemap_VkMemoryAllocateFlagsInfo(handlemap, reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: {
+ handlemap_VkMemoryAllocateFlagsInfo(
+ handlemap, reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
- {
- handlemap_VkDeviceGroupRenderPassBeginInfo(handlemap, reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: {
+ handlemap_VkDeviceGroupRenderPassBeginInfo(
+ handlemap,
+ reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
- {
- handlemap_VkDeviceGroupCommandBufferBeginInfo(handlemap, reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: {
+ handlemap_VkDeviceGroupCommandBufferBeginInfo(
+ handlemap,
+ reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
- {
- handlemap_VkDeviceGroupSubmitInfo(handlemap, reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: {
+ handlemap_VkDeviceGroupSubmitInfo(
+ handlemap, reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
- {
- handlemap_VkDeviceGroupBindSparseInfo(handlemap, reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: {
+ handlemap_VkDeviceGroupBindSparseInfo(
+ handlemap, reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
- {
- handlemap_VkBindBufferMemoryDeviceGroupInfo(handlemap, reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: {
+ handlemap_VkBindBufferMemoryDeviceGroupInfo(
+ handlemap,
+ reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
- {
- handlemap_VkBindImageMemoryDeviceGroupInfo(handlemap, reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: {
+ handlemap_VkBindImageMemoryDeviceGroupInfo(
+ handlemap,
+ reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
- {
- handlemap_VkDeviceGroupDeviceCreateInfo(handlemap, reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: {
+ handlemap_VkDeviceGroupDeviceCreateInfo(
+ handlemap, reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
- {
- handlemap_VkPhysicalDeviceFeatures2(handlemap, reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
+ handlemap_VkPhysicalDeviceFeatures2(
+ handlemap, reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
- {
- handlemap_VkPhysicalDevicePointClippingProperties(handlemap, reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: {
+ handlemap_VkPhysicalDevicePointClippingProperties(
+ handlemap,
+ reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
- {
- handlemap_VkRenderPassInputAttachmentAspectCreateInfo(handlemap, reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: {
+ handlemap_VkRenderPassInputAttachmentAspectCreateInfo(
+ handlemap, reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
- {
- handlemap_VkImageViewUsageCreateInfo(handlemap, reinterpret_cast<VkImageViewUsageCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: {
+ handlemap_VkImageViewUsageCreateInfo(
+ handlemap, reinterpret_cast<VkImageViewUsageCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
- {
- handlemap_VkPipelineTessellationDomainOriginStateCreateInfo(handlemap, reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: {
+ handlemap_VkPipelineTessellationDomainOriginStateCreateInfo(
+ handlemap, reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
- {
- handlemap_VkRenderPassMultiviewCreateInfo(handlemap, reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: {
+ handlemap_VkRenderPassMultiviewCreateInfo(
+ handlemap, reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
- {
- handlemap_VkPhysicalDeviceMultiviewFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
+ handlemap_VkPhysicalDeviceMultiviewFeatures(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
- {
- handlemap_VkPhysicalDeviceMultiviewProperties(handlemap, reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: {
+ handlemap_VkPhysicalDeviceMultiviewProperties(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
- {
- handlemap_VkPhysicalDeviceVariablePointersFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
+ handlemap_VkPhysicalDeviceVariablePointersFeatures(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
- {
- handlemap_VkPhysicalDeviceProtectedMemoryFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
+ handlemap_VkPhysicalDeviceProtectedMemoryFeatures(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
- {
- handlemap_VkPhysicalDeviceProtectedMemoryProperties(handlemap, reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: {
+ handlemap_VkPhysicalDeviceProtectedMemoryProperties(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
- {
- handlemap_VkProtectedSubmitInfo(handlemap, reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: {
+ handlemap_VkProtectedSubmitInfo(
+ handlemap, reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
- {
- handlemap_VkSamplerYcbcrConversionInfo(handlemap, reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: {
+ handlemap_VkSamplerYcbcrConversionInfo(
+ handlemap, reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
- {
- handlemap_VkBindImagePlaneMemoryInfo(handlemap, reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: {
+ handlemap_VkBindImagePlaneMemoryInfo(
+ handlemap, reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
- {
- handlemap_VkImagePlaneMemoryRequirementsInfo(handlemap, reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: {
+ handlemap_VkImagePlaneMemoryRequirementsInfo(
+ handlemap,
+ reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
- {
- handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
+ handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+ handlemap, reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
- {
- handlemap_VkSamplerYcbcrConversionImageFormatProperties(handlemap, reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: {
+ handlemap_VkSamplerYcbcrConversionImageFormatProperties(
+ handlemap, reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
- {
- handlemap_VkPhysicalDeviceExternalImageFormatInfo(handlemap, reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: {
+ handlemap_VkPhysicalDeviceExternalImageFormatInfo(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
- {
- handlemap_VkExternalImageFormatProperties(handlemap, reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: {
+ handlemap_VkExternalImageFormatProperties(
+ handlemap, reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
- {
- handlemap_VkPhysicalDeviceIDProperties(handlemap, reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: {
+ handlemap_VkPhysicalDeviceIDProperties(
+ handlemap, reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
- {
- handlemap_VkExternalMemoryImageCreateInfo(handlemap, reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: {
+ handlemap_VkExternalMemoryImageCreateInfo(
+ handlemap, reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
- {
- handlemap_VkExternalMemoryBufferCreateInfo(handlemap, reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: {
+ handlemap_VkExternalMemoryBufferCreateInfo(
+ handlemap,
+ reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
- {
- handlemap_VkExportMemoryAllocateInfo(handlemap, reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: {
+ handlemap_VkExportMemoryAllocateInfo(
+ handlemap, reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
- {
- handlemap_VkExportFenceCreateInfo(handlemap, reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: {
+ handlemap_VkExportFenceCreateInfo(
+ handlemap, reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
- {
- handlemap_VkExportSemaphoreCreateInfo(handlemap, reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: {
+ handlemap_VkExportSemaphoreCreateInfo(
+ handlemap, reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
- {
- handlemap_VkPhysicalDeviceMaintenance3Properties(handlemap, reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: {
+ handlemap_VkPhysicalDeviceMaintenance3Properties(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
- {
- handlemap_VkPhysicalDeviceShaderDrawParametersFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
+ handlemap_VkPhysicalDeviceShaderDrawParametersFeatures(
+ handlemap, reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_VERSION_1_2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
- {
- handlemap_VkPhysicalDeviceVulkan11Features(handlemap, reinterpret_cast<VkPhysicalDeviceVulkan11Features*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: {
+ handlemap_VkPhysicalDeviceVulkan11Features(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceVulkan11Features*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
- {
- handlemap_VkPhysicalDeviceVulkan11Properties(handlemap, reinterpret_cast<VkPhysicalDeviceVulkan11Properties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: {
+ handlemap_VkPhysicalDeviceVulkan11Properties(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceVulkan11Properties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
- {
- handlemap_VkPhysicalDeviceVulkan12Features(handlemap, reinterpret_cast<VkPhysicalDeviceVulkan12Features*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: {
+ handlemap_VkPhysicalDeviceVulkan12Features(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceVulkan12Features*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
- {
- handlemap_VkPhysicalDeviceVulkan12Properties(handlemap, reinterpret_cast<VkPhysicalDeviceVulkan12Properties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: {
+ handlemap_VkPhysicalDeviceVulkan12Properties(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceVulkan12Properties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
- {
- handlemap_VkImageFormatListCreateInfo(handlemap, reinterpret_cast<VkImageFormatListCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: {
+ handlemap_VkImageFormatListCreateInfo(
+ handlemap, reinterpret_cast<VkImageFormatListCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
- {
- handlemap_VkPhysicalDevice8BitStorageFeatures(handlemap, reinterpret_cast<VkPhysicalDevice8BitStorageFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: {
+ handlemap_VkPhysicalDevice8BitStorageFeatures(
+ handlemap,
+ reinterpret_cast<VkPhysicalDevice8BitStorageFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
- {
- handlemap_VkPhysicalDeviceDriverProperties(handlemap, reinterpret_cast<VkPhysicalDeviceDriverProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: {
+ handlemap_VkPhysicalDeviceDriverProperties(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceDriverProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
- {
- handlemap_VkPhysicalDeviceShaderAtomicInt64Features(handlemap, reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: {
+ handlemap_VkPhysicalDeviceShaderAtomicInt64Features(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
- {
- handlemap_VkPhysicalDeviceShaderFloat16Int8Features(handlemap, reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: {
+ handlemap_VkPhysicalDeviceShaderFloat16Int8Features(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
- {
- handlemap_VkPhysicalDeviceFloatControlsProperties(handlemap, reinterpret_cast<VkPhysicalDeviceFloatControlsProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: {
+ handlemap_VkPhysicalDeviceFloatControlsProperties(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceFloatControlsProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
- {
- handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfo(handlemap, reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: {
+ handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfo(
+ handlemap, reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
- {
- handlemap_VkPhysicalDeviceDescriptorIndexingFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: {
+ handlemap_VkPhysicalDeviceDescriptorIndexingFeatures(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
- {
- handlemap_VkPhysicalDeviceDescriptorIndexingProperties(handlemap, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: {
+ handlemap_VkPhysicalDeviceDescriptorIndexingProperties(
+ handlemap, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
- {
- handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfo(handlemap, reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: {
+ handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfo(
+ handlemap, reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
- {
- handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupport(handlemap, reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: {
+ handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupport(
+ handlemap, reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
- {
- handlemap_VkSubpassDescriptionDepthStencilResolve(handlemap, reinterpret_cast<VkSubpassDescriptionDepthStencilResolve*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: {
+ handlemap_VkSubpassDescriptionDepthStencilResolve(
+ handlemap,
+ reinterpret_cast<VkSubpassDescriptionDepthStencilResolve*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
- {
- handlemap_VkPhysicalDeviceDepthStencilResolveProperties(handlemap, reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: {
+ handlemap_VkPhysicalDeviceDepthStencilResolveProperties(
+ handlemap, reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
- {
- handlemap_VkPhysicalDeviceScalarBlockLayoutFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: {
+ handlemap_VkPhysicalDeviceScalarBlockLayoutFeatures(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
- {
- handlemap_VkImageStencilUsageCreateInfo(handlemap, reinterpret_cast<VkImageStencilUsageCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: {
+ handlemap_VkImageStencilUsageCreateInfo(
+ handlemap, reinterpret_cast<VkImageStencilUsageCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
- {
- handlemap_VkSamplerReductionModeCreateInfo(handlemap, reinterpret_cast<VkSamplerReductionModeCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: {
+ handlemap_VkSamplerReductionModeCreateInfo(
+ handlemap,
+ reinterpret_cast<VkSamplerReductionModeCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
- {
- handlemap_VkPhysicalDeviceSamplerFilterMinmaxProperties(handlemap, reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: {
+ handlemap_VkPhysicalDeviceSamplerFilterMinmaxProperties(
+ handlemap, reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
- {
- handlemap_VkPhysicalDeviceVulkanMemoryModelFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: {
+ handlemap_VkPhysicalDeviceVulkanMemoryModelFeatures(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
- {
- handlemap_VkPhysicalDeviceImagelessFramebufferFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: {
+ handlemap_VkPhysicalDeviceImagelessFramebufferFeatures(
+ handlemap, reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
- {
- handlemap_VkFramebufferAttachmentsCreateInfo(handlemap, reinterpret_cast<VkFramebufferAttachmentsCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: {
+ handlemap_VkFramebufferAttachmentsCreateInfo(
+ handlemap,
+ reinterpret_cast<VkFramebufferAttachmentsCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
- {
- handlemap_VkRenderPassAttachmentBeginInfo(handlemap, reinterpret_cast<VkRenderPassAttachmentBeginInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: {
+ handlemap_VkRenderPassAttachmentBeginInfo(
+ handlemap, reinterpret_cast<VkRenderPassAttachmentBeginInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
- {
- handlemap_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: {
+ handlemap_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
+ handlemap, reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
- {
- handlemap_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: {
+ handlemap_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
+ handlemap, reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
- {
- handlemap_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: {
+ handlemap_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
+ handlemap, reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
- {
- handlemap_VkAttachmentReferenceStencilLayout(handlemap, reinterpret_cast<VkAttachmentReferenceStencilLayout*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: {
+ handlemap_VkAttachmentReferenceStencilLayout(
+ handlemap,
+ reinterpret_cast<VkAttachmentReferenceStencilLayout*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
- {
- handlemap_VkAttachmentDescriptionStencilLayout(handlemap, reinterpret_cast<VkAttachmentDescriptionStencilLayout*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: {
+ handlemap_VkAttachmentDescriptionStencilLayout(
+ handlemap,
+ reinterpret_cast<VkAttachmentDescriptionStencilLayout*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
- {
- handlemap_VkPhysicalDeviceHostQueryResetFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: {
+ handlemap_VkPhysicalDeviceHostQueryResetFeatures(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
- {
- handlemap_VkPhysicalDeviceTimelineSemaphoreFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: {
+ handlemap_VkPhysicalDeviceTimelineSemaphoreFeatures(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
- {
- handlemap_VkPhysicalDeviceTimelineSemaphoreProperties(handlemap, reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: {
+ handlemap_VkPhysicalDeviceTimelineSemaphoreProperties(
+ handlemap, reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
- {
- handlemap_VkSemaphoreTypeCreateInfo(handlemap, reinterpret_cast<VkSemaphoreTypeCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: {
+ handlemap_VkSemaphoreTypeCreateInfo(
+ handlemap, reinterpret_cast<VkSemaphoreTypeCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
- {
- handlemap_VkTimelineSemaphoreSubmitInfo(handlemap, reinterpret_cast<VkTimelineSemaphoreSubmitInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: {
+ handlemap_VkTimelineSemaphoreSubmitInfo(
+ handlemap, reinterpret_cast<VkTimelineSemaphoreSubmitInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
- {
- handlemap_VkPhysicalDeviceBufferDeviceAddressFeatures(handlemap, reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: {
+ handlemap_VkPhysicalDeviceBufferDeviceAddressFeatures(
+ handlemap, reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
- {
- handlemap_VkBufferOpaqueCaptureAddressCreateInfo(handlemap, reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: {
+ handlemap_VkBufferOpaqueCaptureAddressCreateInfo(
+ handlemap,
+ reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
- {
- handlemap_VkMemoryOpaqueCaptureAddressAllocateInfo(handlemap, reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: {
+ handlemap_VkMemoryOpaqueCaptureAddressAllocateInfo(
+ handlemap,
+ reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_swapchain
- case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
- {
- handlemap_VkImageSwapchainCreateInfoKHR(handlemap, reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
+ handlemap_VkImageSwapchainCreateInfoKHR(
+ handlemap, reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
- {
- handlemap_VkBindImageMemorySwapchainInfoKHR(handlemap, reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: {
+ handlemap_VkBindImageMemorySwapchainInfoKHR(
+ handlemap,
+ reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
- {
- handlemap_VkDeviceGroupPresentInfoKHR(handlemap, reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: {
+ handlemap_VkDeviceGroupPresentInfoKHR(
+ handlemap, reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
- {
- handlemap_VkDeviceGroupSwapchainCreateInfoKHR(handlemap, reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: {
+ handlemap_VkDeviceGroupSwapchainCreateInfoKHR(
+ handlemap,
+ reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_display_swapchain
- case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
- {
- handlemap_VkDisplayPresentInfoKHR(handlemap, reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: {
+ handlemap_VkDisplayPresentInfoKHR(
+ handlemap, reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_video_queue
- case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR:
- {
- handlemap_VkVideoQueueFamilyProperties2KHR(handlemap, reinterpret_cast<VkVideoQueueFamilyProperties2KHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: {
+ handlemap_VkVideoQueueFamilyProperties2KHR(
+ handlemap,
+ reinterpret_cast<VkVideoQueueFamilyProperties2KHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR:
- {
- handlemap_VkVideoProfileKHR(handlemap, reinterpret_cast<VkVideoProfileKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR: {
+ handlemap_VkVideoProfileKHR(handlemap,
+ reinterpret_cast<VkVideoProfileKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR:
- {
- handlemap_VkVideoProfilesKHR(handlemap, reinterpret_cast<VkVideoProfilesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR: {
+ handlemap_VkVideoProfilesKHR(
+ handlemap, reinterpret_cast<VkVideoProfilesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_dynamic_rendering
- case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR:
- {
- handlemap_VkPipelineRenderingCreateInfoKHR(handlemap, reinterpret_cast<VkPipelineRenderingCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: {
+ handlemap_VkPipelineRenderingCreateInfoKHR(
+ handlemap,
+ reinterpret_cast<VkPipelineRenderingCreateInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR:
- {
- handlemap_VkPhysicalDeviceDynamicRenderingFeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: {
+ handlemap_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+ handlemap, reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR:
- {
- handlemap_VkCommandBufferInheritanceRenderingInfoKHR(handlemap, reinterpret_cast<VkCommandBufferInheritanceRenderingInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: {
+ handlemap_VkCommandBufferInheritanceRenderingInfoKHR(
+ handlemap,
+ reinterpret_cast<VkCommandBufferInheritanceRenderingInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
- {
- handlemap_VkRenderingFragmentShadingRateAttachmentInfoKHR(handlemap, reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
+ handlemap_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+ handlemap, reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
- {
- handlemap_VkRenderingFragmentDensityMapAttachmentInfoEXT(handlemap, reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
+ handlemap_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ handlemap, reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
- {
- handlemap_VkAttachmentSampleCountInfoAMD(handlemap, reinterpret_cast<VkAttachmentSampleCountInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
+ handlemap_VkAttachmentSampleCountInfoAMD(
+ handlemap, reinterpret_cast<VkAttachmentSampleCountInfoAMD*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
- {
- handlemap_VkMultiviewPerViewAttributesInfoNVX(handlemap, reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
+ handlemap_VkMultiviewPerViewAttributesInfoNVX(
+ handlemap,
+ reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_memory_win32
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
- {
- handlemap_VkImportMemoryWin32HandleInfoKHR(handlemap, reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
+ handlemap_VkImportMemoryWin32HandleInfoKHR(
+ handlemap,
+ reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
- {
- handlemap_VkExportMemoryWin32HandleInfoKHR(handlemap, reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
+ handlemap_VkExportMemoryWin32HandleInfoKHR(
+ handlemap,
+ reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_memory_fd
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
- {
- handlemap_VkImportMemoryFdInfoKHR(handlemap, reinterpret_cast<VkImportMemoryFdInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: {
+ handlemap_VkImportMemoryFdInfoKHR(
+ handlemap, reinterpret_cast<VkImportMemoryFdInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_win32_keyed_mutex
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
- {
- handlemap_VkWin32KeyedMutexAcquireReleaseInfoKHR(handlemap, reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: {
+ handlemap_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+ handlemap,
+ reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_semaphore_win32
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
- {
- handlemap_VkExportSemaphoreWin32HandleInfoKHR(handlemap, reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: {
+ handlemap_VkExportSemaphoreWin32HandleInfoKHR(
+ handlemap,
+ reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
- {
- handlemap_VkD3D12FenceSubmitInfoKHR(handlemap, reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: {
+ handlemap_VkD3D12FenceSubmitInfoKHR(
+ handlemap, reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_push_descriptor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
- {
- handlemap_VkPhysicalDevicePushDescriptorPropertiesKHR(handlemap, reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: {
+ handlemap_VkPhysicalDevicePushDescriptorPropertiesKHR(
+ handlemap, reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_incremental_present
- case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
- {
- handlemap_VkPresentRegionsKHR(handlemap, reinterpret_cast<VkPresentRegionsKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: {
+ handlemap_VkPresentRegionsKHR(
+ handlemap, reinterpret_cast<VkPresentRegionsKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shared_presentable_image
- case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
- {
- handlemap_VkSharedPresentSurfaceCapabilitiesKHR(handlemap, reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
+ handlemap_VkSharedPresentSurfaceCapabilitiesKHR(
+ handlemap,
+ reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_fence_win32
- case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
- {
- handlemap_VkExportFenceWin32HandleInfoKHR(handlemap, reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: {
+ handlemap_VkExportFenceWin32HandleInfoKHR(
+ handlemap, reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_performance_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
- {
- handlemap_VkPhysicalDevicePerformanceQueryFeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: {
+ handlemap_VkPhysicalDevicePerformanceQueryFeaturesKHR(
+ handlemap, reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
- {
- handlemap_VkPhysicalDevicePerformanceQueryPropertiesKHR(handlemap, reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: {
+ handlemap_VkPhysicalDevicePerformanceQueryPropertiesKHR(
+ handlemap, reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
- {
- handlemap_VkQueryPoolPerformanceCreateInfoKHR(handlemap, reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: {
+ handlemap_VkQueryPoolPerformanceCreateInfoKHR(
+ handlemap,
+ reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
- {
- handlemap_VkPerformanceQuerySubmitInfoKHR(handlemap, reinterpret_cast<VkPerformanceQuerySubmitInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: {
+ handlemap_VkPerformanceQuerySubmitInfoKHR(
+ handlemap, reinterpret_cast<VkPerformanceQuerySubmitInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_portability_subset
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
- {
- handlemap_VkPhysicalDevicePortabilitySubsetFeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
+ handlemap_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
+ handlemap, reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
- {
- handlemap_VkPhysicalDevicePortabilitySubsetPropertiesKHR(handlemap, reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
+ handlemap_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
+ handlemap, reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shader_clock
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
- {
- handlemap_VkPhysicalDeviceShaderClockFeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
+ handlemap_VkPhysicalDeviceShaderClockFeaturesKHR(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shader_terminate_invocation
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR:
- {
- handlemap_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: {
+ handlemap_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
+ handlemap, reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_fragment_shading_rate
- case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
- {
- handlemap_VkFragmentShadingRateAttachmentInfoKHR(handlemap, reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
+ handlemap_VkFragmentShadingRateAttachmentInfoKHR(
+ handlemap,
+ reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
- {
- handlemap_VkPipelineFragmentShadingRateStateCreateInfoKHR(handlemap, reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: {
+ handlemap_VkPipelineFragmentShadingRateStateCreateInfoKHR(
+ handlemap, reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
- {
- handlemap_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: {
+ handlemap_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
+ handlemap, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
- {
- handlemap_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(handlemap, reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: {
+ handlemap_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
+ handlemap, reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_surface_protected_capabilities
- case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
- {
- handlemap_VkSurfaceProtectedCapabilitiesKHR(handlemap, reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: {
+ handlemap_VkSurfaceProtectedCapabilitiesKHR(
+ handlemap,
+ reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_present_wait
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
- {
- handlemap_VkPhysicalDevicePresentWaitFeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDevicePresentWaitFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: {
+ handlemap_VkPhysicalDevicePresentWaitFeaturesKHR(
+ handlemap,
+ reinterpret_cast<VkPhysicalDevicePresentWaitFeaturesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
- {
- handlemap_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: {
+ handlemap_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
+ handlemap,
+ reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shader_integer_dot_product
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR:
- {
- handlemap_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: {
+ handlemap_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
+ handlemap, reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR:
- {
- handlemap_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(handlemap, reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: {
+ handlemap_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
+ handlemap, reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_present_id
- case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
- {
- handlemap_VkPresentIdKHR(handlemap, reinterpret_cast<VkPresentIdKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: {
+ handlemap_VkPresentIdKHR(handlemap,
+ reinterpret_cast<VkPresentIdKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
- {
- handlemap_VkPhysicalDevicePresentIdFeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDevicePresentIdFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: {
+ handlemap_VkPhysicalDevicePresentIdFeaturesKHR(
+ handlemap,
+ reinterpret_cast<VkPhysicalDevicePresentIdFeaturesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_video_encode_queue
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
- {
- handlemap_VkVideoEncodeRateControlInfoKHR(handlemap, reinterpret_cast<VkVideoEncodeRateControlInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
+ handlemap_VkVideoEncodeRateControlInfoKHR(
+ handlemap, reinterpret_cast<VkVideoEncodeRateControlInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_synchronization2
- case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR:
- {
- handlemap_VkMemoryBarrier2KHR(handlemap, reinterpret_cast<VkMemoryBarrier2KHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: {
+ handlemap_VkMemoryBarrier2KHR(
+ handlemap, reinterpret_cast<VkMemoryBarrier2KHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR:
- {
- handlemap_VkPhysicalDeviceSynchronization2FeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDeviceSynchronization2FeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: {
+ handlemap_VkPhysicalDeviceSynchronization2FeaturesKHR(
+ handlemap, reinterpret_cast<VkPhysicalDeviceSynchronization2FeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
- {
- handlemap_VkQueueFamilyCheckpointProperties2NV(handlemap, reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
+ handlemap_VkQueueFamilyCheckpointProperties2NV(
+ handlemap,
+ reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
- {
- handlemap_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
+ handlemap_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR:
- {
- handlemap_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: {
+ handlemap_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
- {
- handlemap_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
+ handlemap_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_format_feature_flags2
- case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR:
- {
- handlemap_VkFormatProperties3KHR(handlemap, reinterpret_cast<VkFormatProperties3KHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: {
+ handlemap_VkFormatProperties3KHR(
+ handlemap, reinterpret_cast<VkFormatProperties3KHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_maintenance4
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR:
- {
- handlemap_VkPhysicalDeviceMaintenance4FeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: {
+ handlemap_VkPhysicalDeviceMaintenance4FeaturesKHR(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR:
- {
- handlemap_VkPhysicalDeviceMaintenance4PropertiesKHR(handlemap, reinterpret_cast<VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: {
+ handlemap_VkPhysicalDeviceMaintenance4PropertiesKHR(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_ANDROID_native_buffer
- case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
- {
- handlemap_VkNativeBufferANDROID(handlemap, reinterpret_cast<VkNativeBufferANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
+ handlemap_VkNativeBufferANDROID(
+ handlemap, reinterpret_cast<VkNativeBufferANDROID*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_debug_report
- case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
- {
- handlemap_VkDebugReportCallbackCreateInfoEXT(handlemap, reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: {
+ handlemap_VkDebugReportCallbackCreateInfoEXT(
+ handlemap,
+ reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_rasterization_order
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
- {
- handlemap_VkPipelineRasterizationStateRasterizationOrderAMD(handlemap, reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: {
+ handlemap_VkPipelineRasterizationStateRasterizationOrderAMD(
+ handlemap, reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_dedicated_allocation
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
- {
- handlemap_VkDedicatedAllocationImageCreateInfoNV(handlemap, reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: {
+ handlemap_VkDedicatedAllocationImageCreateInfoNV(
+ handlemap,
+ reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
- {
- handlemap_VkDedicatedAllocationBufferCreateInfoNV(handlemap, reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: {
+ handlemap_VkDedicatedAllocationBufferCreateInfoNV(
+ handlemap,
+ reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
- {
- handlemap_VkDedicatedAllocationMemoryAllocateInfoNV(handlemap, reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: {
+ handlemap_VkDedicatedAllocationMemoryAllocateInfoNV(
+ handlemap,
+ reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_transform_feedback
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceTransformFeedbackFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
- {
- handlemap_VkPhysicalDeviceTransformFeedbackPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: {
+ handlemap_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
- {
- handlemap_VkPipelineRasterizationStateStreamCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: {
+ handlemap_VkPipelineRasterizationStateStreamCreateInfoEXT(
+ handlemap, reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_video_encode_h264
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT:
- {
- handlemap_VkVideoEncodeH264CapabilitiesEXT(handlemap, reinterpret_cast<VkVideoEncodeH264CapabilitiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
+ handlemap_VkVideoEncodeH264CapabilitiesEXT(
+ handlemap,
+ reinterpret_cast<VkVideoEncodeH264CapabilitiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT:
- {
- handlemap_VkVideoEncodeH264SessionCreateInfoEXT(handlemap, reinterpret_cast<VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: {
+ handlemap_VkVideoEncodeH264SessionCreateInfoEXT(
+ handlemap,
+ reinterpret_cast<VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- handlemap_VkVideoEncodeH264SessionParametersAddInfoEXT(handlemap, reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ handlemap_VkVideoEncodeH264SessionParametersAddInfoEXT(
+ handlemap, reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- handlemap_VkVideoEncodeH264SessionParametersCreateInfoEXT(handlemap, reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ handlemap_VkVideoEncodeH264SessionParametersCreateInfoEXT(
+ handlemap, reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT:
- {
- handlemap_VkVideoEncodeH264VclFrameInfoEXT(handlemap, reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
+ handlemap_VkVideoEncodeH264VclFrameInfoEXT(
+ handlemap,
+ reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT:
- {
- handlemap_VkVideoEncodeH264EmitPictureParametersEXT(handlemap, reinterpret_cast<VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: {
+ handlemap_VkVideoEncodeH264EmitPictureParametersEXT(
+ handlemap,
+ reinterpret_cast<VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT:
- {
- handlemap_VkVideoEncodeH264ProfileEXT(handlemap, reinterpret_cast<VkVideoEncodeH264ProfileEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT: {
+ handlemap_VkVideoEncodeH264ProfileEXT(
+ handlemap, reinterpret_cast<VkVideoEncodeH264ProfileEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_video_encode_h265
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT:
- {
- handlemap_VkVideoEncodeH265CapabilitiesEXT(handlemap, reinterpret_cast<VkVideoEncodeH265CapabilitiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
+ handlemap_VkVideoEncodeH265CapabilitiesEXT(
+ handlemap,
+ reinterpret_cast<VkVideoEncodeH265CapabilitiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT:
- {
- handlemap_VkVideoEncodeH265SessionCreateInfoEXT(handlemap, reinterpret_cast<VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: {
+ handlemap_VkVideoEncodeH265SessionCreateInfoEXT(
+ handlemap,
+ reinterpret_cast<VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- handlemap_VkVideoEncodeH265SessionParametersAddInfoEXT(handlemap, reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ handlemap_VkVideoEncodeH265SessionParametersAddInfoEXT(
+ handlemap, reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- handlemap_VkVideoEncodeH265SessionParametersCreateInfoEXT(handlemap, reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ handlemap_VkVideoEncodeH265SessionParametersCreateInfoEXT(
+ handlemap, reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT:
- {
- handlemap_VkVideoEncodeH265VclFrameInfoEXT(handlemap, reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
+ handlemap_VkVideoEncodeH265VclFrameInfoEXT(
+ handlemap,
+ reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT:
- {
- handlemap_VkVideoEncodeH265EmitPictureParametersEXT(handlemap, reinterpret_cast<VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: {
+ handlemap_VkVideoEncodeH265EmitPictureParametersEXT(
+ handlemap,
+ reinterpret_cast<VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT:
- {
- handlemap_VkVideoEncodeH265ProfileEXT(handlemap, reinterpret_cast<VkVideoEncodeH265ProfileEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT: {
+ handlemap_VkVideoEncodeH265ProfileEXT(
+ handlemap, reinterpret_cast<VkVideoEncodeH265ProfileEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_video_decode_h264
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT:
- {
- handlemap_VkVideoDecodeH264ProfileEXT(handlemap, reinterpret_cast<VkVideoDecodeH264ProfileEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT: {
+ handlemap_VkVideoDecodeH264ProfileEXT(
+ handlemap, reinterpret_cast<VkVideoDecodeH264ProfileEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT:
- {
- handlemap_VkVideoDecodeH264CapabilitiesEXT(handlemap, reinterpret_cast<VkVideoDecodeH264CapabilitiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: {
+ handlemap_VkVideoDecodeH264CapabilitiesEXT(
+ handlemap,
+ reinterpret_cast<VkVideoDecodeH264CapabilitiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT:
- {
- handlemap_VkVideoDecodeH264SessionCreateInfoEXT(handlemap, reinterpret_cast<VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: {
+ handlemap_VkVideoDecodeH264SessionCreateInfoEXT(
+ handlemap,
+ reinterpret_cast<VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- handlemap_VkVideoDecodeH264SessionParametersAddInfoEXT(handlemap, reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ handlemap_VkVideoDecodeH264SessionParametersAddInfoEXT(
+ handlemap, reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- handlemap_VkVideoDecodeH264SessionParametersCreateInfoEXT(handlemap, reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ handlemap_VkVideoDecodeH264SessionParametersCreateInfoEXT(
+ handlemap, reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT:
- {
- handlemap_VkVideoDecodeH264PictureInfoEXT(handlemap, reinterpret_cast<VkVideoDecodeH264PictureInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: {
+ handlemap_VkVideoDecodeH264PictureInfoEXT(
+ handlemap, reinterpret_cast<VkVideoDecodeH264PictureInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT:
- {
- handlemap_VkVideoDecodeH264MvcEXT(handlemap, reinterpret_cast<VkVideoDecodeH264MvcEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT: {
+ handlemap_VkVideoDecodeH264MvcEXT(
+ handlemap, reinterpret_cast<VkVideoDecodeH264MvcEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT:
- {
- handlemap_VkVideoDecodeH264DpbSlotInfoEXT(handlemap, reinterpret_cast<VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: {
+ handlemap_VkVideoDecodeH264DpbSlotInfoEXT(
+ handlemap, reinterpret_cast<VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_texture_gather_bias_lod
- case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
- {
- handlemap_VkTextureLODGatherFormatPropertiesAMD(handlemap, reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
+ handlemap_VkTextureLODGatherFormatPropertiesAMD(
+ handlemap,
+ reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_corner_sampled_image
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
- {
- handlemap_VkPhysicalDeviceCornerSampledImageFeaturesNV(handlemap, reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: {
+ handlemap_VkPhysicalDeviceCornerSampledImageFeaturesNV(
+ handlemap, reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_external_memory
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
- {
- handlemap_VkExternalMemoryImageCreateInfoNV(handlemap, reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: {
+ handlemap_VkExternalMemoryImageCreateInfoNV(
+ handlemap,
+ reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
- {
- handlemap_VkExportMemoryAllocateInfoNV(handlemap, reinterpret_cast<VkExportMemoryAllocateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: {
+ handlemap_VkExportMemoryAllocateInfoNV(
+ handlemap, reinterpret_cast<VkExportMemoryAllocateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_external_memory_win32
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
- {
- handlemap_VkImportMemoryWin32HandleInfoNV(handlemap, reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
+ handlemap_VkImportMemoryWin32HandleInfoNV(
+ handlemap, reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
- {
- handlemap_VkExportMemoryWin32HandleInfoNV(handlemap, reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
+ handlemap_VkExportMemoryWin32HandleInfoNV(
+ handlemap, reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_win32_keyed_mutex
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
- {
- handlemap_VkWin32KeyedMutexAcquireReleaseInfoNV(handlemap, reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: {
+ handlemap_VkWin32KeyedMutexAcquireReleaseInfoNV(
+ handlemap,
+ reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_validation_flags
- case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
- {
- handlemap_VkValidationFlagsEXT(handlemap, reinterpret_cast<VkValidationFlagsEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: {
+ handlemap_VkValidationFlagsEXT(
+ handlemap, reinterpret_cast<VkValidationFlagsEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_astc_decode_mode
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
- {
- handlemap_VkImageViewASTCDecodeModeEXT(handlemap, reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
+ handlemap_VkImageViewASTCDecodeModeEXT(
+ handlemap, reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceASTCDecodeFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceASTCDecodeFeaturesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_conditional_rendering
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceConditionalRenderingFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
- {
- handlemap_VkCommandBufferInheritanceConditionalRenderingInfoEXT(handlemap, reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: {
+ handlemap_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+ handlemap, reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_clip_space_w_scaling
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
- {
- handlemap_VkPipelineViewportWScalingStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: {
+ handlemap_VkPipelineViewportWScalingStateCreateInfoNV(
+ handlemap, reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_display_control
- case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
- {
- handlemap_VkSwapchainCounterCreateInfoEXT(handlemap, reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: {
+ handlemap_VkSwapchainCounterCreateInfoEXT(
+ handlemap, reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_GOOGLE_display_timing
- case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
- {
- handlemap_VkPresentTimesInfoGOOGLE(handlemap, reinterpret_cast<VkPresentTimesInfoGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: {
+ handlemap_VkPresentTimesInfoGOOGLE(
+ handlemap, reinterpret_cast<VkPresentTimesInfoGOOGLE*>(structExtension_out));
break;
}
#endif
#ifdef VK_NVX_multiview_per_view_attributes
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
- {
- handlemap_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(handlemap, reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: {
+ handlemap_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_viewport_swizzle
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
- {
- handlemap_VkPipelineViewportSwizzleStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: {
+ handlemap_VkPipelineViewportSwizzleStateCreateInfoNV(
+ handlemap,
+ reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_discard_rectangles
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
- {
- handlemap_VkPhysicalDeviceDiscardRectanglePropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: {
+ handlemap_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
- {
- handlemap_VkPipelineDiscardRectangleStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: {
+ handlemap_VkPipelineDiscardRectangleStateCreateInfoEXT(
+ handlemap, reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_conservative_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
- {
- handlemap_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: {
+ handlemap_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
- {
- handlemap_VkPipelineRasterizationConservativeStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: {
+ handlemap_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+ handlemap, reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_depth_clip_enable
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceDepthClipEnableFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
- {
- handlemap_VkPipelineRasterizationDepthClipStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ handlemap_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ handlemap, reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_debug_utils
- case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
- {
- handlemap_VkDebugUtilsMessengerCreateInfoEXT(handlemap, reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
+ handlemap_VkDebugUtilsMessengerCreateInfoEXT(
+ handlemap,
+ reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
- {
- handlemap_VkAndroidHardwareBufferUsageANDROID(handlemap, reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: {
+ handlemap_VkAndroidHardwareBufferUsageANDROID(
+ handlemap,
+ reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
- {
- handlemap_VkAndroidHardwareBufferFormatPropertiesANDROID(handlemap, reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: {
+ handlemap_VkAndroidHardwareBufferFormatPropertiesANDROID(
+ handlemap, reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
- {
- handlemap_VkImportAndroidHardwareBufferInfoANDROID(handlemap, reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: {
+ handlemap_VkImportAndroidHardwareBufferInfoANDROID(
+ handlemap,
+ reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
- {
- handlemap_VkExternalFormatANDROID(handlemap, reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: {
+ handlemap_VkExternalFormatANDROID(
+ handlemap, reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
- {
- handlemap_VkAndroidHardwareBufferFormatProperties2ANDROID(handlemap, reinterpret_cast<VkAndroidHardwareBufferFormatProperties2ANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: {
+ handlemap_VkAndroidHardwareBufferFormatProperties2ANDROID(
+ handlemap, reinterpret_cast<VkAndroidHardwareBufferFormatProperties2ANDROID*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_inline_uniform_block
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
- {
- handlemap_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
+ handlemap_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT:
- {
- handlemap_VkWriteDescriptorSetInlineUniformBlockEXT(handlemap, reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
+ handlemap_VkWriteDescriptorSetInlineUniformBlockEXT(
+ handlemap,
+ reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT:
- {
- handlemap_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(handlemap, reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
+ handlemap_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
+ handlemap, reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_sample_locations
- case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
- {
- handlemap_VkSampleLocationsInfoEXT(handlemap, reinterpret_cast<VkSampleLocationsInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
+ handlemap_VkSampleLocationsInfoEXT(
+ handlemap, reinterpret_cast<VkSampleLocationsInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
- {
- handlemap_VkRenderPassSampleLocationsBeginInfoEXT(handlemap, reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: {
+ handlemap_VkRenderPassSampleLocationsBeginInfoEXT(
+ handlemap,
+ reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
- {
- handlemap_VkPipelineSampleLocationsStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: {
+ handlemap_VkPipelineSampleLocationsStateCreateInfoEXT(
+ handlemap, reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
- {
- handlemap_VkPhysicalDeviceSampleLocationsPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: {
+ handlemap_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_blend_operation_advanced
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
- {
- handlemap_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: {
+ handlemap_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
- {
- handlemap_VkPipelineColorBlendAdvancedStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: {
+ handlemap_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+ handlemap, reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_fragment_coverage_to_color
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
- {
- handlemap_VkPipelineCoverageToColorStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: {
+ handlemap_VkPipelineCoverageToColorStateCreateInfoNV(
+ handlemap,
+ reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_framebuffer_mixed_samples
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
- {
- handlemap_VkPipelineCoverageModulationStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: {
+ handlemap_VkPipelineCoverageModulationStateCreateInfoNV(
+ handlemap, reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_shader_sm_builtins
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
- {
- handlemap_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(handlemap, reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: {
+ handlemap_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
+ handlemap, reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
- {
- handlemap_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(handlemap, reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: {
+ handlemap_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_image_drm_format_modifier
- case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
- {
- handlemap_VkDrmFormatModifierPropertiesListEXT(handlemap, reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: {
+ handlemap_VkDrmFormatModifierPropertiesListEXT(
+ handlemap,
+ reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
- {
- handlemap_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(handlemap, reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: {
+ handlemap_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
- {
- handlemap_VkImageDrmFormatModifierListCreateInfoEXT(handlemap, reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: {
+ handlemap_VkImageDrmFormatModifierListCreateInfoEXT(
+ handlemap,
+ reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
- {
- handlemap_VkImageDrmFormatModifierExplicitCreateInfoEXT(handlemap, reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: {
+ handlemap_VkImageDrmFormatModifierExplicitCreateInfoEXT(
+ handlemap, reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
- {
- handlemap_VkDrmFormatModifierPropertiesList2EXT(handlemap, reinterpret_cast<VkDrmFormatModifierPropertiesList2EXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: {
+ handlemap_VkDrmFormatModifierPropertiesList2EXT(
+ handlemap,
+ reinterpret_cast<VkDrmFormatModifierPropertiesList2EXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_validation_cache
- case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
- {
- handlemap_VkShaderModuleValidationCacheCreateInfoEXT(handlemap, reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: {
+ handlemap_VkShaderModuleValidationCacheCreateInfoEXT(
+ handlemap,
+ reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_shading_rate_image
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
- {
- handlemap_VkPipelineViewportShadingRateImageStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: {
+ handlemap_VkPipelineViewportShadingRateImageStateCreateInfoNV(
+ handlemap, reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
- {
- handlemap_VkPhysicalDeviceShadingRateImageFeaturesNV(handlemap, reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: {
+ handlemap_VkPhysicalDeviceShadingRateImageFeaturesNV(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
- {
- handlemap_VkPhysicalDeviceShadingRateImagePropertiesNV(handlemap, reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: {
+ handlemap_VkPhysicalDeviceShadingRateImagePropertiesNV(
+ handlemap, reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
- {
- handlemap_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: {
+ handlemap_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
+ handlemap, reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_ray_tracing
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
- {
- handlemap_VkWriteDescriptorSetAccelerationStructureNV(handlemap, reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: {
+ handlemap_VkWriteDescriptorSetAccelerationStructureNV(
+ handlemap, reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
- {
- handlemap_VkPhysicalDeviceRayTracingPropertiesNV(handlemap, reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: {
+ handlemap_VkPhysicalDeviceRayTracingPropertiesNV(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_representative_fragment_test
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
- {
- handlemap_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(handlemap, reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: {
+ handlemap_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
+ handlemap, reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
- {
- handlemap_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: {
+ handlemap_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
+ handlemap, reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_filter_cubic
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
- {
- handlemap_VkPhysicalDeviceImageViewImageFormatInfoEXT(handlemap, reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: {
+ handlemap_VkPhysicalDeviceImageViewImageFormatInfoEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
- {
- handlemap_VkFilterCubicImageViewImageFormatPropertiesEXT(handlemap, reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: {
+ handlemap_VkFilterCubicImageViewImageFormatPropertiesEXT(
+ handlemap, reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_global_priority
- case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
- {
- handlemap_VkDeviceQueueGlobalPriorityCreateInfoEXT(handlemap, reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
+ handlemap_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+ handlemap,
+ reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_external_memory_host
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
- {
- handlemap_VkImportMemoryHostPointerInfoEXT(handlemap, reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
+ handlemap_VkImportMemoryHostPointerInfoEXT(
+ handlemap,
+ reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
- {
- handlemap_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: {
+ handlemap_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_AMD_pipeline_compiler_control
- case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
- {
- handlemap_VkPipelineCompilerControlCreateInfoAMD(handlemap, reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: {
+ handlemap_VkPipelineCompilerControlCreateInfoAMD(
+ handlemap,
+ reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_shader_core_properties
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
- {
- handlemap_VkPhysicalDeviceShaderCorePropertiesAMD(handlemap, reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: {
+ handlemap_VkPhysicalDeviceShaderCorePropertiesAMD(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_video_decode_h265
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT:
- {
- handlemap_VkVideoDecodeH265ProfileEXT(handlemap, reinterpret_cast<VkVideoDecodeH265ProfileEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT: {
+ handlemap_VkVideoDecodeH265ProfileEXT(
+ handlemap, reinterpret_cast<VkVideoDecodeH265ProfileEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT:
- {
- handlemap_VkVideoDecodeH265CapabilitiesEXT(handlemap, reinterpret_cast<VkVideoDecodeH265CapabilitiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: {
+ handlemap_VkVideoDecodeH265CapabilitiesEXT(
+ handlemap,
+ reinterpret_cast<VkVideoDecodeH265CapabilitiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT:
- {
- handlemap_VkVideoDecodeH265SessionCreateInfoEXT(handlemap, reinterpret_cast<VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: {
+ handlemap_VkVideoDecodeH265SessionCreateInfoEXT(
+ handlemap,
+ reinterpret_cast<VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- handlemap_VkVideoDecodeH265SessionParametersAddInfoEXT(handlemap, reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ handlemap_VkVideoDecodeH265SessionParametersAddInfoEXT(
+ handlemap, reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- handlemap_VkVideoDecodeH265SessionParametersCreateInfoEXT(handlemap, reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ handlemap_VkVideoDecodeH265SessionParametersCreateInfoEXT(
+ handlemap, reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT:
- {
- handlemap_VkVideoDecodeH265PictureInfoEXT(handlemap, reinterpret_cast<VkVideoDecodeH265PictureInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: {
+ handlemap_VkVideoDecodeH265PictureInfoEXT(
+ handlemap, reinterpret_cast<VkVideoDecodeH265PictureInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT:
- {
- handlemap_VkVideoDecodeH265DpbSlotInfoEXT(handlemap, reinterpret_cast<VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: {
+ handlemap_VkVideoDecodeH265DpbSlotInfoEXT(
+ handlemap, reinterpret_cast<VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_memory_overallocation_behavior
- case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
- {
- handlemap_VkDeviceMemoryOverallocationCreateInfoAMD(handlemap, reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
+ handlemap_VkDeviceMemoryOverallocationCreateInfoAMD(
+ handlemap,
+ reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_vertex_attribute_divisor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
- {
- handlemap_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
+ handlemap_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
- {
- handlemap_VkPipelineVertexInputDivisorStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: {
+ handlemap_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+ handlemap, reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_GGP_frame_token
- case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
- {
- handlemap_VkPresentFrameTokenGGP(handlemap, reinterpret_cast<VkPresentFrameTokenGGP*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: {
+ handlemap_VkPresentFrameTokenGGP(
+ handlemap, reinterpret_cast<VkPresentFrameTokenGGP*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_pipeline_creation_feedback
- case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT:
- {
- handlemap_VkPipelineCreationFeedbackCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
+ handlemap_VkPipelineCreationFeedbackCreateInfoEXT(
+ handlemap,
+ reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_compute_shader_derivatives
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
- {
- handlemap_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(handlemap, reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
+ handlemap_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
+ handlemap, reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_mesh_shader
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
- {
- handlemap_VkPhysicalDeviceMeshShaderFeaturesNV(handlemap, reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: {
+ handlemap_VkPhysicalDeviceMeshShaderFeaturesNV(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
- {
- handlemap_VkPhysicalDeviceMeshShaderPropertiesNV(handlemap, reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: {
+ handlemap_VkPhysicalDeviceMeshShaderPropertiesNV(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_fragment_shader_barycentric
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV:
- {
- handlemap_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(handlemap, reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
+ handlemap_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
+ handlemap, reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_shader_image_footprint
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
- {
- handlemap_VkPhysicalDeviceShaderImageFootprintFeaturesNV(handlemap, reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
+ handlemap_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
+ handlemap, reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_scissor_exclusive
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
- {
- handlemap_VkPipelineViewportExclusiveScissorStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: {
+ handlemap_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
+ handlemap, reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
- {
- handlemap_VkPhysicalDeviceExclusiveScissorFeaturesNV(handlemap, reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: {
+ handlemap_VkPhysicalDeviceExclusiveScissorFeaturesNV(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
- {
- handlemap_VkQueueFamilyCheckpointPropertiesNV(handlemap, reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: {
+ handlemap_VkQueueFamilyCheckpointPropertiesNV(
+ handlemap,
+ reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_INTEL_shader_integer_functions2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
- {
- handlemap_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(handlemap, reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: {
+ handlemap_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
+ handlemap, reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_INTEL_performance_query
- case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
- {
- handlemap_VkQueryPoolPerformanceQueryCreateInfoINTEL(handlemap, reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: {
+ handlemap_VkQueryPoolPerformanceQueryCreateInfoINTEL(
+ handlemap,
+ reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_pci_bus_info
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
- {
- handlemap_VkPhysicalDevicePCIBusInfoPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: {
+ handlemap_VkPhysicalDevicePCIBusInfoPropertiesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_display_native_hdr
- case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
- {
- handlemap_VkDisplayNativeHdrSurfaceCapabilitiesAMD(handlemap, reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: {
+ handlemap_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
+ handlemap,
+ reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
- {
- handlemap_VkSwapchainDisplayNativeHdrCreateInfoAMD(handlemap, reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: {
+ handlemap_VkSwapchainDisplayNativeHdrCreateInfoAMD(
+ handlemap,
+ reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_fragment_density_map
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
- {
- handlemap_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: {
+ handlemap_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
- {
- handlemap_VkRenderPassFragmentDensityMapCreateInfoEXT(handlemap, reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: {
+ handlemap_VkRenderPassFragmentDensityMapCreateInfoEXT(
+ handlemap, reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_subgroup_size_control
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
- {
- handlemap_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: {
+ handlemap_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:
- {
- handlemap_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: {
+ handlemap_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
+ handlemap,
+ reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_AMD_shader_core_properties2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
- {
- handlemap_VkPhysicalDeviceShaderCoreProperties2AMD(handlemap, reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
+ handlemap_VkPhysicalDeviceShaderCoreProperties2AMD(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_device_coherent_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
- {
- handlemap_VkPhysicalDeviceCoherentMemoryFeaturesAMD(handlemap, reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: {
+ handlemap_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_shader_image_atomic_int64
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_memory_budget
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
- {
- handlemap_VkPhysicalDeviceMemoryBudgetPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: {
+ handlemap_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_memory_priority
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceMemoryPriorityFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
- {
- handlemap_VkMemoryPriorityAllocateInfoEXT(handlemap, reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: {
+ handlemap_VkMemoryPriorityAllocateInfoEXT(
+ handlemap, reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
- {
- handlemap_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(handlemap, reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: {
+ handlemap_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_buffer_device_address
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
- {
- handlemap_VkBufferDeviceAddressCreateInfoEXT(handlemap, reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: {
+ handlemap_VkBufferDeviceAddressCreateInfoEXT(
+ handlemap,
+ reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_validation_features
- case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
- {
- handlemap_VkValidationFeaturesEXT(handlemap, reinterpret_cast<VkValidationFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: {
+ handlemap_VkValidationFeaturesEXT(
+ handlemap, reinterpret_cast<VkValidationFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_cooperative_matrix
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
- {
- handlemap_VkPhysicalDeviceCooperativeMatrixFeaturesNV(handlemap, reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: {
+ handlemap_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
+ handlemap, reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
- {
- handlemap_VkPhysicalDeviceCooperativeMatrixPropertiesNV(handlemap, reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: {
+ handlemap_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
+ handlemap, reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_coverage_reduction_mode
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
- {
- handlemap_VkPhysicalDeviceCoverageReductionModeFeaturesNV(handlemap, reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: {
+ handlemap_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
+ handlemap, reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
- {
- handlemap_VkPipelineCoverageReductionStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: {
+ handlemap_VkPipelineCoverageReductionStateCreateInfoNV(
+ handlemap, reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_fragment_shader_interlock
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_ycbcr_image_arrays
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_provoking_vertex
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceProvokingVertexFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceProvokingVertexFeaturesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
- {
- handlemap_VkPhysicalDeviceProvokingVertexPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceProvokingVertexPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: {
+ handlemap_VkPhysicalDeviceProvokingVertexPropertiesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceProvokingVertexPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
- {
- handlemap_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: {
+ handlemap_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
+ handlemap,
+ reinterpret_cast<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_full_screen_exclusive
- case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
- {
- handlemap_VkSurfaceFullScreenExclusiveInfoEXT(handlemap, reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: {
+ handlemap_VkSurfaceFullScreenExclusiveInfoEXT(
+ handlemap,
+ reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
- {
- handlemap_VkSurfaceCapabilitiesFullScreenExclusiveEXT(handlemap, reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: {
+ handlemap_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
+ handlemap, reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
- {
- handlemap_VkSurfaceFullScreenExclusiveWin32InfoEXT(handlemap, reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: {
+ handlemap_VkSurfaceFullScreenExclusiveWin32InfoEXT(
+ handlemap,
+ reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_line_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceLineRasterizationFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceLineRasterizationFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
- {
- handlemap_VkPhysicalDeviceLineRasterizationPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: {
+ handlemap_VkPhysicalDeviceLineRasterizationPropertiesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
- {
- handlemap_VkPipelineRasterizationLineStateCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: {
+ handlemap_VkPipelineRasterizationLineStateCreateInfoEXT(
+ handlemap, reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_shader_atomic_float
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_index_type_uint8
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_shader_atomic_float2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_device_generated_commands
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
- {
- handlemap_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(handlemap, reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: {
+ handlemap_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
+ handlemap, reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
- {
- handlemap_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(handlemap, reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: {
+ handlemap_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
+ handlemap, reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
- {
- handlemap_VkGraphicsPipelineShaderGroupsCreateInfoNV(handlemap, reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: {
+ handlemap_VkGraphicsPipelineShaderGroupsCreateInfoNV(
+ handlemap,
+ reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_inherited_viewport_scissor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
- {
- handlemap_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(handlemap, reinterpret_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: {
+ handlemap_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
+ handlemap, reinterpret_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
- {
- handlemap_VkCommandBufferInheritanceViewportScissorInfoNV(handlemap, reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: {
+ handlemap_VkCommandBufferInheritanceViewportScissorInfoNV(
+ handlemap, reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_texel_buffer_alignment
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
- {
- handlemap_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
+ handlemap_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_QCOM_render_pass_transform
- case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
- {
- handlemap_VkRenderPassTransformBeginInfoQCOM(handlemap, reinterpret_cast<VkRenderPassTransformBeginInfoQCOM*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
+ handlemap_VkRenderPassTransformBeginInfoQCOM(
+ handlemap,
+ reinterpret_cast<VkRenderPassTransformBeginInfoQCOM*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
- {
- handlemap_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(handlemap, reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: {
+ handlemap_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
+ handlemap, reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_device_memory_report
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
- {
- handlemap_VkDeviceDeviceMemoryReportCreateInfoEXT(handlemap, reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: {
+ handlemap_VkDeviceDeviceMemoryReportCreateInfoEXT(
+ handlemap,
+ reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_robustness2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceRobustness2FeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceRobustness2FeaturesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
- {
- handlemap_VkPhysicalDeviceRobustness2PropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: {
+ handlemap_VkPhysicalDeviceRobustness2PropertiesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_custom_border_color
- case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
- {
- handlemap_VkSamplerCustomBorderColorCreateInfoEXT(handlemap, reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: {
+ handlemap_VkSamplerCustomBorderColorCreateInfoEXT(
+ handlemap,
+ reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
- {
- handlemap_VkPhysicalDeviceCustomBorderColorPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: {
+ handlemap_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceCustomBorderColorFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_private_data
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT:
- {
- handlemap_VkPhysicalDevicePrivateDataFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
+ handlemap_VkPhysicalDevicePrivateDataFeaturesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
- {
- handlemap_VkDevicePrivateDataCreateInfoEXT(handlemap, reinterpret_cast<VkDevicePrivateDataCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: {
+ handlemap_VkDevicePrivateDataCreateInfoEXT(
+ handlemap,
+ reinterpret_cast<VkDevicePrivateDataCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT:
- {
- handlemap_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
+ handlemap_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_device_diagnostics_config
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
- {
- handlemap_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(handlemap, reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: {
+ handlemap_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
+ handlemap, reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
- {
- handlemap_VkDeviceDiagnosticsConfigCreateInfoNV(handlemap, reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: {
+ handlemap_VkDeviceDiagnosticsConfigCreateInfoNV(
+ handlemap,
+ reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_fragment_shading_rate_enums
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
- {
- handlemap_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(handlemap, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
+ handlemap_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
+ handlemap, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
- {
- handlemap_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(handlemap, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: {
+ handlemap_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
+ handlemap, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
- {
- handlemap_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(handlemap, reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: {
+ handlemap_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
+ handlemap, reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_ray_tracing_motion_blur
- case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
- {
- handlemap_VkAccelerationStructureGeometryMotionTrianglesDataNV(handlemap, reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: {
+ handlemap_VkAccelerationStructureGeometryMotionTrianglesDataNV(
+ handlemap, reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
- {
- handlemap_VkAccelerationStructureMotionInfoNV(handlemap, reinterpret_cast<VkAccelerationStructureMotionInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: {
+ handlemap_VkAccelerationStructureMotionInfoNV(
+ handlemap,
+ reinterpret_cast<VkAccelerationStructureMotionInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
- {
- handlemap_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(handlemap, reinterpret_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: {
+ handlemap_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
+ handlemap, reinterpret_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_fragment_density_map2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
- {
- handlemap_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: {
+ handlemap_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_QCOM_rotated_copy_commands
- case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
- {
- handlemap_VkCopyCommandTransformInfoQCOM(handlemap, reinterpret_cast<VkCopyCommandTransformInfoQCOM*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: {
+ handlemap_VkCopyCommandTransformInfoQCOM(
+ handlemap, reinterpret_cast<VkCopyCommandTransformInfoQCOM*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_image_robustness
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceImageRobustnessFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_4444_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
- {
- handlemap_VkPhysicalDevice4444FormatsFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: {
+ handlemap_VkPhysicalDevice4444FormatsFeaturesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_rgba10x6_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_VALVE_mutable_descriptor_type
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE:
- {
- handlemap_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(handlemap, reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: {
+ handlemap_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+ handlemap, reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE:
- {
- handlemap_VkMutableDescriptorTypeCreateInfoVALVE(handlemap, reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: {
+ handlemap_VkMutableDescriptorTypeCreateInfoVALVE(
+ handlemap,
+ reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_physical_device_drm
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
- {
- handlemap_VkPhysicalDeviceDrmPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceDrmPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: {
+ handlemap_VkPhysicalDeviceDrmPropertiesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceDrmPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_primitive_topology_list_restart
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
- {
- handlemap_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
+ handlemap_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_FUCHSIA_external_memory
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
- {
- handlemap_VkImportMemoryZirconHandleInfoFUCHSIA(handlemap, reinterpret_cast<VkImportMemoryZirconHandleInfoFUCHSIA*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: {
+ handlemap_VkImportMemoryZirconHandleInfoFUCHSIA(
+ handlemap,
+ reinterpret_cast<VkImportMemoryZirconHandleInfoFUCHSIA*>(structExtension_out));
break;
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
- {
- handlemap_VkImportMemoryBufferCollectionFUCHSIA(handlemap, reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIA*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: {
+ handlemap_VkImportMemoryBufferCollectionFUCHSIA(
+ handlemap,
+ reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIA*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
- {
- handlemap_VkBufferCollectionImageCreateInfoFUCHSIA(handlemap, reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: {
+ handlemap_VkBufferCollectionImageCreateInfoFUCHSIA(
+ handlemap,
+ reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
- {
- handlemap_VkBufferCollectionBufferCreateInfoFUCHSIA(handlemap, reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: {
+ handlemap_VkBufferCollectionBufferCreateInfoFUCHSIA(
+ handlemap,
+ reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA*>(structExtension_out));
break;
}
#endif
#ifdef VK_HUAWEI_subpass_shading
- case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
- {
- handlemap_VkSubpassShadingPipelineCreateInfoHUAWEI(handlemap, reinterpret_cast<VkSubpassShadingPipelineCreateInfoHUAWEI*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: {
+ handlemap_VkSubpassShadingPipelineCreateInfoHUAWEI(
+ handlemap,
+ reinterpret_cast<VkSubpassShadingPipelineCreateInfoHUAWEI*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
- {
- handlemap_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(handlemap, reinterpret_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: {
+ handlemap_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
+ handlemap, reinterpret_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
- {
- handlemap_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(handlemap, reinterpret_cast<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: {
+ handlemap_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
+ handlemap, reinterpret_cast<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_HUAWEI_invocation_mask
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
- {
- handlemap_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(handlemap, reinterpret_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: {
+ handlemap_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
+ handlemap, reinterpret_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_external_memory_rdma
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
- {
- handlemap_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(handlemap, reinterpret_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: {
+ handlemap_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
+ handlemap, reinterpret_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_extended_dynamic_state2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_color_write_enable
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceColorWriteEnableFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
- {
- handlemap_VkPipelineColorWriteCreateInfoEXT(handlemap, reinterpret_cast<VkPipelineColorWriteCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: {
+ handlemap_VkPipelineColorWriteCreateInfoEXT(
+ handlemap,
+ reinterpret_cast<VkPipelineColorWriteCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_GOOGLE_gfxstream
- case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
- {
- handlemap_VkImportColorBufferGOOGLE(handlemap, reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
+ handlemap_VkImportColorBufferGOOGLE(
+ handlemap, reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
- {
- handlemap_VkImportBufferGOOGLE(handlemap, reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE: {
+ handlemap_VkImportBufferGOOGLE(
+ handlemap, reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
- {
- handlemap_VkImportPhysicalAddressGOOGLE(handlemap, reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE: {
+ handlemap_VkImportPhysicalAddressGOOGLE(
+ handlemap, reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_global_priority_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT:
- {
- handlemap_VkQueueFamilyGlobalPriorityPropertiesEXT(handlemap, reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: {
+ handlemap_VkQueueFamilyGlobalPriorityPropertiesEXT(
+ handlemap,
+ reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_multi_draw
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceMultiDrawFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceMultiDrawFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceMultiDrawFeaturesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceMultiDrawFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
- {
- handlemap_VkPhysicalDeviceMultiDrawPropertiesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceMultiDrawPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: {
+ handlemap_VkPhysicalDeviceMultiDrawPropertiesEXT(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceMultiDrawPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_border_color_swizzle
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
- {
- handlemap_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
+ handlemap_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
- {
- handlemap_VkSamplerBorderColorComponentMappingCreateInfoEXT(handlemap, reinterpret_cast<VkSamplerBorderColorComponentMappingCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: {
+ handlemap_VkSamplerBorderColorComponentMappingCreateInfoEXT(
+ handlemap, reinterpret_cast<VkSamplerBorderColorComponentMappingCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_pageable_device_local_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
- {
- handlemap_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(handlemap, reinterpret_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: {
+ handlemap_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
+ handlemap, reinterpret_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_acceleration_structure
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
- {
- handlemap_VkWriteDescriptorSetAccelerationStructureKHR(handlemap, reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
+ handlemap_VkWriteDescriptorSetAccelerationStructureKHR(
+ handlemap, reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
- {
- handlemap_VkPhysicalDeviceAccelerationStructureFeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: {
+ handlemap_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
+ handlemap, reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
- {
- handlemap_VkPhysicalDeviceAccelerationStructurePropertiesKHR(handlemap, reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: {
+ handlemap_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
+ handlemap, reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
- {
- handlemap_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
+ handlemap_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ handlemap, reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
- {
- handlemap_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(handlemap, reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: {
+ handlemap_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ handlemap, reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_ray_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
- {
- handlemap_VkPhysicalDeviceRayQueryFeaturesKHR(handlemap, reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: {
+ handlemap_VkPhysicalDeviceRayQueryFeaturesKHR(
+ handlemap,
+ reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension_out));
break;
}
#endif
- default:
- {
+ default: {
return;
}
}
}
-
-} // namespace goldfish_vk
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_handlemap_guest.h b/system/vulkan_enc/goldfish_vk_handlemap_guest.h
index 770f009..6e4c295 100644
--- a/system/vulkan_enc/goldfish_vk_handlemap_guest.h
+++ b/system/vulkan_enc/goldfish_vk_handlemap_guest.h
@@ -14,24 +14,27 @@
// limitations under the License.
// Autogenerated module goldfish_vk_handlemap_guest
-// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal -o ../qemu/android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+//
+// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
+// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
-// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
-
+//
+// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
+// $CEREAL_OUTPUT_DIR
+//
#pragma once
-
#include <vulkan/vulkan.h>
-
-#include "vk_platform_compat.h"
-
-#include "goldfish_vk_private_defs.h"
#include "VulkanHandleMapping.h"
+#include "goldfish_vk_private_defs.h"
+#include "vk_platform_compat.h"
+#include "vulkan_gfxstream.h"
// Stuff we are not going to use but if included,
// will cause compile errors. These are Android Vulkan
// required extensions, but the approach will be to
@@ -39,1201 +42,860 @@
#undef VK_KHR_android_surface
#undef VK_ANDROID_external_memory_android_hardware_buffer
-
namespace goldfish_vk {
-
#ifdef VK_VERSION_1_0
-void handlemap_VkExtent2D(
- VulkanHandleMapping* handlemap,
- VkExtent2D* toMap);
+void handlemap_VkExtent2D(VulkanHandleMapping* handlemap, VkExtent2D* toMap);
-void handlemap_VkExtent3D(
- VulkanHandleMapping* handlemap,
- VkExtent3D* toMap);
+void handlemap_VkExtent3D(VulkanHandleMapping* handlemap, VkExtent3D* toMap);
-void handlemap_VkOffset2D(
- VulkanHandleMapping* handlemap,
- VkOffset2D* toMap);
+void handlemap_VkOffset2D(VulkanHandleMapping* handlemap, VkOffset2D* toMap);
-void handlemap_VkOffset3D(
- VulkanHandleMapping* handlemap,
- VkOffset3D* toMap);
+void handlemap_VkOffset3D(VulkanHandleMapping* handlemap, VkOffset3D* toMap);
-void handlemap_VkRect2D(
- VulkanHandleMapping* handlemap,
- VkRect2D* toMap);
+void handlemap_VkRect2D(VulkanHandleMapping* handlemap, VkRect2D* toMap);
-void handlemap_VkBaseInStructure(
- VulkanHandleMapping* handlemap,
- VkBaseInStructure* toMap);
+void handlemap_VkBaseInStructure(VulkanHandleMapping* handlemap, VkBaseInStructure* toMap);
-void handlemap_VkBaseOutStructure(
- VulkanHandleMapping* handlemap,
- VkBaseOutStructure* toMap);
+void handlemap_VkBaseOutStructure(VulkanHandleMapping* handlemap, VkBaseOutStructure* toMap);
-void handlemap_VkBufferMemoryBarrier(
- VulkanHandleMapping* handlemap,
- VkBufferMemoryBarrier* toMap);
+void handlemap_VkBufferMemoryBarrier(VulkanHandleMapping* handlemap, VkBufferMemoryBarrier* toMap);
-void handlemap_VkDispatchIndirectCommand(
- VulkanHandleMapping* handlemap,
- VkDispatchIndirectCommand* toMap);
+void handlemap_VkDispatchIndirectCommand(VulkanHandleMapping* handlemap,
+ VkDispatchIndirectCommand* toMap);
-void handlemap_VkDrawIndexedIndirectCommand(
- VulkanHandleMapping* handlemap,
- VkDrawIndexedIndirectCommand* toMap);
+void handlemap_VkDrawIndexedIndirectCommand(VulkanHandleMapping* handlemap,
+ VkDrawIndexedIndirectCommand* toMap);
-void handlemap_VkDrawIndirectCommand(
- VulkanHandleMapping* handlemap,
- VkDrawIndirectCommand* toMap);
+void handlemap_VkDrawIndirectCommand(VulkanHandleMapping* handlemap, VkDrawIndirectCommand* toMap);
-void handlemap_VkImageSubresourceRange(
- VulkanHandleMapping* handlemap,
- VkImageSubresourceRange* toMap);
+void handlemap_VkImageSubresourceRange(VulkanHandleMapping* handlemap,
+ VkImageSubresourceRange* toMap);
-void handlemap_VkImageMemoryBarrier(
- VulkanHandleMapping* handlemap,
- VkImageMemoryBarrier* toMap);
+void handlemap_VkImageMemoryBarrier(VulkanHandleMapping* handlemap, VkImageMemoryBarrier* toMap);
-void handlemap_VkMemoryBarrier(
- VulkanHandleMapping* handlemap,
- VkMemoryBarrier* toMap);
+void handlemap_VkMemoryBarrier(VulkanHandleMapping* handlemap, VkMemoryBarrier* toMap);
-void handlemap_VkPipelineCacheHeaderVersionOne(
- VulkanHandleMapping* handlemap,
- VkPipelineCacheHeaderVersionOne* toMap);
+void handlemap_VkPipelineCacheHeaderVersionOne(VulkanHandleMapping* handlemap,
+ VkPipelineCacheHeaderVersionOne* toMap);
-void handlemap_VkAllocationCallbacks(
- VulkanHandleMapping* handlemap,
- VkAllocationCallbacks* toMap);
+void handlemap_VkAllocationCallbacks(VulkanHandleMapping* handlemap, VkAllocationCallbacks* toMap);
-void handlemap_VkApplicationInfo(
- VulkanHandleMapping* handlemap,
- VkApplicationInfo* toMap);
+void handlemap_VkApplicationInfo(VulkanHandleMapping* handlemap, VkApplicationInfo* toMap);
-void handlemap_VkFormatProperties(
- VulkanHandleMapping* handlemap,
- VkFormatProperties* toMap);
+void handlemap_VkFormatProperties(VulkanHandleMapping* handlemap, VkFormatProperties* toMap);
-void handlemap_VkImageFormatProperties(
- VulkanHandleMapping* handlemap,
- VkImageFormatProperties* toMap);
+void handlemap_VkImageFormatProperties(VulkanHandleMapping* handlemap,
+ VkImageFormatProperties* toMap);
-void handlemap_VkInstanceCreateInfo(
- VulkanHandleMapping* handlemap,
- VkInstanceCreateInfo* toMap);
+void handlemap_VkInstanceCreateInfo(VulkanHandleMapping* handlemap, VkInstanceCreateInfo* toMap);
-void handlemap_VkMemoryHeap(
- VulkanHandleMapping* handlemap,
- VkMemoryHeap* toMap);
+void handlemap_VkMemoryHeap(VulkanHandleMapping* handlemap, VkMemoryHeap* toMap);
-void handlemap_VkMemoryType(
- VulkanHandleMapping* handlemap,
- VkMemoryType* toMap);
+void handlemap_VkMemoryType(VulkanHandleMapping* handlemap, VkMemoryType* toMap);
-void handlemap_VkPhysicalDeviceFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFeatures* toMap);
+void handlemap_VkPhysicalDeviceFeatures(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceFeatures* toMap);
-void handlemap_VkPhysicalDeviceLimits(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceLimits* toMap);
+void handlemap_VkPhysicalDeviceLimits(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceLimits* toMap);
-void handlemap_VkPhysicalDeviceMemoryProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMemoryProperties* toMap);
+void handlemap_VkPhysicalDeviceMemoryProperties(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMemoryProperties* toMap);
-void handlemap_VkPhysicalDeviceSparseProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSparseProperties* toMap);
+void handlemap_VkPhysicalDeviceSparseProperties(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceSparseProperties* toMap);
-void handlemap_VkPhysicalDeviceProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceProperties* toMap);
+void handlemap_VkPhysicalDeviceProperties(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceProperties* toMap);
-void handlemap_VkQueueFamilyProperties(
- VulkanHandleMapping* handlemap,
- VkQueueFamilyProperties* toMap);
+void handlemap_VkQueueFamilyProperties(VulkanHandleMapping* handlemap,
+ VkQueueFamilyProperties* toMap);
-void handlemap_VkDeviceQueueCreateInfo(
- VulkanHandleMapping* handlemap,
- VkDeviceQueueCreateInfo* toMap);
+void handlemap_VkDeviceQueueCreateInfo(VulkanHandleMapping* handlemap,
+ VkDeviceQueueCreateInfo* toMap);
-void handlemap_VkDeviceCreateInfo(
- VulkanHandleMapping* handlemap,
- VkDeviceCreateInfo* toMap);
+void handlemap_VkDeviceCreateInfo(VulkanHandleMapping* handlemap, VkDeviceCreateInfo* toMap);
-void handlemap_VkExtensionProperties(
- VulkanHandleMapping* handlemap,
- VkExtensionProperties* toMap);
+void handlemap_VkExtensionProperties(VulkanHandleMapping* handlemap, VkExtensionProperties* toMap);
-void handlemap_VkLayerProperties(
- VulkanHandleMapping* handlemap,
- VkLayerProperties* toMap);
+void handlemap_VkLayerProperties(VulkanHandleMapping* handlemap, VkLayerProperties* toMap);
-void handlemap_VkSubmitInfo(
- VulkanHandleMapping* handlemap,
- VkSubmitInfo* toMap);
+void handlemap_VkSubmitInfo(VulkanHandleMapping* handlemap, VkSubmitInfo* toMap);
-void handlemap_VkMappedMemoryRange(
- VulkanHandleMapping* handlemap,
- VkMappedMemoryRange* toMap);
+void handlemap_VkMappedMemoryRange(VulkanHandleMapping* handlemap, VkMappedMemoryRange* toMap);
-void handlemap_VkMemoryAllocateInfo(
- VulkanHandleMapping* handlemap,
- VkMemoryAllocateInfo* toMap);
+void handlemap_VkMemoryAllocateInfo(VulkanHandleMapping* handlemap, VkMemoryAllocateInfo* toMap);
-void handlemap_VkMemoryRequirements(
- VulkanHandleMapping* handlemap,
- VkMemoryRequirements* toMap);
+void handlemap_VkMemoryRequirements(VulkanHandleMapping* handlemap, VkMemoryRequirements* toMap);
-void handlemap_VkSparseMemoryBind(
- VulkanHandleMapping* handlemap,
- VkSparseMemoryBind* toMap);
+void handlemap_VkSparseMemoryBind(VulkanHandleMapping* handlemap, VkSparseMemoryBind* toMap);
-void handlemap_VkSparseBufferMemoryBindInfo(
- VulkanHandleMapping* handlemap,
- VkSparseBufferMemoryBindInfo* toMap);
+void handlemap_VkSparseBufferMemoryBindInfo(VulkanHandleMapping* handlemap,
+ VkSparseBufferMemoryBindInfo* toMap);
-void handlemap_VkSparseImageOpaqueMemoryBindInfo(
- VulkanHandleMapping* handlemap,
- VkSparseImageOpaqueMemoryBindInfo* toMap);
+void handlemap_VkSparseImageOpaqueMemoryBindInfo(VulkanHandleMapping* handlemap,
+ VkSparseImageOpaqueMemoryBindInfo* toMap);
-void handlemap_VkImageSubresource(
- VulkanHandleMapping* handlemap,
- VkImageSubresource* toMap);
+void handlemap_VkImageSubresource(VulkanHandleMapping* handlemap, VkImageSubresource* toMap);
-void handlemap_VkSparseImageMemoryBind(
- VulkanHandleMapping* handlemap,
- VkSparseImageMemoryBind* toMap);
+void handlemap_VkSparseImageMemoryBind(VulkanHandleMapping* handlemap,
+ VkSparseImageMemoryBind* toMap);
-void handlemap_VkSparseImageMemoryBindInfo(
- VulkanHandleMapping* handlemap,
- VkSparseImageMemoryBindInfo* toMap);
+void handlemap_VkSparseImageMemoryBindInfo(VulkanHandleMapping* handlemap,
+ VkSparseImageMemoryBindInfo* toMap);
-void handlemap_VkBindSparseInfo(
- VulkanHandleMapping* handlemap,
- VkBindSparseInfo* toMap);
+void handlemap_VkBindSparseInfo(VulkanHandleMapping* handlemap, VkBindSparseInfo* toMap);
-void handlemap_VkSparseImageFormatProperties(
- VulkanHandleMapping* handlemap,
- VkSparseImageFormatProperties* toMap);
+void handlemap_VkSparseImageFormatProperties(VulkanHandleMapping* handlemap,
+ VkSparseImageFormatProperties* toMap);
-void handlemap_VkSparseImageMemoryRequirements(
- VulkanHandleMapping* handlemap,
- VkSparseImageMemoryRequirements* toMap);
+void handlemap_VkSparseImageMemoryRequirements(VulkanHandleMapping* handlemap,
+ VkSparseImageMemoryRequirements* toMap);
-void handlemap_VkFenceCreateInfo(
- VulkanHandleMapping* handlemap,
- VkFenceCreateInfo* toMap);
+void handlemap_VkFenceCreateInfo(VulkanHandleMapping* handlemap, VkFenceCreateInfo* toMap);
-void handlemap_VkSemaphoreCreateInfo(
- VulkanHandleMapping* handlemap,
- VkSemaphoreCreateInfo* toMap);
+void handlemap_VkSemaphoreCreateInfo(VulkanHandleMapping* handlemap, VkSemaphoreCreateInfo* toMap);
-void handlemap_VkEventCreateInfo(
- VulkanHandleMapping* handlemap,
- VkEventCreateInfo* toMap);
+void handlemap_VkEventCreateInfo(VulkanHandleMapping* handlemap, VkEventCreateInfo* toMap);
-void handlemap_VkQueryPoolCreateInfo(
- VulkanHandleMapping* handlemap,
- VkQueryPoolCreateInfo* toMap);
+void handlemap_VkQueryPoolCreateInfo(VulkanHandleMapping* handlemap, VkQueryPoolCreateInfo* toMap);
-void handlemap_VkBufferCreateInfo(
- VulkanHandleMapping* handlemap,
- VkBufferCreateInfo* toMap);
+void handlemap_VkBufferCreateInfo(VulkanHandleMapping* handlemap, VkBufferCreateInfo* toMap);
-void handlemap_VkBufferViewCreateInfo(
- VulkanHandleMapping* handlemap,
- VkBufferViewCreateInfo* toMap);
+void handlemap_VkBufferViewCreateInfo(VulkanHandleMapping* handlemap,
+ VkBufferViewCreateInfo* toMap);
-void handlemap_VkImageCreateInfo(
- VulkanHandleMapping* handlemap,
- VkImageCreateInfo* toMap);
+void handlemap_VkImageCreateInfo(VulkanHandleMapping* handlemap, VkImageCreateInfo* toMap);
-void handlemap_VkSubresourceLayout(
- VulkanHandleMapping* handlemap,
- VkSubresourceLayout* toMap);
+void handlemap_VkSubresourceLayout(VulkanHandleMapping* handlemap, VkSubresourceLayout* toMap);
-void handlemap_VkComponentMapping(
- VulkanHandleMapping* handlemap,
- VkComponentMapping* toMap);
+void handlemap_VkComponentMapping(VulkanHandleMapping* handlemap, VkComponentMapping* toMap);
-void handlemap_VkImageViewCreateInfo(
- VulkanHandleMapping* handlemap,
- VkImageViewCreateInfo* toMap);
+void handlemap_VkImageViewCreateInfo(VulkanHandleMapping* handlemap, VkImageViewCreateInfo* toMap);
-void handlemap_VkShaderModuleCreateInfo(
- VulkanHandleMapping* handlemap,
- VkShaderModuleCreateInfo* toMap);
+void handlemap_VkShaderModuleCreateInfo(VulkanHandleMapping* handlemap,
+ VkShaderModuleCreateInfo* toMap);
-void handlemap_VkPipelineCacheCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineCacheCreateInfo* toMap);
+void handlemap_VkPipelineCacheCreateInfo(VulkanHandleMapping* handlemap,
+ VkPipelineCacheCreateInfo* toMap);
-void handlemap_VkSpecializationMapEntry(
- VulkanHandleMapping* handlemap,
- VkSpecializationMapEntry* toMap);
+void handlemap_VkSpecializationMapEntry(VulkanHandleMapping* handlemap,
+ VkSpecializationMapEntry* toMap);
-void handlemap_VkSpecializationInfo(
- VulkanHandleMapping* handlemap,
- VkSpecializationInfo* toMap);
+void handlemap_VkSpecializationInfo(VulkanHandleMapping* handlemap, VkSpecializationInfo* toMap);
-void handlemap_VkPipelineShaderStageCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineShaderStageCreateInfo* toMap);
+void handlemap_VkPipelineShaderStageCreateInfo(VulkanHandleMapping* handlemap,
+ VkPipelineShaderStageCreateInfo* toMap);
-void handlemap_VkComputePipelineCreateInfo(
- VulkanHandleMapping* handlemap,
- VkComputePipelineCreateInfo* toMap);
+void handlemap_VkComputePipelineCreateInfo(VulkanHandleMapping* handlemap,
+ VkComputePipelineCreateInfo* toMap);
-void handlemap_VkVertexInputBindingDescription(
- VulkanHandleMapping* handlemap,
- VkVertexInputBindingDescription* toMap);
+void handlemap_VkVertexInputBindingDescription(VulkanHandleMapping* handlemap,
+ VkVertexInputBindingDescription* toMap);
-void handlemap_VkVertexInputAttributeDescription(
- VulkanHandleMapping* handlemap,
- VkVertexInputAttributeDescription* toMap);
+void handlemap_VkVertexInputAttributeDescription(VulkanHandleMapping* handlemap,
+ VkVertexInputAttributeDescription* toMap);
-void handlemap_VkPipelineVertexInputStateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineVertexInputStateCreateInfo* toMap);
+void handlemap_VkPipelineVertexInputStateCreateInfo(VulkanHandleMapping* handlemap,
+ VkPipelineVertexInputStateCreateInfo* toMap);
void handlemap_VkPipelineInputAssemblyStateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineInputAssemblyStateCreateInfo* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineInputAssemblyStateCreateInfo* toMap);
-void handlemap_VkPipelineTessellationStateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineTessellationStateCreateInfo* toMap);
+void handlemap_VkPipelineTessellationStateCreateInfo(VulkanHandleMapping* handlemap,
+ VkPipelineTessellationStateCreateInfo* toMap);
-void handlemap_VkViewport(
- VulkanHandleMapping* handlemap,
- VkViewport* toMap);
+void handlemap_VkViewport(VulkanHandleMapping* handlemap, VkViewport* toMap);
-void handlemap_VkPipelineViewportStateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineViewportStateCreateInfo* toMap);
+void handlemap_VkPipelineViewportStateCreateInfo(VulkanHandleMapping* handlemap,
+ VkPipelineViewportStateCreateInfo* toMap);
void handlemap_VkPipelineRasterizationStateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineRasterizationStateCreateInfo* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineRasterizationStateCreateInfo* toMap);
-void handlemap_VkPipelineMultisampleStateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineMultisampleStateCreateInfo* toMap);
+void handlemap_VkPipelineMultisampleStateCreateInfo(VulkanHandleMapping* handlemap,
+ VkPipelineMultisampleStateCreateInfo* toMap);
-void handlemap_VkStencilOpState(
- VulkanHandleMapping* handlemap,
- VkStencilOpState* toMap);
+void handlemap_VkStencilOpState(VulkanHandleMapping* handlemap, VkStencilOpState* toMap);
-void handlemap_VkPipelineDepthStencilStateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineDepthStencilStateCreateInfo* toMap);
+void handlemap_VkPipelineDepthStencilStateCreateInfo(VulkanHandleMapping* handlemap,
+ VkPipelineDepthStencilStateCreateInfo* toMap);
-void handlemap_VkPipelineColorBlendAttachmentState(
- VulkanHandleMapping* handlemap,
- VkPipelineColorBlendAttachmentState* toMap);
+void handlemap_VkPipelineColorBlendAttachmentState(VulkanHandleMapping* handlemap,
+ VkPipelineColorBlendAttachmentState* toMap);
-void handlemap_VkPipelineColorBlendStateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineColorBlendStateCreateInfo* toMap);
+void handlemap_VkPipelineColorBlendStateCreateInfo(VulkanHandleMapping* handlemap,
+ VkPipelineColorBlendStateCreateInfo* toMap);
-void handlemap_VkPipelineDynamicStateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineDynamicStateCreateInfo* toMap);
+void handlemap_VkPipelineDynamicStateCreateInfo(VulkanHandleMapping* handlemap,
+ VkPipelineDynamicStateCreateInfo* toMap);
-void handlemap_VkGraphicsPipelineCreateInfo(
- VulkanHandleMapping* handlemap,
- VkGraphicsPipelineCreateInfo* toMap);
+void handlemap_VkGraphicsPipelineCreateInfo(VulkanHandleMapping* handlemap,
+ VkGraphicsPipelineCreateInfo* toMap);
-void handlemap_VkPushConstantRange(
- VulkanHandleMapping* handlemap,
- VkPushConstantRange* toMap);
+void handlemap_VkPushConstantRange(VulkanHandleMapping* handlemap, VkPushConstantRange* toMap);
-void handlemap_VkPipelineLayoutCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineLayoutCreateInfo* toMap);
+void handlemap_VkPipelineLayoutCreateInfo(VulkanHandleMapping* handlemap,
+ VkPipelineLayoutCreateInfo* toMap);
-void handlemap_VkSamplerCreateInfo(
- VulkanHandleMapping* handlemap,
- VkSamplerCreateInfo* toMap);
+void handlemap_VkSamplerCreateInfo(VulkanHandleMapping* handlemap, VkSamplerCreateInfo* toMap);
-void handlemap_VkCopyDescriptorSet(
- VulkanHandleMapping* handlemap,
- VkCopyDescriptorSet* toMap);
+void handlemap_VkCopyDescriptorSet(VulkanHandleMapping* handlemap, VkCopyDescriptorSet* toMap);
-void handlemap_VkDescriptorBufferInfo(
- VulkanHandleMapping* handlemap,
- VkDescriptorBufferInfo* toMap);
+void handlemap_VkDescriptorBufferInfo(VulkanHandleMapping* handlemap,
+ VkDescriptorBufferInfo* toMap);
-void handlemap_VkDescriptorImageInfo(
- VulkanHandleMapping* handlemap,
- VkDescriptorImageInfo* toMap);
+void handlemap_VkDescriptorImageInfo(VulkanHandleMapping* handlemap, VkDescriptorImageInfo* toMap);
-void handlemap_VkDescriptorPoolSize(
- VulkanHandleMapping* handlemap,
- VkDescriptorPoolSize* toMap);
+void handlemap_VkDescriptorPoolSize(VulkanHandleMapping* handlemap, VkDescriptorPoolSize* toMap);
-void handlemap_VkDescriptorPoolCreateInfo(
- VulkanHandleMapping* handlemap,
- VkDescriptorPoolCreateInfo* toMap);
+void handlemap_VkDescriptorPoolCreateInfo(VulkanHandleMapping* handlemap,
+ VkDescriptorPoolCreateInfo* toMap);
-void handlemap_VkDescriptorSetAllocateInfo(
- VulkanHandleMapping* handlemap,
- VkDescriptorSetAllocateInfo* toMap);
+void handlemap_VkDescriptorSetAllocateInfo(VulkanHandleMapping* handlemap,
+ VkDescriptorSetAllocateInfo* toMap);
-void handlemap_VkDescriptorSetLayoutBinding(
- VulkanHandleMapping* handlemap,
- VkDescriptorSetLayoutBinding* toMap);
+void handlemap_VkDescriptorSetLayoutBinding(VulkanHandleMapping* handlemap,
+ VkDescriptorSetLayoutBinding* toMap);
-void handlemap_VkDescriptorSetLayoutCreateInfo(
- VulkanHandleMapping* handlemap,
- VkDescriptorSetLayoutCreateInfo* toMap);
+void handlemap_VkDescriptorSetLayoutCreateInfo(VulkanHandleMapping* handlemap,
+ VkDescriptorSetLayoutCreateInfo* toMap);
-void handlemap_VkWriteDescriptorSet(
- VulkanHandleMapping* handlemap,
- VkWriteDescriptorSet* toMap);
+void handlemap_VkWriteDescriptorSet(VulkanHandleMapping* handlemap, VkWriteDescriptorSet* toMap);
-void handlemap_VkAttachmentDescription(
- VulkanHandleMapping* handlemap,
- VkAttachmentDescription* toMap);
+void handlemap_VkAttachmentDescription(VulkanHandleMapping* handlemap,
+ VkAttachmentDescription* toMap);
-void handlemap_VkAttachmentReference(
- VulkanHandleMapping* handlemap,
- VkAttachmentReference* toMap);
+void handlemap_VkAttachmentReference(VulkanHandleMapping* handlemap, VkAttachmentReference* toMap);
-void handlemap_VkFramebufferCreateInfo(
- VulkanHandleMapping* handlemap,
- VkFramebufferCreateInfo* toMap);
+void handlemap_VkFramebufferCreateInfo(VulkanHandleMapping* handlemap,
+ VkFramebufferCreateInfo* toMap);
-void handlemap_VkSubpassDescription(
- VulkanHandleMapping* handlemap,
- VkSubpassDescription* toMap);
+void handlemap_VkSubpassDescription(VulkanHandleMapping* handlemap, VkSubpassDescription* toMap);
-void handlemap_VkSubpassDependency(
- VulkanHandleMapping* handlemap,
- VkSubpassDependency* toMap);
+void handlemap_VkSubpassDependency(VulkanHandleMapping* handlemap, VkSubpassDependency* toMap);
-void handlemap_VkRenderPassCreateInfo(
- VulkanHandleMapping* handlemap,
- VkRenderPassCreateInfo* toMap);
+void handlemap_VkRenderPassCreateInfo(VulkanHandleMapping* handlemap,
+ VkRenderPassCreateInfo* toMap);
-void handlemap_VkCommandPoolCreateInfo(
- VulkanHandleMapping* handlemap,
- VkCommandPoolCreateInfo* toMap);
+void handlemap_VkCommandPoolCreateInfo(VulkanHandleMapping* handlemap,
+ VkCommandPoolCreateInfo* toMap);
-void handlemap_VkCommandBufferAllocateInfo(
- VulkanHandleMapping* handlemap,
- VkCommandBufferAllocateInfo* toMap);
+void handlemap_VkCommandBufferAllocateInfo(VulkanHandleMapping* handlemap,
+ VkCommandBufferAllocateInfo* toMap);
-void handlemap_VkCommandBufferInheritanceInfo(
- VulkanHandleMapping* handlemap,
- VkCommandBufferInheritanceInfo* toMap);
+void handlemap_VkCommandBufferInheritanceInfo(VulkanHandleMapping* handlemap,
+ VkCommandBufferInheritanceInfo* toMap);
-void handlemap_VkCommandBufferBeginInfo(
- VulkanHandleMapping* handlemap,
- VkCommandBufferBeginInfo* toMap);
+void handlemap_VkCommandBufferBeginInfo(VulkanHandleMapping* handlemap,
+ VkCommandBufferBeginInfo* toMap);
-void handlemap_VkBufferCopy(
- VulkanHandleMapping* handlemap,
- VkBufferCopy* toMap);
+void handlemap_VkBufferCopy(VulkanHandleMapping* handlemap, VkBufferCopy* toMap);
-void handlemap_VkImageSubresourceLayers(
- VulkanHandleMapping* handlemap,
- VkImageSubresourceLayers* toMap);
+void handlemap_VkImageSubresourceLayers(VulkanHandleMapping* handlemap,
+ VkImageSubresourceLayers* toMap);
-void handlemap_VkBufferImageCopy(
- VulkanHandleMapping* handlemap,
- VkBufferImageCopy* toMap);
+void handlemap_VkBufferImageCopy(VulkanHandleMapping* handlemap, VkBufferImageCopy* toMap);
-void handlemap_VkClearColorValue(
- VulkanHandleMapping* handlemap,
- VkClearColorValue* toMap);
+void handlemap_VkClearColorValue(VulkanHandleMapping* handlemap, VkClearColorValue* toMap);
-void handlemap_VkClearDepthStencilValue(
- VulkanHandleMapping* handlemap,
- VkClearDepthStencilValue* toMap);
+void handlemap_VkClearDepthStencilValue(VulkanHandleMapping* handlemap,
+ VkClearDepthStencilValue* toMap);
-void handlemap_VkClearValue(
- VulkanHandleMapping* handlemap,
- VkClearValue* toMap);
+void handlemap_VkClearValue(VulkanHandleMapping* handlemap, VkClearValue* toMap);
-void handlemap_VkClearAttachment(
- VulkanHandleMapping* handlemap,
- VkClearAttachment* toMap);
+void handlemap_VkClearAttachment(VulkanHandleMapping* handlemap, VkClearAttachment* toMap);
-void handlemap_VkClearRect(
- VulkanHandleMapping* handlemap,
- VkClearRect* toMap);
+void handlemap_VkClearRect(VulkanHandleMapping* handlemap, VkClearRect* toMap);
-void handlemap_VkImageBlit(
- VulkanHandleMapping* handlemap,
- VkImageBlit* toMap);
+void handlemap_VkImageBlit(VulkanHandleMapping* handlemap, VkImageBlit* toMap);
-void handlemap_VkImageCopy(
- VulkanHandleMapping* handlemap,
- VkImageCopy* toMap);
+void handlemap_VkImageCopy(VulkanHandleMapping* handlemap, VkImageCopy* toMap);
-void handlemap_VkImageResolve(
- VulkanHandleMapping* handlemap,
- VkImageResolve* toMap);
+void handlemap_VkImageResolve(VulkanHandleMapping* handlemap, VkImageResolve* toMap);
-void handlemap_VkRenderPassBeginInfo(
- VulkanHandleMapping* handlemap,
- VkRenderPassBeginInfo* toMap);
+void handlemap_VkRenderPassBeginInfo(VulkanHandleMapping* handlemap, VkRenderPassBeginInfo* toMap);
#endif
#ifdef VK_VERSION_1_1
-void handlemap_VkPhysicalDeviceSubgroupProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSubgroupProperties* toMap);
+void handlemap_VkPhysicalDeviceSubgroupProperties(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceSubgroupProperties* toMap);
-void handlemap_VkBindBufferMemoryInfo(
- VulkanHandleMapping* handlemap,
- VkBindBufferMemoryInfo* toMap);
+void handlemap_VkBindBufferMemoryInfo(VulkanHandleMapping* handlemap,
+ VkBindBufferMemoryInfo* toMap);
-void handlemap_VkBindImageMemoryInfo(
- VulkanHandleMapping* handlemap,
- VkBindImageMemoryInfo* toMap);
+void handlemap_VkBindImageMemoryInfo(VulkanHandleMapping* handlemap, VkBindImageMemoryInfo* toMap);
-void handlemap_VkPhysicalDevice16BitStorageFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevice16BitStorageFeatures* toMap);
+void handlemap_VkPhysicalDevice16BitStorageFeatures(VulkanHandleMapping* handlemap,
+ VkPhysicalDevice16BitStorageFeatures* toMap);
-void handlemap_VkMemoryDedicatedRequirements(
- VulkanHandleMapping* handlemap,
- VkMemoryDedicatedRequirements* toMap);
+void handlemap_VkMemoryDedicatedRequirements(VulkanHandleMapping* handlemap,
+ VkMemoryDedicatedRequirements* toMap);
-void handlemap_VkMemoryDedicatedAllocateInfo(
- VulkanHandleMapping* handlemap,
- VkMemoryDedicatedAllocateInfo* toMap);
+void handlemap_VkMemoryDedicatedAllocateInfo(VulkanHandleMapping* handlemap,
+ VkMemoryDedicatedAllocateInfo* toMap);
-void handlemap_VkMemoryAllocateFlagsInfo(
- VulkanHandleMapping* handlemap,
- VkMemoryAllocateFlagsInfo* toMap);
+void handlemap_VkMemoryAllocateFlagsInfo(VulkanHandleMapping* handlemap,
+ VkMemoryAllocateFlagsInfo* toMap);
-void handlemap_VkDeviceGroupRenderPassBeginInfo(
- VulkanHandleMapping* handlemap,
- VkDeviceGroupRenderPassBeginInfo* toMap);
+void handlemap_VkDeviceGroupRenderPassBeginInfo(VulkanHandleMapping* handlemap,
+ VkDeviceGroupRenderPassBeginInfo* toMap);
-void handlemap_VkDeviceGroupCommandBufferBeginInfo(
- VulkanHandleMapping* handlemap,
- VkDeviceGroupCommandBufferBeginInfo* toMap);
+void handlemap_VkDeviceGroupCommandBufferBeginInfo(VulkanHandleMapping* handlemap,
+ VkDeviceGroupCommandBufferBeginInfo* toMap);
-void handlemap_VkDeviceGroupSubmitInfo(
- VulkanHandleMapping* handlemap,
- VkDeviceGroupSubmitInfo* toMap);
+void handlemap_VkDeviceGroupSubmitInfo(VulkanHandleMapping* handlemap,
+ VkDeviceGroupSubmitInfo* toMap);
-void handlemap_VkDeviceGroupBindSparseInfo(
- VulkanHandleMapping* handlemap,
- VkDeviceGroupBindSparseInfo* toMap);
+void handlemap_VkDeviceGroupBindSparseInfo(VulkanHandleMapping* handlemap,
+ VkDeviceGroupBindSparseInfo* toMap);
-void handlemap_VkBindBufferMemoryDeviceGroupInfo(
- VulkanHandleMapping* handlemap,
- VkBindBufferMemoryDeviceGroupInfo* toMap);
+void handlemap_VkBindBufferMemoryDeviceGroupInfo(VulkanHandleMapping* handlemap,
+ VkBindBufferMemoryDeviceGroupInfo* toMap);
-void handlemap_VkBindImageMemoryDeviceGroupInfo(
- VulkanHandleMapping* handlemap,
- VkBindImageMemoryDeviceGroupInfo* toMap);
+void handlemap_VkBindImageMemoryDeviceGroupInfo(VulkanHandleMapping* handlemap,
+ VkBindImageMemoryDeviceGroupInfo* toMap);
-void handlemap_VkPhysicalDeviceGroupProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceGroupProperties* toMap);
+void handlemap_VkPhysicalDeviceGroupProperties(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceGroupProperties* toMap);
-void handlemap_VkDeviceGroupDeviceCreateInfo(
- VulkanHandleMapping* handlemap,
- VkDeviceGroupDeviceCreateInfo* toMap);
+void handlemap_VkDeviceGroupDeviceCreateInfo(VulkanHandleMapping* handlemap,
+ VkDeviceGroupDeviceCreateInfo* toMap);
-void handlemap_VkBufferMemoryRequirementsInfo2(
- VulkanHandleMapping* handlemap,
- VkBufferMemoryRequirementsInfo2* toMap);
+void handlemap_VkBufferMemoryRequirementsInfo2(VulkanHandleMapping* handlemap,
+ VkBufferMemoryRequirementsInfo2* toMap);
-void handlemap_VkImageMemoryRequirementsInfo2(
- VulkanHandleMapping* handlemap,
- VkImageMemoryRequirementsInfo2* toMap);
+void handlemap_VkImageMemoryRequirementsInfo2(VulkanHandleMapping* handlemap,
+ VkImageMemoryRequirementsInfo2* toMap);
-void handlemap_VkImageSparseMemoryRequirementsInfo2(
- VulkanHandleMapping* handlemap,
- VkImageSparseMemoryRequirementsInfo2* toMap);
+void handlemap_VkImageSparseMemoryRequirementsInfo2(VulkanHandleMapping* handlemap,
+ VkImageSparseMemoryRequirementsInfo2* toMap);
-void handlemap_VkMemoryRequirements2(
- VulkanHandleMapping* handlemap,
- VkMemoryRequirements2* toMap);
+void handlemap_VkMemoryRequirements2(VulkanHandleMapping* handlemap, VkMemoryRequirements2* toMap);
-void handlemap_VkSparseImageMemoryRequirements2(
- VulkanHandleMapping* handlemap,
- VkSparseImageMemoryRequirements2* toMap);
+void handlemap_VkSparseImageMemoryRequirements2(VulkanHandleMapping* handlemap,
+ VkSparseImageMemoryRequirements2* toMap);
-void handlemap_VkPhysicalDeviceFeatures2(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFeatures2* toMap);
+void handlemap_VkPhysicalDeviceFeatures2(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceFeatures2* toMap);
-void handlemap_VkPhysicalDeviceProperties2(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceProperties2* toMap);
+void handlemap_VkPhysicalDeviceProperties2(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceProperties2* toMap);
-void handlemap_VkFormatProperties2(
- VulkanHandleMapping* handlemap,
- VkFormatProperties2* toMap);
+void handlemap_VkFormatProperties2(VulkanHandleMapping* handlemap, VkFormatProperties2* toMap);
-void handlemap_VkImageFormatProperties2(
- VulkanHandleMapping* handlemap,
- VkImageFormatProperties2* toMap);
+void handlemap_VkImageFormatProperties2(VulkanHandleMapping* handlemap,
+ VkImageFormatProperties2* toMap);
-void handlemap_VkPhysicalDeviceImageFormatInfo2(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceImageFormatInfo2* toMap);
+void handlemap_VkPhysicalDeviceImageFormatInfo2(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceImageFormatInfo2* toMap);
-void handlemap_VkQueueFamilyProperties2(
- VulkanHandleMapping* handlemap,
- VkQueueFamilyProperties2* toMap);
+void handlemap_VkQueueFamilyProperties2(VulkanHandleMapping* handlemap,
+ VkQueueFamilyProperties2* toMap);
-void handlemap_VkPhysicalDeviceMemoryProperties2(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMemoryProperties2* toMap);
+void handlemap_VkPhysicalDeviceMemoryProperties2(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMemoryProperties2* toMap);
-void handlemap_VkSparseImageFormatProperties2(
- VulkanHandleMapping* handlemap,
- VkSparseImageFormatProperties2* toMap);
+void handlemap_VkSparseImageFormatProperties2(VulkanHandleMapping* handlemap,
+ VkSparseImageFormatProperties2* toMap);
void handlemap_VkPhysicalDeviceSparseImageFormatInfo2(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSparseImageFormatInfo2* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceSparseImageFormatInfo2* toMap);
void handlemap_VkPhysicalDevicePointClippingProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePointClippingProperties* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePointClippingProperties* toMap);
-void handlemap_VkInputAttachmentAspectReference(
- VulkanHandleMapping* handlemap,
- VkInputAttachmentAspectReference* toMap);
+void handlemap_VkInputAttachmentAspectReference(VulkanHandleMapping* handlemap,
+ VkInputAttachmentAspectReference* toMap);
void handlemap_VkRenderPassInputAttachmentAspectCreateInfo(
- VulkanHandleMapping* handlemap,
- VkRenderPassInputAttachmentAspectCreateInfo* toMap);
+ VulkanHandleMapping* handlemap, VkRenderPassInputAttachmentAspectCreateInfo* toMap);
-void handlemap_VkImageViewUsageCreateInfo(
- VulkanHandleMapping* handlemap,
- VkImageViewUsageCreateInfo* toMap);
+void handlemap_VkImageViewUsageCreateInfo(VulkanHandleMapping* handlemap,
+ VkImageViewUsageCreateInfo* toMap);
void handlemap_VkPipelineTessellationDomainOriginStateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkPipelineTessellationDomainOriginStateCreateInfo* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineTessellationDomainOriginStateCreateInfo* toMap);
-void handlemap_VkRenderPassMultiviewCreateInfo(
- VulkanHandleMapping* handlemap,
- VkRenderPassMultiviewCreateInfo* toMap);
+void handlemap_VkRenderPassMultiviewCreateInfo(VulkanHandleMapping* handlemap,
+ VkRenderPassMultiviewCreateInfo* toMap);
-void handlemap_VkPhysicalDeviceMultiviewFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMultiviewFeatures* toMap);
+void handlemap_VkPhysicalDeviceMultiviewFeatures(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMultiviewFeatures* toMap);
-void handlemap_VkPhysicalDeviceMultiviewProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMultiviewProperties* toMap);
+void handlemap_VkPhysicalDeviceMultiviewProperties(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMultiviewProperties* toMap);
void handlemap_VkPhysicalDeviceVariablePointersFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceVariablePointersFeatures* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceVariablePointersFeatures* toMap);
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceVariablePointersFeatures, handlemap_VkPhysicalDeviceVariablePointerFeatures)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceVariablePointersFeatures,
+ handlemap_VkPhysicalDeviceVariablePointerFeatures)
void handlemap_VkPhysicalDeviceProtectedMemoryFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceProtectedMemoryFeatures* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceProtectedMemoryFeatures* toMap);
void handlemap_VkPhysicalDeviceProtectedMemoryProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceProtectedMemoryProperties* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceProtectedMemoryProperties* toMap);
-void handlemap_VkDeviceQueueInfo2(
- VulkanHandleMapping* handlemap,
- VkDeviceQueueInfo2* toMap);
+void handlemap_VkDeviceQueueInfo2(VulkanHandleMapping* handlemap, VkDeviceQueueInfo2* toMap);
-void handlemap_VkProtectedSubmitInfo(
- VulkanHandleMapping* handlemap,
- VkProtectedSubmitInfo* toMap);
+void handlemap_VkProtectedSubmitInfo(VulkanHandleMapping* handlemap, VkProtectedSubmitInfo* toMap);
-void handlemap_VkSamplerYcbcrConversionCreateInfo(
- VulkanHandleMapping* handlemap,
- VkSamplerYcbcrConversionCreateInfo* toMap);
+void handlemap_VkSamplerYcbcrConversionCreateInfo(VulkanHandleMapping* handlemap,
+ VkSamplerYcbcrConversionCreateInfo* toMap);
-void handlemap_VkSamplerYcbcrConversionInfo(
- VulkanHandleMapping* handlemap,
- VkSamplerYcbcrConversionInfo* toMap);
+void handlemap_VkSamplerYcbcrConversionInfo(VulkanHandleMapping* handlemap,
+ VkSamplerYcbcrConversionInfo* toMap);
-void handlemap_VkBindImagePlaneMemoryInfo(
- VulkanHandleMapping* handlemap,
- VkBindImagePlaneMemoryInfo* toMap);
+void handlemap_VkBindImagePlaneMemoryInfo(VulkanHandleMapping* handlemap,
+ VkBindImagePlaneMemoryInfo* toMap);
-void handlemap_VkImagePlaneMemoryRequirementsInfo(
- VulkanHandleMapping* handlemap,
- VkImagePlaneMemoryRequirementsInfo* toMap);
+void handlemap_VkImagePlaneMemoryRequirementsInfo(VulkanHandleMapping* handlemap,
+ VkImagePlaneMemoryRequirementsInfo* toMap);
void handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSamplerYcbcrConversionFeatures* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceSamplerYcbcrConversionFeatures* toMap);
void handlemap_VkSamplerYcbcrConversionImageFormatProperties(
- VulkanHandleMapping* handlemap,
- VkSamplerYcbcrConversionImageFormatProperties* toMap);
+ VulkanHandleMapping* handlemap, VkSamplerYcbcrConversionImageFormatProperties* toMap);
-void handlemap_VkDescriptorUpdateTemplateEntry(
- VulkanHandleMapping* handlemap,
- VkDescriptorUpdateTemplateEntry* toMap);
+void handlemap_VkDescriptorUpdateTemplateEntry(VulkanHandleMapping* handlemap,
+ VkDescriptorUpdateTemplateEntry* toMap);
-void handlemap_VkDescriptorUpdateTemplateCreateInfo(
- VulkanHandleMapping* handlemap,
- VkDescriptorUpdateTemplateCreateInfo* toMap);
+void handlemap_VkDescriptorUpdateTemplateCreateInfo(VulkanHandleMapping* handlemap,
+ VkDescriptorUpdateTemplateCreateInfo* toMap);
-void handlemap_VkExternalMemoryProperties(
- VulkanHandleMapping* handlemap,
- VkExternalMemoryProperties* toMap);
+void handlemap_VkExternalMemoryProperties(VulkanHandleMapping* handlemap,
+ VkExternalMemoryProperties* toMap);
void handlemap_VkPhysicalDeviceExternalImageFormatInfo(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceExternalImageFormatInfo* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceExternalImageFormatInfo* toMap);
-void handlemap_VkExternalImageFormatProperties(
- VulkanHandleMapping* handlemap,
- VkExternalImageFormatProperties* toMap);
+void handlemap_VkExternalImageFormatProperties(VulkanHandleMapping* handlemap,
+ VkExternalImageFormatProperties* toMap);
-void handlemap_VkPhysicalDeviceExternalBufferInfo(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceExternalBufferInfo* toMap);
+void handlemap_VkPhysicalDeviceExternalBufferInfo(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceExternalBufferInfo* toMap);
-void handlemap_VkExternalBufferProperties(
- VulkanHandleMapping* handlemap,
- VkExternalBufferProperties* toMap);
+void handlemap_VkExternalBufferProperties(VulkanHandleMapping* handlemap,
+ VkExternalBufferProperties* toMap);
-void handlemap_VkPhysicalDeviceIDProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceIDProperties* toMap);
+void handlemap_VkPhysicalDeviceIDProperties(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceIDProperties* toMap);
-void handlemap_VkExternalMemoryImageCreateInfo(
- VulkanHandleMapping* handlemap,
- VkExternalMemoryImageCreateInfo* toMap);
+void handlemap_VkExternalMemoryImageCreateInfo(VulkanHandleMapping* handlemap,
+ VkExternalMemoryImageCreateInfo* toMap);
-void handlemap_VkExternalMemoryBufferCreateInfo(
- VulkanHandleMapping* handlemap,
- VkExternalMemoryBufferCreateInfo* toMap);
+void handlemap_VkExternalMemoryBufferCreateInfo(VulkanHandleMapping* handlemap,
+ VkExternalMemoryBufferCreateInfo* toMap);
-void handlemap_VkExportMemoryAllocateInfo(
- VulkanHandleMapping* handlemap,
- VkExportMemoryAllocateInfo* toMap);
+void handlemap_VkExportMemoryAllocateInfo(VulkanHandleMapping* handlemap,
+ VkExportMemoryAllocateInfo* toMap);
-void handlemap_VkPhysicalDeviceExternalFenceInfo(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceExternalFenceInfo* toMap);
+void handlemap_VkPhysicalDeviceExternalFenceInfo(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceExternalFenceInfo* toMap);
-void handlemap_VkExternalFenceProperties(
- VulkanHandleMapping* handlemap,
- VkExternalFenceProperties* toMap);
+void handlemap_VkExternalFenceProperties(VulkanHandleMapping* handlemap,
+ VkExternalFenceProperties* toMap);
-void handlemap_VkExportFenceCreateInfo(
- VulkanHandleMapping* handlemap,
- VkExportFenceCreateInfo* toMap);
+void handlemap_VkExportFenceCreateInfo(VulkanHandleMapping* handlemap,
+ VkExportFenceCreateInfo* toMap);
-void handlemap_VkExportSemaphoreCreateInfo(
- VulkanHandleMapping* handlemap,
- VkExportSemaphoreCreateInfo* toMap);
+void handlemap_VkExportSemaphoreCreateInfo(VulkanHandleMapping* handlemap,
+ VkExportSemaphoreCreateInfo* toMap);
-void handlemap_VkPhysicalDeviceExternalSemaphoreInfo(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceExternalSemaphoreInfo* toMap);
+void handlemap_VkPhysicalDeviceExternalSemaphoreInfo(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceExternalSemaphoreInfo* toMap);
-void handlemap_VkExternalSemaphoreProperties(
- VulkanHandleMapping* handlemap,
- VkExternalSemaphoreProperties* toMap);
+void handlemap_VkExternalSemaphoreProperties(VulkanHandleMapping* handlemap,
+ VkExternalSemaphoreProperties* toMap);
void handlemap_VkPhysicalDeviceMaintenance3Properties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMaintenance3Properties* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceMaintenance3Properties* toMap);
-void handlemap_VkDescriptorSetLayoutSupport(
- VulkanHandleMapping* handlemap,
- VkDescriptorSetLayoutSupport* toMap);
+void handlemap_VkDescriptorSetLayoutSupport(VulkanHandleMapping* handlemap,
+ VkDescriptorSetLayoutSupport* toMap);
void handlemap_VkPhysicalDeviceShaderDrawParametersFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderDrawParametersFeatures* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderDrawParametersFeatures* toMap);
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderDrawParametersFeatures, handlemap_VkPhysicalDeviceShaderDrawParameterFeatures)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderDrawParametersFeatures,
+ handlemap_VkPhysicalDeviceShaderDrawParameterFeatures)
#endif
#ifdef VK_VERSION_1_2
-void handlemap_VkPhysicalDeviceVulkan11Features(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceVulkan11Features* toMap);
+void handlemap_VkPhysicalDeviceVulkan11Features(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceVulkan11Features* toMap);
-void handlemap_VkPhysicalDeviceVulkan11Properties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceVulkan11Properties* toMap);
+void handlemap_VkPhysicalDeviceVulkan11Properties(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceVulkan11Properties* toMap);
-void handlemap_VkPhysicalDeviceVulkan12Features(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceVulkan12Features* toMap);
+void handlemap_VkPhysicalDeviceVulkan12Features(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceVulkan12Features* toMap);
-void handlemap_VkConformanceVersion(
- VulkanHandleMapping* handlemap,
- VkConformanceVersion* toMap);
+void handlemap_VkConformanceVersion(VulkanHandleMapping* handlemap, VkConformanceVersion* toMap);
-void handlemap_VkPhysicalDeviceVulkan12Properties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceVulkan12Properties* toMap);
+void handlemap_VkPhysicalDeviceVulkan12Properties(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceVulkan12Properties* toMap);
-void handlemap_VkImageFormatListCreateInfo(
- VulkanHandleMapping* handlemap,
- VkImageFormatListCreateInfo* toMap);
+void handlemap_VkImageFormatListCreateInfo(VulkanHandleMapping* handlemap,
+ VkImageFormatListCreateInfo* toMap);
-void handlemap_VkAttachmentDescription2(
- VulkanHandleMapping* handlemap,
- VkAttachmentDescription2* toMap);
+void handlemap_VkAttachmentDescription2(VulkanHandleMapping* handlemap,
+ VkAttachmentDescription2* toMap);
-void handlemap_VkAttachmentReference2(
- VulkanHandleMapping* handlemap,
- VkAttachmentReference2* toMap);
+void handlemap_VkAttachmentReference2(VulkanHandleMapping* handlemap,
+ VkAttachmentReference2* toMap);
-void handlemap_VkSubpassDescription2(
- VulkanHandleMapping* handlemap,
- VkSubpassDescription2* toMap);
+void handlemap_VkSubpassDescription2(VulkanHandleMapping* handlemap, VkSubpassDescription2* toMap);
-void handlemap_VkSubpassDependency2(
- VulkanHandleMapping* handlemap,
- VkSubpassDependency2* toMap);
+void handlemap_VkSubpassDependency2(VulkanHandleMapping* handlemap, VkSubpassDependency2* toMap);
-void handlemap_VkRenderPassCreateInfo2(
- VulkanHandleMapping* handlemap,
- VkRenderPassCreateInfo2* toMap);
+void handlemap_VkRenderPassCreateInfo2(VulkanHandleMapping* handlemap,
+ VkRenderPassCreateInfo2* toMap);
-void handlemap_VkSubpassBeginInfo(
- VulkanHandleMapping* handlemap,
- VkSubpassBeginInfo* toMap);
+void handlemap_VkSubpassBeginInfo(VulkanHandleMapping* handlemap, VkSubpassBeginInfo* toMap);
-void handlemap_VkSubpassEndInfo(
- VulkanHandleMapping* handlemap,
- VkSubpassEndInfo* toMap);
+void handlemap_VkSubpassEndInfo(VulkanHandleMapping* handlemap, VkSubpassEndInfo* toMap);
-void handlemap_VkPhysicalDevice8BitStorageFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevice8BitStorageFeatures* toMap);
+void handlemap_VkPhysicalDevice8BitStorageFeatures(VulkanHandleMapping* handlemap,
+ VkPhysicalDevice8BitStorageFeatures* toMap);
-void handlemap_VkPhysicalDeviceDriverProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDriverProperties* toMap);
+void handlemap_VkPhysicalDeviceDriverProperties(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceDriverProperties* toMap);
void handlemap_VkPhysicalDeviceShaderAtomicInt64Features(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderAtomicInt64Features* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderAtomicInt64Features* toMap);
void handlemap_VkPhysicalDeviceShaderFloat16Int8Features(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderFloat16Int8Features* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderFloat16Int8Features* toMap);
void handlemap_VkPhysicalDeviceFloatControlsProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFloatControlsProperties* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFloatControlsProperties* toMap);
void handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfo(
- VulkanHandleMapping* handlemap,
- VkDescriptorSetLayoutBindingFlagsCreateInfo* toMap);
+ VulkanHandleMapping* handlemap, VkDescriptorSetLayoutBindingFlagsCreateInfo* toMap);
void handlemap_VkPhysicalDeviceDescriptorIndexingFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDescriptorIndexingFeatures* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDescriptorIndexingFeatures* toMap);
void handlemap_VkPhysicalDeviceDescriptorIndexingProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDescriptorIndexingProperties* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDescriptorIndexingProperties* toMap);
void handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfo(
- VulkanHandleMapping* handlemap,
- VkDescriptorSetVariableDescriptorCountAllocateInfo* toMap);
+ VulkanHandleMapping* handlemap, VkDescriptorSetVariableDescriptorCountAllocateInfo* toMap);
void handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupport(
- VulkanHandleMapping* handlemap,
- VkDescriptorSetVariableDescriptorCountLayoutSupport* toMap);
+ VulkanHandleMapping* handlemap, VkDescriptorSetVariableDescriptorCountLayoutSupport* toMap);
void handlemap_VkSubpassDescriptionDepthStencilResolve(
- VulkanHandleMapping* handlemap,
- VkSubpassDescriptionDepthStencilResolve* toMap);
+ VulkanHandleMapping* handlemap, VkSubpassDescriptionDepthStencilResolve* toMap);
void handlemap_VkPhysicalDeviceDepthStencilResolveProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDepthStencilResolveProperties* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDepthStencilResolveProperties* toMap);
void handlemap_VkPhysicalDeviceScalarBlockLayoutFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceScalarBlockLayoutFeatures* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceScalarBlockLayoutFeatures* toMap);
-void handlemap_VkImageStencilUsageCreateInfo(
- VulkanHandleMapping* handlemap,
- VkImageStencilUsageCreateInfo* toMap);
+void handlemap_VkImageStencilUsageCreateInfo(VulkanHandleMapping* handlemap,
+ VkImageStencilUsageCreateInfo* toMap);
-void handlemap_VkSamplerReductionModeCreateInfo(
- VulkanHandleMapping* handlemap,
- VkSamplerReductionModeCreateInfo* toMap);
+void handlemap_VkSamplerReductionModeCreateInfo(VulkanHandleMapping* handlemap,
+ VkSamplerReductionModeCreateInfo* toMap);
void handlemap_VkPhysicalDeviceSamplerFilterMinmaxProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSamplerFilterMinmaxProperties* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceSamplerFilterMinmaxProperties* toMap);
void handlemap_VkPhysicalDeviceVulkanMemoryModelFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceVulkanMemoryModelFeatures* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceVulkanMemoryModelFeatures* toMap);
void handlemap_VkPhysicalDeviceImagelessFramebufferFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceImagelessFramebufferFeatures* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceImagelessFramebufferFeatures* toMap);
-void handlemap_VkFramebufferAttachmentImageInfo(
- VulkanHandleMapping* handlemap,
- VkFramebufferAttachmentImageInfo* toMap);
+void handlemap_VkFramebufferAttachmentImageInfo(VulkanHandleMapping* handlemap,
+ VkFramebufferAttachmentImageInfo* toMap);
-void handlemap_VkFramebufferAttachmentsCreateInfo(
- VulkanHandleMapping* handlemap,
- VkFramebufferAttachmentsCreateInfo* toMap);
+void handlemap_VkFramebufferAttachmentsCreateInfo(VulkanHandleMapping* handlemap,
+ VkFramebufferAttachmentsCreateInfo* toMap);
-void handlemap_VkRenderPassAttachmentBeginInfo(
- VulkanHandleMapping* handlemap,
- VkRenderPassAttachmentBeginInfo* toMap);
+void handlemap_VkRenderPassAttachmentBeginInfo(VulkanHandleMapping* handlemap,
+ VkRenderPassAttachmentBeginInfo* toMap);
void handlemap_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceUniformBufferStandardLayoutFeatures* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceUniformBufferStandardLayoutFeatures* toMap);
void handlemap_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* toMap);
void handlemap_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* toMap);
-void handlemap_VkAttachmentReferenceStencilLayout(
- VulkanHandleMapping* handlemap,
- VkAttachmentReferenceStencilLayout* toMap);
+void handlemap_VkAttachmentReferenceStencilLayout(VulkanHandleMapping* handlemap,
+ VkAttachmentReferenceStencilLayout* toMap);
-void handlemap_VkAttachmentDescriptionStencilLayout(
- VulkanHandleMapping* handlemap,
- VkAttachmentDescriptionStencilLayout* toMap);
+void handlemap_VkAttachmentDescriptionStencilLayout(VulkanHandleMapping* handlemap,
+ VkAttachmentDescriptionStencilLayout* toMap);
void handlemap_VkPhysicalDeviceHostQueryResetFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceHostQueryResetFeatures* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceHostQueryResetFeatures* toMap);
void handlemap_VkPhysicalDeviceTimelineSemaphoreFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceTimelineSemaphoreFeatures* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceTimelineSemaphoreFeatures* toMap);
void handlemap_VkPhysicalDeviceTimelineSemaphoreProperties(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceTimelineSemaphoreProperties* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceTimelineSemaphoreProperties* toMap);
-void handlemap_VkSemaphoreTypeCreateInfo(
- VulkanHandleMapping* handlemap,
- VkSemaphoreTypeCreateInfo* toMap);
+void handlemap_VkSemaphoreTypeCreateInfo(VulkanHandleMapping* handlemap,
+ VkSemaphoreTypeCreateInfo* toMap);
-void handlemap_VkTimelineSemaphoreSubmitInfo(
- VulkanHandleMapping* handlemap,
- VkTimelineSemaphoreSubmitInfo* toMap);
+void handlemap_VkTimelineSemaphoreSubmitInfo(VulkanHandleMapping* handlemap,
+ VkTimelineSemaphoreSubmitInfo* toMap);
-void handlemap_VkSemaphoreWaitInfo(
- VulkanHandleMapping* handlemap,
- VkSemaphoreWaitInfo* toMap);
+void handlemap_VkSemaphoreWaitInfo(VulkanHandleMapping* handlemap, VkSemaphoreWaitInfo* toMap);
-void handlemap_VkSemaphoreSignalInfo(
- VulkanHandleMapping* handlemap,
- VkSemaphoreSignalInfo* toMap);
+void handlemap_VkSemaphoreSignalInfo(VulkanHandleMapping* handlemap, VkSemaphoreSignalInfo* toMap);
void handlemap_VkPhysicalDeviceBufferDeviceAddressFeatures(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceBufferDeviceAddressFeatures* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceBufferDeviceAddressFeatures* toMap);
-void handlemap_VkBufferDeviceAddressInfo(
- VulkanHandleMapping* handlemap,
- VkBufferDeviceAddressInfo* toMap);
+void handlemap_VkBufferDeviceAddressInfo(VulkanHandleMapping* handlemap,
+ VkBufferDeviceAddressInfo* toMap);
void handlemap_VkBufferOpaqueCaptureAddressCreateInfo(
- VulkanHandleMapping* handlemap,
- VkBufferOpaqueCaptureAddressCreateInfo* toMap);
+ VulkanHandleMapping* handlemap, VkBufferOpaqueCaptureAddressCreateInfo* toMap);
void handlemap_VkMemoryOpaqueCaptureAddressAllocateInfo(
- VulkanHandleMapping* handlemap,
- VkMemoryOpaqueCaptureAddressAllocateInfo* toMap);
+ VulkanHandleMapping* handlemap, VkMemoryOpaqueCaptureAddressAllocateInfo* toMap);
void handlemap_VkDeviceMemoryOpaqueCaptureAddressInfo(
- VulkanHandleMapping* handlemap,
- VkDeviceMemoryOpaqueCaptureAddressInfo* toMap);
+ VulkanHandleMapping* handlemap, VkDeviceMemoryOpaqueCaptureAddressInfo* toMap);
#endif
#ifdef VK_KHR_surface
-void handlemap_VkSurfaceCapabilitiesKHR(
- VulkanHandleMapping* handlemap,
- VkSurfaceCapabilitiesKHR* toMap);
+void handlemap_VkSurfaceCapabilitiesKHR(VulkanHandleMapping* handlemap,
+ VkSurfaceCapabilitiesKHR* toMap);
-void handlemap_VkSurfaceFormatKHR(
- VulkanHandleMapping* handlemap,
- VkSurfaceFormatKHR* toMap);
+void handlemap_VkSurfaceFormatKHR(VulkanHandleMapping* handlemap, VkSurfaceFormatKHR* toMap);
#endif
#ifdef VK_KHR_swapchain
-void handlemap_VkSwapchainCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkSwapchainCreateInfoKHR* toMap);
+void handlemap_VkSwapchainCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkSwapchainCreateInfoKHR* toMap);
-void handlemap_VkPresentInfoKHR(
- VulkanHandleMapping* handlemap,
- VkPresentInfoKHR* toMap);
+void handlemap_VkPresentInfoKHR(VulkanHandleMapping* handlemap, VkPresentInfoKHR* toMap);
-void handlemap_VkImageSwapchainCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkImageSwapchainCreateInfoKHR* toMap);
+void handlemap_VkImageSwapchainCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkImageSwapchainCreateInfoKHR* toMap);
-void handlemap_VkBindImageMemorySwapchainInfoKHR(
- VulkanHandleMapping* handlemap,
- VkBindImageMemorySwapchainInfoKHR* toMap);
+void handlemap_VkBindImageMemorySwapchainInfoKHR(VulkanHandleMapping* handlemap,
+ VkBindImageMemorySwapchainInfoKHR* toMap);
-void handlemap_VkAcquireNextImageInfoKHR(
- VulkanHandleMapping* handlemap,
- VkAcquireNextImageInfoKHR* toMap);
+void handlemap_VkAcquireNextImageInfoKHR(VulkanHandleMapping* handlemap,
+ VkAcquireNextImageInfoKHR* toMap);
-void handlemap_VkDeviceGroupPresentCapabilitiesKHR(
- VulkanHandleMapping* handlemap,
- VkDeviceGroupPresentCapabilitiesKHR* toMap);
+void handlemap_VkDeviceGroupPresentCapabilitiesKHR(VulkanHandleMapping* handlemap,
+ VkDeviceGroupPresentCapabilitiesKHR* toMap);
-void handlemap_VkDeviceGroupPresentInfoKHR(
- VulkanHandleMapping* handlemap,
- VkDeviceGroupPresentInfoKHR* toMap);
+void handlemap_VkDeviceGroupPresentInfoKHR(VulkanHandleMapping* handlemap,
+ VkDeviceGroupPresentInfoKHR* toMap);
-void handlemap_VkDeviceGroupSwapchainCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkDeviceGroupSwapchainCreateInfoKHR* toMap);
+void handlemap_VkDeviceGroupSwapchainCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkDeviceGroupSwapchainCreateInfoKHR* toMap);
#endif
#ifdef VK_KHR_display
-void handlemap_VkDisplayModeParametersKHR(
- VulkanHandleMapping* handlemap,
- VkDisplayModeParametersKHR* toMap);
+void handlemap_VkDisplayModeParametersKHR(VulkanHandleMapping* handlemap,
+ VkDisplayModeParametersKHR* toMap);
-void handlemap_VkDisplayModeCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkDisplayModeCreateInfoKHR* toMap);
+void handlemap_VkDisplayModeCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkDisplayModeCreateInfoKHR* toMap);
-void handlemap_VkDisplayModePropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkDisplayModePropertiesKHR* toMap);
+void handlemap_VkDisplayModePropertiesKHR(VulkanHandleMapping* handlemap,
+ VkDisplayModePropertiesKHR* toMap);
-void handlemap_VkDisplayPlaneCapabilitiesKHR(
- VulkanHandleMapping* handlemap,
- VkDisplayPlaneCapabilitiesKHR* toMap);
+void handlemap_VkDisplayPlaneCapabilitiesKHR(VulkanHandleMapping* handlemap,
+ VkDisplayPlaneCapabilitiesKHR* toMap);
-void handlemap_VkDisplayPlanePropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkDisplayPlanePropertiesKHR* toMap);
+void handlemap_VkDisplayPlanePropertiesKHR(VulkanHandleMapping* handlemap,
+ VkDisplayPlanePropertiesKHR* toMap);
-void handlemap_VkDisplayPropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkDisplayPropertiesKHR* toMap);
+void handlemap_VkDisplayPropertiesKHR(VulkanHandleMapping* handlemap,
+ VkDisplayPropertiesKHR* toMap);
-void handlemap_VkDisplaySurfaceCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkDisplaySurfaceCreateInfoKHR* toMap);
+void handlemap_VkDisplaySurfaceCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkDisplaySurfaceCreateInfoKHR* toMap);
#endif
#ifdef VK_KHR_display_swapchain
-void handlemap_VkDisplayPresentInfoKHR(
- VulkanHandleMapping* handlemap,
- VkDisplayPresentInfoKHR* toMap);
+void handlemap_VkDisplayPresentInfoKHR(VulkanHandleMapping* handlemap,
+ VkDisplayPresentInfoKHR* toMap);
#endif
#ifdef VK_KHR_xlib_surface
-void handlemap_VkXlibSurfaceCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkXlibSurfaceCreateInfoKHR* toMap);
+void handlemap_VkXlibSurfaceCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkXlibSurfaceCreateInfoKHR* toMap);
#endif
#ifdef VK_KHR_xcb_surface
-void handlemap_VkXcbSurfaceCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkXcbSurfaceCreateInfoKHR* toMap);
+void handlemap_VkXcbSurfaceCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkXcbSurfaceCreateInfoKHR* toMap);
#endif
#ifdef VK_KHR_wayland_surface
-void handlemap_VkWaylandSurfaceCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkWaylandSurfaceCreateInfoKHR* toMap);
+void handlemap_VkWaylandSurfaceCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkWaylandSurfaceCreateInfoKHR* toMap);
#endif
#ifdef VK_KHR_android_surface
-void handlemap_VkAndroidSurfaceCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkAndroidSurfaceCreateInfoKHR* toMap);
+void handlemap_VkAndroidSurfaceCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkAndroidSurfaceCreateInfoKHR* toMap);
#endif
#ifdef VK_KHR_win32_surface
-void handlemap_VkWin32SurfaceCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkWin32SurfaceCreateInfoKHR* toMap);
+void handlemap_VkWin32SurfaceCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkWin32SurfaceCreateInfoKHR* toMap);
#endif
#ifdef VK_KHR_sampler_mirror_clamp_to_edge
#endif
#ifdef VK_KHR_video_queue
-void handlemap_VkVideoQueueFamilyProperties2KHR(
- VulkanHandleMapping* handlemap,
- VkVideoQueueFamilyProperties2KHR* toMap);
+void handlemap_VkVideoQueueFamilyProperties2KHR(VulkanHandleMapping* handlemap,
+ VkVideoQueueFamilyProperties2KHR* toMap);
-void handlemap_VkVideoProfileKHR(
- VulkanHandleMapping* handlemap,
- VkVideoProfileKHR* toMap);
+void handlemap_VkVideoProfileKHR(VulkanHandleMapping* handlemap, VkVideoProfileKHR* toMap);
-void handlemap_VkVideoProfilesKHR(
- VulkanHandleMapping* handlemap,
- VkVideoProfilesKHR* toMap);
+void handlemap_VkVideoProfilesKHR(VulkanHandleMapping* handlemap, VkVideoProfilesKHR* toMap);
-void handlemap_VkVideoCapabilitiesKHR(
- VulkanHandleMapping* handlemap,
- VkVideoCapabilitiesKHR* toMap);
+void handlemap_VkVideoCapabilitiesKHR(VulkanHandleMapping* handlemap,
+ VkVideoCapabilitiesKHR* toMap);
-void handlemap_VkPhysicalDeviceVideoFormatInfoKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceVideoFormatInfoKHR* toMap);
+void handlemap_VkPhysicalDeviceVideoFormatInfoKHR(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceVideoFormatInfoKHR* toMap);
-void handlemap_VkVideoFormatPropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkVideoFormatPropertiesKHR* toMap);
+void handlemap_VkVideoFormatPropertiesKHR(VulkanHandleMapping* handlemap,
+ VkVideoFormatPropertiesKHR* toMap);
-void handlemap_VkVideoPictureResourceKHR(
- VulkanHandleMapping* handlemap,
- VkVideoPictureResourceKHR* toMap);
+void handlemap_VkVideoPictureResourceKHR(VulkanHandleMapping* handlemap,
+ VkVideoPictureResourceKHR* toMap);
-void handlemap_VkVideoReferenceSlotKHR(
- VulkanHandleMapping* handlemap,
- VkVideoReferenceSlotKHR* toMap);
+void handlemap_VkVideoReferenceSlotKHR(VulkanHandleMapping* handlemap,
+ VkVideoReferenceSlotKHR* toMap);
-void handlemap_VkVideoGetMemoryPropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkVideoGetMemoryPropertiesKHR* toMap);
+void handlemap_VkVideoGetMemoryPropertiesKHR(VulkanHandleMapping* handlemap,
+ VkVideoGetMemoryPropertiesKHR* toMap);
-void handlemap_VkVideoBindMemoryKHR(
- VulkanHandleMapping* handlemap,
- VkVideoBindMemoryKHR* toMap);
+void handlemap_VkVideoBindMemoryKHR(VulkanHandleMapping* handlemap, VkVideoBindMemoryKHR* toMap);
-void handlemap_VkVideoSessionCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkVideoSessionCreateInfoKHR* toMap);
+void handlemap_VkVideoSessionCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkVideoSessionCreateInfoKHR* toMap);
-void handlemap_VkVideoSessionParametersCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkVideoSessionParametersCreateInfoKHR* toMap);
+void handlemap_VkVideoSessionParametersCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkVideoSessionParametersCreateInfoKHR* toMap);
-void handlemap_VkVideoSessionParametersUpdateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkVideoSessionParametersUpdateInfoKHR* toMap);
+void handlemap_VkVideoSessionParametersUpdateInfoKHR(VulkanHandleMapping* handlemap,
+ VkVideoSessionParametersUpdateInfoKHR* toMap);
-void handlemap_VkVideoBeginCodingInfoKHR(
- VulkanHandleMapping* handlemap,
- VkVideoBeginCodingInfoKHR* toMap);
+void handlemap_VkVideoBeginCodingInfoKHR(VulkanHandleMapping* handlemap,
+ VkVideoBeginCodingInfoKHR* toMap);
-void handlemap_VkVideoEndCodingInfoKHR(
- VulkanHandleMapping* handlemap,
- VkVideoEndCodingInfoKHR* toMap);
+void handlemap_VkVideoEndCodingInfoKHR(VulkanHandleMapping* handlemap,
+ VkVideoEndCodingInfoKHR* toMap);
-void handlemap_VkVideoCodingControlInfoKHR(
- VulkanHandleMapping* handlemap,
- VkVideoCodingControlInfoKHR* toMap);
+void handlemap_VkVideoCodingControlInfoKHR(VulkanHandleMapping* handlemap,
+ VkVideoCodingControlInfoKHR* toMap);
#endif
#ifdef VK_KHR_video_decode_queue
-void handlemap_VkVideoDecodeInfoKHR(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeInfoKHR* toMap);
+void handlemap_VkVideoDecodeInfoKHR(VulkanHandleMapping* handlemap, VkVideoDecodeInfoKHR* toMap);
#endif
#ifdef VK_KHR_dynamic_rendering
-void handlemap_VkRenderingAttachmentInfoKHR(
- VulkanHandleMapping* handlemap,
- VkRenderingAttachmentInfoKHR* toMap);
+void handlemap_VkRenderingAttachmentInfoKHR(VulkanHandleMapping* handlemap,
+ VkRenderingAttachmentInfoKHR* toMap);
-void handlemap_VkRenderingInfoKHR(
- VulkanHandleMapping* handlemap,
- VkRenderingInfoKHR* toMap);
+void handlemap_VkRenderingInfoKHR(VulkanHandleMapping* handlemap, VkRenderingInfoKHR* toMap);
-void handlemap_VkPipelineRenderingCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkPipelineRenderingCreateInfoKHR* toMap);
+void handlemap_VkPipelineRenderingCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkPipelineRenderingCreateInfoKHR* toMap);
void handlemap_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDynamicRenderingFeaturesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDynamicRenderingFeaturesKHR* toMap);
void handlemap_VkCommandBufferInheritanceRenderingInfoKHR(
- VulkanHandleMapping* handlemap,
- VkCommandBufferInheritanceRenderingInfoKHR* toMap);
+ VulkanHandleMapping* handlemap, VkCommandBufferInheritanceRenderingInfoKHR* toMap);
void handlemap_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- VulkanHandleMapping* handlemap,
- VkRenderingFragmentShadingRateAttachmentInfoKHR* toMap);
+ VulkanHandleMapping* handlemap, VkRenderingFragmentShadingRateAttachmentInfoKHR* toMap);
void handlemap_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- VulkanHandleMapping* handlemap,
- VkRenderingFragmentDensityMapAttachmentInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkRenderingFragmentDensityMapAttachmentInfoEXT* toMap);
-void handlemap_VkAttachmentSampleCountInfoAMD(
- VulkanHandleMapping* handlemap,
- VkAttachmentSampleCountInfoAMD* toMap);
+void handlemap_VkAttachmentSampleCountInfoAMD(VulkanHandleMapping* handlemap,
+ VkAttachmentSampleCountInfoAMD* toMap);
-DEFINE_ALIAS_FUNCTION(handlemap_VkAttachmentSampleCountInfoAMD, handlemap_VkAttachmentSampleCountInfoNV)
+DEFINE_ALIAS_FUNCTION(handlemap_VkAttachmentSampleCountInfoAMD,
+ handlemap_VkAttachmentSampleCountInfoNV)
-void handlemap_VkMultiviewPerViewAttributesInfoNVX(
- VulkanHandleMapping* handlemap,
- VkMultiviewPerViewAttributesInfoNVX* toMap);
+void handlemap_VkMultiviewPerViewAttributesInfoNVX(VulkanHandleMapping* handlemap,
+ VkMultiviewPerViewAttributesInfoNVX* toMap);
#endif
#ifdef VK_KHR_multiview
-DEFINE_ALIAS_FUNCTION(handlemap_VkRenderPassMultiviewCreateInfo, handlemap_VkRenderPassMultiviewCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkRenderPassMultiviewCreateInfo,
+ handlemap_VkRenderPassMultiviewCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceMultiviewFeatures, handlemap_VkPhysicalDeviceMultiviewFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceMultiviewFeatures,
+ handlemap_VkPhysicalDeviceMultiviewFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceMultiviewProperties, handlemap_VkPhysicalDeviceMultiviewPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceMultiviewProperties,
+ handlemap_VkPhysicalDeviceMultiviewPropertiesKHR)
#endif
#ifdef VK_KHR_get_physical_device_properties2
DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceFeatures2, handlemap_VkPhysicalDeviceFeatures2KHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceProperties2, handlemap_VkPhysicalDeviceProperties2KHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceProperties2,
+ handlemap_VkPhysicalDeviceProperties2KHR)
DEFINE_ALIAS_FUNCTION(handlemap_VkFormatProperties2, handlemap_VkFormatProperties2KHR)
DEFINE_ALIAS_FUNCTION(handlemap_VkImageFormatProperties2, handlemap_VkImageFormatProperties2KHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceImageFormatInfo2, handlemap_VkPhysicalDeviceImageFormatInfo2KHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceImageFormatInfo2,
+ handlemap_VkPhysicalDeviceImageFormatInfo2KHR)
DEFINE_ALIAS_FUNCTION(handlemap_VkQueueFamilyProperties2, handlemap_VkQueueFamilyProperties2KHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceMemoryProperties2, handlemap_VkPhysicalDeviceMemoryProperties2KHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceMemoryProperties2,
+ handlemap_VkPhysicalDeviceMemoryProperties2KHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkSparseImageFormatProperties2, handlemap_VkSparseImageFormatProperties2KHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkSparseImageFormatProperties2,
+ handlemap_VkSparseImageFormatProperties2KHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceSparseImageFormatInfo2, handlemap_VkPhysicalDeviceSparseImageFormatInfo2KHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceSparseImageFormatInfo2,
+ handlemap_VkPhysicalDeviceSparseImageFormatInfo2KHR)
#endif
#ifdef VK_KHR_device_group
DEFINE_ALIAS_FUNCTION(handlemap_VkMemoryAllocateFlagsInfo, handlemap_VkMemoryAllocateFlagsInfoKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceGroupRenderPassBeginInfo, handlemap_VkDeviceGroupRenderPassBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceGroupRenderPassBeginInfo,
+ handlemap_VkDeviceGroupRenderPassBeginInfoKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceGroupCommandBufferBeginInfo, handlemap_VkDeviceGroupCommandBufferBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceGroupCommandBufferBeginInfo,
+ handlemap_VkDeviceGroupCommandBufferBeginInfoKHR)
DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceGroupSubmitInfo, handlemap_VkDeviceGroupSubmitInfoKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceGroupBindSparseInfo, handlemap_VkDeviceGroupBindSparseInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceGroupBindSparseInfo,
+ handlemap_VkDeviceGroupBindSparseInfoKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkBindBufferMemoryDeviceGroupInfo, handlemap_VkBindBufferMemoryDeviceGroupInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkBindBufferMemoryDeviceGroupInfo,
+ handlemap_VkBindBufferMemoryDeviceGroupInfoKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkBindImageMemoryDeviceGroupInfo, handlemap_VkBindImageMemoryDeviceGroupInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkBindImageMemoryDeviceGroupInfo,
+ handlemap_VkBindImageMemoryDeviceGroupInfoKHR)
#endif
#ifdef VK_KHR_shader_draw_parameters
@@ -1241,153 +903,151 @@
#ifdef VK_KHR_maintenance1
#endif
#ifdef VK_KHR_device_group_creation
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceGroupProperties, handlemap_VkPhysicalDeviceGroupPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceGroupProperties,
+ handlemap_VkPhysicalDeviceGroupPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceGroupDeviceCreateInfo, handlemap_VkDeviceGroupDeviceCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceGroupDeviceCreateInfo,
+ handlemap_VkDeviceGroupDeviceCreateInfoKHR)
#endif
#ifdef VK_KHR_external_memory_capabilities
DEFINE_ALIAS_FUNCTION(handlemap_VkExternalMemoryProperties, handlemap_VkExternalMemoryPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceExternalImageFormatInfo, handlemap_VkPhysicalDeviceExternalImageFormatInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceExternalImageFormatInfo,
+ handlemap_VkPhysicalDeviceExternalImageFormatInfoKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkExternalImageFormatProperties, handlemap_VkExternalImageFormatPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkExternalImageFormatProperties,
+ handlemap_VkExternalImageFormatPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceExternalBufferInfo, handlemap_VkPhysicalDeviceExternalBufferInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceExternalBufferInfo,
+ handlemap_VkPhysicalDeviceExternalBufferInfoKHR)
DEFINE_ALIAS_FUNCTION(handlemap_VkExternalBufferProperties, handlemap_VkExternalBufferPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceIDProperties, handlemap_VkPhysicalDeviceIDPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceIDProperties,
+ handlemap_VkPhysicalDeviceIDPropertiesKHR)
#endif
#ifdef VK_KHR_external_memory
-DEFINE_ALIAS_FUNCTION(handlemap_VkExternalMemoryImageCreateInfo, handlemap_VkExternalMemoryImageCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkExternalMemoryImageCreateInfo,
+ handlemap_VkExternalMemoryImageCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkExternalMemoryBufferCreateInfo, handlemap_VkExternalMemoryBufferCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkExternalMemoryBufferCreateInfo,
+ handlemap_VkExternalMemoryBufferCreateInfoKHR)
DEFINE_ALIAS_FUNCTION(handlemap_VkExportMemoryAllocateInfo, handlemap_VkExportMemoryAllocateInfoKHR)
#endif
#ifdef VK_KHR_external_memory_win32
-void handlemap_VkImportMemoryWin32HandleInfoKHR(
- VulkanHandleMapping* handlemap,
- VkImportMemoryWin32HandleInfoKHR* toMap);
+void handlemap_VkImportMemoryWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
+ VkImportMemoryWin32HandleInfoKHR* toMap);
-void handlemap_VkExportMemoryWin32HandleInfoKHR(
- VulkanHandleMapping* handlemap,
- VkExportMemoryWin32HandleInfoKHR* toMap);
+void handlemap_VkExportMemoryWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
+ VkExportMemoryWin32HandleInfoKHR* toMap);
-void handlemap_VkMemoryWin32HandlePropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkMemoryWin32HandlePropertiesKHR* toMap);
+void handlemap_VkMemoryWin32HandlePropertiesKHR(VulkanHandleMapping* handlemap,
+ VkMemoryWin32HandlePropertiesKHR* toMap);
-void handlemap_VkMemoryGetWin32HandleInfoKHR(
- VulkanHandleMapping* handlemap,
- VkMemoryGetWin32HandleInfoKHR* toMap);
+void handlemap_VkMemoryGetWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
+ VkMemoryGetWin32HandleInfoKHR* toMap);
#endif
#ifdef VK_KHR_external_memory_fd
-void handlemap_VkImportMemoryFdInfoKHR(
- VulkanHandleMapping* handlemap,
- VkImportMemoryFdInfoKHR* toMap);
+void handlemap_VkImportMemoryFdInfoKHR(VulkanHandleMapping* handlemap,
+ VkImportMemoryFdInfoKHR* toMap);
-void handlemap_VkMemoryFdPropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkMemoryFdPropertiesKHR* toMap);
+void handlemap_VkMemoryFdPropertiesKHR(VulkanHandleMapping* handlemap,
+ VkMemoryFdPropertiesKHR* toMap);
-void handlemap_VkMemoryGetFdInfoKHR(
- VulkanHandleMapping* handlemap,
- VkMemoryGetFdInfoKHR* toMap);
+void handlemap_VkMemoryGetFdInfoKHR(VulkanHandleMapping* handlemap, VkMemoryGetFdInfoKHR* toMap);
#endif
#ifdef VK_KHR_win32_keyed_mutex
void handlemap_VkWin32KeyedMutexAcquireReleaseInfoKHR(
- VulkanHandleMapping* handlemap,
- VkWin32KeyedMutexAcquireReleaseInfoKHR* toMap);
+ VulkanHandleMapping* handlemap, VkWin32KeyedMutexAcquireReleaseInfoKHR* toMap);
#endif
#ifdef VK_KHR_external_semaphore_capabilities
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceExternalSemaphoreInfo, handlemap_VkPhysicalDeviceExternalSemaphoreInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceExternalSemaphoreInfo,
+ handlemap_VkPhysicalDeviceExternalSemaphoreInfoKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkExternalSemaphoreProperties, handlemap_VkExternalSemaphorePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkExternalSemaphoreProperties,
+ handlemap_VkExternalSemaphorePropertiesKHR)
#endif
#ifdef VK_KHR_external_semaphore
-DEFINE_ALIAS_FUNCTION(handlemap_VkExportSemaphoreCreateInfo, handlemap_VkExportSemaphoreCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkExportSemaphoreCreateInfo,
+ handlemap_VkExportSemaphoreCreateInfoKHR)
#endif
#ifdef VK_KHR_external_semaphore_win32
-void handlemap_VkImportSemaphoreWin32HandleInfoKHR(
- VulkanHandleMapping* handlemap,
- VkImportSemaphoreWin32HandleInfoKHR* toMap);
+void handlemap_VkImportSemaphoreWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
+ VkImportSemaphoreWin32HandleInfoKHR* toMap);
-void handlemap_VkExportSemaphoreWin32HandleInfoKHR(
- VulkanHandleMapping* handlemap,
- VkExportSemaphoreWin32HandleInfoKHR* toMap);
+void handlemap_VkExportSemaphoreWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
+ VkExportSemaphoreWin32HandleInfoKHR* toMap);
-void handlemap_VkD3D12FenceSubmitInfoKHR(
- VulkanHandleMapping* handlemap,
- VkD3D12FenceSubmitInfoKHR* toMap);
+void handlemap_VkD3D12FenceSubmitInfoKHR(VulkanHandleMapping* handlemap,
+ VkD3D12FenceSubmitInfoKHR* toMap);
-void handlemap_VkSemaphoreGetWin32HandleInfoKHR(
- VulkanHandleMapping* handlemap,
- VkSemaphoreGetWin32HandleInfoKHR* toMap);
+void handlemap_VkSemaphoreGetWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
+ VkSemaphoreGetWin32HandleInfoKHR* toMap);
#endif
#ifdef VK_KHR_external_semaphore_fd
-void handlemap_VkImportSemaphoreFdInfoKHR(
- VulkanHandleMapping* handlemap,
- VkImportSemaphoreFdInfoKHR* toMap);
+void handlemap_VkImportSemaphoreFdInfoKHR(VulkanHandleMapping* handlemap,
+ VkImportSemaphoreFdInfoKHR* toMap);
-void handlemap_VkSemaphoreGetFdInfoKHR(
- VulkanHandleMapping* handlemap,
- VkSemaphoreGetFdInfoKHR* toMap);
+void handlemap_VkSemaphoreGetFdInfoKHR(VulkanHandleMapping* handlemap,
+ VkSemaphoreGetFdInfoKHR* toMap);
#endif
#ifdef VK_KHR_push_descriptor
void handlemap_VkPhysicalDevicePushDescriptorPropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePushDescriptorPropertiesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePushDescriptorPropertiesKHR* toMap);
#endif
#ifdef VK_KHR_shader_float16_int8
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderFloat16Int8Features, handlemap_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderFloat16Int8Features,
+ handlemap_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderFloat16Int8Features, handlemap_VkPhysicalDeviceFloat16Int8FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderFloat16Int8Features,
+ handlemap_VkPhysicalDeviceFloat16Int8FeaturesKHR)
#endif
#ifdef VK_KHR_16bit_storage
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDevice16BitStorageFeatures, handlemap_VkPhysicalDevice16BitStorageFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDevice16BitStorageFeatures,
+ handlemap_VkPhysicalDevice16BitStorageFeaturesKHR)
#endif
#ifdef VK_KHR_incremental_present
-void handlemap_VkRectLayerKHR(
- VulkanHandleMapping* handlemap,
- VkRectLayerKHR* toMap);
+void handlemap_VkRectLayerKHR(VulkanHandleMapping* handlemap, VkRectLayerKHR* toMap);
-void handlemap_VkPresentRegionKHR(
- VulkanHandleMapping* handlemap,
- VkPresentRegionKHR* toMap);
+void handlemap_VkPresentRegionKHR(VulkanHandleMapping* handlemap, VkPresentRegionKHR* toMap);
-void handlemap_VkPresentRegionsKHR(
- VulkanHandleMapping* handlemap,
- VkPresentRegionsKHR* toMap);
+void handlemap_VkPresentRegionsKHR(VulkanHandleMapping* handlemap, VkPresentRegionsKHR* toMap);
#endif
#ifdef VK_KHR_descriptor_update_template
-DEFINE_ALIAS_FUNCTION(handlemap_VkDescriptorUpdateTemplateEntry, handlemap_VkDescriptorUpdateTemplateEntryKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkDescriptorUpdateTemplateEntry,
+ handlemap_VkDescriptorUpdateTemplateEntryKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkDescriptorUpdateTemplateCreateInfo, handlemap_VkDescriptorUpdateTemplateCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkDescriptorUpdateTemplateCreateInfo,
+ handlemap_VkDescriptorUpdateTemplateCreateInfoKHR)
#endif
#ifdef VK_KHR_imageless_framebuffer
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceImagelessFramebufferFeatures, handlemap_VkPhysicalDeviceImagelessFramebufferFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceImagelessFramebufferFeatures,
+ handlemap_VkPhysicalDeviceImagelessFramebufferFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkFramebufferAttachmentsCreateInfo, handlemap_VkFramebufferAttachmentsCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkFramebufferAttachmentsCreateInfo,
+ handlemap_VkFramebufferAttachmentsCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkFramebufferAttachmentImageInfo, handlemap_VkFramebufferAttachmentImageInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkFramebufferAttachmentImageInfo,
+ handlemap_VkFramebufferAttachmentImageInfoKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkRenderPassAttachmentBeginInfo, handlemap_VkRenderPassAttachmentBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkRenderPassAttachmentBeginInfo,
+ handlemap_VkRenderPassAttachmentBeginInfoKHR)
#endif
#ifdef VK_KHR_create_renderpass2
@@ -1407,13 +1067,13 @@
#endif
#ifdef VK_KHR_shared_presentable_image
-void handlemap_VkSharedPresentSurfaceCapabilitiesKHR(
- VulkanHandleMapping* handlemap,
- VkSharedPresentSurfaceCapabilitiesKHR* toMap);
+void handlemap_VkSharedPresentSurfaceCapabilitiesKHR(VulkanHandleMapping* handlemap,
+ VkSharedPresentSurfaceCapabilitiesKHR* toMap);
#endif
#ifdef VK_KHR_external_fence_capabilities
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceExternalFenceInfo, handlemap_VkPhysicalDeviceExternalFenceInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceExternalFenceInfo,
+ handlemap_VkPhysicalDeviceExternalFenceInfoKHR)
DEFINE_ALIAS_FUNCTION(handlemap_VkExternalFenceProperties, handlemap_VkExternalFencePropertiesKHR)
@@ -1423,121 +1083,106 @@
#endif
#ifdef VK_KHR_external_fence_win32
-void handlemap_VkImportFenceWin32HandleInfoKHR(
- VulkanHandleMapping* handlemap,
- VkImportFenceWin32HandleInfoKHR* toMap);
+void handlemap_VkImportFenceWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
+ VkImportFenceWin32HandleInfoKHR* toMap);
-void handlemap_VkExportFenceWin32HandleInfoKHR(
- VulkanHandleMapping* handlemap,
- VkExportFenceWin32HandleInfoKHR* toMap);
+void handlemap_VkExportFenceWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
+ VkExportFenceWin32HandleInfoKHR* toMap);
-void handlemap_VkFenceGetWin32HandleInfoKHR(
- VulkanHandleMapping* handlemap,
- VkFenceGetWin32HandleInfoKHR* toMap);
+void handlemap_VkFenceGetWin32HandleInfoKHR(VulkanHandleMapping* handlemap,
+ VkFenceGetWin32HandleInfoKHR* toMap);
#endif
#ifdef VK_KHR_external_fence_fd
-void handlemap_VkImportFenceFdInfoKHR(
- VulkanHandleMapping* handlemap,
- VkImportFenceFdInfoKHR* toMap);
+void handlemap_VkImportFenceFdInfoKHR(VulkanHandleMapping* handlemap,
+ VkImportFenceFdInfoKHR* toMap);
-void handlemap_VkFenceGetFdInfoKHR(
- VulkanHandleMapping* handlemap,
- VkFenceGetFdInfoKHR* toMap);
+void handlemap_VkFenceGetFdInfoKHR(VulkanHandleMapping* handlemap, VkFenceGetFdInfoKHR* toMap);
#endif
#ifdef VK_KHR_performance_query
void handlemap_VkPhysicalDevicePerformanceQueryFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePerformanceQueryFeaturesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePerformanceQueryFeaturesKHR* toMap);
void handlemap_VkPhysicalDevicePerformanceQueryPropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePerformanceQueryPropertiesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePerformanceQueryPropertiesKHR* toMap);
-void handlemap_VkPerformanceCounterKHR(
- VulkanHandleMapping* handlemap,
- VkPerformanceCounterKHR* toMap);
+void handlemap_VkPerformanceCounterKHR(VulkanHandleMapping* handlemap,
+ VkPerformanceCounterKHR* toMap);
-void handlemap_VkPerformanceCounterDescriptionKHR(
- VulkanHandleMapping* handlemap,
- VkPerformanceCounterDescriptionKHR* toMap);
+void handlemap_VkPerformanceCounterDescriptionKHR(VulkanHandleMapping* handlemap,
+ VkPerformanceCounterDescriptionKHR* toMap);
-void handlemap_VkQueryPoolPerformanceCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkQueryPoolPerformanceCreateInfoKHR* toMap);
+void handlemap_VkQueryPoolPerformanceCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkQueryPoolPerformanceCreateInfoKHR* toMap);
-void handlemap_VkPerformanceCounterResultKHR(
- VulkanHandleMapping* handlemap,
- VkPerformanceCounterResultKHR* toMap);
+void handlemap_VkPerformanceCounterResultKHR(VulkanHandleMapping* handlemap,
+ VkPerformanceCounterResultKHR* toMap);
-void handlemap_VkAcquireProfilingLockInfoKHR(
- VulkanHandleMapping* handlemap,
- VkAcquireProfilingLockInfoKHR* toMap);
+void handlemap_VkAcquireProfilingLockInfoKHR(VulkanHandleMapping* handlemap,
+ VkAcquireProfilingLockInfoKHR* toMap);
-void handlemap_VkPerformanceQuerySubmitInfoKHR(
- VulkanHandleMapping* handlemap,
- VkPerformanceQuerySubmitInfoKHR* toMap);
+void handlemap_VkPerformanceQuerySubmitInfoKHR(VulkanHandleMapping* handlemap,
+ VkPerformanceQuerySubmitInfoKHR* toMap);
#endif
#ifdef VK_KHR_maintenance2
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDevicePointClippingProperties, handlemap_VkPhysicalDevicePointClippingPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDevicePointClippingProperties,
+ handlemap_VkPhysicalDevicePointClippingPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkRenderPassInputAttachmentAspectCreateInfo, handlemap_VkRenderPassInputAttachmentAspectCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkRenderPassInputAttachmentAspectCreateInfo,
+ handlemap_VkRenderPassInputAttachmentAspectCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkInputAttachmentAspectReference, handlemap_VkInputAttachmentAspectReferenceKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkInputAttachmentAspectReference,
+ handlemap_VkInputAttachmentAspectReferenceKHR)
DEFINE_ALIAS_FUNCTION(handlemap_VkImageViewUsageCreateInfo, handlemap_VkImageViewUsageCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkPipelineTessellationDomainOriginStateCreateInfo, handlemap_VkPipelineTessellationDomainOriginStateCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPipelineTessellationDomainOriginStateCreateInfo,
+ handlemap_VkPipelineTessellationDomainOriginStateCreateInfoKHR)
#endif
#ifdef VK_KHR_get_surface_capabilities2
-void handlemap_VkPhysicalDeviceSurfaceInfo2KHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSurfaceInfo2KHR* toMap);
+void handlemap_VkPhysicalDeviceSurfaceInfo2KHR(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceSurfaceInfo2KHR* toMap);
-void handlemap_VkSurfaceCapabilities2KHR(
- VulkanHandleMapping* handlemap,
- VkSurfaceCapabilities2KHR* toMap);
+void handlemap_VkSurfaceCapabilities2KHR(VulkanHandleMapping* handlemap,
+ VkSurfaceCapabilities2KHR* toMap);
-void handlemap_VkSurfaceFormat2KHR(
- VulkanHandleMapping* handlemap,
- VkSurfaceFormat2KHR* toMap);
+void handlemap_VkSurfaceFormat2KHR(VulkanHandleMapping* handlemap, VkSurfaceFormat2KHR* toMap);
#endif
#ifdef VK_KHR_variable_pointers
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceVariablePointersFeatures, handlemap_VkPhysicalDeviceVariablePointerFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceVariablePointersFeatures,
+ handlemap_VkPhysicalDeviceVariablePointerFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceVariablePointersFeatures, handlemap_VkPhysicalDeviceVariablePointersFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceVariablePointersFeatures,
+ handlemap_VkPhysicalDeviceVariablePointersFeaturesKHR)
#endif
#ifdef VK_KHR_get_display_properties2
-void handlemap_VkDisplayProperties2KHR(
- VulkanHandleMapping* handlemap,
- VkDisplayProperties2KHR* toMap);
+void handlemap_VkDisplayProperties2KHR(VulkanHandleMapping* handlemap,
+ VkDisplayProperties2KHR* toMap);
-void handlemap_VkDisplayPlaneProperties2KHR(
- VulkanHandleMapping* handlemap,
- VkDisplayPlaneProperties2KHR* toMap);
+void handlemap_VkDisplayPlaneProperties2KHR(VulkanHandleMapping* handlemap,
+ VkDisplayPlaneProperties2KHR* toMap);
-void handlemap_VkDisplayModeProperties2KHR(
- VulkanHandleMapping* handlemap,
- VkDisplayModeProperties2KHR* toMap);
+void handlemap_VkDisplayModeProperties2KHR(VulkanHandleMapping* handlemap,
+ VkDisplayModeProperties2KHR* toMap);
-void handlemap_VkDisplayPlaneInfo2KHR(
- VulkanHandleMapping* handlemap,
- VkDisplayPlaneInfo2KHR* toMap);
+void handlemap_VkDisplayPlaneInfo2KHR(VulkanHandleMapping* handlemap,
+ VkDisplayPlaneInfo2KHR* toMap);
-void handlemap_VkDisplayPlaneCapabilities2KHR(
- VulkanHandleMapping* handlemap,
- VkDisplayPlaneCapabilities2KHR* toMap);
+void handlemap_VkDisplayPlaneCapabilities2KHR(VulkanHandleMapping* handlemap,
+ VkDisplayPlaneCapabilities2KHR* toMap);
#endif
#ifdef VK_KHR_dedicated_allocation
-DEFINE_ALIAS_FUNCTION(handlemap_VkMemoryDedicatedRequirements, handlemap_VkMemoryDedicatedRequirementsKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkMemoryDedicatedRequirements,
+ handlemap_VkMemoryDedicatedRequirementsKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkMemoryDedicatedAllocateInfo, handlemap_VkMemoryDedicatedAllocateInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkMemoryDedicatedAllocateInfo,
+ handlemap_VkMemoryDedicatedAllocateInfoKHR)
#endif
#ifdef VK_KHR_storage_buffer_storage_class
@@ -1545,33 +1190,43 @@
#ifdef VK_KHR_relaxed_block_layout
#endif
#ifdef VK_KHR_get_memory_requirements2
-DEFINE_ALIAS_FUNCTION(handlemap_VkBufferMemoryRequirementsInfo2, handlemap_VkBufferMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkBufferMemoryRequirementsInfo2,
+ handlemap_VkBufferMemoryRequirementsInfo2KHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkImageMemoryRequirementsInfo2, handlemap_VkImageMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkImageMemoryRequirementsInfo2,
+ handlemap_VkImageMemoryRequirementsInfo2KHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkImageSparseMemoryRequirementsInfo2, handlemap_VkImageSparseMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkImageSparseMemoryRequirementsInfo2,
+ handlemap_VkImageSparseMemoryRequirementsInfo2KHR)
DEFINE_ALIAS_FUNCTION(handlemap_VkMemoryRequirements2, handlemap_VkMemoryRequirements2KHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkSparseImageMemoryRequirements2, handlemap_VkSparseImageMemoryRequirements2KHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkSparseImageMemoryRequirements2,
+ handlemap_VkSparseImageMemoryRequirements2KHR)
#endif
#ifdef VK_KHR_image_format_list
-DEFINE_ALIAS_FUNCTION(handlemap_VkImageFormatListCreateInfo, handlemap_VkImageFormatListCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkImageFormatListCreateInfo,
+ handlemap_VkImageFormatListCreateInfoKHR)
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
-DEFINE_ALIAS_FUNCTION(handlemap_VkSamplerYcbcrConversionCreateInfo, handlemap_VkSamplerYcbcrConversionCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkSamplerYcbcrConversionCreateInfo,
+ handlemap_VkSamplerYcbcrConversionCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkSamplerYcbcrConversionInfo, handlemap_VkSamplerYcbcrConversionInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkSamplerYcbcrConversionInfo,
+ handlemap_VkSamplerYcbcrConversionInfoKHR)
DEFINE_ALIAS_FUNCTION(handlemap_VkBindImagePlaneMemoryInfo, handlemap_VkBindImagePlaneMemoryInfoKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkImagePlaneMemoryRequirementsInfo, handlemap_VkImagePlaneMemoryRequirementsInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkImagePlaneMemoryRequirementsInfo,
+ handlemap_VkImagePlaneMemoryRequirementsInfoKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeatures, handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeatures,
+ handlemap_VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkSamplerYcbcrConversionImageFormatProperties, handlemap_VkSamplerYcbcrConversionImageFormatPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkSamplerYcbcrConversionImageFormatProperties,
+ handlemap_VkSamplerYcbcrConversionImageFormatPropertiesKHR)
#endif
#ifdef VK_KHR_bind_memory2
@@ -1582,66 +1237,75 @@
#endif
#ifdef VK_KHR_portability_subset
void handlemap_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePortabilitySubsetFeaturesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePortabilitySubsetFeaturesKHR* toMap);
void handlemap_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePortabilitySubsetPropertiesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePortabilitySubsetPropertiesKHR* toMap);
#endif
#ifdef VK_KHR_maintenance3
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceMaintenance3Properties, handlemap_VkPhysicalDeviceMaintenance3PropertiesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceMaintenance3Properties,
+ handlemap_VkPhysicalDeviceMaintenance3PropertiesKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkDescriptorSetLayoutSupport, handlemap_VkDescriptorSetLayoutSupportKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkDescriptorSetLayoutSupport,
+ handlemap_VkDescriptorSetLayoutSupportKHR)
#endif
#ifdef VK_KHR_draw_indirect_count
#endif
#ifdef VK_KHR_shader_subgroup_extended_types
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, handlemap_VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures,
+ handlemap_VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)
#endif
#ifdef VK_KHR_8bit_storage
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDevice8BitStorageFeatures, handlemap_VkPhysicalDevice8BitStorageFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDevice8BitStorageFeatures,
+ handlemap_VkPhysicalDevice8BitStorageFeaturesKHR)
#endif
#ifdef VK_KHR_shader_atomic_int64
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderAtomicInt64Features, handlemap_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderAtomicInt64Features,
+ handlemap_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR)
#endif
#ifdef VK_KHR_shader_clock
void handlemap_VkPhysicalDeviceShaderClockFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderClockFeaturesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderClockFeaturesKHR* toMap);
#endif
#ifdef VK_KHR_driver_properties
DEFINE_ALIAS_FUNCTION(handlemap_VkConformanceVersion, handlemap_VkConformanceVersionKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceDriverProperties, handlemap_VkPhysicalDeviceDriverPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceDriverProperties,
+ handlemap_VkPhysicalDeviceDriverPropertiesKHR)
#endif
#ifdef VK_KHR_shader_float_controls
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceFloatControlsProperties, handlemap_VkPhysicalDeviceFloatControlsPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceFloatControlsProperties,
+ handlemap_VkPhysicalDeviceFloatControlsPropertiesKHR)
#endif
#ifdef VK_KHR_depth_stencil_resolve
-DEFINE_ALIAS_FUNCTION(handlemap_VkSubpassDescriptionDepthStencilResolve, handlemap_VkSubpassDescriptionDepthStencilResolveKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkSubpassDescriptionDepthStencilResolve,
+ handlemap_VkSubpassDescriptionDepthStencilResolveKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceDepthStencilResolveProperties, handlemap_VkPhysicalDeviceDepthStencilResolvePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceDepthStencilResolveProperties,
+ handlemap_VkPhysicalDeviceDepthStencilResolvePropertiesKHR)
#endif
#ifdef VK_KHR_swapchain_mutable_format
#endif
#ifdef VK_KHR_timeline_semaphore
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceTimelineSemaphoreFeatures, handlemap_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceTimelineSemaphoreFeatures,
+ handlemap_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceTimelineSemaphoreProperties, handlemap_VkPhysicalDeviceTimelineSemaphorePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceTimelineSemaphoreProperties,
+ handlemap_VkPhysicalDeviceTimelineSemaphorePropertiesKHR)
DEFINE_ALIAS_FUNCTION(handlemap_VkSemaphoreTypeCreateInfo, handlemap_VkSemaphoreTypeCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkTimelineSemaphoreSubmitInfo, handlemap_VkTimelineSemaphoreSubmitInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkTimelineSemaphoreSubmitInfo,
+ handlemap_VkTimelineSemaphoreSubmitInfoKHR)
DEFINE_ALIAS_FUNCTION(handlemap_VkSemaphoreWaitInfo, handlemap_VkSemaphoreWaitInfoKHR)
@@ -1649,185 +1313,155 @@
#endif
#ifdef VK_KHR_vulkan_memory_model
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceVulkanMemoryModelFeatures, handlemap_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceVulkanMemoryModelFeatures,
+ handlemap_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR)
#endif
#ifdef VK_KHR_shader_terminate_invocation
void handlemap_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toMap);
#endif
#ifdef VK_KHR_fragment_shading_rate
void handlemap_VkFragmentShadingRateAttachmentInfoKHR(
- VulkanHandleMapping* handlemap,
- VkFragmentShadingRateAttachmentInfoKHR* toMap);
+ VulkanHandleMapping* handlemap, VkFragmentShadingRateAttachmentInfoKHR* toMap);
void handlemap_VkPipelineFragmentShadingRateStateCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkPipelineFragmentShadingRateStateCreateInfoKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineFragmentShadingRateStateCreateInfoKHR* toMap);
void handlemap_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentShadingRateFeaturesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShadingRateFeaturesKHR* toMap);
void handlemap_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentShadingRatePropertiesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShadingRatePropertiesKHR* toMap);
void handlemap_VkPhysicalDeviceFragmentShadingRateKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentShadingRateKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShadingRateKHR* toMap);
#endif
#ifdef VK_KHR_spirv_1_4
#endif
#ifdef VK_KHR_surface_protected_capabilities
-void handlemap_VkSurfaceProtectedCapabilitiesKHR(
- VulkanHandleMapping* handlemap,
- VkSurfaceProtectedCapabilitiesKHR* toMap);
+void handlemap_VkSurfaceProtectedCapabilitiesKHR(VulkanHandleMapping* handlemap,
+ VkSurfaceProtectedCapabilitiesKHR* toMap);
#endif
#ifdef VK_KHR_separate_depth_stencil_layouts
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, handlemap_VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures,
+ handlemap_VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkAttachmentReferenceStencilLayout, handlemap_VkAttachmentReferenceStencilLayoutKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkAttachmentReferenceStencilLayout,
+ handlemap_VkAttachmentReferenceStencilLayoutKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkAttachmentDescriptionStencilLayout, handlemap_VkAttachmentDescriptionStencilLayoutKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkAttachmentDescriptionStencilLayout,
+ handlemap_VkAttachmentDescriptionStencilLayoutKHR)
#endif
#ifdef VK_KHR_present_wait
void handlemap_VkPhysicalDevicePresentWaitFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePresentWaitFeaturesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePresentWaitFeaturesKHR* toMap);
#endif
#ifdef VK_KHR_uniform_buffer_standard_layout
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceUniformBufferStandardLayoutFeatures, handlemap_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceUniformBufferStandardLayoutFeatures,
+ handlemap_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)
#endif
#ifdef VK_KHR_buffer_device_address
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceBufferDeviceAddressFeatures, handlemap_VkPhysicalDeviceBufferDeviceAddressFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceBufferDeviceAddressFeatures,
+ handlemap_VkPhysicalDeviceBufferDeviceAddressFeaturesKHR)
DEFINE_ALIAS_FUNCTION(handlemap_VkBufferDeviceAddressInfo, handlemap_VkBufferDeviceAddressInfoKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkBufferOpaqueCaptureAddressCreateInfo, handlemap_VkBufferOpaqueCaptureAddressCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkBufferOpaqueCaptureAddressCreateInfo,
+ handlemap_VkBufferOpaqueCaptureAddressCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkMemoryOpaqueCaptureAddressAllocateInfo, handlemap_VkMemoryOpaqueCaptureAddressAllocateInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkMemoryOpaqueCaptureAddressAllocateInfo,
+ handlemap_VkMemoryOpaqueCaptureAddressAllocateInfoKHR)
-DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceMemoryOpaqueCaptureAddressInfo, handlemap_VkDeviceMemoryOpaqueCaptureAddressInfoKHR)
+DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceMemoryOpaqueCaptureAddressInfo,
+ handlemap_VkDeviceMemoryOpaqueCaptureAddressInfoKHR)
#endif
#ifdef VK_KHR_deferred_host_operations
#endif
#ifdef VK_KHR_pipeline_executable_properties
void handlemap_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* toMap);
-void handlemap_VkPipelineInfoKHR(
- VulkanHandleMapping* handlemap,
- VkPipelineInfoKHR* toMap);
+void handlemap_VkPipelineInfoKHR(VulkanHandleMapping* handlemap, VkPipelineInfoKHR* toMap);
-void handlemap_VkPipelineExecutablePropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkPipelineExecutablePropertiesKHR* toMap);
+void handlemap_VkPipelineExecutablePropertiesKHR(VulkanHandleMapping* handlemap,
+ VkPipelineExecutablePropertiesKHR* toMap);
-void handlemap_VkPipelineExecutableInfoKHR(
- VulkanHandleMapping* handlemap,
- VkPipelineExecutableInfoKHR* toMap);
+void handlemap_VkPipelineExecutableInfoKHR(VulkanHandleMapping* handlemap,
+ VkPipelineExecutableInfoKHR* toMap);
-void handlemap_VkPipelineExecutableStatisticValueKHR(
- VulkanHandleMapping* handlemap,
- VkPipelineExecutableStatisticValueKHR* toMap);
+void handlemap_VkPipelineExecutableStatisticValueKHR(VulkanHandleMapping* handlemap,
+ VkPipelineExecutableStatisticValueKHR* toMap);
-void handlemap_VkPipelineExecutableStatisticKHR(
- VulkanHandleMapping* handlemap,
- VkPipelineExecutableStatisticKHR* toMap);
+void handlemap_VkPipelineExecutableStatisticKHR(VulkanHandleMapping* handlemap,
+ VkPipelineExecutableStatisticKHR* toMap);
void handlemap_VkPipelineExecutableInternalRepresentationKHR(
- VulkanHandleMapping* handlemap,
- VkPipelineExecutableInternalRepresentationKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineExecutableInternalRepresentationKHR* toMap);
#endif
#ifdef VK_KHR_shader_integer_dot_product
void handlemap_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* toMap);
void handlemap_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* toMap);
#endif
#ifdef VK_KHR_pipeline_library
-void handlemap_VkPipelineLibraryCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkPipelineLibraryCreateInfoKHR* toMap);
+void handlemap_VkPipelineLibraryCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkPipelineLibraryCreateInfoKHR* toMap);
#endif
#ifdef VK_KHR_shader_non_semantic_info
#endif
#ifdef VK_KHR_present_id
-void handlemap_VkPresentIdKHR(
- VulkanHandleMapping* handlemap,
- VkPresentIdKHR* toMap);
+void handlemap_VkPresentIdKHR(VulkanHandleMapping* handlemap, VkPresentIdKHR* toMap);
-void handlemap_VkPhysicalDevicePresentIdFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePresentIdFeaturesKHR* toMap);
+void handlemap_VkPhysicalDevicePresentIdFeaturesKHR(VulkanHandleMapping* handlemap,
+ VkPhysicalDevicePresentIdFeaturesKHR* toMap);
#endif
#ifdef VK_KHR_video_encode_queue
-void handlemap_VkVideoEncodeInfoKHR(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeInfoKHR* toMap);
+void handlemap_VkVideoEncodeInfoKHR(VulkanHandleMapping* handlemap, VkVideoEncodeInfoKHR* toMap);
-void handlemap_VkVideoEncodeRateControlInfoKHR(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeRateControlInfoKHR* toMap);
+void handlemap_VkVideoEncodeRateControlInfoKHR(VulkanHandleMapping* handlemap,
+ VkVideoEncodeRateControlInfoKHR* toMap);
#endif
#ifdef VK_KHR_synchronization2
-void handlemap_VkMemoryBarrier2KHR(
- VulkanHandleMapping* handlemap,
- VkMemoryBarrier2KHR* toMap);
+void handlemap_VkMemoryBarrier2KHR(VulkanHandleMapping* handlemap, VkMemoryBarrier2KHR* toMap);
-void handlemap_VkBufferMemoryBarrier2KHR(
- VulkanHandleMapping* handlemap,
- VkBufferMemoryBarrier2KHR* toMap);
+void handlemap_VkBufferMemoryBarrier2KHR(VulkanHandleMapping* handlemap,
+ VkBufferMemoryBarrier2KHR* toMap);
-void handlemap_VkImageMemoryBarrier2KHR(
- VulkanHandleMapping* handlemap,
- VkImageMemoryBarrier2KHR* toMap);
+void handlemap_VkImageMemoryBarrier2KHR(VulkanHandleMapping* handlemap,
+ VkImageMemoryBarrier2KHR* toMap);
-void handlemap_VkDependencyInfoKHR(
- VulkanHandleMapping* handlemap,
- VkDependencyInfoKHR* toMap);
+void handlemap_VkDependencyInfoKHR(VulkanHandleMapping* handlemap, VkDependencyInfoKHR* toMap);
-void handlemap_VkSemaphoreSubmitInfoKHR(
- VulkanHandleMapping* handlemap,
- VkSemaphoreSubmitInfoKHR* toMap);
+void handlemap_VkSemaphoreSubmitInfoKHR(VulkanHandleMapping* handlemap,
+ VkSemaphoreSubmitInfoKHR* toMap);
-void handlemap_VkCommandBufferSubmitInfoKHR(
- VulkanHandleMapping* handlemap,
- VkCommandBufferSubmitInfoKHR* toMap);
+void handlemap_VkCommandBufferSubmitInfoKHR(VulkanHandleMapping* handlemap,
+ VkCommandBufferSubmitInfoKHR* toMap);
-void handlemap_VkSubmitInfo2KHR(
- VulkanHandleMapping* handlemap,
- VkSubmitInfo2KHR* toMap);
+void handlemap_VkSubmitInfo2KHR(VulkanHandleMapping* handlemap, VkSubmitInfo2KHR* toMap);
void handlemap_VkPhysicalDeviceSynchronization2FeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSynchronization2FeaturesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceSynchronization2FeaturesKHR* toMap);
-void handlemap_VkQueueFamilyCheckpointProperties2NV(
- VulkanHandleMapping* handlemap,
- VkQueueFamilyCheckpointProperties2NV* toMap);
+void handlemap_VkQueueFamilyCheckpointProperties2NV(VulkanHandleMapping* handlemap,
+ VkQueueFamilyCheckpointProperties2NV* toMap);
-void handlemap_VkCheckpointData2NV(
- VulkanHandleMapping* handlemap,
- VkCheckpointData2NV* toMap);
+void handlemap_VkCheckpointData2NV(VulkanHandleMapping* handlemap, VkCheckpointData2NV* toMap);
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
@@ -1849,85 +1483,58 @@
#endif
#ifdef VK_KHR_copy_commands2
-void handlemap_VkBufferCopy2KHR(
- VulkanHandleMapping* handlemap,
- VkBufferCopy2KHR* toMap);
+void handlemap_VkBufferCopy2KHR(VulkanHandleMapping* handlemap, VkBufferCopy2KHR* toMap);
-void handlemap_VkCopyBufferInfo2KHR(
- VulkanHandleMapping* handlemap,
- VkCopyBufferInfo2KHR* toMap);
+void handlemap_VkCopyBufferInfo2KHR(VulkanHandleMapping* handlemap, VkCopyBufferInfo2KHR* toMap);
-void handlemap_VkImageCopy2KHR(
- VulkanHandleMapping* handlemap,
- VkImageCopy2KHR* toMap);
+void handlemap_VkImageCopy2KHR(VulkanHandleMapping* handlemap, VkImageCopy2KHR* toMap);
-void handlemap_VkCopyImageInfo2KHR(
- VulkanHandleMapping* handlemap,
- VkCopyImageInfo2KHR* toMap);
+void handlemap_VkCopyImageInfo2KHR(VulkanHandleMapping* handlemap, VkCopyImageInfo2KHR* toMap);
-void handlemap_VkBufferImageCopy2KHR(
- VulkanHandleMapping* handlemap,
- VkBufferImageCopy2KHR* toMap);
+void handlemap_VkBufferImageCopy2KHR(VulkanHandleMapping* handlemap, VkBufferImageCopy2KHR* toMap);
-void handlemap_VkCopyBufferToImageInfo2KHR(
- VulkanHandleMapping* handlemap,
- VkCopyBufferToImageInfo2KHR* toMap);
+void handlemap_VkCopyBufferToImageInfo2KHR(VulkanHandleMapping* handlemap,
+ VkCopyBufferToImageInfo2KHR* toMap);
-void handlemap_VkCopyImageToBufferInfo2KHR(
- VulkanHandleMapping* handlemap,
- VkCopyImageToBufferInfo2KHR* toMap);
+void handlemap_VkCopyImageToBufferInfo2KHR(VulkanHandleMapping* handlemap,
+ VkCopyImageToBufferInfo2KHR* toMap);
-void handlemap_VkImageBlit2KHR(
- VulkanHandleMapping* handlemap,
- VkImageBlit2KHR* toMap);
+void handlemap_VkImageBlit2KHR(VulkanHandleMapping* handlemap, VkImageBlit2KHR* toMap);
-void handlemap_VkBlitImageInfo2KHR(
- VulkanHandleMapping* handlemap,
- VkBlitImageInfo2KHR* toMap);
+void handlemap_VkBlitImageInfo2KHR(VulkanHandleMapping* handlemap, VkBlitImageInfo2KHR* toMap);
-void handlemap_VkImageResolve2KHR(
- VulkanHandleMapping* handlemap,
- VkImageResolve2KHR* toMap);
+void handlemap_VkImageResolve2KHR(VulkanHandleMapping* handlemap, VkImageResolve2KHR* toMap);
-void handlemap_VkResolveImageInfo2KHR(
- VulkanHandleMapping* handlemap,
- VkResolveImageInfo2KHR* toMap);
+void handlemap_VkResolveImageInfo2KHR(VulkanHandleMapping* handlemap,
+ VkResolveImageInfo2KHR* toMap);
#endif
#ifdef VK_KHR_format_feature_flags2
-void handlemap_VkFormatProperties3KHR(
- VulkanHandleMapping* handlemap,
- VkFormatProperties3KHR* toMap);
+void handlemap_VkFormatProperties3KHR(VulkanHandleMapping* handlemap,
+ VkFormatProperties3KHR* toMap);
#endif
#ifdef VK_KHR_maintenance4
void handlemap_VkPhysicalDeviceMaintenance4FeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMaintenance4FeaturesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceMaintenance4FeaturesKHR* toMap);
void handlemap_VkPhysicalDeviceMaintenance4PropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMaintenance4PropertiesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceMaintenance4PropertiesKHR* toMap);
-void handlemap_VkDeviceBufferMemoryRequirementsKHR(
- VulkanHandleMapping* handlemap,
- VkDeviceBufferMemoryRequirementsKHR* toMap);
+void handlemap_VkDeviceBufferMemoryRequirementsKHR(VulkanHandleMapping* handlemap,
+ VkDeviceBufferMemoryRequirementsKHR* toMap);
-void handlemap_VkDeviceImageMemoryRequirementsKHR(
- VulkanHandleMapping* handlemap,
- VkDeviceImageMemoryRequirementsKHR* toMap);
+void handlemap_VkDeviceImageMemoryRequirementsKHR(VulkanHandleMapping* handlemap,
+ VkDeviceImageMemoryRequirementsKHR* toMap);
#endif
#ifdef VK_ANDROID_native_buffer
-void handlemap_VkNativeBufferANDROID(
- VulkanHandleMapping* handlemap,
- VkNativeBufferANDROID* toMap);
+void handlemap_VkNativeBufferANDROID(VulkanHandleMapping* handlemap, VkNativeBufferANDROID* toMap);
#endif
#ifdef VK_EXT_debug_report
-void handlemap_VkDebugReportCallbackCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDebugReportCallbackCreateInfoEXT* toMap);
+void handlemap_VkDebugReportCallbackCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkDebugReportCallbackCreateInfoEXT* toMap);
#endif
#ifdef VK_NV_glsl_shader
@@ -1938,8 +1545,7 @@
#endif
#ifdef VK_AMD_rasterization_order
void handlemap_VkPipelineRasterizationStateRasterizationOrderAMD(
- VulkanHandleMapping* handlemap,
- VkPipelineRasterizationStateRasterizationOrderAMD* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineRasterizationStateRasterizationOrderAMD* toMap);
#endif
#ifdef VK_AMD_shader_trinary_minmax
@@ -1947,71 +1553,56 @@
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
-void handlemap_VkDebugMarkerObjectNameInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDebugMarkerObjectNameInfoEXT* toMap);
+void handlemap_VkDebugMarkerObjectNameInfoEXT(VulkanHandleMapping* handlemap,
+ VkDebugMarkerObjectNameInfoEXT* toMap);
-void handlemap_VkDebugMarkerObjectTagInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDebugMarkerObjectTagInfoEXT* toMap);
+void handlemap_VkDebugMarkerObjectTagInfoEXT(VulkanHandleMapping* handlemap,
+ VkDebugMarkerObjectTagInfoEXT* toMap);
-void handlemap_VkDebugMarkerMarkerInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDebugMarkerMarkerInfoEXT* toMap);
+void handlemap_VkDebugMarkerMarkerInfoEXT(VulkanHandleMapping* handlemap,
+ VkDebugMarkerMarkerInfoEXT* toMap);
#endif
#ifdef VK_AMD_gcn_shader
#endif
#ifdef VK_NV_dedicated_allocation
void handlemap_VkDedicatedAllocationImageCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkDedicatedAllocationImageCreateInfoNV* toMap);
+ VulkanHandleMapping* handlemap, VkDedicatedAllocationImageCreateInfoNV* toMap);
void handlemap_VkDedicatedAllocationBufferCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkDedicatedAllocationBufferCreateInfoNV* toMap);
+ VulkanHandleMapping* handlemap, VkDedicatedAllocationBufferCreateInfoNV* toMap);
void handlemap_VkDedicatedAllocationMemoryAllocateInfoNV(
- VulkanHandleMapping* handlemap,
- VkDedicatedAllocationMemoryAllocateInfoNV* toMap);
+ VulkanHandleMapping* handlemap, VkDedicatedAllocationMemoryAllocateInfoNV* toMap);
#endif
#ifdef VK_EXT_transform_feedback
void handlemap_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceTransformFeedbackFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceTransformFeedbackFeaturesEXT* toMap);
void handlemap_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceTransformFeedbackPropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceTransformFeedbackPropertiesEXT* toMap);
void handlemap_VkPipelineRasterizationStateStreamCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineRasterizationStateStreamCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineRasterizationStateStreamCreateInfoEXT* toMap);
#endif
#ifdef VK_NVX_binary_import
-void handlemap_VkCuModuleCreateInfoNVX(
- VulkanHandleMapping* handlemap,
- VkCuModuleCreateInfoNVX* toMap);
+void handlemap_VkCuModuleCreateInfoNVX(VulkanHandleMapping* handlemap,
+ VkCuModuleCreateInfoNVX* toMap);
-void handlemap_VkCuFunctionCreateInfoNVX(
- VulkanHandleMapping* handlemap,
- VkCuFunctionCreateInfoNVX* toMap);
+void handlemap_VkCuFunctionCreateInfoNVX(VulkanHandleMapping* handlemap,
+ VkCuFunctionCreateInfoNVX* toMap);
-void handlemap_VkCuLaunchInfoNVX(
- VulkanHandleMapping* handlemap,
- VkCuLaunchInfoNVX* toMap);
+void handlemap_VkCuLaunchInfoNVX(VulkanHandleMapping* handlemap, VkCuLaunchInfoNVX* toMap);
#endif
#ifdef VK_NVX_image_view_handle
-void handlemap_VkImageViewHandleInfoNVX(
- VulkanHandleMapping* handlemap,
- VkImageViewHandleInfoNVX* toMap);
+void handlemap_VkImageViewHandleInfoNVX(VulkanHandleMapping* handlemap,
+ VkImageViewHandleInfoNVX* toMap);
-void handlemap_VkImageViewAddressPropertiesNVX(
- VulkanHandleMapping* handlemap,
- VkImageViewAddressPropertiesNVX* toMap);
+void handlemap_VkImageViewAddressPropertiesNVX(VulkanHandleMapping* handlemap,
+ VkImageViewAddressPropertiesNVX* toMap);
#endif
#ifdef VK_AMD_draw_indirect_count
@@ -2023,193 +1614,152 @@
#ifdef VK_AMD_shader_ballot
#endif
#ifdef VK_EXT_video_encode_h264
-void handlemap_VkVideoEncodeH264CapabilitiesEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH264CapabilitiesEXT* toMap);
+void handlemap_VkVideoEncodeH264CapabilitiesEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH264CapabilitiesEXT* toMap);
-void handlemap_VkVideoEncodeH264SessionCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH264SessionCreateInfoEXT* toMap);
+void handlemap_VkVideoEncodeH264SessionCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH264SessionCreateInfoEXT* toMap);
void handlemap_VkVideoEncodeH264SessionParametersAddInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH264SessionParametersAddInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkVideoEncodeH264SessionParametersAddInfoEXT* toMap);
void handlemap_VkVideoEncodeH264SessionParametersCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH264SessionParametersCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkVideoEncodeH264SessionParametersCreateInfoEXT* toMap);
-void handlemap_VkVideoEncodeH264DpbSlotInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH264DpbSlotInfoEXT* toMap);
+void handlemap_VkVideoEncodeH264DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH264DpbSlotInfoEXT* toMap);
-void handlemap_VkVideoEncodeH264NaluSliceEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH264NaluSliceEXT* toMap);
+void handlemap_VkVideoEncodeH264NaluSliceEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH264NaluSliceEXT* toMap);
-void handlemap_VkVideoEncodeH264VclFrameInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH264VclFrameInfoEXT* toMap);
+void handlemap_VkVideoEncodeH264VclFrameInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH264VclFrameInfoEXT* toMap);
void handlemap_VkVideoEncodeH264EmitPictureParametersEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH264EmitPictureParametersEXT* toMap);
+ VulkanHandleMapping* handlemap, VkVideoEncodeH264EmitPictureParametersEXT* toMap);
-void handlemap_VkVideoEncodeH264ProfileEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH264ProfileEXT* toMap);
+void handlemap_VkVideoEncodeH264ProfileEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH264ProfileEXT* toMap);
#endif
#ifdef VK_EXT_video_encode_h265
-void handlemap_VkVideoEncodeH265CapabilitiesEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH265CapabilitiesEXT* toMap);
+void handlemap_VkVideoEncodeH265CapabilitiesEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH265CapabilitiesEXT* toMap);
-void handlemap_VkVideoEncodeH265SessionCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH265SessionCreateInfoEXT* toMap);
+void handlemap_VkVideoEncodeH265SessionCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH265SessionCreateInfoEXT* toMap);
void handlemap_VkVideoEncodeH265SessionParametersAddInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH265SessionParametersAddInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkVideoEncodeH265SessionParametersAddInfoEXT* toMap);
void handlemap_VkVideoEncodeH265SessionParametersCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH265SessionParametersCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkVideoEncodeH265SessionParametersCreateInfoEXT* toMap);
-void handlemap_VkVideoEncodeH265DpbSlotInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH265DpbSlotInfoEXT* toMap);
+void handlemap_VkVideoEncodeH265DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH265DpbSlotInfoEXT* toMap);
-void handlemap_VkVideoEncodeH265ReferenceListsEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH265ReferenceListsEXT* toMap);
+void handlemap_VkVideoEncodeH265ReferenceListsEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH265ReferenceListsEXT* toMap);
-void handlemap_VkVideoEncodeH265NaluSliceEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH265NaluSliceEXT* toMap);
+void handlemap_VkVideoEncodeH265NaluSliceEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH265NaluSliceEXT* toMap);
-void handlemap_VkVideoEncodeH265VclFrameInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH265VclFrameInfoEXT* toMap);
+void handlemap_VkVideoEncodeH265VclFrameInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH265VclFrameInfoEXT* toMap);
void handlemap_VkVideoEncodeH265EmitPictureParametersEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH265EmitPictureParametersEXT* toMap);
+ VulkanHandleMapping* handlemap, VkVideoEncodeH265EmitPictureParametersEXT* toMap);
-void handlemap_VkVideoEncodeH265ProfileEXT(
- VulkanHandleMapping* handlemap,
- VkVideoEncodeH265ProfileEXT* toMap);
+void handlemap_VkVideoEncodeH265ProfileEXT(VulkanHandleMapping* handlemap,
+ VkVideoEncodeH265ProfileEXT* toMap);
#endif
#ifdef VK_EXT_video_decode_h264
-void handlemap_VkVideoDecodeH264ProfileEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH264ProfileEXT* toMap);
+void handlemap_VkVideoDecodeH264ProfileEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH264ProfileEXT* toMap);
-void handlemap_VkVideoDecodeH264CapabilitiesEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH264CapabilitiesEXT* toMap);
+void handlemap_VkVideoDecodeH264CapabilitiesEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH264CapabilitiesEXT* toMap);
-void handlemap_VkVideoDecodeH264SessionCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH264SessionCreateInfoEXT* toMap);
+void handlemap_VkVideoDecodeH264SessionCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH264SessionCreateInfoEXT* toMap);
void handlemap_VkVideoDecodeH264SessionParametersAddInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH264SessionParametersAddInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkVideoDecodeH264SessionParametersAddInfoEXT* toMap);
void handlemap_VkVideoDecodeH264SessionParametersCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH264SessionParametersCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkVideoDecodeH264SessionParametersCreateInfoEXT* toMap);
-void handlemap_VkVideoDecodeH264PictureInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH264PictureInfoEXT* toMap);
+void handlemap_VkVideoDecodeH264PictureInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH264PictureInfoEXT* toMap);
-void handlemap_VkVideoDecodeH264MvcEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH264MvcEXT* toMap);
+void handlemap_VkVideoDecodeH264MvcEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH264MvcEXT* toMap);
-void handlemap_VkVideoDecodeH264DpbSlotInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH264DpbSlotInfoEXT* toMap);
+void handlemap_VkVideoDecodeH264DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH264DpbSlotInfoEXT* toMap);
#endif
#ifdef VK_AMD_texture_gather_bias_lod
-void handlemap_VkTextureLODGatherFormatPropertiesAMD(
- VulkanHandleMapping* handlemap,
- VkTextureLODGatherFormatPropertiesAMD* toMap);
+void handlemap_VkTextureLODGatherFormatPropertiesAMD(VulkanHandleMapping* handlemap,
+ VkTextureLODGatherFormatPropertiesAMD* toMap);
#endif
#ifdef VK_AMD_shader_info
-void handlemap_VkShaderResourceUsageAMD(
- VulkanHandleMapping* handlemap,
- VkShaderResourceUsageAMD* toMap);
+void handlemap_VkShaderResourceUsageAMD(VulkanHandleMapping* handlemap,
+ VkShaderResourceUsageAMD* toMap);
-void handlemap_VkShaderStatisticsInfoAMD(
- VulkanHandleMapping* handlemap,
- VkShaderStatisticsInfoAMD* toMap);
+void handlemap_VkShaderStatisticsInfoAMD(VulkanHandleMapping* handlemap,
+ VkShaderStatisticsInfoAMD* toMap);
#endif
#ifdef VK_AMD_shader_image_load_store_lod
#endif
#ifdef VK_GGP_stream_descriptor_surface
void handlemap_VkStreamDescriptorSurfaceCreateInfoGGP(
- VulkanHandleMapping* handlemap,
- VkStreamDescriptorSurfaceCreateInfoGGP* toMap);
+ VulkanHandleMapping* handlemap, VkStreamDescriptorSurfaceCreateInfoGGP* toMap);
#endif
#ifdef VK_NV_corner_sampled_image
void handlemap_VkPhysicalDeviceCornerSampledImageFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceCornerSampledImageFeaturesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceCornerSampledImageFeaturesNV* toMap);
#endif
#ifdef VK_IMG_format_pvrtc
#endif
#ifdef VK_NV_external_memory_capabilities
-void handlemap_VkExternalImageFormatPropertiesNV(
- VulkanHandleMapping* handlemap,
- VkExternalImageFormatPropertiesNV* toMap);
+void handlemap_VkExternalImageFormatPropertiesNV(VulkanHandleMapping* handlemap,
+ VkExternalImageFormatPropertiesNV* toMap);
#endif
#ifdef VK_NV_external_memory
-void handlemap_VkExternalMemoryImageCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkExternalMemoryImageCreateInfoNV* toMap);
+void handlemap_VkExternalMemoryImageCreateInfoNV(VulkanHandleMapping* handlemap,
+ VkExternalMemoryImageCreateInfoNV* toMap);
-void handlemap_VkExportMemoryAllocateInfoNV(
- VulkanHandleMapping* handlemap,
- VkExportMemoryAllocateInfoNV* toMap);
+void handlemap_VkExportMemoryAllocateInfoNV(VulkanHandleMapping* handlemap,
+ VkExportMemoryAllocateInfoNV* toMap);
#endif
#ifdef VK_NV_external_memory_win32
-void handlemap_VkImportMemoryWin32HandleInfoNV(
- VulkanHandleMapping* handlemap,
- VkImportMemoryWin32HandleInfoNV* toMap);
+void handlemap_VkImportMemoryWin32HandleInfoNV(VulkanHandleMapping* handlemap,
+ VkImportMemoryWin32HandleInfoNV* toMap);
-void handlemap_VkExportMemoryWin32HandleInfoNV(
- VulkanHandleMapping* handlemap,
- VkExportMemoryWin32HandleInfoNV* toMap);
+void handlemap_VkExportMemoryWin32HandleInfoNV(VulkanHandleMapping* handlemap,
+ VkExportMemoryWin32HandleInfoNV* toMap);
#endif
#ifdef VK_NV_win32_keyed_mutex
-void handlemap_VkWin32KeyedMutexAcquireReleaseInfoNV(
- VulkanHandleMapping* handlemap,
- VkWin32KeyedMutexAcquireReleaseInfoNV* toMap);
+void handlemap_VkWin32KeyedMutexAcquireReleaseInfoNV(VulkanHandleMapping* handlemap,
+ VkWin32KeyedMutexAcquireReleaseInfoNV* toMap);
#endif
#ifdef VK_EXT_validation_flags
-void handlemap_VkValidationFlagsEXT(
- VulkanHandleMapping* handlemap,
- VkValidationFlagsEXT* toMap);
+void handlemap_VkValidationFlagsEXT(VulkanHandleMapping* handlemap, VkValidationFlagsEXT* toMap);
#endif
#ifdef VK_NN_vi_surface
-void handlemap_VkViSurfaceCreateInfoNN(
- VulkanHandleMapping* handlemap,
- VkViSurfaceCreateInfoNN* toMap);
+void handlemap_VkViSurfaceCreateInfoNN(VulkanHandleMapping* handlemap,
+ VkViSurfaceCreateInfoNN* toMap);
#endif
#ifdef VK_EXT_shader_subgroup_ballot
@@ -2218,42 +1768,33 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
void handlemap_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toMap);
#endif
#ifdef VK_EXT_astc_decode_mode
-void handlemap_VkImageViewASTCDecodeModeEXT(
- VulkanHandleMapping* handlemap,
- VkImageViewASTCDecodeModeEXT* toMap);
+void handlemap_VkImageViewASTCDecodeModeEXT(VulkanHandleMapping* handlemap,
+ VkImageViewASTCDecodeModeEXT* toMap);
-void handlemap_VkPhysicalDeviceASTCDecodeFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceASTCDecodeFeaturesEXT* toMap);
+void handlemap_VkPhysicalDeviceASTCDecodeFeaturesEXT(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceASTCDecodeFeaturesEXT* toMap);
#endif
#ifdef VK_EXT_conditional_rendering
-void handlemap_VkConditionalRenderingBeginInfoEXT(
- VulkanHandleMapping* handlemap,
- VkConditionalRenderingBeginInfoEXT* toMap);
+void handlemap_VkConditionalRenderingBeginInfoEXT(VulkanHandleMapping* handlemap,
+ VkConditionalRenderingBeginInfoEXT* toMap);
void handlemap_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceConditionalRenderingFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceConditionalRenderingFeaturesEXT* toMap);
void handlemap_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
- VulkanHandleMapping* handlemap,
- VkCommandBufferInheritanceConditionalRenderingInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkCommandBufferInheritanceConditionalRenderingInfoEXT* toMap);
#endif
#ifdef VK_NV_clip_space_w_scaling
-void handlemap_VkViewportWScalingNV(
- VulkanHandleMapping* handlemap,
- VkViewportWScalingNV* toMap);
+void handlemap_VkViewportWScalingNV(VulkanHandleMapping* handlemap, VkViewportWScalingNV* toMap);
void handlemap_VkPipelineViewportWScalingStateCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkPipelineViewportWScalingStateCreateInfoNV* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineViewportWScalingStateCreateInfoNV* toMap);
#endif
#ifdef VK_EXT_direct_mode_display
@@ -2261,45 +1802,32 @@
#ifdef VK_EXT_acquire_xlib_display
#endif
#ifdef VK_EXT_display_surface_counter
-void handlemap_VkSurfaceCapabilities2EXT(
- VulkanHandleMapping* handlemap,
- VkSurfaceCapabilities2EXT* toMap);
+void handlemap_VkSurfaceCapabilities2EXT(VulkanHandleMapping* handlemap,
+ VkSurfaceCapabilities2EXT* toMap);
#endif
#ifdef VK_EXT_display_control
-void handlemap_VkDisplayPowerInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDisplayPowerInfoEXT* toMap);
+void handlemap_VkDisplayPowerInfoEXT(VulkanHandleMapping* handlemap, VkDisplayPowerInfoEXT* toMap);
-void handlemap_VkDeviceEventInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDeviceEventInfoEXT* toMap);
+void handlemap_VkDeviceEventInfoEXT(VulkanHandleMapping* handlemap, VkDeviceEventInfoEXT* toMap);
-void handlemap_VkDisplayEventInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDisplayEventInfoEXT* toMap);
+void handlemap_VkDisplayEventInfoEXT(VulkanHandleMapping* handlemap, VkDisplayEventInfoEXT* toMap);
-void handlemap_VkSwapchainCounterCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkSwapchainCounterCreateInfoEXT* toMap);
+void handlemap_VkSwapchainCounterCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkSwapchainCounterCreateInfoEXT* toMap);
#endif
#ifdef VK_GOOGLE_display_timing
-void handlemap_VkRefreshCycleDurationGOOGLE(
- VulkanHandleMapping* handlemap,
- VkRefreshCycleDurationGOOGLE* toMap);
+void handlemap_VkRefreshCycleDurationGOOGLE(VulkanHandleMapping* handlemap,
+ VkRefreshCycleDurationGOOGLE* toMap);
-void handlemap_VkPastPresentationTimingGOOGLE(
- VulkanHandleMapping* handlemap,
- VkPastPresentationTimingGOOGLE* toMap);
+void handlemap_VkPastPresentationTimingGOOGLE(VulkanHandleMapping* handlemap,
+ VkPastPresentationTimingGOOGLE* toMap);
-void handlemap_VkPresentTimeGOOGLE(
- VulkanHandleMapping* handlemap,
- VkPresentTimeGOOGLE* toMap);
+void handlemap_VkPresentTimeGOOGLE(VulkanHandleMapping* handlemap, VkPresentTimeGOOGLE* toMap);
-void handlemap_VkPresentTimesInfoGOOGLE(
- VulkanHandleMapping* handlemap,
- VkPresentTimesInfoGOOGLE* toMap);
+void handlemap_VkPresentTimesInfoGOOGLE(VulkanHandleMapping* handlemap,
+ VkPresentTimesInfoGOOGLE* toMap);
#endif
#ifdef VK_NV_sample_mask_override_coverage
@@ -2310,72 +1838,56 @@
#endif
#ifdef VK_NVX_multiview_per_view_attributes
void handlemap_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toMap);
#endif
#ifdef VK_NV_viewport_swizzle
-void handlemap_VkViewportSwizzleNV(
- VulkanHandleMapping* handlemap,
- VkViewportSwizzleNV* toMap);
+void handlemap_VkViewportSwizzleNV(VulkanHandleMapping* handlemap, VkViewportSwizzleNV* toMap);
void handlemap_VkPipelineViewportSwizzleStateCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkPipelineViewportSwizzleStateCreateInfoNV* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineViewportSwizzleStateCreateInfoNV* toMap);
#endif
#ifdef VK_EXT_discard_rectangles
void handlemap_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDiscardRectanglePropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDiscardRectanglePropertiesEXT* toMap);
void handlemap_VkPipelineDiscardRectangleStateCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineDiscardRectangleStateCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineDiscardRectangleStateCreateInfoEXT* toMap);
#endif
#ifdef VK_EXT_conservative_rasterization
void handlemap_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceConservativeRasterizationPropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceConservativeRasterizationPropertiesEXT* toMap);
void handlemap_VkPipelineRasterizationConservativeStateCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineRasterizationConservativeStateCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineRasterizationConservativeStateCreateInfoEXT* toMap);
#endif
#ifdef VK_EXT_depth_clip_enable
void handlemap_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDepthClipEnableFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDepthClipEnableFeaturesEXT* toMap);
void handlemap_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineRasterizationDepthClipStateCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineRasterizationDepthClipStateCreateInfoEXT* toMap);
#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
-void handlemap_VkXYColorEXT(
- VulkanHandleMapping* handlemap,
- VkXYColorEXT* toMap);
+void handlemap_VkXYColorEXT(VulkanHandleMapping* handlemap, VkXYColorEXT* toMap);
-void handlemap_VkHdrMetadataEXT(
- VulkanHandleMapping* handlemap,
- VkHdrMetadataEXT* toMap);
+void handlemap_VkHdrMetadataEXT(VulkanHandleMapping* handlemap, VkHdrMetadataEXT* toMap);
#endif
#ifdef VK_MVK_ios_surface
-void handlemap_VkIOSSurfaceCreateInfoMVK(
- VulkanHandleMapping* handlemap,
- VkIOSSurfaceCreateInfoMVK* toMap);
+void handlemap_VkIOSSurfaceCreateInfoMVK(VulkanHandleMapping* handlemap,
+ VkIOSSurfaceCreateInfoMVK* toMap);
#endif
#ifdef VK_MVK_macos_surface
-void handlemap_VkMacOSSurfaceCreateInfoMVK(
- VulkanHandleMapping* handlemap,
- VkMacOSSurfaceCreateInfoMVK* toMap);
+void handlemap_VkMacOSSurfaceCreateInfoMVK(VulkanHandleMapping* handlemap,
+ VkMacOSSurfaceCreateInfoMVK* toMap);
#endif
#ifdef VK_MVK_moltenvk
@@ -2385,61 +1897,50 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
-void handlemap_VkDebugUtilsLabelEXT(
- VulkanHandleMapping* handlemap,
- VkDebugUtilsLabelEXT* toMap);
+void handlemap_VkDebugUtilsLabelEXT(VulkanHandleMapping* handlemap, VkDebugUtilsLabelEXT* toMap);
-void handlemap_VkDebugUtilsObjectNameInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDebugUtilsObjectNameInfoEXT* toMap);
+void handlemap_VkDebugUtilsObjectNameInfoEXT(VulkanHandleMapping* handlemap,
+ VkDebugUtilsObjectNameInfoEXT* toMap);
-void handlemap_VkDebugUtilsMessengerCallbackDataEXT(
- VulkanHandleMapping* handlemap,
- VkDebugUtilsMessengerCallbackDataEXT* toMap);
+void handlemap_VkDebugUtilsMessengerCallbackDataEXT(VulkanHandleMapping* handlemap,
+ VkDebugUtilsMessengerCallbackDataEXT* toMap);
-void handlemap_VkDebugUtilsMessengerCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDebugUtilsMessengerCreateInfoEXT* toMap);
+void handlemap_VkDebugUtilsMessengerCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkDebugUtilsMessengerCreateInfoEXT* toMap);
-void handlemap_VkDebugUtilsObjectTagInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDebugUtilsObjectTagInfoEXT* toMap);
+void handlemap_VkDebugUtilsObjectTagInfoEXT(VulkanHandleMapping* handlemap,
+ VkDebugUtilsObjectTagInfoEXT* toMap);
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
-void handlemap_VkAndroidHardwareBufferUsageANDROID(
- VulkanHandleMapping* handlemap,
- VkAndroidHardwareBufferUsageANDROID* toMap);
+void handlemap_VkAndroidHardwareBufferUsageANDROID(VulkanHandleMapping* handlemap,
+ VkAndroidHardwareBufferUsageANDROID* toMap);
void handlemap_VkAndroidHardwareBufferPropertiesANDROID(
- VulkanHandleMapping* handlemap,
- VkAndroidHardwareBufferPropertiesANDROID* toMap);
+ VulkanHandleMapping* handlemap, VkAndroidHardwareBufferPropertiesANDROID* toMap);
void handlemap_VkAndroidHardwareBufferFormatPropertiesANDROID(
- VulkanHandleMapping* handlemap,
- VkAndroidHardwareBufferFormatPropertiesANDROID* toMap);
+ VulkanHandleMapping* handlemap, VkAndroidHardwareBufferFormatPropertiesANDROID* toMap);
void handlemap_VkImportAndroidHardwareBufferInfoANDROID(
- VulkanHandleMapping* handlemap,
- VkImportAndroidHardwareBufferInfoANDROID* toMap);
+ VulkanHandleMapping* handlemap, VkImportAndroidHardwareBufferInfoANDROID* toMap);
void handlemap_VkMemoryGetAndroidHardwareBufferInfoANDROID(
- VulkanHandleMapping* handlemap,
- VkMemoryGetAndroidHardwareBufferInfoANDROID* toMap);
+ VulkanHandleMapping* handlemap, VkMemoryGetAndroidHardwareBufferInfoANDROID* toMap);
-void handlemap_VkExternalFormatANDROID(
- VulkanHandleMapping* handlemap,
- VkExternalFormatANDROID* toMap);
+void handlemap_VkExternalFormatANDROID(VulkanHandleMapping* handlemap,
+ VkExternalFormatANDROID* toMap);
void handlemap_VkAndroidHardwareBufferFormatProperties2ANDROID(
- VulkanHandleMapping* handlemap,
- VkAndroidHardwareBufferFormatProperties2ANDROID* toMap);
+ VulkanHandleMapping* handlemap, VkAndroidHardwareBufferFormatProperties2ANDROID* toMap);
#endif
#ifdef VK_EXT_sampler_filter_minmax
-DEFINE_ALIAS_FUNCTION(handlemap_VkSamplerReductionModeCreateInfo, handlemap_VkSamplerReductionModeCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(handlemap_VkSamplerReductionModeCreateInfo,
+ handlemap_VkSamplerReductionModeCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceSamplerFilterMinmaxProperties, handlemap_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceSamplerFilterMinmaxProperties,
+ handlemap_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT)
#endif
#ifdef VK_AMD_gpu_shader_int16
@@ -2450,526 +1951,422 @@
#endif
#ifdef VK_EXT_inline_uniform_block
void handlemap_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toMap);
void handlemap_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toMap);
void handlemap_VkWriteDescriptorSetInlineUniformBlockEXT(
- VulkanHandleMapping* handlemap,
- VkWriteDescriptorSetInlineUniformBlockEXT* toMap);
+ VulkanHandleMapping* handlemap, VkWriteDescriptorSetInlineUniformBlockEXT* toMap);
void handlemap_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toMap);
#endif
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
-void handlemap_VkSampleLocationEXT(
- VulkanHandleMapping* handlemap,
- VkSampleLocationEXT* toMap);
+void handlemap_VkSampleLocationEXT(VulkanHandleMapping* handlemap, VkSampleLocationEXT* toMap);
-void handlemap_VkSampleLocationsInfoEXT(
- VulkanHandleMapping* handlemap,
- VkSampleLocationsInfoEXT* toMap);
+void handlemap_VkSampleLocationsInfoEXT(VulkanHandleMapping* handlemap,
+ VkSampleLocationsInfoEXT* toMap);
-void handlemap_VkAttachmentSampleLocationsEXT(
- VulkanHandleMapping* handlemap,
- VkAttachmentSampleLocationsEXT* toMap);
+void handlemap_VkAttachmentSampleLocationsEXT(VulkanHandleMapping* handlemap,
+ VkAttachmentSampleLocationsEXT* toMap);
-void handlemap_VkSubpassSampleLocationsEXT(
- VulkanHandleMapping* handlemap,
- VkSubpassSampleLocationsEXT* toMap);
+void handlemap_VkSubpassSampleLocationsEXT(VulkanHandleMapping* handlemap,
+ VkSubpassSampleLocationsEXT* toMap);
void handlemap_VkRenderPassSampleLocationsBeginInfoEXT(
- VulkanHandleMapping* handlemap,
- VkRenderPassSampleLocationsBeginInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkRenderPassSampleLocationsBeginInfoEXT* toMap);
void handlemap_VkPipelineSampleLocationsStateCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineSampleLocationsStateCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineSampleLocationsStateCreateInfoEXT* toMap);
void handlemap_VkPhysicalDeviceSampleLocationsPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSampleLocationsPropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceSampleLocationsPropertiesEXT* toMap);
-void handlemap_VkMultisamplePropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkMultisamplePropertiesEXT* toMap);
+void handlemap_VkMultisamplePropertiesEXT(VulkanHandleMapping* handlemap,
+ VkMultisamplePropertiesEXT* toMap);
#endif
#ifdef VK_EXT_blend_operation_advanced
void handlemap_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* toMap);
void handlemap_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toMap);
void handlemap_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineColorBlendAdvancedStateCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineColorBlendAdvancedStateCreateInfoEXT* toMap);
#endif
#ifdef VK_NV_fragment_coverage_to_color
void handlemap_VkPipelineCoverageToColorStateCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkPipelineCoverageToColorStateCreateInfoNV* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineCoverageToColorStateCreateInfoNV* toMap);
#endif
#ifdef VK_NV_framebuffer_mixed_samples
void handlemap_VkPipelineCoverageModulationStateCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkPipelineCoverageModulationStateCreateInfoNV* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineCoverageModulationStateCreateInfoNV* toMap);
#endif
#ifdef VK_NV_fill_rectangle
#endif
#ifdef VK_NV_shader_sm_builtins
void handlemap_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* toMap);
void handlemap_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* toMap);
#endif
#ifdef VK_EXT_post_depth_coverage
#endif
#ifdef VK_EXT_image_drm_format_modifier
-void handlemap_VkDrmFormatModifierPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkDrmFormatModifierPropertiesEXT* toMap);
+void handlemap_VkDrmFormatModifierPropertiesEXT(VulkanHandleMapping* handlemap,
+ VkDrmFormatModifierPropertiesEXT* toMap);
-void handlemap_VkDrmFormatModifierPropertiesListEXT(
- VulkanHandleMapping* handlemap,
- VkDrmFormatModifierPropertiesListEXT* toMap);
+void handlemap_VkDrmFormatModifierPropertiesListEXT(VulkanHandleMapping* handlemap,
+ VkDrmFormatModifierPropertiesListEXT* toMap);
void handlemap_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceImageDrmFormatModifierInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceImageDrmFormatModifierInfoEXT* toMap);
void handlemap_VkImageDrmFormatModifierListCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkImageDrmFormatModifierListCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkImageDrmFormatModifierListCreateInfoEXT* toMap);
void handlemap_VkImageDrmFormatModifierExplicitCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkImageDrmFormatModifierExplicitCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkImageDrmFormatModifierExplicitCreateInfoEXT* toMap);
-void handlemap_VkImageDrmFormatModifierPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkImageDrmFormatModifierPropertiesEXT* toMap);
+void handlemap_VkImageDrmFormatModifierPropertiesEXT(VulkanHandleMapping* handlemap,
+ VkImageDrmFormatModifierPropertiesEXT* toMap);
-void handlemap_VkDrmFormatModifierProperties2EXT(
- VulkanHandleMapping* handlemap,
- VkDrmFormatModifierProperties2EXT* toMap);
+void handlemap_VkDrmFormatModifierProperties2EXT(VulkanHandleMapping* handlemap,
+ VkDrmFormatModifierProperties2EXT* toMap);
-void handlemap_VkDrmFormatModifierPropertiesList2EXT(
- VulkanHandleMapping* handlemap,
- VkDrmFormatModifierPropertiesList2EXT* toMap);
+void handlemap_VkDrmFormatModifierPropertiesList2EXT(VulkanHandleMapping* handlemap,
+ VkDrmFormatModifierPropertiesList2EXT* toMap);
#endif
#ifdef VK_EXT_validation_cache
-void handlemap_VkValidationCacheCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkValidationCacheCreateInfoEXT* toMap);
+void handlemap_VkValidationCacheCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkValidationCacheCreateInfoEXT* toMap);
void handlemap_VkShaderModuleValidationCacheCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkShaderModuleValidationCacheCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkShaderModuleValidationCacheCreateInfoEXT* toMap);
#endif
#ifdef VK_EXT_descriptor_indexing
-DEFINE_ALIAS_FUNCTION(handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfo, handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfo,
+ handlemap_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceDescriptorIndexingFeatures, handlemap_VkPhysicalDeviceDescriptorIndexingFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceDescriptorIndexingFeatures,
+ handlemap_VkPhysicalDeviceDescriptorIndexingFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceDescriptorIndexingProperties, handlemap_VkPhysicalDeviceDescriptorIndexingPropertiesEXT)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceDescriptorIndexingProperties,
+ handlemap_VkPhysicalDeviceDescriptorIndexingPropertiesEXT)
-DEFINE_ALIAS_FUNCTION(handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfo, handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT)
+DEFINE_ALIAS_FUNCTION(handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfo,
+ handlemap_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT)
-DEFINE_ALIAS_FUNCTION(handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupport, handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT)
+DEFINE_ALIAS_FUNCTION(handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupport,
+ handlemap_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT)
#endif
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_NV_shading_rate_image
-void handlemap_VkShadingRatePaletteNV(
- VulkanHandleMapping* handlemap,
- VkShadingRatePaletteNV* toMap);
+void handlemap_VkShadingRatePaletteNV(VulkanHandleMapping* handlemap,
+ VkShadingRatePaletteNV* toMap);
void handlemap_VkPipelineViewportShadingRateImageStateCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkPipelineViewportShadingRateImageStateCreateInfoNV* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineViewportShadingRateImageStateCreateInfoNV* toMap);
void handlemap_VkPhysicalDeviceShadingRateImageFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShadingRateImageFeaturesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShadingRateImageFeaturesNV* toMap);
void handlemap_VkPhysicalDeviceShadingRateImagePropertiesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShadingRateImagePropertiesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShadingRateImagePropertiesNV* toMap);
-void handlemap_VkCoarseSampleLocationNV(
- VulkanHandleMapping* handlemap,
- VkCoarseSampleLocationNV* toMap);
+void handlemap_VkCoarseSampleLocationNV(VulkanHandleMapping* handlemap,
+ VkCoarseSampleLocationNV* toMap);
-void handlemap_VkCoarseSampleOrderCustomNV(
- VulkanHandleMapping* handlemap,
- VkCoarseSampleOrderCustomNV* toMap);
+void handlemap_VkCoarseSampleOrderCustomNV(VulkanHandleMapping* handlemap,
+ VkCoarseSampleOrderCustomNV* toMap);
void handlemap_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* toMap);
#endif
#ifdef VK_NV_ray_tracing
-void handlemap_VkRayTracingShaderGroupCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkRayTracingShaderGroupCreateInfoNV* toMap);
+void handlemap_VkRayTracingShaderGroupCreateInfoNV(VulkanHandleMapping* handlemap,
+ VkRayTracingShaderGroupCreateInfoNV* toMap);
-void handlemap_VkRayTracingPipelineCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkRayTracingPipelineCreateInfoNV* toMap);
+void handlemap_VkRayTracingPipelineCreateInfoNV(VulkanHandleMapping* handlemap,
+ VkRayTracingPipelineCreateInfoNV* toMap);
-void handlemap_VkGeometryTrianglesNV(
- VulkanHandleMapping* handlemap,
- VkGeometryTrianglesNV* toMap);
+void handlemap_VkGeometryTrianglesNV(VulkanHandleMapping* handlemap, VkGeometryTrianglesNV* toMap);
-void handlemap_VkGeometryAABBNV(
- VulkanHandleMapping* handlemap,
- VkGeometryAABBNV* toMap);
+void handlemap_VkGeometryAABBNV(VulkanHandleMapping* handlemap, VkGeometryAABBNV* toMap);
-void handlemap_VkGeometryDataNV(
- VulkanHandleMapping* handlemap,
- VkGeometryDataNV* toMap);
+void handlemap_VkGeometryDataNV(VulkanHandleMapping* handlemap, VkGeometryDataNV* toMap);
-void handlemap_VkGeometryNV(
- VulkanHandleMapping* handlemap,
- VkGeometryNV* toMap);
+void handlemap_VkGeometryNV(VulkanHandleMapping* handlemap, VkGeometryNV* toMap);
-void handlemap_VkAccelerationStructureInfoNV(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureInfoNV* toMap);
+void handlemap_VkAccelerationStructureInfoNV(VulkanHandleMapping* handlemap,
+ VkAccelerationStructureInfoNV* toMap);
-void handlemap_VkAccelerationStructureCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureCreateInfoNV* toMap);
+void handlemap_VkAccelerationStructureCreateInfoNV(VulkanHandleMapping* handlemap,
+ VkAccelerationStructureCreateInfoNV* toMap);
void handlemap_VkBindAccelerationStructureMemoryInfoNV(
- VulkanHandleMapping* handlemap,
- VkBindAccelerationStructureMemoryInfoNV* toMap);
+ VulkanHandleMapping* handlemap, VkBindAccelerationStructureMemoryInfoNV* toMap);
void handlemap_VkWriteDescriptorSetAccelerationStructureNV(
- VulkanHandleMapping* handlemap,
- VkWriteDescriptorSetAccelerationStructureNV* toMap);
+ VulkanHandleMapping* handlemap, VkWriteDescriptorSetAccelerationStructureNV* toMap);
void handlemap_VkAccelerationStructureMemoryRequirementsInfoNV(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureMemoryRequirementsInfoNV* toMap);
+ VulkanHandleMapping* handlemap, VkAccelerationStructureMemoryRequirementsInfoNV* toMap);
void handlemap_VkPhysicalDeviceRayTracingPropertiesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceRayTracingPropertiesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingPropertiesNV* toMap);
-void handlemap_VkTransformMatrixKHR(
- VulkanHandleMapping* handlemap,
- VkTransformMatrixKHR* toMap);
+void handlemap_VkTransformMatrixKHR(VulkanHandleMapping* handlemap, VkTransformMatrixKHR* toMap);
DEFINE_ALIAS_FUNCTION(handlemap_VkTransformMatrixKHR, handlemap_VkTransformMatrixNV)
-void handlemap_VkAabbPositionsKHR(
- VulkanHandleMapping* handlemap,
- VkAabbPositionsKHR* toMap);
+void handlemap_VkAabbPositionsKHR(VulkanHandleMapping* handlemap, VkAabbPositionsKHR* toMap);
DEFINE_ALIAS_FUNCTION(handlemap_VkAabbPositionsKHR, handlemap_VkAabbPositionsNV)
-void handlemap_VkAccelerationStructureInstanceKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureInstanceKHR* toMap);
+void handlemap_VkAccelerationStructureInstanceKHR(VulkanHandleMapping* handlemap,
+ VkAccelerationStructureInstanceKHR* toMap);
-DEFINE_ALIAS_FUNCTION(handlemap_VkAccelerationStructureInstanceKHR, handlemap_VkAccelerationStructureInstanceNV)
+DEFINE_ALIAS_FUNCTION(handlemap_VkAccelerationStructureInstanceKHR,
+ handlemap_VkAccelerationStructureInstanceNV)
#endif
#ifdef VK_NV_representative_fragment_test
void handlemap_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* toMap);
void handlemap_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkPipelineRepresentativeFragmentTestStateCreateInfoNV* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineRepresentativeFragmentTestStateCreateInfoNV* toMap);
#endif
#ifdef VK_EXT_filter_cubic
void handlemap_VkPhysicalDeviceImageViewImageFormatInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceImageViewImageFormatInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceImageViewImageFormatInfoEXT* toMap);
void handlemap_VkFilterCubicImageViewImageFormatPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkFilterCubicImageViewImageFormatPropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkFilterCubicImageViewImageFormatPropertiesEXT* toMap);
#endif
#ifdef VK_QCOM_render_pass_shader_resolve
#endif
#ifdef VK_EXT_global_priority
void handlemap_VkDeviceQueueGlobalPriorityCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDeviceQueueGlobalPriorityCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkDeviceQueueGlobalPriorityCreateInfoEXT* toMap);
#endif
#ifdef VK_EXT_external_memory_host
-void handlemap_VkImportMemoryHostPointerInfoEXT(
- VulkanHandleMapping* handlemap,
- VkImportMemoryHostPointerInfoEXT* toMap);
+void handlemap_VkImportMemoryHostPointerInfoEXT(VulkanHandleMapping* handlemap,
+ VkImportMemoryHostPointerInfoEXT* toMap);
-void handlemap_VkMemoryHostPointerPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkMemoryHostPointerPropertiesEXT* toMap);
+void handlemap_VkMemoryHostPointerPropertiesEXT(VulkanHandleMapping* handlemap,
+ VkMemoryHostPointerPropertiesEXT* toMap);
void handlemap_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toMap);
#endif
#ifdef VK_AMD_buffer_marker
#endif
#ifdef VK_AMD_pipeline_compiler_control
void handlemap_VkPipelineCompilerControlCreateInfoAMD(
- VulkanHandleMapping* handlemap,
- VkPipelineCompilerControlCreateInfoAMD* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineCompilerControlCreateInfoAMD* toMap);
#endif
#ifdef VK_EXT_calibrated_timestamps
-void handlemap_VkCalibratedTimestampInfoEXT(
- VulkanHandleMapping* handlemap,
- VkCalibratedTimestampInfoEXT* toMap);
+void handlemap_VkCalibratedTimestampInfoEXT(VulkanHandleMapping* handlemap,
+ VkCalibratedTimestampInfoEXT* toMap);
#endif
#ifdef VK_AMD_shader_core_properties
void handlemap_VkPhysicalDeviceShaderCorePropertiesAMD(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderCorePropertiesAMD* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderCorePropertiesAMD* toMap);
#endif
#ifdef VK_EXT_video_decode_h265
-void handlemap_VkVideoDecodeH265ProfileEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH265ProfileEXT* toMap);
+void handlemap_VkVideoDecodeH265ProfileEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH265ProfileEXT* toMap);
-void handlemap_VkVideoDecodeH265CapabilitiesEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH265CapabilitiesEXT* toMap);
+void handlemap_VkVideoDecodeH265CapabilitiesEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH265CapabilitiesEXT* toMap);
-void handlemap_VkVideoDecodeH265SessionCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH265SessionCreateInfoEXT* toMap);
+void handlemap_VkVideoDecodeH265SessionCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH265SessionCreateInfoEXT* toMap);
void handlemap_VkVideoDecodeH265SessionParametersAddInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH265SessionParametersAddInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkVideoDecodeH265SessionParametersAddInfoEXT* toMap);
void handlemap_VkVideoDecodeH265SessionParametersCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH265SessionParametersCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkVideoDecodeH265SessionParametersCreateInfoEXT* toMap);
-void handlemap_VkVideoDecodeH265PictureInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH265PictureInfoEXT* toMap);
+void handlemap_VkVideoDecodeH265PictureInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH265PictureInfoEXT* toMap);
-void handlemap_VkVideoDecodeH265DpbSlotInfoEXT(
- VulkanHandleMapping* handlemap,
- VkVideoDecodeH265DpbSlotInfoEXT* toMap);
+void handlemap_VkVideoDecodeH265DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
+ VkVideoDecodeH265DpbSlotInfoEXT* toMap);
#endif
#ifdef VK_AMD_memory_overallocation_behavior
void handlemap_VkDeviceMemoryOverallocationCreateInfoAMD(
- VulkanHandleMapping* handlemap,
- VkDeviceMemoryOverallocationCreateInfoAMD* toMap);
+ VulkanHandleMapping* handlemap, VkDeviceMemoryOverallocationCreateInfoAMD* toMap);
#endif
#ifdef VK_EXT_vertex_attribute_divisor
void handlemap_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toMap);
void handlemap_VkVertexInputBindingDivisorDescriptionEXT(
- VulkanHandleMapping* handlemap,
- VkVertexInputBindingDivisorDescriptionEXT* toMap);
+ VulkanHandleMapping* handlemap, VkVertexInputBindingDivisorDescriptionEXT* toMap);
void handlemap_VkPipelineVertexInputDivisorStateCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineVertexInputDivisorStateCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineVertexInputDivisorStateCreateInfoEXT* toMap);
void handlemap_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* toMap);
#endif
#ifdef VK_GGP_frame_token
-void handlemap_VkPresentFrameTokenGGP(
- VulkanHandleMapping* handlemap,
- VkPresentFrameTokenGGP* toMap);
+void handlemap_VkPresentFrameTokenGGP(VulkanHandleMapping* handlemap,
+ VkPresentFrameTokenGGP* toMap);
#endif
#ifdef VK_EXT_pipeline_creation_feedback
-void handlemap_VkPipelineCreationFeedbackEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineCreationFeedbackEXT* toMap);
+void handlemap_VkPipelineCreationFeedbackEXT(VulkanHandleMapping* handlemap,
+ VkPipelineCreationFeedbackEXT* toMap);
void handlemap_VkPipelineCreationFeedbackCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineCreationFeedbackCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineCreationFeedbackCreateInfoEXT* toMap);
#endif
#ifdef VK_NV_shader_subgroup_partitioned
#endif
#ifdef VK_NV_compute_shader_derivatives
void handlemap_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* toMap);
#endif
#ifdef VK_NV_mesh_shader
-void handlemap_VkPhysicalDeviceMeshShaderFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMeshShaderFeaturesNV* toMap);
+void handlemap_VkPhysicalDeviceMeshShaderFeaturesNV(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMeshShaderFeaturesNV* toMap);
void handlemap_VkPhysicalDeviceMeshShaderPropertiesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMeshShaderPropertiesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceMeshShaderPropertiesNV* toMap);
-void handlemap_VkDrawMeshTasksIndirectCommandNV(
- VulkanHandleMapping* handlemap,
- VkDrawMeshTasksIndirectCommandNV* toMap);
+void handlemap_VkDrawMeshTasksIndirectCommandNV(VulkanHandleMapping* handlemap,
+ VkDrawMeshTasksIndirectCommandNV* toMap);
#endif
#ifdef VK_NV_fragment_shader_barycentric
void handlemap_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toMap);
#endif
#ifdef VK_NV_shader_image_footprint
void handlemap_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderImageFootprintFeaturesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderImageFootprintFeaturesNV* toMap);
#endif
#ifdef VK_NV_scissor_exclusive
void handlemap_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkPipelineViewportExclusiveScissorStateCreateInfoNV* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineViewportExclusiveScissorStateCreateInfoNV* toMap);
void handlemap_VkPhysicalDeviceExclusiveScissorFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceExclusiveScissorFeaturesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceExclusiveScissorFeaturesNV* toMap);
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
-void handlemap_VkQueueFamilyCheckpointPropertiesNV(
- VulkanHandleMapping* handlemap,
- VkQueueFamilyCheckpointPropertiesNV* toMap);
+void handlemap_VkQueueFamilyCheckpointPropertiesNV(VulkanHandleMapping* handlemap,
+ VkQueueFamilyCheckpointPropertiesNV* toMap);
-void handlemap_VkCheckpointDataNV(
- VulkanHandleMapping* handlemap,
- VkCheckpointDataNV* toMap);
+void handlemap_VkCheckpointDataNV(VulkanHandleMapping* handlemap, VkCheckpointDataNV* toMap);
#endif
#ifdef VK_INTEL_shader_integer_functions2
void handlemap_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* toMap);
#endif
#ifdef VK_INTEL_performance_query
-void handlemap_VkPerformanceValueDataINTEL(
- VulkanHandleMapping* handlemap,
- VkPerformanceValueDataINTEL* toMap);
+void handlemap_VkPerformanceValueDataINTEL(VulkanHandleMapping* handlemap,
+ VkPerformanceValueDataINTEL* toMap);
-void handlemap_VkPerformanceValueINTEL(
- VulkanHandleMapping* handlemap,
- VkPerformanceValueINTEL* toMap);
+void handlemap_VkPerformanceValueINTEL(VulkanHandleMapping* handlemap,
+ VkPerformanceValueINTEL* toMap);
-void handlemap_VkInitializePerformanceApiInfoINTEL(
- VulkanHandleMapping* handlemap,
- VkInitializePerformanceApiInfoINTEL* toMap);
+void handlemap_VkInitializePerformanceApiInfoINTEL(VulkanHandleMapping* handlemap,
+ VkInitializePerformanceApiInfoINTEL* toMap);
void handlemap_VkQueryPoolPerformanceQueryCreateInfoINTEL(
- VulkanHandleMapping* handlemap,
- VkQueryPoolPerformanceQueryCreateInfoINTEL* toMap);
+ VulkanHandleMapping* handlemap, VkQueryPoolPerformanceQueryCreateInfoINTEL* toMap);
-DEFINE_ALIAS_FUNCTION(handlemap_VkQueryPoolPerformanceQueryCreateInfoINTEL, handlemap_VkQueryPoolCreateInfoINTEL)
+DEFINE_ALIAS_FUNCTION(handlemap_VkQueryPoolPerformanceQueryCreateInfoINTEL,
+ handlemap_VkQueryPoolCreateInfoINTEL)
-void handlemap_VkPerformanceMarkerInfoINTEL(
- VulkanHandleMapping* handlemap,
- VkPerformanceMarkerInfoINTEL* toMap);
+void handlemap_VkPerformanceMarkerInfoINTEL(VulkanHandleMapping* handlemap,
+ VkPerformanceMarkerInfoINTEL* toMap);
-void handlemap_VkPerformanceStreamMarkerInfoINTEL(
- VulkanHandleMapping* handlemap,
- VkPerformanceStreamMarkerInfoINTEL* toMap);
+void handlemap_VkPerformanceStreamMarkerInfoINTEL(VulkanHandleMapping* handlemap,
+ VkPerformanceStreamMarkerInfoINTEL* toMap);
-void handlemap_VkPerformanceOverrideInfoINTEL(
- VulkanHandleMapping* handlemap,
- VkPerformanceOverrideInfoINTEL* toMap);
+void handlemap_VkPerformanceOverrideInfoINTEL(VulkanHandleMapping* handlemap,
+ VkPerformanceOverrideInfoINTEL* toMap);
void handlemap_VkPerformanceConfigurationAcquireInfoINTEL(
- VulkanHandleMapping* handlemap,
- VkPerformanceConfigurationAcquireInfoINTEL* toMap);
+ VulkanHandleMapping* handlemap, VkPerformanceConfigurationAcquireInfoINTEL* toMap);
#endif
#ifdef VK_EXT_pci_bus_info
void handlemap_VkPhysicalDevicePCIBusInfoPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePCIBusInfoPropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePCIBusInfoPropertiesEXT* toMap);
#endif
#ifdef VK_AMD_display_native_hdr
void handlemap_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
- VulkanHandleMapping* handlemap,
- VkDisplayNativeHdrSurfaceCapabilitiesAMD* toMap);
+ VulkanHandleMapping* handlemap, VkDisplayNativeHdrSurfaceCapabilitiesAMD* toMap);
void handlemap_VkSwapchainDisplayNativeHdrCreateInfoAMD(
- VulkanHandleMapping* handlemap,
- VkSwapchainDisplayNativeHdrCreateInfoAMD* toMap);
+ VulkanHandleMapping* handlemap, VkSwapchainDisplayNativeHdrCreateInfoAMD* toMap);
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
-void handlemap_VkImagePipeSurfaceCreateInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkImagePipeSurfaceCreateInfoFUCHSIA* toMap);
+void handlemap_VkImagePipeSurfaceCreateInfoFUCHSIA(VulkanHandleMapping* handlemap,
+ VkImagePipeSurfaceCreateInfoFUCHSIA* toMap);
#endif
#ifdef VK_EXT_metal_surface
-void handlemap_VkMetalSurfaceCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkMetalSurfaceCreateInfoEXT* toMap);
+void handlemap_VkMetalSurfaceCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkMetalSurfaceCreateInfoEXT* toMap);
#endif
#ifdef VK_EXT_fragment_density_map
void handlemap_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toMap);
void handlemap_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toMap);
void handlemap_VkRenderPassFragmentDensityMapCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkRenderPassFragmentDensityMapCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkRenderPassFragmentDensityMapCreateInfoEXT* toMap);
#endif
#ifdef VK_EXT_scalar_block_layout
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceScalarBlockLayoutFeatures, handlemap_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceScalarBlockLayoutFeatures,
+ handlemap_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT)
#endif
#ifdef VK_GOOGLE_hlsl_functionality1
@@ -2978,50 +2375,41 @@
#endif
#ifdef VK_EXT_subgroup_size_control
void handlemap_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toMap);
void handlemap_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* toMap);
void handlemap_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toMap);
#endif
#ifdef VK_AMD_shader_core_properties2
void handlemap_VkPhysicalDeviceShaderCoreProperties2AMD(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderCoreProperties2AMD* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderCoreProperties2AMD* toMap);
#endif
#ifdef VK_AMD_device_coherent_memory
void handlemap_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceCoherentMemoryFeaturesAMD* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceCoherentMemoryFeaturesAMD* toMap);
#endif
#ifdef VK_EXT_shader_image_atomic_int64
void handlemap_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* toMap);
#endif
#ifdef VK_EXT_memory_budget
void handlemap_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMemoryBudgetPropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceMemoryBudgetPropertiesEXT* toMap);
#endif
#ifdef VK_EXT_memory_priority
void handlemap_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMemoryPriorityFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceMemoryPriorityFeaturesEXT* toMap);
-void handlemap_VkMemoryPriorityAllocateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkMemoryPriorityAllocateInfoEXT* toMap);
+void handlemap_VkMemoryPriorityAllocateInfoEXT(VulkanHandleMapping* handlemap,
+ VkMemoryPriorityAllocateInfoEXT* toMap);
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
@@ -3032,82 +2420,70 @@
#endif
#ifdef VK_EXT_buffer_device_address
void handlemap_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* toMap);
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, handlemap_VkPhysicalDeviceBufferAddressFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT,
+ handlemap_VkPhysicalDeviceBufferAddressFeaturesEXT)
DEFINE_ALIAS_FUNCTION(handlemap_VkBufferDeviceAddressInfo, handlemap_VkBufferDeviceAddressInfoEXT)
-void handlemap_VkBufferDeviceAddressCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkBufferDeviceAddressCreateInfoEXT* toMap);
+void handlemap_VkBufferDeviceAddressCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkBufferDeviceAddressCreateInfoEXT* toMap);
#endif
#ifdef VK_EXT_tooling_info
-void handlemap_VkPhysicalDeviceToolPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceToolPropertiesEXT* toMap);
+void handlemap_VkPhysicalDeviceToolPropertiesEXT(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceToolPropertiesEXT* toMap);
#endif
#ifdef VK_EXT_separate_stencil_usage
-DEFINE_ALIAS_FUNCTION(handlemap_VkImageStencilUsageCreateInfo, handlemap_VkImageStencilUsageCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(handlemap_VkImageStencilUsageCreateInfo,
+ handlemap_VkImageStencilUsageCreateInfoEXT)
#endif
#ifdef VK_EXT_validation_features
-void handlemap_VkValidationFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkValidationFeaturesEXT* toMap);
+void handlemap_VkValidationFeaturesEXT(VulkanHandleMapping* handlemap,
+ VkValidationFeaturesEXT* toMap);
#endif
#ifdef VK_NV_cooperative_matrix
-void handlemap_VkCooperativeMatrixPropertiesNV(
- VulkanHandleMapping* handlemap,
- VkCooperativeMatrixPropertiesNV* toMap);
+void handlemap_VkCooperativeMatrixPropertiesNV(VulkanHandleMapping* handlemap,
+ VkCooperativeMatrixPropertiesNV* toMap);
void handlemap_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceCooperativeMatrixFeaturesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceCooperativeMatrixFeaturesNV* toMap);
void handlemap_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceCooperativeMatrixPropertiesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceCooperativeMatrixPropertiesNV* toMap);
#endif
#ifdef VK_NV_coverage_reduction_mode
void handlemap_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceCoverageReductionModeFeaturesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceCoverageReductionModeFeaturesNV* toMap);
void handlemap_VkPipelineCoverageReductionStateCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkPipelineCoverageReductionStateCreateInfoNV* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineCoverageReductionStateCreateInfoNV* toMap);
void handlemap_VkFramebufferMixedSamplesCombinationNV(
- VulkanHandleMapping* handlemap,
- VkFramebufferMixedSamplesCombinationNV* toMap);
+ VulkanHandleMapping* handlemap, VkFramebufferMixedSamplesCombinationNV* toMap);
#endif
#ifdef VK_EXT_fragment_shader_interlock
void handlemap_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* toMap);
#endif
#ifdef VK_EXT_ycbcr_image_arrays
void handlemap_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* toMap);
#endif
#ifdef VK_EXT_provoking_vertex
void handlemap_VkPhysicalDeviceProvokingVertexFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceProvokingVertexFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceProvokingVertexFeaturesEXT* toMap);
void handlemap_VkPhysicalDeviceProvokingVertexPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceProvokingVertexPropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceProvokingVertexPropertiesEXT* toMap);
void handlemap_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
VulkanHandleMapping* handlemap,
@@ -3115,65 +2491,55 @@
#endif
#ifdef VK_EXT_full_screen_exclusive
-void handlemap_VkSurfaceFullScreenExclusiveInfoEXT(
- VulkanHandleMapping* handlemap,
- VkSurfaceFullScreenExclusiveInfoEXT* toMap);
+void handlemap_VkSurfaceFullScreenExclusiveInfoEXT(VulkanHandleMapping* handlemap,
+ VkSurfaceFullScreenExclusiveInfoEXT* toMap);
void handlemap_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
- VulkanHandleMapping* handlemap,
- VkSurfaceCapabilitiesFullScreenExclusiveEXT* toMap);
+ VulkanHandleMapping* handlemap, VkSurfaceCapabilitiesFullScreenExclusiveEXT* toMap);
void handlemap_VkSurfaceFullScreenExclusiveWin32InfoEXT(
- VulkanHandleMapping* handlemap,
- VkSurfaceFullScreenExclusiveWin32InfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkSurfaceFullScreenExclusiveWin32InfoEXT* toMap);
#endif
#ifdef VK_EXT_headless_surface
-void handlemap_VkHeadlessSurfaceCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkHeadlessSurfaceCreateInfoEXT* toMap);
+void handlemap_VkHeadlessSurfaceCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkHeadlessSurfaceCreateInfoEXT* toMap);
#endif
#ifdef VK_EXT_line_rasterization
void handlemap_VkPhysicalDeviceLineRasterizationFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceLineRasterizationFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceLineRasterizationFeaturesEXT* toMap);
void handlemap_VkPhysicalDeviceLineRasterizationPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceLineRasterizationPropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceLineRasterizationPropertiesEXT* toMap);
void handlemap_VkPipelineRasterizationLineStateCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineRasterizationLineStateCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineRasterizationLineStateCreateInfoEXT* toMap);
#endif
#ifdef VK_EXT_shader_atomic_float
void handlemap_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* toMap);
#endif
#ifdef VK_EXT_host_query_reset
-DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceHostQueryResetFeatures, handlemap_VkPhysicalDeviceHostQueryResetFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceHostQueryResetFeatures,
+ handlemap_VkPhysicalDeviceHostQueryResetFeaturesEXT)
#endif
#ifdef VK_EXT_index_type_uint8
void handlemap_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceIndexTypeUint8FeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceIndexTypeUint8FeaturesEXT* toMap);
#endif
#ifdef VK_EXT_extended_dynamic_state
void handlemap_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toMap);
#endif
#ifdef VK_EXT_shader_atomic_float2
void handlemap_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* toMap);
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
@@ -3184,589 +2550,462 @@
#endif
#ifdef VK_NV_device_generated_commands
void handlemap_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* toMap);
void handlemap_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* toMap);
-void handlemap_VkGraphicsShaderGroupCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkGraphicsShaderGroupCreateInfoNV* toMap);
+void handlemap_VkGraphicsShaderGroupCreateInfoNV(VulkanHandleMapping* handlemap,
+ VkGraphicsShaderGroupCreateInfoNV* toMap);
void handlemap_VkGraphicsPipelineShaderGroupsCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkGraphicsPipelineShaderGroupsCreateInfoNV* toMap);
+ VulkanHandleMapping* handlemap, VkGraphicsPipelineShaderGroupsCreateInfoNV* toMap);
-void handlemap_VkBindShaderGroupIndirectCommandNV(
- VulkanHandleMapping* handlemap,
- VkBindShaderGroupIndirectCommandNV* toMap);
+void handlemap_VkBindShaderGroupIndirectCommandNV(VulkanHandleMapping* handlemap,
+ VkBindShaderGroupIndirectCommandNV* toMap);
-void handlemap_VkBindIndexBufferIndirectCommandNV(
- VulkanHandleMapping* handlemap,
- VkBindIndexBufferIndirectCommandNV* toMap);
+void handlemap_VkBindIndexBufferIndirectCommandNV(VulkanHandleMapping* handlemap,
+ VkBindIndexBufferIndirectCommandNV* toMap);
-void handlemap_VkBindVertexBufferIndirectCommandNV(
- VulkanHandleMapping* handlemap,
- VkBindVertexBufferIndirectCommandNV* toMap);
+void handlemap_VkBindVertexBufferIndirectCommandNV(VulkanHandleMapping* handlemap,
+ VkBindVertexBufferIndirectCommandNV* toMap);
-void handlemap_VkSetStateFlagsIndirectCommandNV(
- VulkanHandleMapping* handlemap,
- VkSetStateFlagsIndirectCommandNV* toMap);
+void handlemap_VkSetStateFlagsIndirectCommandNV(VulkanHandleMapping* handlemap,
+ VkSetStateFlagsIndirectCommandNV* toMap);
-void handlemap_VkIndirectCommandsStreamNV(
- VulkanHandleMapping* handlemap,
- VkIndirectCommandsStreamNV* toMap);
+void handlemap_VkIndirectCommandsStreamNV(VulkanHandleMapping* handlemap,
+ VkIndirectCommandsStreamNV* toMap);
-void handlemap_VkIndirectCommandsLayoutTokenNV(
- VulkanHandleMapping* handlemap,
- VkIndirectCommandsLayoutTokenNV* toMap);
+void handlemap_VkIndirectCommandsLayoutTokenNV(VulkanHandleMapping* handlemap,
+ VkIndirectCommandsLayoutTokenNV* toMap);
-void handlemap_VkIndirectCommandsLayoutCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkIndirectCommandsLayoutCreateInfoNV* toMap);
+void handlemap_VkIndirectCommandsLayoutCreateInfoNV(VulkanHandleMapping* handlemap,
+ VkIndirectCommandsLayoutCreateInfoNV* toMap);
-void handlemap_VkGeneratedCommandsInfoNV(
- VulkanHandleMapping* handlemap,
- VkGeneratedCommandsInfoNV* toMap);
+void handlemap_VkGeneratedCommandsInfoNV(VulkanHandleMapping* handlemap,
+ VkGeneratedCommandsInfoNV* toMap);
void handlemap_VkGeneratedCommandsMemoryRequirementsInfoNV(
- VulkanHandleMapping* handlemap,
- VkGeneratedCommandsMemoryRequirementsInfoNV* toMap);
+ VulkanHandleMapping* handlemap, VkGeneratedCommandsMemoryRequirementsInfoNV* toMap);
#endif
#ifdef VK_NV_inherited_viewport_scissor
void handlemap_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceInheritedViewportScissorFeaturesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceInheritedViewportScissorFeaturesNV* toMap);
void handlemap_VkCommandBufferInheritanceViewportScissorInfoNV(
- VulkanHandleMapping* handlemap,
- VkCommandBufferInheritanceViewportScissorInfoNV* toMap);
+ VulkanHandleMapping* handlemap, VkCommandBufferInheritanceViewportScissorInfoNV* toMap);
#endif
#ifdef VK_EXT_texel_buffer_alignment
void handlemap_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toMap);
void handlemap_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* toMap);
#endif
#ifdef VK_QCOM_render_pass_transform
-void handlemap_VkRenderPassTransformBeginInfoQCOM(
- VulkanHandleMapping* handlemap,
- VkRenderPassTransformBeginInfoQCOM* toMap);
+void handlemap_VkRenderPassTransformBeginInfoQCOM(VulkanHandleMapping* handlemap,
+ VkRenderPassTransformBeginInfoQCOM* toMap);
void handlemap_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
- VulkanHandleMapping* handlemap,
- VkCommandBufferInheritanceRenderPassTransformInfoQCOM* toMap);
+ VulkanHandleMapping* handlemap, VkCommandBufferInheritanceRenderPassTransformInfoQCOM* toMap);
#endif
#ifdef VK_EXT_device_memory_report
void handlemap_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* toMap);
-void handlemap_VkDeviceMemoryReportCallbackDataEXT(
- VulkanHandleMapping* handlemap,
- VkDeviceMemoryReportCallbackDataEXT* toMap);
+void handlemap_VkDeviceMemoryReportCallbackDataEXT(VulkanHandleMapping* handlemap,
+ VkDeviceMemoryReportCallbackDataEXT* toMap);
void handlemap_VkDeviceDeviceMemoryReportCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDeviceDeviceMemoryReportCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkDeviceDeviceMemoryReportCreateInfoEXT* toMap);
#endif
#ifdef VK_EXT_acquire_drm_display
#endif
#ifdef VK_EXT_robustness2
void handlemap_VkPhysicalDeviceRobustness2FeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceRobustness2FeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceRobustness2FeaturesEXT* toMap);
void handlemap_VkPhysicalDeviceRobustness2PropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceRobustness2PropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceRobustness2PropertiesEXT* toMap);
#endif
#ifdef VK_EXT_custom_border_color
void handlemap_VkSamplerCustomBorderColorCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkSamplerCustomBorderColorCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkSamplerCustomBorderColorCreateInfoEXT* toMap);
void handlemap_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceCustomBorderColorPropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceCustomBorderColorPropertiesEXT* toMap);
void handlemap_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceCustomBorderColorFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceCustomBorderColorFeaturesEXT* toMap);
#endif
#ifdef VK_GOOGLE_user_type
#endif
#ifdef VK_EXT_private_data
void handlemap_VkPhysicalDevicePrivateDataFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePrivateDataFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePrivateDataFeaturesEXT* toMap);
-void handlemap_VkDevicePrivateDataCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDevicePrivateDataCreateInfoEXT* toMap);
+void handlemap_VkDevicePrivateDataCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkDevicePrivateDataCreateInfoEXT* toMap);
-void handlemap_VkPrivateDataSlotCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPrivateDataSlotCreateInfoEXT* toMap);
+void handlemap_VkPrivateDataSlotCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkPrivateDataSlotCreateInfoEXT* toMap);
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
void handlemap_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toMap);
#endif
#ifdef VK_NV_device_diagnostics_config
void handlemap_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toMap);
-void handlemap_VkDeviceDiagnosticsConfigCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkDeviceDiagnosticsConfigCreateInfoNV* toMap);
+void handlemap_VkDeviceDiagnosticsConfigCreateInfoNV(VulkanHandleMapping* handlemap,
+ VkDeviceDiagnosticsConfigCreateInfoNV* toMap);
#endif
#ifdef VK_QCOM_render_pass_store_ops
#endif
#ifdef VK_NV_fragment_shading_rate_enums
void handlemap_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* toMap);
void handlemap_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* toMap);
void handlemap_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
- VulkanHandleMapping* handlemap,
- VkPipelineFragmentShadingRateEnumStateCreateInfoNV* toMap);
+ VulkanHandleMapping* handlemap, VkPipelineFragmentShadingRateEnumStateCreateInfoNV* toMap);
#endif
#ifdef VK_NV_ray_tracing_motion_blur
-void handlemap_VkDeviceOrHostAddressConstKHR(
- VulkanHandleMapping* handlemap,
- VkDeviceOrHostAddressConstKHR* toMap);
+void handlemap_VkDeviceOrHostAddressConstKHR(VulkanHandleMapping* handlemap,
+ VkDeviceOrHostAddressConstKHR* toMap);
void handlemap_VkAccelerationStructureGeometryMotionTrianglesDataNV(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureGeometryMotionTrianglesDataNV* toMap);
+ VulkanHandleMapping* handlemap, VkAccelerationStructureGeometryMotionTrianglesDataNV* toMap);
-void handlemap_VkAccelerationStructureMotionInfoNV(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureMotionInfoNV* toMap);
+void handlemap_VkAccelerationStructureMotionInfoNV(VulkanHandleMapping* handlemap,
+ VkAccelerationStructureMotionInfoNV* toMap);
void handlemap_VkAccelerationStructureMatrixMotionInstanceNV(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureMatrixMotionInstanceNV* toMap);
+ VulkanHandleMapping* handlemap, VkAccelerationStructureMatrixMotionInstanceNV* toMap);
-void handlemap_VkSRTDataNV(
- VulkanHandleMapping* handlemap,
- VkSRTDataNV* toMap);
+void handlemap_VkSRTDataNV(VulkanHandleMapping* handlemap, VkSRTDataNV* toMap);
void handlemap_VkAccelerationStructureSRTMotionInstanceNV(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureSRTMotionInstanceNV* toMap);
+ VulkanHandleMapping* handlemap, VkAccelerationStructureSRTMotionInstanceNV* toMap);
void handlemap_VkAccelerationStructureMotionInstanceDataNV(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureMotionInstanceDataNV* toMap);
+ VulkanHandleMapping* handlemap, VkAccelerationStructureMotionInstanceDataNV* toMap);
void handlemap_VkAccelerationStructureMotionInstanceNV(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureMotionInstanceNV* toMap);
+ VulkanHandleMapping* handlemap, VkAccelerationStructureMotionInstanceNV* toMap);
void handlemap_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* toMap);
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
void handlemap_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* toMap);
#endif
#ifdef VK_EXT_fragment_density_map2
void handlemap_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* toMap);
void handlemap_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* toMap);
#endif
#ifdef VK_QCOM_rotated_copy_commands
-void handlemap_VkCopyCommandTransformInfoQCOM(
- VulkanHandleMapping* handlemap,
- VkCopyCommandTransformInfoQCOM* toMap);
+void handlemap_VkCopyCommandTransformInfoQCOM(VulkanHandleMapping* handlemap,
+ VkCopyCommandTransformInfoQCOM* toMap);
#endif
#ifdef VK_EXT_image_robustness
void handlemap_VkPhysicalDeviceImageRobustnessFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceImageRobustnessFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceImageRobustnessFeaturesEXT* toMap);
#endif
#ifdef VK_EXT_4444_formats
void handlemap_VkPhysicalDevice4444FormatsFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevice4444FormatsFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDevice4444FormatsFeaturesEXT* toMap);
#endif
#ifdef VK_EXT_rgba10x6_formats
void handlemap_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* toMap);
#endif
#ifdef VK_NV_acquire_winrt_display
#endif
#ifdef VK_EXT_directfb_surface
-void handlemap_VkDirectFBSurfaceCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkDirectFBSurfaceCreateInfoEXT* toMap);
+void handlemap_VkDirectFBSurfaceCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkDirectFBSurfaceCreateInfoEXT* toMap);
#endif
#ifdef VK_VALVE_mutable_descriptor_type
void handlemap_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* toMap);
-void handlemap_VkMutableDescriptorTypeListVALVE(
- VulkanHandleMapping* handlemap,
- VkMutableDescriptorTypeListVALVE* toMap);
+void handlemap_VkMutableDescriptorTypeListVALVE(VulkanHandleMapping* handlemap,
+ VkMutableDescriptorTypeListVALVE* toMap);
void handlemap_VkMutableDescriptorTypeCreateInfoVALVE(
- VulkanHandleMapping* handlemap,
- VkMutableDescriptorTypeCreateInfoVALVE* toMap);
+ VulkanHandleMapping* handlemap, VkMutableDescriptorTypeCreateInfoVALVE* toMap);
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
void handlemap_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* toMap);
-void handlemap_VkVertexInputBindingDescription2EXT(
- VulkanHandleMapping* handlemap,
- VkVertexInputBindingDescription2EXT* toMap);
+void handlemap_VkVertexInputBindingDescription2EXT(VulkanHandleMapping* handlemap,
+ VkVertexInputBindingDescription2EXT* toMap);
-void handlemap_VkVertexInputAttributeDescription2EXT(
- VulkanHandleMapping* handlemap,
- VkVertexInputAttributeDescription2EXT* toMap);
+void handlemap_VkVertexInputAttributeDescription2EXT(VulkanHandleMapping* handlemap,
+ VkVertexInputAttributeDescription2EXT* toMap);
#endif
#ifdef VK_EXT_physical_device_drm
-void handlemap_VkPhysicalDeviceDrmPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceDrmPropertiesEXT* toMap);
+void handlemap_VkPhysicalDeviceDrmPropertiesEXT(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceDrmPropertiesEXT* toMap);
#endif
#ifdef VK_EXT_primitive_topology_list_restart
void handlemap_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* toMap);
#endif
#ifdef VK_FUCHSIA_external_memory
-void handlemap_VkImportMemoryZirconHandleInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkImportMemoryZirconHandleInfoFUCHSIA* toMap);
+void handlemap_VkImportMemoryZirconHandleInfoFUCHSIA(VulkanHandleMapping* handlemap,
+ VkImportMemoryZirconHandleInfoFUCHSIA* toMap);
-void handlemap_VkMemoryZirconHandlePropertiesFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkMemoryZirconHandlePropertiesFUCHSIA* toMap);
+void handlemap_VkMemoryZirconHandlePropertiesFUCHSIA(VulkanHandleMapping* handlemap,
+ VkMemoryZirconHandlePropertiesFUCHSIA* toMap);
-void handlemap_VkMemoryGetZirconHandleInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkMemoryGetZirconHandleInfoFUCHSIA* toMap);
+void handlemap_VkMemoryGetZirconHandleInfoFUCHSIA(VulkanHandleMapping* handlemap,
+ VkMemoryGetZirconHandleInfoFUCHSIA* toMap);
#endif
#ifdef VK_FUCHSIA_external_semaphore
void handlemap_VkImportSemaphoreZirconHandleInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkImportSemaphoreZirconHandleInfoFUCHSIA* toMap);
+ VulkanHandleMapping* handlemap, VkImportSemaphoreZirconHandleInfoFUCHSIA* toMap);
-void handlemap_VkSemaphoreGetZirconHandleInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkSemaphoreGetZirconHandleInfoFUCHSIA* toMap);
+void handlemap_VkSemaphoreGetZirconHandleInfoFUCHSIA(VulkanHandleMapping* handlemap,
+ VkSemaphoreGetZirconHandleInfoFUCHSIA* toMap);
#endif
#ifdef VK_FUCHSIA_buffer_collection
-void handlemap_VkBufferCollectionCreateInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkBufferCollectionCreateInfoFUCHSIA* toMap);
+void handlemap_VkBufferCollectionCreateInfoFUCHSIA(VulkanHandleMapping* handlemap,
+ VkBufferCollectionCreateInfoFUCHSIA* toMap);
-void handlemap_VkImportMemoryBufferCollectionFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkImportMemoryBufferCollectionFUCHSIA* toMap);
+void handlemap_VkImportMemoryBufferCollectionFUCHSIA(VulkanHandleMapping* handlemap,
+ VkImportMemoryBufferCollectionFUCHSIA* toMap);
void handlemap_VkBufferCollectionImageCreateInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkBufferCollectionImageCreateInfoFUCHSIA* toMap);
+ VulkanHandleMapping* handlemap, VkBufferCollectionImageCreateInfoFUCHSIA* toMap);
void handlemap_VkBufferCollectionConstraintsInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkBufferCollectionConstraintsInfoFUCHSIA* toMap);
+ VulkanHandleMapping* handlemap, VkBufferCollectionConstraintsInfoFUCHSIA* toMap);
-void handlemap_VkBufferConstraintsInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkBufferConstraintsInfoFUCHSIA* toMap);
+void handlemap_VkBufferConstraintsInfoFUCHSIA(VulkanHandleMapping* handlemap,
+ VkBufferConstraintsInfoFUCHSIA* toMap);
void handlemap_VkBufferCollectionBufferCreateInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkBufferCollectionBufferCreateInfoFUCHSIA* toMap);
+ VulkanHandleMapping* handlemap, VkBufferCollectionBufferCreateInfoFUCHSIA* toMap);
-void handlemap_VkSysmemColorSpaceFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkSysmemColorSpaceFUCHSIA* toMap);
+void handlemap_VkSysmemColorSpaceFUCHSIA(VulkanHandleMapping* handlemap,
+ VkSysmemColorSpaceFUCHSIA* toMap);
-void handlemap_VkBufferCollectionPropertiesFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkBufferCollectionPropertiesFUCHSIA* toMap);
+void handlemap_VkBufferCollectionPropertiesFUCHSIA(VulkanHandleMapping* handlemap,
+ VkBufferCollectionPropertiesFUCHSIA* toMap);
-void handlemap_VkImageFormatConstraintsInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkImageFormatConstraintsInfoFUCHSIA* toMap);
+void handlemap_VkImageFormatConstraintsInfoFUCHSIA(VulkanHandleMapping* handlemap,
+ VkImageFormatConstraintsInfoFUCHSIA* toMap);
-void handlemap_VkImageConstraintsInfoFUCHSIA(
- VulkanHandleMapping* handlemap,
- VkImageConstraintsInfoFUCHSIA* toMap);
+void handlemap_VkImageConstraintsInfoFUCHSIA(VulkanHandleMapping* handlemap,
+ VkImageConstraintsInfoFUCHSIA* toMap);
#endif
#ifdef VK_HUAWEI_subpass_shading
void handlemap_VkSubpassShadingPipelineCreateInfoHUAWEI(
- VulkanHandleMapping* handlemap,
- VkSubpassShadingPipelineCreateInfoHUAWEI* toMap);
+ VulkanHandleMapping* handlemap, VkSubpassShadingPipelineCreateInfoHUAWEI* toMap);
void handlemap_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* toMap);
void handlemap_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* toMap);
#endif
#ifdef VK_HUAWEI_invocation_mask
void handlemap_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* toMap);
#endif
#ifdef VK_NV_external_memory_rdma
-void handlemap_VkMemoryGetRemoteAddressInfoNV(
- VulkanHandleMapping* handlemap,
- VkMemoryGetRemoteAddressInfoNV* toMap);
+void handlemap_VkMemoryGetRemoteAddressInfoNV(VulkanHandleMapping* handlemap,
+ VkMemoryGetRemoteAddressInfoNV* toMap);
void handlemap_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* toMap);
#endif
#ifdef VK_EXT_extended_dynamic_state2
void handlemap_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* toMap);
#endif
#ifdef VK_QNX_screen_surface
-void handlemap_VkScreenSurfaceCreateInfoQNX(
- VulkanHandleMapping* handlemap,
- VkScreenSurfaceCreateInfoQNX* toMap);
+void handlemap_VkScreenSurfaceCreateInfoQNX(VulkanHandleMapping* handlemap,
+ VkScreenSurfaceCreateInfoQNX* toMap);
#endif
#ifdef VK_EXT_color_write_enable
void handlemap_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceColorWriteEnableFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceColorWriteEnableFeaturesEXT* toMap);
-void handlemap_VkPipelineColorWriteCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkPipelineColorWriteCreateInfoEXT* toMap);
+void handlemap_VkPipelineColorWriteCreateInfoEXT(VulkanHandleMapping* handlemap,
+ VkPipelineColorWriteCreateInfoEXT* toMap);
#endif
#ifdef VK_GOOGLE_gfxstream
-void handlemap_VkImportColorBufferGOOGLE(
- VulkanHandleMapping* handlemap,
- VkImportColorBufferGOOGLE* toMap);
+void handlemap_VkImportColorBufferGOOGLE(VulkanHandleMapping* handlemap,
+ VkImportColorBufferGOOGLE* toMap);
-void handlemap_VkImportBufferGOOGLE(
- VulkanHandleMapping* handlemap,
- VkImportBufferGOOGLE* toMap);
+void handlemap_VkImportBufferGOOGLE(VulkanHandleMapping* handlemap, VkImportBufferGOOGLE* toMap);
-void handlemap_VkImportPhysicalAddressGOOGLE(
- VulkanHandleMapping* handlemap,
- VkImportPhysicalAddressGOOGLE* toMap);
+void handlemap_VkImportPhysicalAddressGOOGLE(VulkanHandleMapping* handlemap,
+ VkImportPhysicalAddressGOOGLE* toMap);
#endif
#ifdef VK_EXT_global_priority_query
void handlemap_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toMap);
void handlemap_VkQueueFamilyGlobalPriorityPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkQueueFamilyGlobalPriorityPropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkQueueFamilyGlobalPriorityPropertiesEXT* toMap);
#endif
#ifdef VK_EXT_multi_draw
-void handlemap_VkPhysicalDeviceMultiDrawFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMultiDrawFeaturesEXT* toMap);
+void handlemap_VkPhysicalDeviceMultiDrawFeaturesEXT(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceMultiDrawFeaturesEXT* toMap);
void handlemap_VkPhysicalDeviceMultiDrawPropertiesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceMultiDrawPropertiesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceMultiDrawPropertiesEXT* toMap);
-void handlemap_VkMultiDrawInfoEXT(
- VulkanHandleMapping* handlemap,
- VkMultiDrawInfoEXT* toMap);
+void handlemap_VkMultiDrawInfoEXT(VulkanHandleMapping* handlemap, VkMultiDrawInfoEXT* toMap);
-void handlemap_VkMultiDrawIndexedInfoEXT(
- VulkanHandleMapping* handlemap,
- VkMultiDrawIndexedInfoEXT* toMap);
+void handlemap_VkMultiDrawIndexedInfoEXT(VulkanHandleMapping* handlemap,
+ VkMultiDrawIndexedInfoEXT* toMap);
#endif
#ifdef VK_EXT_load_store_op_none
#endif
#ifdef VK_EXT_border_color_swizzle
void handlemap_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* toMap);
void handlemap_VkSamplerBorderColorComponentMappingCreateInfoEXT(
- VulkanHandleMapping* handlemap,
- VkSamplerBorderColorComponentMappingCreateInfoEXT* toMap);
+ VulkanHandleMapping* handlemap, VkSamplerBorderColorComponentMappingCreateInfoEXT* toMap);
#endif
#ifdef VK_EXT_pageable_device_local_memory
void handlemap_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
- VulkanHandleMapping* handlemap,
- VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* toMap);
#endif
#ifdef VK_KHR_acceleration_structure
-void handlemap_VkDeviceOrHostAddressKHR(
- VulkanHandleMapping* handlemap,
- VkDeviceOrHostAddressKHR* toMap);
+void handlemap_VkDeviceOrHostAddressKHR(VulkanHandleMapping* handlemap,
+ VkDeviceOrHostAddressKHR* toMap);
void handlemap_VkAccelerationStructureBuildRangeInfoKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureBuildRangeInfoKHR* toMap);
+ VulkanHandleMapping* handlemap, VkAccelerationStructureBuildRangeInfoKHR* toMap);
void handlemap_VkAccelerationStructureGeometryTrianglesDataKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureGeometryTrianglesDataKHR* toMap);
+ VulkanHandleMapping* handlemap, VkAccelerationStructureGeometryTrianglesDataKHR* toMap);
void handlemap_VkAccelerationStructureGeometryAabbsDataKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureGeometryAabbsDataKHR* toMap);
+ VulkanHandleMapping* handlemap, VkAccelerationStructureGeometryAabbsDataKHR* toMap);
void handlemap_VkAccelerationStructureGeometryInstancesDataKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureGeometryInstancesDataKHR* toMap);
+ VulkanHandleMapping* handlemap, VkAccelerationStructureGeometryInstancesDataKHR* toMap);
void handlemap_VkAccelerationStructureGeometryDataKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureGeometryDataKHR* toMap);
+ VulkanHandleMapping* handlemap, VkAccelerationStructureGeometryDataKHR* toMap);
-void handlemap_VkAccelerationStructureGeometryKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureGeometryKHR* toMap);
+void handlemap_VkAccelerationStructureGeometryKHR(VulkanHandleMapping* handlemap,
+ VkAccelerationStructureGeometryKHR* toMap);
void handlemap_VkAccelerationStructureBuildGeometryInfoKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureBuildGeometryInfoKHR* toMap);
+ VulkanHandleMapping* handlemap, VkAccelerationStructureBuildGeometryInfoKHR* toMap);
-void handlemap_VkAccelerationStructureCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureCreateInfoKHR* toMap);
+void handlemap_VkAccelerationStructureCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkAccelerationStructureCreateInfoKHR* toMap);
void handlemap_VkWriteDescriptorSetAccelerationStructureKHR(
- VulkanHandleMapping* handlemap,
- VkWriteDescriptorSetAccelerationStructureKHR* toMap);
+ VulkanHandleMapping* handlemap, VkWriteDescriptorSetAccelerationStructureKHR* toMap);
void handlemap_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceAccelerationStructureFeaturesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceAccelerationStructureFeaturesKHR* toMap);
void handlemap_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceAccelerationStructurePropertiesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceAccelerationStructurePropertiesKHR* toMap);
void handlemap_VkAccelerationStructureDeviceAddressInfoKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureDeviceAddressInfoKHR* toMap);
+ VulkanHandleMapping* handlemap, VkAccelerationStructureDeviceAddressInfoKHR* toMap);
-void handlemap_VkAccelerationStructureVersionInfoKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureVersionInfoKHR* toMap);
+void handlemap_VkAccelerationStructureVersionInfoKHR(VulkanHandleMapping* handlemap,
+ VkAccelerationStructureVersionInfoKHR* toMap);
void handlemap_VkCopyAccelerationStructureToMemoryInfoKHR(
- VulkanHandleMapping* handlemap,
- VkCopyAccelerationStructureToMemoryInfoKHR* toMap);
+ VulkanHandleMapping* handlemap, VkCopyAccelerationStructureToMemoryInfoKHR* toMap);
void handlemap_VkCopyMemoryToAccelerationStructureInfoKHR(
- VulkanHandleMapping* handlemap,
- VkCopyMemoryToAccelerationStructureInfoKHR* toMap);
+ VulkanHandleMapping* handlemap, VkCopyMemoryToAccelerationStructureInfoKHR* toMap);
-void handlemap_VkCopyAccelerationStructureInfoKHR(
- VulkanHandleMapping* handlemap,
- VkCopyAccelerationStructureInfoKHR* toMap);
+void handlemap_VkCopyAccelerationStructureInfoKHR(VulkanHandleMapping* handlemap,
+ VkCopyAccelerationStructureInfoKHR* toMap);
void handlemap_VkAccelerationStructureBuildSizesInfoKHR(
- VulkanHandleMapping* handlemap,
- VkAccelerationStructureBuildSizesInfoKHR* toMap);
+ VulkanHandleMapping* handlemap, VkAccelerationStructureBuildSizesInfoKHR* toMap);
#endif
#ifdef VK_KHR_ray_tracing_pipeline
-void handlemap_VkRayTracingShaderGroupCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkRayTracingShaderGroupCreateInfoKHR* toMap);
+void handlemap_VkRayTracingShaderGroupCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkRayTracingShaderGroupCreateInfoKHR* toMap);
void handlemap_VkRayTracingPipelineInterfaceCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkRayTracingPipelineInterfaceCreateInfoKHR* toMap);
+ VulkanHandleMapping* handlemap, VkRayTracingPipelineInterfaceCreateInfoKHR* toMap);
-void handlemap_VkRayTracingPipelineCreateInfoKHR(
- VulkanHandleMapping* handlemap,
- VkRayTracingPipelineCreateInfoKHR* toMap);
+void handlemap_VkRayTracingPipelineCreateInfoKHR(VulkanHandleMapping* handlemap,
+ VkRayTracingPipelineCreateInfoKHR* toMap);
void handlemap_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toMap);
void handlemap_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toMap);
+ VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toMap);
-void handlemap_VkStridedDeviceAddressRegionKHR(
- VulkanHandleMapping* handlemap,
- VkStridedDeviceAddressRegionKHR* toMap);
+void handlemap_VkStridedDeviceAddressRegionKHR(VulkanHandleMapping* handlemap,
+ VkStridedDeviceAddressRegionKHR* toMap);
-void handlemap_VkTraceRaysIndirectCommandKHR(
- VulkanHandleMapping* handlemap,
- VkTraceRaysIndirectCommandKHR* toMap);
+void handlemap_VkTraceRaysIndirectCommandKHR(VulkanHandleMapping* handlemap,
+ VkTraceRaysIndirectCommandKHR* toMap);
#endif
#ifdef VK_KHR_ray_query
-void handlemap_VkPhysicalDeviceRayQueryFeaturesKHR(
- VulkanHandleMapping* handlemap,
- VkPhysicalDeviceRayQueryFeaturesKHR* toMap);
+void handlemap_VkPhysicalDeviceRayQueryFeaturesKHR(VulkanHandleMapping* handlemap,
+ VkPhysicalDeviceRayQueryFeaturesKHR* toMap);
#endif
-} // namespace goldfish_vk
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
index 9a3f9dd..f08d17a 100644
--- a/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
@@ -14,206 +14,156 @@
// limitations under the License.
// Autogenerated module goldfish_vk_marshaling_guest
-// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal -o ../qemu/android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+//
+// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
+// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
-// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+//
+// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
+// $CEREAL_OUTPUT_DIR
+//
#include "goldfish_vk_marshaling_guest.h"
+#include <cstring>
#include "goldfish_vk_extension_structs_guest.h"
#include "goldfish_vk_private_defs.h"
-#include <cstring>
-
-
namespace goldfish_vk {
-void marshal_extension_struct(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const void* structExtension);
+void marshal_extension_struct(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const void* structExtension);
-void unmarshal_extension_struct(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- void* structExtension_out);
+void unmarshal_extension_struct(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ void* structExtension_out);
#ifdef VK_VERSION_1_0
-void marshal_VkExtent2D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExtent2D* forMarshaling)
-{
+void marshal_VkExtent2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExtent2D* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
}
-void unmarshal_VkExtent2D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExtent2D* forUnmarshaling)
-{
+void unmarshal_VkExtent2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExtent2D* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
}
-void marshal_VkExtent3D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExtent3D* forMarshaling)
-{
+void marshal_VkExtent3D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExtent3D* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->depth, sizeof(uint32_t));
}
-void unmarshal_VkExtent3D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExtent3D* forUnmarshaling)
-{
+void unmarshal_VkExtent3D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExtent3D* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->depth, sizeof(uint32_t));
}
-void marshal_VkOffset2D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkOffset2D* forMarshaling)
-{
+void marshal_VkOffset2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkOffset2D* forMarshaling) {
(void)rootType;
vkStream->write((int32_t*)&forMarshaling->x, sizeof(int32_t));
vkStream->write((int32_t*)&forMarshaling->y, sizeof(int32_t));
}
-void unmarshal_VkOffset2D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkOffset2D* forUnmarshaling)
-{
+void unmarshal_VkOffset2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkOffset2D* forUnmarshaling) {
(void)rootType;
vkStream->read((int32_t*)&forUnmarshaling->x, sizeof(int32_t));
vkStream->read((int32_t*)&forUnmarshaling->y, sizeof(int32_t));
}
-void marshal_VkOffset3D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkOffset3D* forMarshaling)
-{
+void marshal_VkOffset3D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkOffset3D* forMarshaling) {
(void)rootType;
vkStream->write((int32_t*)&forMarshaling->x, sizeof(int32_t));
vkStream->write((int32_t*)&forMarshaling->y, sizeof(int32_t));
vkStream->write((int32_t*)&forMarshaling->z, sizeof(int32_t));
}
-void unmarshal_VkOffset3D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkOffset3D* forUnmarshaling)
-{
+void unmarshal_VkOffset3D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkOffset3D* forUnmarshaling) {
(void)rootType;
vkStream->read((int32_t*)&forUnmarshaling->x, sizeof(int32_t));
vkStream->read((int32_t*)&forUnmarshaling->y, sizeof(int32_t));
vkStream->read((int32_t*)&forUnmarshaling->z, sizeof(int32_t));
}
-void marshal_VkRect2D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRect2D* forMarshaling)
-{
+void marshal_VkRect2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRect2D* forMarshaling) {
(void)rootType;
marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->offset));
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->extent));
}
-void unmarshal_VkRect2D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRect2D* forUnmarshaling)
-{
+void unmarshal_VkRect2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRect2D* forUnmarshaling) {
(void)rootType;
unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->offset));
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->extent));
}
-void marshal_VkBaseInStructure(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBaseInStructure* forMarshaling)
-{
+void marshal_VkBaseInStructure(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBaseInStructure* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
}
-void unmarshal_VkBaseInStructure(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBaseInStructure* forUnmarshaling)
-{
+void unmarshal_VkBaseInStructure(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBaseInStructure* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
}
-void marshal_VkBaseOutStructure(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBaseOutStructure* forMarshaling)
-{
+void marshal_VkBaseOutStructure(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBaseOutStructure* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
}
-void unmarshal_VkBaseOutStructure(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBaseOutStructure* forUnmarshaling)
-{
+void unmarshal_VkBaseOutStructure(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBaseOutStructure* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
}
-void marshal_VkBufferMemoryBarrier(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferMemoryBarrier* forMarshaling)
-{
+void marshal_VkBufferMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferMemoryBarrier* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -228,15 +178,11 @@
vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
}
-void unmarshal_VkBufferMemoryBarrier(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferMemoryBarrier* forUnmarshaling)
-{
+void unmarshal_VkBufferMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferMemoryBarrier* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -246,38 +192,30 @@
vkStream->read((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+ (VkBuffer*)&forUnmarshaling->buffer, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
}
-void marshal_VkDispatchIndirectCommand(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDispatchIndirectCommand* forMarshaling)
-{
+void marshal_VkDispatchIndirectCommand(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDispatchIndirectCommand* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->x, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->y, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->z, sizeof(uint32_t));
}
-void unmarshal_VkDispatchIndirectCommand(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDispatchIndirectCommand* forUnmarshaling)
-{
+void unmarshal_VkDispatchIndirectCommand(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDispatchIndirectCommand* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->x, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->y, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->z, sizeof(uint32_t));
}
-void marshal_VkDrawIndexedIndirectCommand(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrawIndexedIndirectCommand* forMarshaling)
-{
+void marshal_VkDrawIndexedIndirectCommand(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrawIndexedIndirectCommand* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->indexCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->instanceCount, sizeof(uint32_t));
@@ -286,11 +224,8 @@
vkStream->write((uint32_t*)&forMarshaling->firstInstance, sizeof(uint32_t));
}
-void unmarshal_VkDrawIndexedIndirectCommand(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDrawIndexedIndirectCommand* forUnmarshaling)
-{
+void unmarshal_VkDrawIndexedIndirectCommand(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDrawIndexedIndirectCommand* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->indexCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->instanceCount, sizeof(uint32_t));
@@ -299,11 +234,8 @@
vkStream->read((uint32_t*)&forUnmarshaling->firstInstance, sizeof(uint32_t));
}
-void marshal_VkDrawIndirectCommand(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrawIndirectCommand* forMarshaling)
-{
+void marshal_VkDrawIndirectCommand(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrawIndirectCommand* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->vertexCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->instanceCount, sizeof(uint32_t));
@@ -311,11 +243,8 @@
vkStream->write((uint32_t*)&forMarshaling->firstInstance, sizeof(uint32_t));
}
-void unmarshal_VkDrawIndirectCommand(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDrawIndirectCommand* forUnmarshaling)
-{
+void unmarshal_VkDrawIndirectCommand(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDrawIndirectCommand* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->vertexCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->instanceCount, sizeof(uint32_t));
@@ -323,11 +252,8 @@
vkStream->read((uint32_t*)&forUnmarshaling->firstInstance, sizeof(uint32_t));
}
-void marshal_VkImageSubresourceRange(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageSubresourceRange* forMarshaling)
-{
+void marshal_VkImageSubresourceRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSubresourceRange* forMarshaling) {
(void)rootType;
vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
vkStream->write((uint32_t*)&forMarshaling->baseMipLevel, sizeof(uint32_t));
@@ -336,11 +262,8 @@
vkStream->write((uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
}
-void unmarshal_VkImageSubresourceRange(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageSubresourceRange* forUnmarshaling)
-{
+void unmarshal_VkImageSubresourceRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageSubresourceRange* forUnmarshaling) {
(void)rootType;
vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
vkStream->read((uint32_t*)&forUnmarshaling->baseMipLevel, sizeof(uint32_t));
@@ -349,15 +272,11 @@
vkStream->read((uint32_t*)&forUnmarshaling->layerCount, sizeof(uint32_t));
}
-void marshal_VkImageMemoryBarrier(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageMemoryBarrier* forMarshaling)
-{
+void marshal_VkImageMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageMemoryBarrier* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -370,18 +289,15 @@
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- marshal_VkImageSubresourceRange(vkStream, rootType, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
+ marshal_VkImageSubresourceRange(vkStream, rootType,
+ (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
}
-void unmarshal_VkImageMemoryBarrier(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageMemoryBarrier* forUnmarshaling)
-{
+void unmarshal_VkImageMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageMemoryBarrier* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -393,19 +309,17 @@
vkStream->read((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0, (VkImage*)&forUnmarshaling->image, 1);
- unmarshal_VkImageSubresourceRange(vkStream, rootType, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+ (VkImage*)&forUnmarshaling->image, 1);
+ unmarshal_VkImageSubresourceRange(
+ vkStream, rootType, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
}
-void marshal_VkMemoryBarrier(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryBarrier* forMarshaling)
-{
+void marshal_VkMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryBarrier* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -413,15 +327,11 @@
vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
}
-void unmarshal_VkMemoryBarrier(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryBarrier* forUnmarshaling)
-{
+void unmarshal_VkMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryBarrier* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -429,43 +339,36 @@
vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
}
-void marshal_VkPipelineCacheHeaderVersionOne(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCacheHeaderVersionOne* forMarshaling)
-{
+void marshal_VkPipelineCacheHeaderVersionOne(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCacheHeaderVersionOne* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->headerSize, sizeof(uint32_t));
- vkStream->write((VkPipelineCacheHeaderVersion*)&forMarshaling->headerVersion, sizeof(VkPipelineCacheHeaderVersion));
+ vkStream->write((VkPipelineCacheHeaderVersion*)&forMarshaling->headerVersion,
+ sizeof(VkPipelineCacheHeaderVersion));
vkStream->write((uint32_t*)&forMarshaling->vendorID, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->deviceID, sizeof(uint32_t));
vkStream->write((uint8_t*)forMarshaling->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
}
-void unmarshal_VkPipelineCacheHeaderVersionOne(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineCacheHeaderVersionOne* forUnmarshaling)
-{
+void unmarshal_VkPipelineCacheHeaderVersionOne(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPipelineCacheHeaderVersionOne* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->headerSize, sizeof(uint32_t));
- vkStream->read((VkPipelineCacheHeaderVersion*)&forUnmarshaling->headerVersion, sizeof(VkPipelineCacheHeaderVersion));
+ vkStream->read((VkPipelineCacheHeaderVersion*)&forUnmarshaling->headerVersion,
+ sizeof(VkPipelineCacheHeaderVersion));
vkStream->read((uint32_t*)&forUnmarshaling->vendorID, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->deviceID, sizeof(uint32_t));
vkStream->read((uint8_t*)forUnmarshaling->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
}
-void marshal_VkAllocationCallbacks(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAllocationCallbacks* forMarshaling)
-{
+void marshal_VkAllocationCallbacks(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAllocationCallbacks* forMarshaling) {
(void)rootType;
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pUserData)
- {
+ if (forMarshaling->pUserData) {
vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
}
uint64_t cgen_var_1 = (uint64_t)forMarshaling->pfnAllocation;
@@ -480,155 +383,127 @@
vkStream->putBe64(cgen_var_5);
}
-void unmarshal_VkAllocationCallbacks(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAllocationCallbacks* forUnmarshaling)
-{
+void unmarshal_VkAllocationCallbacks(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAllocationCallbacks* forUnmarshaling) {
(void)rootType;
// WARNING PTR CHECK
void* check_pUserData;
check_pUserData = (void*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pUserData)
- {
- if (!(check_pUserData))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pUserData inconsistent between guest and host\n");
+ if (forUnmarshaling->pUserData) {
+ if (!(check_pUserData)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pUserData inconsistent between guest and host\n");
}
vkStream->read((void*)forUnmarshaling->pUserData, sizeof(uint8_t));
}
forUnmarshaling->pfnAllocation = (PFN_vkAllocationFunction)vkStream->getBe64();
forUnmarshaling->pfnReallocation = (PFN_vkReallocationFunction)vkStream->getBe64();
forUnmarshaling->pfnFree = (PFN_vkFreeFunction)vkStream->getBe64();
- forUnmarshaling->pfnInternalAllocation = (PFN_vkInternalAllocationNotification)vkStream->getBe64();
+ forUnmarshaling->pfnInternalAllocation =
+ (PFN_vkInternalAllocationNotification)vkStream->getBe64();
forUnmarshaling->pfnInternalFree = (PFN_vkInternalFreeNotification)vkStream->getBe64();
}
-void marshal_VkApplicationInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkApplicationInfo* forMarshaling)
-{
+void marshal_VkApplicationInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkApplicationInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
- {
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pApplicationName;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pApplicationName)
- {
+ if (forMarshaling->pApplicationName) {
vkStream->putString(forMarshaling->pApplicationName);
}
- }
- else
- {
+ } else {
vkStream->putString(forMarshaling->pApplicationName);
}
vkStream->write((uint32_t*)&forMarshaling->applicationVersion, sizeof(uint32_t));
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
- {
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pEngineName;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pEngineName)
- {
+ if (forMarshaling->pEngineName) {
vkStream->putString(forMarshaling->pEngineName);
}
- }
- else
- {
+ } else {
vkStream->putString(forMarshaling->pEngineName);
}
vkStream->write((uint32_t*)&forMarshaling->engineVersion, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->apiVersion, sizeof(uint32_t));
}
-void unmarshal_VkApplicationInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkApplicationInfo* forUnmarshaling)
-{
+void unmarshal_VkApplicationInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkApplicationInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
- {
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
// WARNING PTR CHECK
const char* check_pApplicationName;
check_pApplicationName = (const char*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pApplicationName)
- {
- if (!(check_pApplicationName))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pApplicationName inconsistent between guest and host\n");
+ if (forUnmarshaling->pApplicationName) {
+ if (!(check_pApplicationName)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pApplicationName inconsistent between guest and "
+ "host\n");
}
vkStream->loadStringInPlace((char**)&forUnmarshaling->pApplicationName);
}
- }
- else
- {
+ } else {
vkStream->loadStringInPlace((char**)&forUnmarshaling->pApplicationName);
}
vkStream->read((uint32_t*)&forUnmarshaling->applicationVersion, sizeof(uint32_t));
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
- {
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
// WARNING PTR CHECK
const char* check_pEngineName;
check_pEngineName = (const char*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pEngineName)
- {
- if (!(check_pEngineName))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pEngineName inconsistent between guest and host\n");
+ if (forUnmarshaling->pEngineName) {
+ if (!(check_pEngineName)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pEngineName inconsistent between guest and host\n");
}
vkStream->loadStringInPlace((char**)&forUnmarshaling->pEngineName);
}
- }
- else
- {
+ } else {
vkStream->loadStringInPlace((char**)&forUnmarshaling->pEngineName);
}
vkStream->read((uint32_t*)&forUnmarshaling->engineVersion, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->apiVersion, sizeof(uint32_t));
}
-void marshal_VkFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFormatProperties* forMarshaling)
-{
+void marshal_VkFormatProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFormatProperties* forMarshaling) {
(void)rootType;
- vkStream->write((VkFormatFeatureFlags*)&forMarshaling->linearTilingFeatures, sizeof(VkFormatFeatureFlags));
- vkStream->write((VkFormatFeatureFlags*)&forMarshaling->optimalTilingFeatures, sizeof(VkFormatFeatureFlags));
- vkStream->write((VkFormatFeatureFlags*)&forMarshaling->bufferFeatures, sizeof(VkFormatFeatureFlags));
+ vkStream->write((VkFormatFeatureFlags*)&forMarshaling->linearTilingFeatures,
+ sizeof(VkFormatFeatureFlags));
+ vkStream->write((VkFormatFeatureFlags*)&forMarshaling->optimalTilingFeatures,
+ sizeof(VkFormatFeatureFlags));
+ vkStream->write((VkFormatFeatureFlags*)&forMarshaling->bufferFeatures,
+ sizeof(VkFormatFeatureFlags));
}
-void unmarshal_VkFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkFormatProperties* forUnmarshaling)
-{
+void unmarshal_VkFormatProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkFormatProperties* forUnmarshaling) {
(void)rootType;
- vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->linearTilingFeatures, sizeof(VkFormatFeatureFlags));
- vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->optimalTilingFeatures, sizeof(VkFormatFeatureFlags));
- vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->bufferFeatures, sizeof(VkFormatFeatureFlags));
+ vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->linearTilingFeatures,
+ sizeof(VkFormatFeatureFlags));
+ vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->optimalTilingFeatures,
+ sizeof(VkFormatFeatureFlags));
+ vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->bufferFeatures,
+ sizeof(VkFormatFeatureFlags));
}
-void marshal_VkImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageFormatProperties* forMarshaling)
-{
+void marshal_VkImageFormatProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageFormatProperties* forMarshaling) {
(void)rootType;
marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->maxExtent));
vkStream->write((uint32_t*)&forMarshaling->maxMipLevels, sizeof(uint32_t));
@@ -637,11 +512,8 @@
vkStream->write((VkDeviceSize*)&forMarshaling->maxResourceSize, sizeof(VkDeviceSize));
}
-void unmarshal_VkImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageFormatProperties* forUnmarshaling)
-{
+void unmarshal_VkImageFormatProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageFormatProperties* forUnmarshaling) {
(void)rootType;
unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->maxExtent));
vkStream->read((uint32_t*)&forUnmarshaling->maxMipLevels, sizeof(uint32_t));
@@ -650,15 +522,11 @@
vkStream->read((VkDeviceSize*)&forUnmarshaling->maxResourceSize, sizeof(VkDeviceSize));
}
-void marshal_VkInstanceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkInstanceCreateInfo* forMarshaling)
-{
+void marshal_VkInstanceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkInstanceCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -666,25 +534,22 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pApplicationInfo;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pApplicationInfo)
- {
- marshal_VkApplicationInfo(vkStream, rootType, (const VkApplicationInfo*)(forMarshaling->pApplicationInfo));
+ if (forMarshaling->pApplicationInfo) {
+ marshal_VkApplicationInfo(vkStream, rootType,
+ (const VkApplicationInfo*)(forMarshaling->pApplicationInfo));
}
vkStream->write((uint32_t*)&forMarshaling->enabledLayerCount, sizeof(uint32_t));
saveStringArray(vkStream, forMarshaling->ppEnabledLayerNames, forMarshaling->enabledLayerCount);
vkStream->write((uint32_t*)&forMarshaling->enabledExtensionCount, sizeof(uint32_t));
- saveStringArray(vkStream, forMarshaling->ppEnabledExtensionNames, forMarshaling->enabledExtensionCount);
+ saveStringArray(vkStream, forMarshaling->ppEnabledExtensionNames,
+ forMarshaling->enabledExtensionCount);
}
-void unmarshal_VkInstanceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkInstanceCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkInstanceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkInstanceCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -692,13 +557,14 @@
// WARNING PTR CHECK
const VkApplicationInfo* check_pApplicationInfo;
check_pApplicationInfo = (const VkApplicationInfo*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pApplicationInfo)
- {
- if (!(check_pApplicationInfo))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pApplicationInfo inconsistent between guest and host\n");
+ if (forUnmarshaling->pApplicationInfo) {
+ if (!(check_pApplicationInfo)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pApplicationInfo inconsistent between guest and host\n");
}
- unmarshal_VkApplicationInfo(vkStream, rootType, (VkApplicationInfo*)(forUnmarshaling->pApplicationInfo));
+ unmarshal_VkApplicationInfo(vkStream, rootType,
+ (VkApplicationInfo*)(forUnmarshaling->pApplicationInfo));
}
vkStream->read((uint32_t*)&forUnmarshaling->enabledLayerCount, sizeof(uint32_t));
vkStream->loadStringArrayInPlace((char***)&forUnmarshaling->ppEnabledLayerNames);
@@ -706,51 +572,38 @@
vkStream->loadStringArrayInPlace((char***)&forUnmarshaling->ppEnabledExtensionNames);
}
-void marshal_VkMemoryHeap(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryHeap* forMarshaling)
-{
+void marshal_VkMemoryHeap(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryHeap* forMarshaling) {
(void)rootType;
vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
vkStream->write((VkMemoryHeapFlags*)&forMarshaling->flags, sizeof(VkMemoryHeapFlags));
}
-void unmarshal_VkMemoryHeap(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryHeap* forUnmarshaling)
-{
+void unmarshal_VkMemoryHeap(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryHeap* forUnmarshaling) {
(void)rootType;
vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
vkStream->read((VkMemoryHeapFlags*)&forUnmarshaling->flags, sizeof(VkMemoryHeapFlags));
}
-void marshal_VkMemoryType(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryType* forMarshaling)
-{
+void marshal_VkMemoryType(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryType* forMarshaling) {
(void)rootType;
- vkStream->write((VkMemoryPropertyFlags*)&forMarshaling->propertyFlags, sizeof(VkMemoryPropertyFlags));
+ vkStream->write((VkMemoryPropertyFlags*)&forMarshaling->propertyFlags,
+ sizeof(VkMemoryPropertyFlags));
vkStream->write((uint32_t*)&forMarshaling->heapIndex, sizeof(uint32_t));
}
-void unmarshal_VkMemoryType(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryType* forUnmarshaling)
-{
+void unmarshal_VkMemoryType(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryType* forUnmarshaling) {
(void)rootType;
- vkStream->read((VkMemoryPropertyFlags*)&forUnmarshaling->propertyFlags, sizeof(VkMemoryPropertyFlags));
+ vkStream->read((VkMemoryPropertyFlags*)&forUnmarshaling->propertyFlags,
+ sizeof(VkMemoryPropertyFlags));
vkStream->read((uint32_t*)&forUnmarshaling->heapIndex, sizeof(uint32_t));
}
-void marshal_VkPhysicalDeviceFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFeatures* forMarshaling)
-{
+void marshal_VkPhysicalDeviceFeatures(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFeatures* forMarshaling) {
(void)rootType;
vkStream->write((VkBool32*)&forMarshaling->robustBufferAccess, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->fullDrawIndexUint32, sizeof(VkBool32));
@@ -779,16 +632,23 @@
vkStream->write((VkBool32*)&forMarshaling->pipelineStatisticsQuery, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->vertexPipelineStoresAndAtomics, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->fragmentStoresAndAtomics, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderTessellationAndGeometryPointSize, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderTessellationAndGeometryPointSize,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderImageGatherExtended, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageExtendedFormats, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageMultisample, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageReadWithoutFormat, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageWriteWithoutFormat, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayDynamicIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayDynamicIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayDynamicIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayDynamicIndexing, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageReadWithoutFormat,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageWriteWithoutFormat,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayDynamicIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayDynamicIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayDynamicIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayDynamicIndexing,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderClipDistance, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderCullDistance, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderFloat64, sizeof(VkBool32));
@@ -809,11 +669,8 @@
vkStream->write((VkBool32*)&forMarshaling->inheritedQueries, sizeof(VkBool32));
}
-void unmarshal_VkPhysicalDeviceFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceFeatures* forUnmarshaling)
-{
+void unmarshal_VkPhysicalDeviceFeatures(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceFeatures* forUnmarshaling) {
(void)rootType;
vkStream->read((VkBool32*)&forUnmarshaling->robustBufferAccess, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->fullDrawIndexUint32, sizeof(VkBool32));
@@ -842,16 +699,24 @@
vkStream->read((VkBool32*)&forUnmarshaling->pipelineStatisticsQuery, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->vertexPipelineStoresAndAtomics, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->fragmentStoresAndAtomics, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderTessellationAndGeometryPointSize, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderTessellationAndGeometryPointSize,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderImageGatherExtended, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageExtendedFormats, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageExtendedFormats,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageMultisample, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageReadWithoutFormat, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageWriteWithoutFormat, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayDynamicIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayDynamicIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayDynamicIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayDynamicIndexing, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageReadWithoutFormat,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageWriteWithoutFormat,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayDynamicIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayDynamicIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayDynamicIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayDynamicIndexing,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderClipDistance, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderCullDistance, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderFloat64, sizeof(VkBool32));
@@ -872,11 +737,8 @@
vkStream->read((VkBool32*)&forUnmarshaling->inheritedQueries, sizeof(VkBool32));
}
-void marshal_VkPhysicalDeviceLimits(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceLimits* forMarshaling)
-{
+void marshal_VkPhysicalDeviceLimits(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceLimits* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->maxImageDimension1D, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxImageDimension2D, sizeof(uint32_t));
@@ -893,17 +755,24 @@
vkStream->write((VkDeviceSize*)&forMarshaling->sparseAddressSpaceSize, sizeof(VkDeviceSize));
vkStream->write((uint32_t*)&forMarshaling->maxBoundDescriptorSets, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorSamplers, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUniformBuffers, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorStorageBuffers, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorSampledImages, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorStorageImages, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorInputAttachments, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUniformBuffers,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorStorageBuffers,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorSampledImages,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorStorageImages,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorInputAttachments,
+ sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxPerStageResources, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetSamplers, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUniformBuffers, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUniformBuffersDynamic, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUniformBuffersDynamic,
+ sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetStorageBuffers, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetStorageBuffersDynamic, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetStorageBuffersDynamic,
+ sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetSampledImages, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetStorageImages, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetInputAttachments, sizeof(uint32_t));
@@ -914,12 +783,18 @@
vkStream->write((uint32_t*)&forMarshaling->maxVertexOutputComponents, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxTessellationGenerationLevel, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxTessellationPatchSize, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxTessellationControlPerVertexInputComponents, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxTessellationControlPerVertexOutputComponents, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxTessellationControlPerPatchOutputComponents, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxTessellationControlTotalOutputComponents, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxTessellationEvaluationInputComponents, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxTessellationEvaluationOutputComponents, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxTessellationControlPerVertexInputComponents,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxTessellationControlPerVertexOutputComponents,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxTessellationControlPerPatchOutputComponents,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxTessellationControlTotalOutputComponents,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxTessellationEvaluationInputComponents,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxTessellationEvaluationOutputComponents,
+ sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxGeometryShaderInvocations, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxGeometryInputComponents, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxGeometryOutputComponents, sizeof(uint32_t));
@@ -928,7 +803,8 @@
vkStream->write((uint32_t*)&forMarshaling->maxFragmentInputComponents, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxFragmentOutputAttachments, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxFragmentDualSrcAttachments, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxFragmentCombinedOutputResources, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxFragmentCombinedOutputResources,
+ sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxComputeSharedMemorySize, sizeof(uint32_t));
vkStream->write((uint32_t*)forMarshaling->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxComputeWorkGroupInvocations, sizeof(uint32_t));
@@ -946,9 +822,12 @@
vkStream->write((uint32_t*)&forMarshaling->viewportSubPixelBits, sizeof(uint32_t));
uint64_t cgen_var_0 = (uint64_t)forMarshaling->minMemoryMapAlignment;
vkStream->putBe64(cgen_var_0);
- vkStream->write((VkDeviceSize*)&forMarshaling->minTexelBufferOffsetAlignment, sizeof(VkDeviceSize));
- vkStream->write((VkDeviceSize*)&forMarshaling->minUniformBufferOffsetAlignment, sizeof(VkDeviceSize));
- vkStream->write((VkDeviceSize*)&forMarshaling->minStorageBufferOffsetAlignment, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->minTexelBufferOffsetAlignment,
+ sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->minUniformBufferOffsetAlignment,
+ sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->minStorageBufferOffsetAlignment,
+ sizeof(VkDeviceSize));
vkStream->write((int32_t*)&forMarshaling->minTexelOffset, sizeof(int32_t));
vkStream->write((uint32_t*)&forMarshaling->maxTexelOffset, sizeof(uint32_t));
vkStream->write((int32_t*)&forMarshaling->minTexelGatherOffset, sizeof(int32_t));
@@ -959,16 +838,25 @@
vkStream->write((uint32_t*)&forMarshaling->maxFramebufferWidth, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxFramebufferHeight, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxFramebufferLayers, sizeof(uint32_t));
- vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferColorSampleCounts, sizeof(VkSampleCountFlags));
- vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferDepthSampleCounts, sizeof(VkSampleCountFlags));
- vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferStencilSampleCounts, sizeof(VkSampleCountFlags));
- vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferNoAttachmentsSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferColorSampleCounts,
+ sizeof(VkSampleCountFlags));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferDepthSampleCounts,
+ sizeof(VkSampleCountFlags));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferStencilSampleCounts,
+ sizeof(VkSampleCountFlags));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferNoAttachmentsSampleCounts,
+ sizeof(VkSampleCountFlags));
vkStream->write((uint32_t*)&forMarshaling->maxColorAttachments, sizeof(uint32_t));
- vkStream->write((VkSampleCountFlags*)&forMarshaling->sampledImageColorSampleCounts, sizeof(VkSampleCountFlags));
- vkStream->write((VkSampleCountFlags*)&forMarshaling->sampledImageIntegerSampleCounts, sizeof(VkSampleCountFlags));
- vkStream->write((VkSampleCountFlags*)&forMarshaling->sampledImageDepthSampleCounts, sizeof(VkSampleCountFlags));
- vkStream->write((VkSampleCountFlags*)&forMarshaling->sampledImageStencilSampleCounts, sizeof(VkSampleCountFlags));
- vkStream->write((VkSampleCountFlags*)&forMarshaling->storageImageSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->sampledImageColorSampleCounts,
+ sizeof(VkSampleCountFlags));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->sampledImageIntegerSampleCounts,
+ sizeof(VkSampleCountFlags));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->sampledImageDepthSampleCounts,
+ sizeof(VkSampleCountFlags));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->sampledImageStencilSampleCounts,
+ sizeof(VkSampleCountFlags));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->storageImageSampleCounts,
+ sizeof(VkSampleCountFlags));
vkStream->write((uint32_t*)&forMarshaling->maxSampleMaskWords, sizeof(uint32_t));
vkStream->write((VkBool32*)&forMarshaling->timestampComputeAndGraphics, sizeof(VkBool32));
vkStream->write((float*)&forMarshaling->timestampPeriod, sizeof(float));
@@ -982,16 +870,15 @@
vkStream->write((float*)&forMarshaling->lineWidthGranularity, sizeof(float));
vkStream->write((VkBool32*)&forMarshaling->strictLines, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->standardSampleLocations, sizeof(VkBool32));
- vkStream->write((VkDeviceSize*)&forMarshaling->optimalBufferCopyOffsetAlignment, sizeof(VkDeviceSize));
- vkStream->write((VkDeviceSize*)&forMarshaling->optimalBufferCopyRowPitchAlignment, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->optimalBufferCopyOffsetAlignment,
+ sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->optimalBufferCopyRowPitchAlignment,
+ sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->nonCoherentAtomSize, sizeof(VkDeviceSize));
}
-void unmarshal_VkPhysicalDeviceLimits(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceLimits* forUnmarshaling)
-{
+void unmarshal_VkPhysicalDeviceLimits(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceLimits* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->maxImageDimension1D, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxImageDimension2D, sizeof(uint32_t));
@@ -1008,17 +895,24 @@
vkStream->read((VkDeviceSize*)&forUnmarshaling->sparseAddressSpaceSize, sizeof(VkDeviceSize));
vkStream->read((uint32_t*)&forUnmarshaling->maxBoundDescriptorSets, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorSamplers, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUniformBuffers, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorStorageBuffers, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorSampledImages, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorStorageImages, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorInputAttachments, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUniformBuffers,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorStorageBuffers,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorSampledImages,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorStorageImages,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorInputAttachments,
+ sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageResources, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetSamplers, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUniformBuffers, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUniformBuffersDynamic, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUniformBuffersDynamic,
+ sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetStorageBuffers, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetStorageBuffersDynamic, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetStorageBuffersDynamic,
+ sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetSampledImages, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetStorageImages, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetInputAttachments, sizeof(uint32_t));
@@ -1029,12 +923,18 @@
vkStream->read((uint32_t*)&forUnmarshaling->maxVertexOutputComponents, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationGenerationLevel, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationPatchSize, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationControlPerVertexInputComponents, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationControlPerVertexOutputComponents, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationControlPerPatchOutputComponents, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationControlTotalOutputComponents, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationEvaluationInputComponents, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationEvaluationOutputComponents, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationControlPerVertexInputComponents,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationControlPerVertexOutputComponents,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationControlPerPatchOutputComponents,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationControlTotalOutputComponents,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationEvaluationInputComponents,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxTessellationEvaluationOutputComponents,
+ sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxGeometryShaderInvocations, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxGeometryInputComponents, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxGeometryOutputComponents, sizeof(uint32_t));
@@ -1043,7 +943,8 @@
vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentInputComponents, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentOutputAttachments, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentDualSrcAttachments, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentCombinedOutputResources, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentCombinedOutputResources,
+ sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxComputeSharedMemorySize, sizeof(uint32_t));
vkStream->read((uint32_t*)forUnmarshaling->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxComputeWorkGroupInvocations, sizeof(uint32_t));
@@ -1060,9 +961,12 @@
vkStream->read((float*)forUnmarshaling->viewportBoundsRange, 2 * sizeof(float));
vkStream->read((uint32_t*)&forUnmarshaling->viewportSubPixelBits, sizeof(uint32_t));
forUnmarshaling->minMemoryMapAlignment = (size_t)vkStream->getBe64();
- vkStream->read((VkDeviceSize*)&forUnmarshaling->minTexelBufferOffsetAlignment, sizeof(VkDeviceSize));
- vkStream->read((VkDeviceSize*)&forUnmarshaling->minUniformBufferOffsetAlignment, sizeof(VkDeviceSize));
- vkStream->read((VkDeviceSize*)&forUnmarshaling->minStorageBufferOffsetAlignment, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->minTexelBufferOffsetAlignment,
+ sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->minUniformBufferOffsetAlignment,
+ sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->minStorageBufferOffsetAlignment,
+ sizeof(VkDeviceSize));
vkStream->read((int32_t*)&forUnmarshaling->minTexelOffset, sizeof(int32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxTexelOffset, sizeof(uint32_t));
vkStream->read((int32_t*)&forUnmarshaling->minTexelGatherOffset, sizeof(int32_t));
@@ -1073,16 +977,25 @@
vkStream->read((uint32_t*)&forUnmarshaling->maxFramebufferWidth, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxFramebufferHeight, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxFramebufferLayers, sizeof(uint32_t));
- vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferColorSampleCounts, sizeof(VkSampleCountFlags));
- vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferDepthSampleCounts, sizeof(VkSampleCountFlags));
- vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferStencilSampleCounts, sizeof(VkSampleCountFlags));
- vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferNoAttachmentsSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferColorSampleCounts,
+ sizeof(VkSampleCountFlags));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferDepthSampleCounts,
+ sizeof(VkSampleCountFlags));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferStencilSampleCounts,
+ sizeof(VkSampleCountFlags));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferNoAttachmentsSampleCounts,
+ sizeof(VkSampleCountFlags));
vkStream->read((uint32_t*)&forUnmarshaling->maxColorAttachments, sizeof(uint32_t));
- vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampledImageColorSampleCounts, sizeof(VkSampleCountFlags));
- vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampledImageIntegerSampleCounts, sizeof(VkSampleCountFlags));
- vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampledImageDepthSampleCounts, sizeof(VkSampleCountFlags));
- vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampledImageStencilSampleCounts, sizeof(VkSampleCountFlags));
- vkStream->read((VkSampleCountFlags*)&forUnmarshaling->storageImageSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampledImageColorSampleCounts,
+ sizeof(VkSampleCountFlags));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampledImageIntegerSampleCounts,
+ sizeof(VkSampleCountFlags));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampledImageDepthSampleCounts,
+ sizeof(VkSampleCountFlags));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampledImageStencilSampleCounts,
+ sizeof(VkSampleCountFlags));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->storageImageSampleCounts,
+ sizeof(VkSampleCountFlags));
vkStream->read((uint32_t*)&forUnmarshaling->maxSampleMaskWords, sizeof(uint32_t));
vkStream->read((VkBool32*)&forUnmarshaling->timestampComputeAndGraphics, sizeof(VkBool32));
vkStream->read((float*)&forUnmarshaling->timestampPeriod, sizeof(float));
@@ -1096,220 +1009,202 @@
vkStream->read((float*)&forUnmarshaling->lineWidthGranularity, sizeof(float));
vkStream->read((VkBool32*)&forUnmarshaling->strictLines, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->standardSampleLocations, sizeof(VkBool32));
- vkStream->read((VkDeviceSize*)&forUnmarshaling->optimalBufferCopyOffsetAlignment, sizeof(VkDeviceSize));
- vkStream->read((VkDeviceSize*)&forUnmarshaling->optimalBufferCopyRowPitchAlignment, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->optimalBufferCopyOffsetAlignment,
+ sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->optimalBufferCopyRowPitchAlignment,
+ sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->nonCoherentAtomSize, sizeof(VkDeviceSize));
}
void marshal_VkPhysicalDeviceMemoryProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryProperties* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryProperties* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->memoryTypeCount, sizeof(uint32_t));
- for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i)
- {
+ for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i) {
marshal_VkMemoryType(vkStream, rootType, (VkMemoryType*)(forMarshaling->memoryTypes + i));
}
vkStream->write((uint32_t*)&forMarshaling->memoryHeapCount, sizeof(uint32_t));
- for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i)
- {
+ for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i) {
marshal_VkMemoryHeap(vkStream, rootType, (VkMemoryHeap*)(forMarshaling->memoryHeaps + i));
}
}
-void unmarshal_VkPhysicalDeviceMemoryProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceMemoryProperties* forUnmarshaling)
-{
+void unmarshal_VkPhysicalDeviceMemoryProperties(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPhysicalDeviceMemoryProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeCount, sizeof(uint32_t));
- for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i)
- {
- unmarshal_VkMemoryType(vkStream, rootType, (VkMemoryType*)(forUnmarshaling->memoryTypes + i));
+ for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i) {
+ unmarshal_VkMemoryType(vkStream, rootType,
+ (VkMemoryType*)(forUnmarshaling->memoryTypes + i));
}
vkStream->read((uint32_t*)&forUnmarshaling->memoryHeapCount, sizeof(uint32_t));
- for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i)
- {
- unmarshal_VkMemoryHeap(vkStream, rootType, (VkMemoryHeap*)(forUnmarshaling->memoryHeaps + i));
+ for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i) {
+ unmarshal_VkMemoryHeap(vkStream, rootType,
+ (VkMemoryHeap*)(forUnmarshaling->memoryHeaps + i));
}
}
void marshal_VkPhysicalDeviceSparseProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSparseProperties* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSparseProperties* forMarshaling) {
(void)rootType;
vkStream->write((VkBool32*)&forMarshaling->residencyStandard2DBlockShape, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->residencyStandard2DMultisampleBlockShape, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->residencyStandard2DMultisampleBlockShape,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->residencyStandard3DBlockShape, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->residencyAlignedMipSize, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->residencyNonResidentStrict, sizeof(VkBool32));
}
-void unmarshal_VkPhysicalDeviceSparseProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceSparseProperties* forUnmarshaling)
-{
+void unmarshal_VkPhysicalDeviceSparseProperties(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPhysicalDeviceSparseProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkBool32*)&forUnmarshaling->residencyStandard2DBlockShape, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->residencyStandard2DMultisampleBlockShape, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->residencyStandard2DMultisampleBlockShape,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->residencyStandard3DBlockShape, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->residencyAlignedMipSize, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->residencyNonResidentStrict, sizeof(VkBool32));
}
-void marshal_VkPhysicalDeviceProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceProperties* forMarshaling)
-{
+void marshal_VkPhysicalDeviceProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceProperties* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->apiVersion, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->driverVersion, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->vendorID, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->deviceID, sizeof(uint32_t));
- vkStream->write((VkPhysicalDeviceType*)&forMarshaling->deviceType, sizeof(VkPhysicalDeviceType));
- vkStream->write((char*)forMarshaling->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
+ vkStream->write((VkPhysicalDeviceType*)&forMarshaling->deviceType,
+ sizeof(VkPhysicalDeviceType));
+ vkStream->write((char*)forMarshaling->deviceName,
+ VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
vkStream->write((uint8_t*)forMarshaling->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
- marshal_VkPhysicalDeviceLimits(vkStream, rootType, (VkPhysicalDeviceLimits*)(&forMarshaling->limits));
- marshal_VkPhysicalDeviceSparseProperties(vkStream, rootType, (VkPhysicalDeviceSparseProperties*)(&forMarshaling->sparseProperties));
+ marshal_VkPhysicalDeviceLimits(vkStream, rootType,
+ (VkPhysicalDeviceLimits*)(&forMarshaling->limits));
+ marshal_VkPhysicalDeviceSparseProperties(
+ vkStream, rootType, (VkPhysicalDeviceSparseProperties*)(&forMarshaling->sparseProperties));
}
-void unmarshal_VkPhysicalDeviceProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceProperties* forUnmarshaling)
-{
+void unmarshal_VkPhysicalDeviceProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->apiVersion, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->driverVersion, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->vendorID, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->deviceID, sizeof(uint32_t));
- vkStream->read((VkPhysicalDeviceType*)&forUnmarshaling->deviceType, sizeof(VkPhysicalDeviceType));
- vkStream->read((char*)forUnmarshaling->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
+ vkStream->read((VkPhysicalDeviceType*)&forUnmarshaling->deviceType,
+ sizeof(VkPhysicalDeviceType));
+ vkStream->read((char*)forUnmarshaling->deviceName,
+ VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
vkStream->read((uint8_t*)forUnmarshaling->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
- unmarshal_VkPhysicalDeviceLimits(vkStream, rootType, (VkPhysicalDeviceLimits*)(&forUnmarshaling->limits));
- unmarshal_VkPhysicalDeviceSparseProperties(vkStream, rootType, (VkPhysicalDeviceSparseProperties*)(&forUnmarshaling->sparseProperties));
+ unmarshal_VkPhysicalDeviceLimits(vkStream, rootType,
+ (VkPhysicalDeviceLimits*)(&forUnmarshaling->limits));
+ unmarshal_VkPhysicalDeviceSparseProperties(
+ vkStream, rootType,
+ (VkPhysicalDeviceSparseProperties*)(&forUnmarshaling->sparseProperties));
}
-void marshal_VkQueueFamilyProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueueFamilyProperties* forMarshaling)
-{
+void marshal_VkQueueFamilyProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyProperties* forMarshaling) {
(void)rootType;
vkStream->write((VkQueueFlags*)&forMarshaling->queueFlags, sizeof(VkQueueFlags));
vkStream->write((uint32_t*)&forMarshaling->queueCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->timestampValidBits, sizeof(uint32_t));
- marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->minImageTransferGranularity));
+ marshal_VkExtent3D(vkStream, rootType,
+ (VkExtent3D*)(&forMarshaling->minImageTransferGranularity));
}
-void unmarshal_VkQueueFamilyProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkQueueFamilyProperties* forUnmarshaling)
-{
+void unmarshal_VkQueueFamilyProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkQueueFamilyProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkQueueFlags*)&forUnmarshaling->queueFlags, sizeof(VkQueueFlags));
vkStream->read((uint32_t*)&forUnmarshaling->queueCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->timestampValidBits, sizeof(uint32_t));
- unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->minImageTransferGranularity));
+ unmarshal_VkExtent3D(vkStream, rootType,
+ (VkExtent3D*)(&forUnmarshaling->minImageTransferGranularity));
}
-void marshal_VkDeviceQueueCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceQueueCreateInfo* forMarshaling)
-{
+void marshal_VkDeviceQueueCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceQueueCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDeviceQueueCreateFlags*)&forMarshaling->flags, sizeof(VkDeviceQueueCreateFlags));
+ vkStream->write((VkDeviceQueueCreateFlags*)&forMarshaling->flags,
+ sizeof(VkDeviceQueueCreateFlags));
vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->queueCount, sizeof(uint32_t));
- vkStream->write((const float*)forMarshaling->pQueuePriorities, forMarshaling->queueCount * sizeof(const float));
+ vkStream->write((const float*)forMarshaling->pQueuePriorities,
+ forMarshaling->queueCount * sizeof(const float));
}
-void unmarshal_VkDeviceQueueCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceQueueCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkDeviceQueueCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceQueueCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDeviceQueueCreateFlags*)&forUnmarshaling->flags, sizeof(VkDeviceQueueCreateFlags));
+ vkStream->read((VkDeviceQueueCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkDeviceQueueCreateFlags));
vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndex, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->queueCount, sizeof(uint32_t));
- vkStream->read((float*)forUnmarshaling->pQueuePriorities, forUnmarshaling->queueCount * sizeof(const float));
+ vkStream->read((float*)forUnmarshaling->pQueuePriorities,
+ forUnmarshaling->queueCount * sizeof(const float));
}
-void marshal_VkDeviceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceCreateInfo* forMarshaling)
-{
+void marshal_VkDeviceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDeviceCreateFlags*)&forMarshaling->flags, sizeof(VkDeviceCreateFlags));
vkStream->write((uint32_t*)&forMarshaling->queueCreateInfoCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueCreateInfoCount; ++i)
- {
- marshal_VkDeviceQueueCreateInfo(vkStream, rootType, (const VkDeviceQueueCreateInfo*)(forMarshaling->pQueueCreateInfos + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueCreateInfoCount; ++i) {
+ marshal_VkDeviceQueueCreateInfo(
+ vkStream, rootType,
+ (const VkDeviceQueueCreateInfo*)(forMarshaling->pQueueCreateInfos + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->enabledLayerCount, sizeof(uint32_t));
saveStringArray(vkStream, forMarshaling->ppEnabledLayerNames, forMarshaling->enabledLayerCount);
vkStream->write((uint32_t*)&forMarshaling->enabledExtensionCount, sizeof(uint32_t));
- saveStringArray(vkStream, forMarshaling->ppEnabledExtensionNames, forMarshaling->enabledExtensionCount);
+ saveStringArray(vkStream, forMarshaling->ppEnabledExtensionNames,
+ forMarshaling->enabledExtensionCount);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pEnabledFeatures;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pEnabledFeatures)
- {
- marshal_VkPhysicalDeviceFeatures(vkStream, rootType, (const VkPhysicalDeviceFeatures*)(forMarshaling->pEnabledFeatures));
+ if (forMarshaling->pEnabledFeatures) {
+ marshal_VkPhysicalDeviceFeatures(
+ vkStream, rootType, (const VkPhysicalDeviceFeatures*)(forMarshaling->pEnabledFeatures));
}
}
-void unmarshal_VkDeviceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkDeviceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkDeviceCreateFlags*)&forUnmarshaling->flags, sizeof(VkDeviceCreateFlags));
vkStream->read((uint32_t*)&forUnmarshaling->queueCreateInfoCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->queueCreateInfoCount; ++i)
- {
- unmarshal_VkDeviceQueueCreateInfo(vkStream, rootType, (VkDeviceQueueCreateInfo*)(forUnmarshaling->pQueueCreateInfos + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->queueCreateInfoCount; ++i) {
+ unmarshal_VkDeviceQueueCreateInfo(
+ vkStream, rootType,
+ (VkDeviceQueueCreateInfo*)(forUnmarshaling->pQueueCreateInfos + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->enabledLayerCount, sizeof(uint32_t));
@@ -1319,41 +1214,34 @@
// WARNING PTR CHECK
const VkPhysicalDeviceFeatures* check_pEnabledFeatures;
check_pEnabledFeatures = (const VkPhysicalDeviceFeatures*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pEnabledFeatures)
- {
- if (!(check_pEnabledFeatures))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pEnabledFeatures inconsistent between guest and host\n");
+ if (forUnmarshaling->pEnabledFeatures) {
+ if (!(check_pEnabledFeatures)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pEnabledFeatures inconsistent between guest and host\n");
}
- unmarshal_VkPhysicalDeviceFeatures(vkStream, rootType, (VkPhysicalDeviceFeatures*)(forUnmarshaling->pEnabledFeatures));
+ unmarshal_VkPhysicalDeviceFeatures(
+ vkStream, rootType, (VkPhysicalDeviceFeatures*)(forUnmarshaling->pEnabledFeatures));
}
}
-void marshal_VkExtensionProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExtensionProperties* forMarshaling)
-{
+void marshal_VkExtensionProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExtensionProperties* forMarshaling) {
(void)rootType;
vkStream->write((char*)forMarshaling->extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
vkStream->write((uint32_t*)&forMarshaling->specVersion, sizeof(uint32_t));
}
-void unmarshal_VkExtensionProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExtensionProperties* forUnmarshaling)
-{
+void unmarshal_VkExtensionProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExtensionProperties* forUnmarshaling) {
(void)rootType;
- vkStream->read((char*)forUnmarshaling->extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+ vkStream->read((char*)forUnmarshaling->extensionName,
+ VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
vkStream->read((uint32_t*)&forUnmarshaling->specVersion, sizeof(uint32_t));
}
-void marshal_VkLayerProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkLayerProperties* forMarshaling)
-{
+void marshal_VkLayerProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkLayerProperties* forMarshaling) {
(void)rootType;
vkStream->write((char*)forMarshaling->layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
vkStream->write((uint32_t*)&forMarshaling->specVersion, sizeof(uint32_t));
@@ -1361,11 +1249,8 @@
vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
}
-void unmarshal_VkLayerProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkLayerProperties* forUnmarshaling)
-{
+void unmarshal_VkLayerProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkLayerProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((char*)forUnmarshaling->layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
vkStream->read((uint32_t*)&forUnmarshaling->specVersion, sizeof(uint32_t));
@@ -1373,131 +1258,118 @@
vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
}
-void marshal_VkSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubmitInfo* forMarshaling)
-{
+void marshal_VkSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubmitInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
- if (forMarshaling->waitSemaphoreCount)
- {
+ if (forMarshaling->waitSemaphoreCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forMarshaling->waitSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pWaitSemaphores, cgen_var_0, forMarshaling->waitSemaphoreCount);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(
+ forMarshaling->pWaitSemaphores, cgen_var_0, forMarshaling->waitSemaphoreCount);
vkStream->write((uint64_t*)cgen_var_0, forMarshaling->waitSemaphoreCount * 8);
}
- vkStream->write((const VkPipelineStageFlags*)forMarshaling->pWaitDstStageMask, forMarshaling->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
+ vkStream->write((const VkPipelineStageFlags*)forMarshaling->pWaitDstStageMask,
+ forMarshaling->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
vkStream->write((uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
- if (forMarshaling->commandBufferCount)
- {
+ if (forMarshaling->commandBufferCount) {
uint64_t* cgen_var_1;
vkStream->alloc((void**)&cgen_var_1, forMarshaling->commandBufferCount * 8);
- vkStream->handleMapping()->mapHandles_VkCommandBuffer_u64(forMarshaling->pCommandBuffers, cgen_var_1, forMarshaling->commandBufferCount);
+ vkStream->handleMapping()->mapHandles_VkCommandBuffer_u64(
+ forMarshaling->pCommandBuffers, cgen_var_1, forMarshaling->commandBufferCount);
vkStream->write((uint64_t*)cgen_var_1, forMarshaling->commandBufferCount * 8);
}
vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
- if (forMarshaling->signalSemaphoreCount)
- {
+ if (forMarshaling->signalSemaphoreCount) {
uint64_t* cgen_var_2;
vkStream->alloc((void**)&cgen_var_2, forMarshaling->signalSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pSignalSemaphores, cgen_var_2, forMarshaling->signalSemaphoreCount);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(
+ forMarshaling->pSignalSemaphores, cgen_var_2, forMarshaling->signalSemaphoreCount);
vkStream->write((uint64_t*)cgen_var_2, forMarshaling->signalSemaphoreCount * 8);
}
}
-void unmarshal_VkSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubmitInfo* forUnmarshaling)
-{
+void unmarshal_VkSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubmitInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
- if (forUnmarshaling->waitSemaphoreCount)
- {
+ if (forUnmarshaling->waitSemaphoreCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->waitSemaphoreCount * 8);
vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->waitSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_0, (VkSemaphore*)forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
+ cgen_var_0, (VkSemaphore*)forUnmarshaling->pWaitSemaphores,
+ forUnmarshaling->waitSemaphoreCount);
}
- vkStream->read((VkPipelineStageFlags*)forUnmarshaling->pWaitDstStageMask, forUnmarshaling->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
+ vkStream->read((VkPipelineStageFlags*)forUnmarshaling->pWaitDstStageMask,
+ forUnmarshaling->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
vkStream->read((uint32_t*)&forUnmarshaling->commandBufferCount, sizeof(uint32_t));
- if (forUnmarshaling->commandBufferCount)
- {
+ if (forUnmarshaling->commandBufferCount) {
uint64_t* cgen_var_1;
vkStream->alloc((void**)&cgen_var_1, forUnmarshaling->commandBufferCount * 8);
vkStream->read((uint64_t*)cgen_var_1, forUnmarshaling->commandBufferCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkCommandBuffer(cgen_var_1, (VkCommandBuffer*)forUnmarshaling->pCommandBuffers, forUnmarshaling->commandBufferCount);
+ vkStream->handleMapping()->mapHandles_u64_VkCommandBuffer(
+ cgen_var_1, (VkCommandBuffer*)forUnmarshaling->pCommandBuffers,
+ forUnmarshaling->commandBufferCount);
}
vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreCount, sizeof(uint32_t));
- if (forUnmarshaling->signalSemaphoreCount)
- {
+ if (forUnmarshaling->signalSemaphoreCount) {
uint64_t* cgen_var_2;
vkStream->alloc((void**)&cgen_var_2, forUnmarshaling->signalSemaphoreCount * 8);
vkStream->read((uint64_t*)cgen_var_2, forUnmarshaling->signalSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_2, (VkSemaphore*)forUnmarshaling->pSignalSemaphores, forUnmarshaling->signalSemaphoreCount);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
+ cgen_var_2, (VkSemaphore*)forUnmarshaling->pSignalSemaphores,
+ forUnmarshaling->signalSemaphoreCount);
}
}
-void marshal_VkMappedMemoryRange(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMappedMemoryRange* forMarshaling)
-{
+void marshal_VkMappedMemoryRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMappedMemoryRange* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
}
-void unmarshal_VkMappedMemoryRange(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMappedMemoryRange* forUnmarshaling)
-{
+void unmarshal_VkMappedMemoryRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMappedMemoryRange* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+ &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
}
-void marshal_VkMemoryAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryAllocateInfo* forMarshaling)
-{
+void marshal_VkMemoryAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryAllocateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -1505,15 +1377,11 @@
vkStream->write((uint32_t*)&forMarshaling->memoryTypeIndex, sizeof(uint32_t));
}
-void unmarshal_VkMemoryAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryAllocateInfo* forUnmarshaling)
-{
+void unmarshal_VkMemoryAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryAllocateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -1521,517 +1389,439 @@
vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeIndex, sizeof(uint32_t));
}
-void marshal_VkMemoryRequirements(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryRequirements* forMarshaling)
-{
+void marshal_VkMemoryRequirements(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryRequirements* forMarshaling) {
(void)rootType;
vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->alignment, sizeof(VkDeviceSize));
vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
}
-void unmarshal_VkMemoryRequirements(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryRequirements* forUnmarshaling)
-{
+void unmarshal_VkMemoryRequirements(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryRequirements* forUnmarshaling) {
(void)rootType;
vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->alignment, sizeof(VkDeviceSize));
vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
}
-void marshal_VkSparseMemoryBind(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseMemoryBind* forMarshaling)
-{
+void marshal_VkSparseMemoryBind(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseMemoryBind* forMarshaling) {
(void)rootType;
vkStream->write((VkDeviceSize*)&forMarshaling->resourceOffset, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
- vkStream->write((VkSparseMemoryBindFlags*)&forMarshaling->flags, sizeof(VkSparseMemoryBindFlags));
+ vkStream->write((VkSparseMemoryBindFlags*)&forMarshaling->flags,
+ sizeof(VkSparseMemoryBindFlags));
}
-void unmarshal_VkSparseMemoryBind(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSparseMemoryBind* forUnmarshaling)
-{
+void unmarshal_VkSparseMemoryBind(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSparseMemoryBind* forUnmarshaling) {
(void)rootType;
vkStream->read((VkDeviceSize*)&forUnmarshaling->resourceOffset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+ &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
- vkStream->read((VkSparseMemoryBindFlags*)&forUnmarshaling->flags, sizeof(VkSparseMemoryBindFlags));
+ vkStream->read((VkSparseMemoryBindFlags*)&forUnmarshaling->flags,
+ sizeof(VkSparseMemoryBindFlags));
}
-void marshal_VkSparseBufferMemoryBindInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseBufferMemoryBindInfo* forMarshaling)
-{
+void marshal_VkSparseBufferMemoryBindInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseBufferMemoryBindInfo* forMarshaling) {
(void)rootType;
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
- {
- marshal_VkSparseMemoryBind(vkStream, rootType, (const VkSparseMemoryBind*)(forMarshaling->pBinds + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i) {
+ marshal_VkSparseMemoryBind(vkStream, rootType,
+ (const VkSparseMemoryBind*)(forMarshaling->pBinds + i));
}
}
}
-void unmarshal_VkSparseBufferMemoryBindInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSparseBufferMemoryBindInfo* forUnmarshaling)
-{
+void unmarshal_VkSparseBufferMemoryBindInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSparseBufferMemoryBindInfo* forUnmarshaling) {
(void)rootType;
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+ (VkBuffer*)&forUnmarshaling->buffer, 1);
vkStream->read((uint32_t*)&forUnmarshaling->bindCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i)
- {
- unmarshal_VkSparseMemoryBind(vkStream, rootType, (VkSparseMemoryBind*)(forUnmarshaling->pBinds + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i) {
+ unmarshal_VkSparseMemoryBind(vkStream, rootType,
+ (VkSparseMemoryBind*)(forUnmarshaling->pBinds + i));
}
}
}
void marshal_VkSparseImageOpaqueMemoryBindInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageOpaqueMemoryBindInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageOpaqueMemoryBindInfo* forMarshaling) {
(void)rootType;
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
- {
- marshal_VkSparseMemoryBind(vkStream, rootType, (const VkSparseMemoryBind*)(forMarshaling->pBinds + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i) {
+ marshal_VkSparseMemoryBind(vkStream, rootType,
+ (const VkSparseMemoryBind*)(forMarshaling->pBinds + i));
}
}
}
void unmarshal_VkSparseImageOpaqueMemoryBindInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSparseImageOpaqueMemoryBindInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSparseImageOpaqueMemoryBindInfo* forUnmarshaling) {
(void)rootType;
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0, (VkImage*)&forUnmarshaling->image, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+ (VkImage*)&forUnmarshaling->image, 1);
vkStream->read((uint32_t*)&forUnmarshaling->bindCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i)
- {
- unmarshal_VkSparseMemoryBind(vkStream, rootType, (VkSparseMemoryBind*)(forUnmarshaling->pBinds + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i) {
+ unmarshal_VkSparseMemoryBind(vkStream, rootType,
+ (VkSparseMemoryBind*)(forUnmarshaling->pBinds + i));
}
}
}
-void marshal_VkImageSubresource(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageSubresource* forMarshaling)
-{
+void marshal_VkImageSubresource(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSubresource* forMarshaling) {
(void)rootType;
vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
vkStream->write((uint32_t*)&forMarshaling->mipLevel, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->arrayLayer, sizeof(uint32_t));
}
-void unmarshal_VkImageSubresource(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageSubresource* forUnmarshaling)
-{
+void unmarshal_VkImageSubresource(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageSubresource* forUnmarshaling) {
(void)rootType;
vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
vkStream->read((uint32_t*)&forUnmarshaling->mipLevel, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->arrayLayer, sizeof(uint32_t));
}
-void marshal_VkSparseImageMemoryBind(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageMemoryBind* forMarshaling)
-{
+void marshal_VkSparseImageMemoryBind(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageMemoryBind* forMarshaling) {
(void)rootType;
- marshal_VkImageSubresource(vkStream, rootType, (VkImageSubresource*)(&forMarshaling->subresource));
+ marshal_VkImageSubresource(vkStream, rootType,
+ (VkImageSubresource*)(&forMarshaling->subresource));
marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->offset));
marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent));
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
- vkStream->write((VkSparseMemoryBindFlags*)&forMarshaling->flags, sizeof(VkSparseMemoryBindFlags));
+ vkStream->write((VkSparseMemoryBindFlags*)&forMarshaling->flags,
+ sizeof(VkSparseMemoryBindFlags));
}
-void unmarshal_VkSparseImageMemoryBind(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSparseImageMemoryBind* forUnmarshaling)
-{
+void unmarshal_VkSparseImageMemoryBind(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSparseImageMemoryBind* forUnmarshaling) {
(void)rootType;
- unmarshal_VkImageSubresource(vkStream, rootType, (VkImageSubresource*)(&forUnmarshaling->subresource));
+ unmarshal_VkImageSubresource(vkStream, rootType,
+ (VkImageSubresource*)(&forUnmarshaling->subresource));
unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->offset));
unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->extent));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+ &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
- vkStream->read((VkSparseMemoryBindFlags*)&forUnmarshaling->flags, sizeof(VkSparseMemoryBindFlags));
+ vkStream->read((VkSparseMemoryBindFlags*)&forUnmarshaling->flags,
+ sizeof(VkSparseMemoryBindFlags));
}
-void marshal_VkSparseImageMemoryBindInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageMemoryBindInfo* forMarshaling)
-{
+void marshal_VkSparseImageMemoryBindInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageMemoryBindInfo* forMarshaling) {
(void)rootType;
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
- {
- marshal_VkSparseImageMemoryBind(vkStream, rootType, (const VkSparseImageMemoryBind*)(forMarshaling->pBinds + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i) {
+ marshal_VkSparseImageMemoryBind(
+ vkStream, rootType, (const VkSparseImageMemoryBind*)(forMarshaling->pBinds + i));
}
}
}
-void unmarshal_VkSparseImageMemoryBindInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSparseImageMemoryBindInfo* forUnmarshaling)
-{
+void unmarshal_VkSparseImageMemoryBindInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSparseImageMemoryBindInfo* forUnmarshaling) {
(void)rootType;
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0, (VkImage*)&forUnmarshaling->image, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+ (VkImage*)&forUnmarshaling->image, 1);
vkStream->read((uint32_t*)&forUnmarshaling->bindCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i)
- {
- unmarshal_VkSparseImageMemoryBind(vkStream, rootType, (VkSparseImageMemoryBind*)(forUnmarshaling->pBinds + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindCount; ++i) {
+ unmarshal_VkSparseImageMemoryBind(
+ vkStream, rootType, (VkSparseImageMemoryBind*)(forUnmarshaling->pBinds + i));
}
}
}
-void marshal_VkBindSparseInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindSparseInfo* forMarshaling)
-{
+void marshal_VkBindSparseInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindSparseInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
- if (forMarshaling->waitSemaphoreCount)
- {
+ if (forMarshaling->waitSemaphoreCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forMarshaling->waitSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pWaitSemaphores, cgen_var_0, forMarshaling->waitSemaphoreCount);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(
+ forMarshaling->pWaitSemaphores, cgen_var_0, forMarshaling->waitSemaphoreCount);
vkStream->write((uint64_t*)cgen_var_0, forMarshaling->waitSemaphoreCount * 8);
}
vkStream->write((uint32_t*)&forMarshaling->bufferBindCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->bufferBindCount; ++i)
- {
- marshal_VkSparseBufferMemoryBindInfo(vkStream, rootType, (const VkSparseBufferMemoryBindInfo*)(forMarshaling->pBufferBinds + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->bufferBindCount; ++i) {
+ marshal_VkSparseBufferMemoryBindInfo(
+ vkStream, rootType,
+ (const VkSparseBufferMemoryBindInfo*)(forMarshaling->pBufferBinds + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->imageOpaqueBindCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageOpaqueBindCount; ++i)
- {
- marshal_VkSparseImageOpaqueMemoryBindInfo(vkStream, rootType, (const VkSparseImageOpaqueMemoryBindInfo*)(forMarshaling->pImageOpaqueBinds + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageOpaqueBindCount; ++i) {
+ marshal_VkSparseImageOpaqueMemoryBindInfo(
+ vkStream, rootType,
+ (const VkSparseImageOpaqueMemoryBindInfo*)(forMarshaling->pImageOpaqueBinds + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->imageBindCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageBindCount; ++i)
- {
- marshal_VkSparseImageMemoryBindInfo(vkStream, rootType, (const VkSparseImageMemoryBindInfo*)(forMarshaling->pImageBinds + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageBindCount; ++i) {
+ marshal_VkSparseImageMemoryBindInfo(
+ vkStream, rootType,
+ (const VkSparseImageMemoryBindInfo*)(forMarshaling->pImageBinds + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
- if (forMarshaling->signalSemaphoreCount)
- {
+ if (forMarshaling->signalSemaphoreCount) {
uint64_t* cgen_var_1;
vkStream->alloc((void**)&cgen_var_1, forMarshaling->signalSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pSignalSemaphores, cgen_var_1, forMarshaling->signalSemaphoreCount);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(
+ forMarshaling->pSignalSemaphores, cgen_var_1, forMarshaling->signalSemaphoreCount);
vkStream->write((uint64_t*)cgen_var_1, forMarshaling->signalSemaphoreCount * 8);
}
}
-void unmarshal_VkBindSparseInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBindSparseInfo* forUnmarshaling)
-{
+void unmarshal_VkBindSparseInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBindSparseInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
- if (forUnmarshaling->waitSemaphoreCount)
- {
+ if (forUnmarshaling->waitSemaphoreCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->waitSemaphoreCount * 8);
vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->waitSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_0, (VkSemaphore*)forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
+ cgen_var_0, (VkSemaphore*)forUnmarshaling->pWaitSemaphores,
+ forUnmarshaling->waitSemaphoreCount);
}
vkStream->read((uint32_t*)&forUnmarshaling->bufferBindCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bufferBindCount; ++i)
- {
- unmarshal_VkSparseBufferMemoryBindInfo(vkStream, rootType, (VkSparseBufferMemoryBindInfo*)(forUnmarshaling->pBufferBinds + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bufferBindCount; ++i) {
+ unmarshal_VkSparseBufferMemoryBindInfo(
+ vkStream, rootType,
+ (VkSparseBufferMemoryBindInfo*)(forUnmarshaling->pBufferBinds + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->imageOpaqueBindCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->imageOpaqueBindCount; ++i)
- {
- unmarshal_VkSparseImageOpaqueMemoryBindInfo(vkStream, rootType, (VkSparseImageOpaqueMemoryBindInfo*)(forUnmarshaling->pImageOpaqueBinds + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->imageOpaqueBindCount; ++i) {
+ unmarshal_VkSparseImageOpaqueMemoryBindInfo(
+ vkStream, rootType,
+ (VkSparseImageOpaqueMemoryBindInfo*)(forUnmarshaling->pImageOpaqueBinds + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->imageBindCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->imageBindCount; ++i)
- {
- unmarshal_VkSparseImageMemoryBindInfo(vkStream, rootType, (VkSparseImageMemoryBindInfo*)(forUnmarshaling->pImageBinds + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->imageBindCount; ++i) {
+ unmarshal_VkSparseImageMemoryBindInfo(
+ vkStream, rootType,
+ (VkSparseImageMemoryBindInfo*)(forUnmarshaling->pImageBinds + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreCount, sizeof(uint32_t));
- if (forUnmarshaling->signalSemaphoreCount)
- {
+ if (forUnmarshaling->signalSemaphoreCount) {
uint64_t* cgen_var_1;
vkStream->alloc((void**)&cgen_var_1, forUnmarshaling->signalSemaphoreCount * 8);
vkStream->read((uint64_t*)cgen_var_1, forUnmarshaling->signalSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_1, (VkSemaphore*)forUnmarshaling->pSignalSemaphores, forUnmarshaling->signalSemaphoreCount);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
+ cgen_var_1, (VkSemaphore*)forUnmarshaling->pSignalSemaphores,
+ forUnmarshaling->signalSemaphoreCount);
}
}
-void marshal_VkSparseImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageFormatProperties* forMarshaling)
-{
+void marshal_VkSparseImageFormatProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageFormatProperties* forMarshaling) {
(void)rootType;
vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageGranularity));
- vkStream->write((VkSparseImageFormatFlags*)&forMarshaling->flags, sizeof(VkSparseImageFormatFlags));
+ vkStream->write((VkSparseImageFormatFlags*)&forMarshaling->flags,
+ sizeof(VkSparseImageFormatFlags));
}
-void unmarshal_VkSparseImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSparseImageFormatProperties* forUnmarshaling)
-{
+void unmarshal_VkSparseImageFormatProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSparseImageFormatProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageGranularity));
- vkStream->read((VkSparseImageFormatFlags*)&forUnmarshaling->flags, sizeof(VkSparseImageFormatFlags));
+ vkStream->read((VkSparseImageFormatFlags*)&forUnmarshaling->flags,
+ sizeof(VkSparseImageFormatFlags));
}
-void marshal_VkSparseImageMemoryRequirements(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageMemoryRequirements* forMarshaling)
-{
+void marshal_VkSparseImageMemoryRequirements(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageMemoryRequirements* forMarshaling) {
(void)rootType;
- marshal_VkSparseImageFormatProperties(vkStream, rootType, (VkSparseImageFormatProperties*)(&forMarshaling->formatProperties));
+ marshal_VkSparseImageFormatProperties(
+ vkStream, rootType, (VkSparseImageFormatProperties*)(&forMarshaling->formatProperties));
vkStream->write((uint32_t*)&forMarshaling->imageMipTailFirstLod, sizeof(uint32_t));
vkStream->write((VkDeviceSize*)&forMarshaling->imageMipTailSize, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->imageMipTailOffset, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->imageMipTailStride, sizeof(VkDeviceSize));
}
-void unmarshal_VkSparseImageMemoryRequirements(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSparseImageMemoryRequirements* forUnmarshaling)
-{
+void unmarshal_VkSparseImageMemoryRequirements(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkSparseImageMemoryRequirements* forUnmarshaling) {
(void)rootType;
- unmarshal_VkSparseImageFormatProperties(vkStream, rootType, (VkSparseImageFormatProperties*)(&forUnmarshaling->formatProperties));
+ unmarshal_VkSparseImageFormatProperties(
+ vkStream, rootType, (VkSparseImageFormatProperties*)(&forUnmarshaling->formatProperties));
vkStream->read((uint32_t*)&forUnmarshaling->imageMipTailFirstLod, sizeof(uint32_t));
vkStream->read((VkDeviceSize*)&forUnmarshaling->imageMipTailSize, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->imageMipTailOffset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->imageMipTailStride, sizeof(VkDeviceSize));
}
-void marshal_VkFenceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFenceCreateInfo* forMarshaling)
-{
+void marshal_VkFenceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFenceCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkFenceCreateFlags*)&forMarshaling->flags, sizeof(VkFenceCreateFlags));
}
-void unmarshal_VkFenceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkFenceCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkFenceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkFenceCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkFenceCreateFlags*)&forUnmarshaling->flags, sizeof(VkFenceCreateFlags));
}
-void marshal_VkSemaphoreCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreCreateInfo* forMarshaling)
-{
+void marshal_VkSemaphoreCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkSemaphoreCreateFlags*)&forMarshaling->flags, sizeof(VkSemaphoreCreateFlags));
}
-void unmarshal_VkSemaphoreCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSemaphoreCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkSemaphoreCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSemaphoreCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkSemaphoreCreateFlags*)&forUnmarshaling->flags, sizeof(VkSemaphoreCreateFlags));
+ vkStream->read((VkSemaphoreCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkSemaphoreCreateFlags));
}
-void marshal_VkEventCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkEventCreateInfo* forMarshaling)
-{
+void marshal_VkEventCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkEventCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkEventCreateFlags*)&forMarshaling->flags, sizeof(VkEventCreateFlags));
}
-void unmarshal_VkEventCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkEventCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkEventCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkEventCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkEventCreateFlags*)&forUnmarshaling->flags, sizeof(VkEventCreateFlags));
}
-void marshal_VkQueryPoolCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueryPoolCreateInfo* forMarshaling)
-{
+void marshal_VkQueryPoolCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueryPoolCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkQueryPoolCreateFlags*)&forMarshaling->flags, sizeof(VkQueryPoolCreateFlags));
vkStream->write((VkQueryType*)&forMarshaling->queryType, sizeof(VkQueryType));
vkStream->write((uint32_t*)&forMarshaling->queryCount, sizeof(uint32_t));
- vkStream->write((VkQueryPipelineStatisticFlags*)&forMarshaling->pipelineStatistics, sizeof(VkQueryPipelineStatisticFlags));
+ vkStream->write((VkQueryPipelineStatisticFlags*)&forMarshaling->pipelineStatistics,
+ sizeof(VkQueryPipelineStatisticFlags));
}
-void unmarshal_VkQueryPoolCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkQueryPoolCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkQueryPoolCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkQueryPoolCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkQueryPoolCreateFlags*)&forUnmarshaling->flags, sizeof(VkQueryPoolCreateFlags));
+ vkStream->read((VkQueryPoolCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkQueryPoolCreateFlags));
vkStream->read((VkQueryType*)&forUnmarshaling->queryType, sizeof(VkQueryType));
vkStream->read((uint32_t*)&forUnmarshaling->queryCount, sizeof(uint32_t));
- vkStream->read((VkQueryPipelineStatisticFlags*)&forUnmarshaling->pipelineStatistics, sizeof(VkQueryPipelineStatisticFlags));
+ vkStream->read((VkQueryPipelineStatisticFlags*)&forUnmarshaling->pipelineStatistics,
+ sizeof(VkQueryPipelineStatisticFlags));
}
-void marshal_VkBufferCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCreateInfo* forMarshaling)
-{
+void marshal_VkBufferCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -2043,21 +1833,17 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pQueueFamilyIndices)
- {
- vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices, forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ if (forMarshaling->pQueueFamilyIndices) {
+ vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices,
+ forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
}
}
-void unmarshal_VkBufferCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkBufferCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -2069,29 +1855,27 @@
// WARNING PTR CHECK
const uint32_t* check_pQueueFamilyIndices;
check_pQueueFamilyIndices = (const uint32_t*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pQueueFamilyIndices)
- {
- if (!(check_pQueueFamilyIndices))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pQueueFamilyIndices inconsistent between guest and host\n");
+ if (forUnmarshaling->pQueueFamilyIndices) {
+ if (!(check_pQueueFamilyIndices)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pQueueFamilyIndices inconsistent between guest and "
+ "host\n");
}
- vkStream->read((uint32_t*)forUnmarshaling->pQueueFamilyIndices, forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pQueueFamilyIndices,
+ forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
}
}
-void marshal_VkBufferViewCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferViewCreateInfo* forMarshaling)
-{
+void marshal_VkBufferViewCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferViewCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkBufferViewCreateFlags*)&forMarshaling->flags, sizeof(VkBufferViewCreateFlags));
+ vkStream->write((VkBufferViewCreateFlags*)&forMarshaling->flags,
+ sizeof(VkBufferViewCreateFlags));
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -2100,36 +1884,30 @@
vkStream->write((VkDeviceSize*)&forMarshaling->range, sizeof(VkDeviceSize));
}
-void unmarshal_VkBufferViewCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferViewCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkBufferViewCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferViewCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkBufferViewCreateFlags*)&forUnmarshaling->flags, sizeof(VkBufferViewCreateFlags));
+ vkStream->read((VkBufferViewCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkBufferViewCreateFlags));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+ (VkBuffer*)&forUnmarshaling->buffer, 1);
vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->range, sizeof(VkDeviceSize));
}
-void marshal_VkImageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageCreateInfo* forMarshaling)
-{
+void marshal_VkImageCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -2147,22 +1925,18 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pQueueFamilyIndices)
- {
- vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices, forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ if (forMarshaling->pQueueFamilyIndices) {
+ vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices,
+ forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
}
vkStream->write((VkImageLayout*)&forMarshaling->initialLayout, sizeof(VkImageLayout));
}
-void unmarshal_VkImageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkImageCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -2172,7 +1946,8 @@
unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->extent));
vkStream->read((uint32_t*)&forUnmarshaling->mipLevels, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->arrayLayers, sizeof(uint32_t));
- vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples, sizeof(VkSampleCountFlagBits));
+ vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples,
+ sizeof(VkSampleCountFlagBits));
vkStream->read((VkImageTiling*)&forUnmarshaling->tiling, sizeof(VkImageTiling));
vkStream->read((VkImageUsageFlags*)&forUnmarshaling->usage, sizeof(VkImageUsageFlags));
vkStream->read((VkSharingMode*)&forUnmarshaling->sharingMode, sizeof(VkSharingMode));
@@ -2180,22 +1955,20 @@
// WARNING PTR CHECK
const uint32_t* check_pQueueFamilyIndices;
check_pQueueFamilyIndices = (const uint32_t*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pQueueFamilyIndices)
- {
- if (!(check_pQueueFamilyIndices))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pQueueFamilyIndices inconsistent between guest and host\n");
+ if (forUnmarshaling->pQueueFamilyIndices) {
+ if (!(check_pQueueFamilyIndices)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pQueueFamilyIndices inconsistent between guest and "
+ "host\n");
}
- vkStream->read((uint32_t*)forUnmarshaling->pQueueFamilyIndices, forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pQueueFamilyIndices,
+ forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
}
vkStream->read((VkImageLayout*)&forUnmarshaling->initialLayout, sizeof(VkImageLayout));
}
-void marshal_VkSubresourceLayout(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubresourceLayout* forMarshaling)
-{
+void marshal_VkSubresourceLayout(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubresourceLayout* forMarshaling) {
(void)rootType;
vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
@@ -2204,11 +1977,8 @@
vkStream->write((VkDeviceSize*)&forMarshaling->depthPitch, sizeof(VkDeviceSize));
}
-void unmarshal_VkSubresourceLayout(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubresourceLayout* forUnmarshaling)
-{
+void unmarshal_VkSubresourceLayout(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubresourceLayout* forUnmarshaling) {
(void)rootType;
vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
@@ -2217,11 +1987,8 @@
vkStream->read((VkDeviceSize*)&forUnmarshaling->depthPitch, sizeof(VkDeviceSize));
}
-void marshal_VkComponentMapping(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkComponentMapping* forMarshaling)
-{
+void marshal_VkComponentMapping(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkComponentMapping* forMarshaling) {
(void)rootType;
vkStream->write((VkComponentSwizzle*)&forMarshaling->r, sizeof(VkComponentSwizzle));
vkStream->write((VkComponentSwizzle*)&forMarshaling->g, sizeof(VkComponentSwizzle));
@@ -2229,11 +1996,8 @@
vkStream->write((VkComponentSwizzle*)&forMarshaling->a, sizeof(VkComponentSwizzle));
}
-void unmarshal_VkComponentMapping(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkComponentMapping* forUnmarshaling)
-{
+void unmarshal_VkComponentMapping(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkComponentMapping* forUnmarshaling) {
(void)rootType;
vkStream->read((VkComponentSwizzle*)&forUnmarshaling->r, sizeof(VkComponentSwizzle));
vkStream->read((VkComponentSwizzle*)&forUnmarshaling->g, sizeof(VkComponentSwizzle));
@@ -2241,15 +2005,11 @@
vkStream->read((VkComponentSwizzle*)&forUnmarshaling->a, sizeof(VkComponentSwizzle));
}
-void marshal_VkImageViewCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageViewCreateInfo* forMarshaling)
-{
+void marshal_VkImageViewCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageViewCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -2259,107 +2019,98 @@
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((VkImageViewType*)&forMarshaling->viewType, sizeof(VkImageViewType));
vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
- marshal_VkComponentMapping(vkStream, rootType, (VkComponentMapping*)(&forMarshaling->components));
- marshal_VkImageSubresourceRange(vkStream, rootType, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
+ marshal_VkComponentMapping(vkStream, rootType,
+ (VkComponentMapping*)(&forMarshaling->components));
+ marshal_VkImageSubresourceRange(vkStream, rootType,
+ (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
}
-void unmarshal_VkImageViewCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageViewCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkImageViewCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageViewCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkImageViewCreateFlags*)&forUnmarshaling->flags, sizeof(VkImageViewCreateFlags));
+ vkStream->read((VkImageViewCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkImageViewCreateFlags));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0, (VkImage*)&forUnmarshaling->image, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+ (VkImage*)&forUnmarshaling->image, 1);
vkStream->read((VkImageViewType*)&forUnmarshaling->viewType, sizeof(VkImageViewType));
vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
- unmarshal_VkComponentMapping(vkStream, rootType, (VkComponentMapping*)(&forUnmarshaling->components));
- unmarshal_VkImageSubresourceRange(vkStream, rootType, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
+ unmarshal_VkComponentMapping(vkStream, rootType,
+ (VkComponentMapping*)(&forUnmarshaling->components));
+ unmarshal_VkImageSubresourceRange(
+ vkStream, rootType, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
}
-void marshal_VkShaderModuleCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkShaderModuleCreateInfo* forMarshaling)
-{
+void marshal_VkShaderModuleCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkShaderModuleCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkShaderModuleCreateFlags*)&forMarshaling->flags, sizeof(VkShaderModuleCreateFlags));
+ vkStream->write((VkShaderModuleCreateFlags*)&forMarshaling->flags,
+ sizeof(VkShaderModuleCreateFlags));
uint64_t cgen_var_0 = (uint64_t)forMarshaling->codeSize;
vkStream->putBe64(cgen_var_0);
- vkStream->write((const uint32_t*)forMarshaling->pCode, (forMarshaling->codeSize / 4) * sizeof(const uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pCode,
+ (forMarshaling->codeSize / 4) * sizeof(const uint32_t));
}
-void unmarshal_VkShaderModuleCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkShaderModuleCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkShaderModuleCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkShaderModuleCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkShaderModuleCreateFlags*)&forUnmarshaling->flags, sizeof(VkShaderModuleCreateFlags));
+ vkStream->read((VkShaderModuleCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkShaderModuleCreateFlags));
forUnmarshaling->codeSize = (size_t)vkStream->getBe64();
- vkStream->read((uint32_t*)forUnmarshaling->pCode, (forUnmarshaling->codeSize / 4) * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pCode,
+ (forUnmarshaling->codeSize / 4) * sizeof(const uint32_t));
}
-void marshal_VkPipelineCacheCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCacheCreateInfo* forMarshaling)
-{
+void marshal_VkPipelineCacheCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCacheCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineCacheCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCacheCreateFlags));
+ vkStream->write((VkPipelineCacheCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineCacheCreateFlags));
uint64_t cgen_var_0 = (uint64_t)forMarshaling->initialDataSize;
vkStream->putBe64(cgen_var_0);
- vkStream->write((const void*)forMarshaling->pInitialData, forMarshaling->initialDataSize * sizeof(const uint8_t));
+ vkStream->write((const void*)forMarshaling->pInitialData,
+ forMarshaling->initialDataSize * sizeof(const uint8_t));
}
-void unmarshal_VkPipelineCacheCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineCacheCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkPipelineCacheCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineCacheCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineCacheCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCacheCreateFlags));
+ vkStream->read((VkPipelineCacheCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkPipelineCacheCreateFlags));
forUnmarshaling->initialDataSize = (size_t)vkStream->getBe64();
- vkStream->read((void*)forUnmarshaling->pInitialData, forUnmarshaling->initialDataSize * sizeof(const uint8_t));
+ vkStream->read((void*)forUnmarshaling->pInitialData,
+ forUnmarshaling->initialDataSize * sizeof(const uint8_t));
}
-void marshal_VkSpecializationMapEntry(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSpecializationMapEntry* forMarshaling)
-{
+void marshal_VkSpecializationMapEntry(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSpecializationMapEntry* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->constantID, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
@@ -2367,174 +2118,157 @@
vkStream->putBe64(cgen_var_0);
}
-void unmarshal_VkSpecializationMapEntry(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSpecializationMapEntry* forUnmarshaling)
-{
+void unmarshal_VkSpecializationMapEntry(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSpecializationMapEntry* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->constantID, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->offset, sizeof(uint32_t));
forUnmarshaling->size = (size_t)vkStream->getBe64();
}
-void marshal_VkSpecializationInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSpecializationInfo* forMarshaling)
-{
+void marshal_VkSpecializationInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSpecializationInfo* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->mapEntryCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->mapEntryCount; ++i)
- {
- marshal_VkSpecializationMapEntry(vkStream, rootType, (const VkSpecializationMapEntry*)(forMarshaling->pMapEntries + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->mapEntryCount; ++i) {
+ marshal_VkSpecializationMapEntry(
+ vkStream, rootType,
+ (const VkSpecializationMapEntry*)(forMarshaling->pMapEntries + i));
}
}
uint64_t cgen_var_0 = (uint64_t)forMarshaling->dataSize;
vkStream->putBe64(cgen_var_0);
- vkStream->write((const void*)forMarshaling->pData, forMarshaling->dataSize * sizeof(const uint8_t));
+ vkStream->write((const void*)forMarshaling->pData,
+ forMarshaling->dataSize * sizeof(const uint8_t));
}
-void unmarshal_VkSpecializationInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSpecializationInfo* forUnmarshaling)
-{
+void unmarshal_VkSpecializationInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSpecializationInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->mapEntryCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->mapEntryCount; ++i)
- {
- unmarshal_VkSpecializationMapEntry(vkStream, rootType, (VkSpecializationMapEntry*)(forUnmarshaling->pMapEntries + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->mapEntryCount; ++i) {
+ unmarshal_VkSpecializationMapEntry(
+ vkStream, rootType, (VkSpecializationMapEntry*)(forUnmarshaling->pMapEntries + i));
}
}
forUnmarshaling->dataSize = (size_t)vkStream->getBe64();
- vkStream->read((void*)forUnmarshaling->pData, forUnmarshaling->dataSize * sizeof(const uint8_t));
+ vkStream->read((void*)forUnmarshaling->pData,
+ forUnmarshaling->dataSize * sizeof(const uint8_t));
}
-void marshal_VkPipelineShaderStageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineShaderStageCreateInfo* forMarshaling)
-{
+void marshal_VkPipelineShaderStageCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineShaderStageCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineShaderStageCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineShaderStageCreateFlags));
+ vkStream->write((VkPipelineShaderStageCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineShaderStageCreateFlags));
vkStream->write((VkShaderStageFlagBits*)&forMarshaling->stage, sizeof(VkShaderStageFlagBits));
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkShaderModule_u64(&forMarshaling->module, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkShaderModule_u64(&forMarshaling->module, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->putString(forMarshaling->pName);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pSpecializationInfo;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pSpecializationInfo)
- {
- marshal_VkSpecializationInfo(vkStream, rootType, (const VkSpecializationInfo*)(forMarshaling->pSpecializationInfo));
+ if (forMarshaling->pSpecializationInfo) {
+ marshal_VkSpecializationInfo(
+ vkStream, rootType, (const VkSpecializationInfo*)(forMarshaling->pSpecializationInfo));
}
}
-void unmarshal_VkPipelineShaderStageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineShaderStageCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkPipelineShaderStageCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPipelineShaderStageCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineShaderStageCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineShaderStageCreateFlags));
+ vkStream->read((VkPipelineShaderStageCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkPipelineShaderStageCreateFlags));
vkStream->read((VkShaderStageFlagBits*)&forUnmarshaling->stage, sizeof(VkShaderStageFlagBits));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkShaderModule(&cgen_var_0, (VkShaderModule*)&forUnmarshaling->module, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkShaderModule(
+ &cgen_var_0, (VkShaderModule*)&forUnmarshaling->module, 1);
vkStream->loadStringInPlace((char**)&forUnmarshaling->pName);
// WARNING PTR CHECK
const VkSpecializationInfo* check_pSpecializationInfo;
check_pSpecializationInfo = (const VkSpecializationInfo*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pSpecializationInfo)
- {
- if (!(check_pSpecializationInfo))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pSpecializationInfo inconsistent between guest and host\n");
+ if (forUnmarshaling->pSpecializationInfo) {
+ if (!(check_pSpecializationInfo)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pSpecializationInfo inconsistent between guest and "
+ "host\n");
}
- unmarshal_VkSpecializationInfo(vkStream, rootType, (VkSpecializationInfo*)(forUnmarshaling->pSpecializationInfo));
+ unmarshal_VkSpecializationInfo(
+ vkStream, rootType, (VkSpecializationInfo*)(forUnmarshaling->pSpecializationInfo));
}
}
-void marshal_VkComputePipelineCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkComputePipelineCreateInfo* forMarshaling)
-{
+void marshal_VkComputePipelineCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkComputePipelineCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkPipelineCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags));
- marshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (VkPipelineShaderStageCreateInfo*)(&forMarshaling->stage));
+ marshal_VkPipelineShaderStageCreateInfo(
+ vkStream, rootType, (VkPipelineShaderStageCreateInfo*)(&forMarshaling->stage));
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
uint64_t cgen_var_1;
- vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle, &cgen_var_1, 1);
+ vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle,
+ &cgen_var_1, 1);
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
vkStream->write((int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
}
-void unmarshal_VkComputePipelineCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkComputePipelineCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkComputePipelineCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkComputePipelineCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkPipelineCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCreateFlags));
- unmarshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (VkPipelineShaderStageCreateInfo*)(&forUnmarshaling->stage));
+ unmarshal_VkPipelineShaderStageCreateInfo(
+ vkStream, rootType, (VkPipelineShaderStageCreateInfo*)(&forUnmarshaling->stage));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_0, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(
+ &cgen_var_0, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_1, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkPipeline(
+ &cgen_var_1, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
vkStream->read((int32_t*)&forUnmarshaling->basePipelineIndex, sizeof(int32_t));
}
-void marshal_VkVertexInputBindingDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVertexInputBindingDescription* forMarshaling)
-{
+void marshal_VkVertexInputBindingDescription(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVertexInputBindingDescription* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->stride, sizeof(uint32_t));
vkStream->write((VkVertexInputRate*)&forMarshaling->inputRate, sizeof(VkVertexInputRate));
}
-void unmarshal_VkVertexInputBindingDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVertexInputBindingDescription* forUnmarshaling)
-{
+void unmarshal_VkVertexInputBindingDescription(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVertexInputBindingDescription* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->binding, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->stride, sizeof(uint32_t));
@@ -2542,10 +2276,8 @@
}
void marshal_VkVertexInputAttributeDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVertexInputAttributeDescription* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVertexInputAttributeDescription* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->location, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
@@ -2554,10 +2286,8 @@
}
void unmarshal_VkVertexInputAttributeDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVertexInputAttributeDescription* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVertexInputAttributeDescription* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->location, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->binding, sizeof(uint32_t));
@@ -2566,138 +2296,128 @@
}
void marshal_VkPipelineVertexInputStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineVertexInputStateCreateInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineVertexInputStateCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineVertexInputStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineVertexInputStateCreateFlags));
+ vkStream->write((VkPipelineVertexInputStateCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineVertexInputStateCreateFlags));
vkStream->write((uint32_t*)&forMarshaling->vertexBindingDescriptionCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexBindingDescriptionCount; ++i)
- {
- marshal_VkVertexInputBindingDescription(vkStream, rootType, (const VkVertexInputBindingDescription*)(forMarshaling->pVertexBindingDescriptions + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexBindingDescriptionCount; ++i) {
+ marshal_VkVertexInputBindingDescription(
+ vkStream, rootType,
+ (const VkVertexInputBindingDescription*)(forMarshaling->pVertexBindingDescriptions +
+ i));
}
}
vkStream->write((uint32_t*)&forMarshaling->vertexAttributeDescriptionCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexAttributeDescriptionCount; ++i)
- {
- marshal_VkVertexInputAttributeDescription(vkStream, rootType, (const VkVertexInputAttributeDescription*)(forMarshaling->pVertexAttributeDescriptions + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexAttributeDescriptionCount; ++i) {
+ marshal_VkVertexInputAttributeDescription(
+ vkStream, rootType,
+ (const VkVertexInputAttributeDescription*)(forMarshaling
+ ->pVertexAttributeDescriptions +
+ i));
}
}
}
void unmarshal_VkPipelineVertexInputStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineVertexInputStateCreateInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineVertexInputStateCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineVertexInputStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineVertexInputStateCreateFlags));
+ vkStream->read((VkPipelineVertexInputStateCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkPipelineVertexInputStateCreateFlags));
vkStream->read((uint32_t*)&forUnmarshaling->vertexBindingDescriptionCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->vertexBindingDescriptionCount; ++i)
- {
- unmarshal_VkVertexInputBindingDescription(vkStream, rootType, (VkVertexInputBindingDescription*)(forUnmarshaling->pVertexBindingDescriptions + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->vertexBindingDescriptionCount; ++i) {
+ unmarshal_VkVertexInputBindingDescription(
+ vkStream, rootType,
+ (VkVertexInputBindingDescription*)(forUnmarshaling->pVertexBindingDescriptions +
+ i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->vertexAttributeDescriptionCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->vertexAttributeDescriptionCount; ++i)
- {
- unmarshal_VkVertexInputAttributeDescription(vkStream, rootType, (VkVertexInputAttributeDescription*)(forUnmarshaling->pVertexAttributeDescriptions + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->vertexAttributeDescriptionCount; ++i) {
+ unmarshal_VkVertexInputAttributeDescription(
+ vkStream, rootType,
+ (VkVertexInputAttributeDescription*)(forUnmarshaling->pVertexAttributeDescriptions +
+ i));
}
}
}
void marshal_VkPipelineInputAssemblyStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineInputAssemblyStateCreateInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineInputAssemblyStateCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineInputAssemblyStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineInputAssemblyStateCreateFlags));
+ vkStream->write((VkPipelineInputAssemblyStateCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineInputAssemblyStateCreateFlags));
vkStream->write((VkPrimitiveTopology*)&forMarshaling->topology, sizeof(VkPrimitiveTopology));
vkStream->write((VkBool32*)&forMarshaling->primitiveRestartEnable, sizeof(VkBool32));
}
void unmarshal_VkPipelineInputAssemblyStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineInputAssemblyStateCreateInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineInputAssemblyStateCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineInputAssemblyStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineInputAssemblyStateCreateFlags));
+ vkStream->read((VkPipelineInputAssemblyStateCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkPipelineInputAssemblyStateCreateFlags));
vkStream->read((VkPrimitiveTopology*)&forUnmarshaling->topology, sizeof(VkPrimitiveTopology));
vkStream->read((VkBool32*)&forUnmarshaling->primitiveRestartEnable, sizeof(VkBool32));
}
void marshal_VkPipelineTessellationStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineTessellationStateCreateInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineTessellationStateCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineTessellationStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineTessellationStateCreateFlags));
+ vkStream->write((VkPipelineTessellationStateCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineTessellationStateCreateFlags));
vkStream->write((uint32_t*)&forMarshaling->patchControlPoints, sizeof(uint32_t));
}
void unmarshal_VkPipelineTessellationStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineTessellationStateCreateInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineTessellationStateCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineTessellationStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineTessellationStateCreateFlags));
+ vkStream->read((VkPipelineTessellationStateCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkPipelineTessellationStateCreateFlags));
vkStream->read((uint32_t*)&forUnmarshaling->patchControlPoints, sizeof(uint32_t));
}
-void marshal_VkViewport(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkViewport* forMarshaling)
-{
+void marshal_VkViewport(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkViewport* forMarshaling) {
(void)rootType;
vkStream->write((float*)&forMarshaling->x, sizeof(float));
vkStream->write((float*)&forMarshaling->y, sizeof(float));
@@ -2707,11 +2427,8 @@
vkStream->write((float*)&forMarshaling->maxDepth, sizeof(float));
}
-void unmarshal_VkViewport(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkViewport* forUnmarshaling)
-{
+void unmarshal_VkViewport(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkViewport* forUnmarshaling) {
(void)rootType;
vkStream->read((float*)&forUnmarshaling->x, sizeof(float));
vkStream->read((float*)&forUnmarshaling->y, sizeof(float));
@@ -2722,29 +2439,25 @@
}
void marshal_VkPipelineViewportStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineViewportStateCreateInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineViewportStateCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineViewportStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineViewportStateCreateFlags));
+ vkStream->write((VkPipelineViewportStateCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineViewportStateCreateFlags));
vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pViewports;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pViewports)
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
- {
- marshal_VkViewport(vkStream, rootType, (const VkViewport*)(forMarshaling->pViewports + i));
+ if (forMarshaling->pViewports) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i) {
+ marshal_VkViewport(vkStream, rootType,
+ (const VkViewport*)(forMarshaling->pViewports + i));
}
}
}
@@ -2752,46 +2465,40 @@
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pScissors;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pScissors)
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->scissorCount; ++i)
- {
- marshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pScissors + i));
+ if (forMarshaling->pScissors) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->scissorCount; ++i) {
+ marshal_VkRect2D(vkStream, rootType,
+ (const VkRect2D*)(forMarshaling->pScissors + i));
}
}
}
}
void unmarshal_VkPipelineViewportStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineViewportStateCreateInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineViewportStateCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineViewportStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineViewportStateCreateFlags));
+ vkStream->read((VkPipelineViewportStateCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkPipelineViewportStateCreateFlags));
vkStream->read((uint32_t*)&forUnmarshaling->viewportCount, sizeof(uint32_t));
// WARNING PTR CHECK
const VkViewport* check_pViewports;
check_pViewports = (const VkViewport*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pViewports)
- {
- if (!(check_pViewports))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pViewports inconsistent between guest and host\n");
+ if (forUnmarshaling->pViewports) {
+ if (!(check_pViewports)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pViewports inconsistent between guest and host\n");
}
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i)
- {
- unmarshal_VkViewport(vkStream, rootType, (VkViewport*)(forUnmarshaling->pViewports + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i) {
+ unmarshal_VkViewport(vkStream, rootType,
+ (VkViewport*)(forUnmarshaling->pViewports + i));
}
}
}
@@ -2799,16 +2506,13 @@
// WARNING PTR CHECK
const VkRect2D* check_pScissors;
check_pScissors = (const VkRect2D*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pScissors)
- {
- if (!(check_pScissors))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pScissors inconsistent between guest and host\n");
+ if (forUnmarshaling->pScissors) {
+ if (!(check_pScissors)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pScissors inconsistent between guest and host\n");
}
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->scissorCount; ++i)
- {
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->scissorCount; ++i) {
unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(forUnmarshaling->pScissors + i));
}
}
@@ -2816,18 +2520,16 @@
}
void marshal_VkPipelineRasterizationStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationStateCreateInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationStateCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineRasterizationStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineRasterizationStateCreateFlags));
+ vkStream->write((VkPipelineRasterizationStateCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineRasterizationStateCreateFlags));
vkStream->write((VkBool32*)&forMarshaling->depthClampEnable, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->rasterizerDiscardEnable, sizeof(VkBool32));
vkStream->write((VkPolygonMode*)&forMarshaling->polygonMode, sizeof(VkPolygonMode));
@@ -2841,18 +2543,16 @@
}
void unmarshal_VkPipelineRasterizationStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineRasterizationStateCreateInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineRasterizationStateCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineRasterizationStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineRasterizationStateCreateFlags));
+ vkStream->read((VkPipelineRasterizationStateCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkPipelineRasterizationStateCreateFlags));
vkStream->read((VkBool32*)&forUnmarshaling->depthClampEnable, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->rasterizerDiscardEnable, sizeof(VkBool32));
vkStream->read((VkPolygonMode*)&forUnmarshaling->polygonMode, sizeof(VkPolygonMode));
@@ -2866,68 +2566,65 @@
}
void marshal_VkPipelineMultisampleStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineMultisampleStateCreateInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineMultisampleStateCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineMultisampleStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineMultisampleStateCreateFlags));
- vkStream->write((VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples, sizeof(VkSampleCountFlagBits));
+ vkStream->write((VkPipelineMultisampleStateCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineMultisampleStateCreateFlags));
+ vkStream->write((VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples,
+ sizeof(VkSampleCountFlagBits));
vkStream->write((VkBool32*)&forMarshaling->sampleShadingEnable, sizeof(VkBool32));
vkStream->write((float*)&forMarshaling->minSampleShading, sizeof(float));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pSampleMask;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pSampleMask)
- {
- vkStream->write((const VkSampleMask*)forMarshaling->pSampleMask, (((forMarshaling->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
+ if (forMarshaling->pSampleMask) {
+ vkStream->write(
+ (const VkSampleMask*)forMarshaling->pSampleMask,
+ (((forMarshaling->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
}
vkStream->write((VkBool32*)&forMarshaling->alphaToCoverageEnable, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->alphaToOneEnable, sizeof(VkBool32));
}
void unmarshal_VkPipelineMultisampleStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineMultisampleStateCreateInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineMultisampleStateCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineMultisampleStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineMultisampleStateCreateFlags));
- vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->rasterizationSamples, sizeof(VkSampleCountFlagBits));
+ vkStream->read((VkPipelineMultisampleStateCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkPipelineMultisampleStateCreateFlags));
+ vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->rasterizationSamples,
+ sizeof(VkSampleCountFlagBits));
vkStream->read((VkBool32*)&forUnmarshaling->sampleShadingEnable, sizeof(VkBool32));
vkStream->read((float*)&forUnmarshaling->minSampleShading, sizeof(float));
// WARNING PTR CHECK
const VkSampleMask* check_pSampleMask;
check_pSampleMask = (const VkSampleMask*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pSampleMask)
- {
- if (!(check_pSampleMask))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pSampleMask inconsistent between guest and host\n");
+ if (forUnmarshaling->pSampleMask) {
+ if (!(check_pSampleMask)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pSampleMask inconsistent between guest and host\n");
}
- vkStream->read((VkSampleMask*)forUnmarshaling->pSampleMask, (((forUnmarshaling->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
+ vkStream->read(
+ (VkSampleMask*)forUnmarshaling->pSampleMask,
+ (((forUnmarshaling->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
}
vkStream->read((VkBool32*)&forUnmarshaling->alphaToCoverageEnable, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->alphaToOneEnable, sizeof(VkBool32));
}
-void marshal_VkStencilOpState(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkStencilOpState* forMarshaling)
-{
+void marshal_VkStencilOpState(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkStencilOpState* forMarshaling) {
(void)rootType;
vkStream->write((VkStencilOp*)&forMarshaling->failOp, sizeof(VkStencilOp));
vkStream->write((VkStencilOp*)&forMarshaling->passOp, sizeof(VkStencilOp));
@@ -2938,11 +2635,8 @@
vkStream->write((uint32_t*)&forMarshaling->reference, sizeof(uint32_t));
}
-void unmarshal_VkStencilOpState(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkStencilOpState* forUnmarshaling)
-{
+void unmarshal_VkStencilOpState(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkStencilOpState* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStencilOp*)&forUnmarshaling->failOp, sizeof(VkStencilOp));
vkStream->read((VkStencilOp*)&forUnmarshaling->passOp, sizeof(VkStencilOp));
@@ -2954,18 +2648,16 @@
}
void marshal_VkPipelineDepthStencilStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineDepthStencilStateCreateInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineDepthStencilStateCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineDepthStencilStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineDepthStencilStateCreateFlags));
+ vkStream->write((VkPipelineDepthStencilStateCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineDepthStencilStateCreateFlags));
vkStream->write((VkBool32*)&forMarshaling->depthTestEnable, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->depthWriteEnable, sizeof(VkBool32));
vkStream->write((VkCompareOp*)&forMarshaling->depthCompareOp, sizeof(VkCompareOp));
@@ -2978,18 +2670,16 @@
}
void unmarshal_VkPipelineDepthStencilStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineDepthStencilStateCreateInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineDepthStencilStateCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineDepthStencilStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineDepthStencilStateCreateFlags));
+ vkStream->read((VkPipelineDepthStencilStateCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkPipelineDepthStencilStateCreateFlags));
vkStream->read((VkBool32*)&forUnmarshaling->depthTestEnable, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->depthWriteEnable, sizeof(VkBool32));
vkStream->read((VkCompareOp*)&forUnmarshaling->depthCompareOp, sizeof(VkCompareOp));
@@ -3002,10 +2692,8 @@
}
void marshal_VkPipelineColorBlendAttachmentState(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineColorBlendAttachmentState* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineColorBlendAttachmentState* forMarshaling) {
(void)rootType;
vkStream->write((VkBool32*)&forMarshaling->blendEnable, sizeof(VkBool32));
vkStream->write((VkBlendFactor*)&forMarshaling->srcColorBlendFactor, sizeof(VkBlendFactor));
@@ -3014,14 +2702,13 @@
vkStream->write((VkBlendFactor*)&forMarshaling->srcAlphaBlendFactor, sizeof(VkBlendFactor));
vkStream->write((VkBlendFactor*)&forMarshaling->dstAlphaBlendFactor, sizeof(VkBlendFactor));
vkStream->write((VkBlendOp*)&forMarshaling->alphaBlendOp, sizeof(VkBlendOp));
- vkStream->write((VkColorComponentFlags*)&forMarshaling->colorWriteMask, sizeof(VkColorComponentFlags));
+ vkStream->write((VkColorComponentFlags*)&forMarshaling->colorWriteMask,
+ sizeof(VkColorComponentFlags));
}
void unmarshal_VkPipelineColorBlendAttachmentState(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineColorBlendAttachmentState* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineColorBlendAttachmentState* forUnmarshaling) {
(void)rootType;
vkStream->read((VkBool32*)&forUnmarshaling->blendEnable, sizeof(VkBool32));
vkStream->read((VkBlendFactor*)&forUnmarshaling->srcColorBlendFactor, sizeof(VkBlendFactor));
@@ -3030,498 +2717,489 @@
vkStream->read((VkBlendFactor*)&forUnmarshaling->srcAlphaBlendFactor, sizeof(VkBlendFactor));
vkStream->read((VkBlendFactor*)&forUnmarshaling->dstAlphaBlendFactor, sizeof(VkBlendFactor));
vkStream->read((VkBlendOp*)&forUnmarshaling->alphaBlendOp, sizeof(VkBlendOp));
- vkStream->read((VkColorComponentFlags*)&forUnmarshaling->colorWriteMask, sizeof(VkColorComponentFlags));
+ vkStream->read((VkColorComponentFlags*)&forUnmarshaling->colorWriteMask,
+ sizeof(VkColorComponentFlags));
}
void marshal_VkPipelineColorBlendStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineColorBlendStateCreateInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineColorBlendStateCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineColorBlendStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineColorBlendStateCreateFlags));
+ vkStream->write((VkPipelineColorBlendStateCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineColorBlendStateCreateFlags));
vkStream->write((VkBool32*)&forMarshaling->logicOpEnable, sizeof(VkBool32));
vkStream->write((VkLogicOp*)&forMarshaling->logicOp, sizeof(VkLogicOp));
vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i)
- {
- marshal_VkPipelineColorBlendAttachmentState(vkStream, rootType, (const VkPipelineColorBlendAttachmentState*)(forMarshaling->pAttachments + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i) {
+ marshal_VkPipelineColorBlendAttachmentState(
+ vkStream, rootType,
+ (const VkPipelineColorBlendAttachmentState*)(forMarshaling->pAttachments + i));
}
}
vkStream->write((float*)forMarshaling->blendConstants, 4 * sizeof(float));
}
void unmarshal_VkPipelineColorBlendStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineColorBlendStateCreateInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineColorBlendStateCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineColorBlendStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineColorBlendStateCreateFlags));
+ vkStream->read((VkPipelineColorBlendStateCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkPipelineColorBlendStateCreateFlags));
vkStream->read((VkBool32*)&forUnmarshaling->logicOpEnable, sizeof(VkBool32));
vkStream->read((VkLogicOp*)&forUnmarshaling->logicOp, sizeof(VkLogicOp));
vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentCount; ++i)
- {
- unmarshal_VkPipelineColorBlendAttachmentState(vkStream, rootType, (VkPipelineColorBlendAttachmentState*)(forUnmarshaling->pAttachments + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentCount; ++i) {
+ unmarshal_VkPipelineColorBlendAttachmentState(
+ vkStream, rootType,
+ (VkPipelineColorBlendAttachmentState*)(forUnmarshaling->pAttachments + i));
}
}
vkStream->read((float*)forUnmarshaling->blendConstants, 4 * sizeof(float));
}
void marshal_VkPipelineDynamicStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineDynamicStateCreateInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineDynamicStateCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineDynamicStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineDynamicStateCreateFlags));
+ vkStream->write((VkPipelineDynamicStateCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineDynamicStateCreateFlags));
vkStream->write((uint32_t*)&forMarshaling->dynamicStateCount, sizeof(uint32_t));
- vkStream->write((const VkDynamicState*)forMarshaling->pDynamicStates, forMarshaling->dynamicStateCount * sizeof(const VkDynamicState));
+ vkStream->write((const VkDynamicState*)forMarshaling->pDynamicStates,
+ forMarshaling->dynamicStateCount * sizeof(const VkDynamicState));
}
-void unmarshal_VkPipelineDynamicStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineDynamicStateCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkPipelineDynamicStateCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPipelineDynamicStateCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineDynamicStateCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineDynamicStateCreateFlags));
+ vkStream->read((VkPipelineDynamicStateCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkPipelineDynamicStateCreateFlags));
vkStream->read((uint32_t*)&forUnmarshaling->dynamicStateCount, sizeof(uint32_t));
- vkStream->read((VkDynamicState*)forUnmarshaling->pDynamicStates, forUnmarshaling->dynamicStateCount * sizeof(const VkDynamicState));
+ vkStream->read((VkDynamicState*)forUnmarshaling->pDynamicStates,
+ forUnmarshaling->dynamicStateCount * sizeof(const VkDynamicState));
}
-void marshal_VkGraphicsPipelineCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGraphicsPipelineCreateInfo* forMarshaling)
-{
+void marshal_VkGraphicsPipelineCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGraphicsPipelineCreateInfo* forMarshaling) {
(void)rootType;
uint32_t hasRasterization = 1;
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
- {
- hasRasterization = (((0 == forMarshaling->pRasterizationState)) ? (0) : (!((*(forMarshaling->pRasterizationState)).rasterizerDiscardEnable)));
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
+ hasRasterization =
+ (((0 == forMarshaling->pRasterizationState))
+ ? (0)
+ : (!((*(forMarshaling->pRasterizationState)).rasterizerDiscardEnable)));
uint32_t cgen_var_0 = (uint32_t)hasRasterization;
vkStream->putBe32(cgen_var_0);
}
uint32_t hasTessellation = 1;
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
- {
- hasTessellation = arrayany(forMarshaling->pStages, 0, forMarshaling->stageCount, [](VkPipelineShaderStageCreateInfo s) { return ((s.stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) || (s.stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)); });
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
+ hasTessellation =
+ arrayany(forMarshaling->pStages, 0, forMarshaling->stageCount,
+ [](VkPipelineShaderStageCreateInfo s) {
+ return ((s.stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) ||
+ (s.stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT));
+ });
uint32_t cgen_var_0 = (uint32_t)hasTessellation;
vkStream->putBe32(cgen_var_0);
}
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkPipelineCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags));
vkStream->write((uint32_t*)&forMarshaling->stageCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i)
- {
- marshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i) {
+ marshal_VkPipelineShaderStageCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
}
}
// WARNING PTR CHECK
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
- {
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pVertexInputState;
vkStream->putBe64(cgen_var_0);
}
- if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forMarshaling->pVertexInputState))
- {
- marshal_VkPipelineVertexInputStateCreateInfo(vkStream, rootType, (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState));
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ forMarshaling->pVertexInputState)) {
+ marshal_VkPipelineVertexInputStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState));
}
// WARNING PTR CHECK
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
- {
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pInputAssemblyState;
vkStream->putBe64(cgen_var_0);
}
- if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forMarshaling->pInputAssemblyState))
- {
- marshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, rootType, (const VkPipelineInputAssemblyStateCreateInfo*)(forMarshaling->pInputAssemblyState));
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ forMarshaling->pInputAssemblyState)) {
+ marshal_VkPipelineInputAssemblyStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineInputAssemblyStateCreateInfo*)(forMarshaling->pInputAssemblyState));
}
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pTessellationState;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pTessellationState)
- {
- if (hasTessellation)
- {
- marshal_VkPipelineTessellationStateCreateInfo(vkStream, rootType, (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState));
+ if (forMarshaling->pTessellationState) {
+ if (hasTessellation) {
+ marshal_VkPipelineTessellationStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState));
}
}
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pViewportState;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pViewportState)
- {
- if (hasRasterization)
- {
- marshal_VkPipelineViewportStateCreateInfo(vkStream, rootType, (const VkPipelineViewportStateCreateInfo*)(forMarshaling->pViewportState));
+ if (forMarshaling->pViewportState) {
+ if (hasRasterization) {
+ marshal_VkPipelineViewportStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineViewportStateCreateInfo*)(forMarshaling->pViewportState));
}
}
// WARNING PTR CHECK
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
- {
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
uint64_t cgen_var_1_0 = (uint64_t)(uintptr_t)forMarshaling->pRasterizationState;
vkStream->putBe64(cgen_var_1_0);
}
- if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forMarshaling->pRasterizationState))
- {
- marshal_VkPipelineRasterizationStateCreateInfo(vkStream, rootType, (const VkPipelineRasterizationStateCreateInfo*)(forMarshaling->pRasterizationState));
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ forMarshaling->pRasterizationState)) {
+ marshal_VkPipelineRasterizationStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineRasterizationStateCreateInfo*)(forMarshaling->pRasterizationState));
}
// WARNING PTR CHECK
uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pMultisampleState;
vkStream->putBe64(cgen_var_2);
- if (forMarshaling->pMultisampleState)
- {
- if (hasRasterization)
- {
- marshal_VkPipelineMultisampleStateCreateInfo(vkStream, rootType, (const VkPipelineMultisampleStateCreateInfo*)(forMarshaling->pMultisampleState));
+ if (forMarshaling->pMultisampleState) {
+ if (hasRasterization) {
+ marshal_VkPipelineMultisampleStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineMultisampleStateCreateInfo*)(forMarshaling->pMultisampleState));
}
}
// WARNING PTR CHECK
uint64_t cgen_var_3 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilState;
vkStream->putBe64(cgen_var_3);
- if (forMarshaling->pDepthStencilState)
- {
- if (hasRasterization)
- {
- marshal_VkPipelineDepthStencilStateCreateInfo(vkStream, rootType, (const VkPipelineDepthStencilStateCreateInfo*)(forMarshaling->pDepthStencilState));
+ if (forMarshaling->pDepthStencilState) {
+ if (hasRasterization) {
+ marshal_VkPipelineDepthStencilStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineDepthStencilStateCreateInfo*)(forMarshaling->pDepthStencilState));
}
}
// WARNING PTR CHECK
uint64_t cgen_var_4 = (uint64_t)(uintptr_t)forMarshaling->pColorBlendState;
vkStream->putBe64(cgen_var_4);
- if (forMarshaling->pColorBlendState)
- {
- if (hasRasterization)
- {
- marshal_VkPipelineColorBlendStateCreateInfo(vkStream, rootType, (const VkPipelineColorBlendStateCreateInfo*)(forMarshaling->pColorBlendState));
+ if (forMarshaling->pColorBlendState) {
+ if (hasRasterization) {
+ marshal_VkPipelineColorBlendStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineColorBlendStateCreateInfo*)(forMarshaling->pColorBlendState));
}
}
// WARNING PTR CHECK
uint64_t cgen_var_5 = (uint64_t)(uintptr_t)forMarshaling->pDynamicState;
vkStream->putBe64(cgen_var_5);
- if (forMarshaling->pDynamicState)
- {
- marshal_VkPipelineDynamicStateCreateInfo(vkStream, rootType, (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState));
+ if (forMarshaling->pDynamicState) {
+ marshal_VkPipelineDynamicStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState));
}
uint64_t cgen_var_6;
- vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_6, 1);
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_6,
+ 1);
vkStream->write((uint64_t*)&cgen_var_6, 1 * 8);
uint64_t cgen_var_7;
- vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_7, 1);
+ vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_7,
+ 1);
vkStream->write((uint64_t*)&cgen_var_7, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
uint64_t cgen_var_8;
- vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle, &cgen_var_8, 1);
+ vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle,
+ &cgen_var_8, 1);
vkStream->write((uint64_t*)&cgen_var_8, 1 * 8);
vkStream->write((int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
}
-void unmarshal_VkGraphicsPipelineCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkGraphicsPipelineCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkGraphicsPipelineCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkGraphicsPipelineCreateInfo* forUnmarshaling) {
(void)rootType;
uint32_t hasRasterization = 1;
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
- {
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
hasRasterization = (const uint32_t)vkStream->getBe32();
}
uint32_t hasTessellation = 1;
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
- {
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
hasTessellation = (const uint32_t)vkStream->getBe32();
}
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkPipelineCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCreateFlags));
vkStream->read((uint32_t*)&forUnmarshaling->stageCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->stageCount; ++i)
- {
- unmarshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->stageCount; ++i) {
+ unmarshal_VkPipelineShaderStageCreateInfo(
+ vkStream, rootType,
+ (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
}
}
// WARNING PTR CHECK
const VkPipelineVertexInputStateCreateInfo* check_pVertexInputState;
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
- {
- check_pVertexInputState = (const VkPipelineVertexInputStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
+ check_pVertexInputState =
+ (const VkPipelineVertexInputStateCreateInfo*)(uintptr_t)vkStream->getBe64();
}
- if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forUnmarshaling->pVertexInputState))
- {
- unmarshal_VkPipelineVertexInputStateCreateInfo(vkStream, rootType, (VkPipelineVertexInputStateCreateInfo*)(forUnmarshaling->pVertexInputState));
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ forUnmarshaling->pVertexInputState)) {
+ unmarshal_VkPipelineVertexInputStateCreateInfo(
+ vkStream, rootType,
+ (VkPipelineVertexInputStateCreateInfo*)(forUnmarshaling->pVertexInputState));
}
// WARNING PTR CHECK
const VkPipelineInputAssemblyStateCreateInfo* check_pInputAssemblyState;
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
- {
- check_pInputAssemblyState = (const VkPipelineInputAssemblyStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
+ check_pInputAssemblyState =
+ (const VkPipelineInputAssemblyStateCreateInfo*)(uintptr_t)vkStream->getBe64();
}
- if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forUnmarshaling->pInputAssemblyState))
- {
- unmarshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, rootType, (VkPipelineInputAssemblyStateCreateInfo*)(forUnmarshaling->pInputAssemblyState));
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ forUnmarshaling->pInputAssemblyState)) {
+ unmarshal_VkPipelineInputAssemblyStateCreateInfo(
+ vkStream, rootType,
+ (VkPipelineInputAssemblyStateCreateInfo*)(forUnmarshaling->pInputAssemblyState));
}
// WARNING PTR CHECK
const VkPipelineTessellationStateCreateInfo* check_pTessellationState;
- check_pTessellationState = (const VkPipelineTessellationStateCreateInfo*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pTessellationState)
- {
- if (!(check_pTessellationState))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pTessellationState inconsistent between guest and host\n");
+ check_pTessellationState =
+ (const VkPipelineTessellationStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pTessellationState) {
+ if (!(check_pTessellationState)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pTessellationState inconsistent between guest and host\n");
}
- if (hasTessellation)
- {
- unmarshal_VkPipelineTessellationStateCreateInfo(vkStream, rootType, (VkPipelineTessellationStateCreateInfo*)(forUnmarshaling->pTessellationState));
- }
- else
- {
+ if (hasTessellation) {
+ unmarshal_VkPipelineTessellationStateCreateInfo(
+ vkStream, rootType,
+ (VkPipelineTessellationStateCreateInfo*)(forUnmarshaling->pTessellationState));
+ } else {
forUnmarshaling->pTessellationState = 0;
}
}
// WARNING PTR CHECK
const VkPipelineViewportStateCreateInfo* check_pViewportState;
check_pViewportState = (const VkPipelineViewportStateCreateInfo*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pViewportState)
- {
- if (!(check_pViewportState))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pViewportState inconsistent between guest and host\n");
+ if (forUnmarshaling->pViewportState) {
+ if (!(check_pViewportState)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pViewportState inconsistent between guest and host\n");
}
- if (hasRasterization)
- {
- unmarshal_VkPipelineViewportStateCreateInfo(vkStream, rootType, (VkPipelineViewportStateCreateInfo*)(forUnmarshaling->pViewportState));
- }
- else
- {
+ if (hasRasterization) {
+ unmarshal_VkPipelineViewportStateCreateInfo(
+ vkStream, rootType,
+ (VkPipelineViewportStateCreateInfo*)(forUnmarshaling->pViewportState));
+ } else {
forUnmarshaling->pViewportState = 0;
}
}
// WARNING PTR CHECK
const VkPipelineRasterizationStateCreateInfo* check_pRasterizationState;
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
- {
- check_pRasterizationState = (const VkPipelineRasterizationStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
+ check_pRasterizationState =
+ (const VkPipelineRasterizationStateCreateInfo*)(uintptr_t)vkStream->getBe64();
}
- if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forUnmarshaling->pRasterizationState))
- {
- unmarshal_VkPipelineRasterizationStateCreateInfo(vkStream, rootType, (VkPipelineRasterizationStateCreateInfo*)(forUnmarshaling->pRasterizationState));
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ forUnmarshaling->pRasterizationState)) {
+ unmarshal_VkPipelineRasterizationStateCreateInfo(
+ vkStream, rootType,
+ (VkPipelineRasterizationStateCreateInfo*)(forUnmarshaling->pRasterizationState));
}
// WARNING PTR CHECK
const VkPipelineMultisampleStateCreateInfo* check_pMultisampleState;
- check_pMultisampleState = (const VkPipelineMultisampleStateCreateInfo*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pMultisampleState)
- {
- if (!(check_pMultisampleState))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pMultisampleState inconsistent between guest and host\n");
+ check_pMultisampleState =
+ (const VkPipelineMultisampleStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pMultisampleState) {
+ if (!(check_pMultisampleState)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pMultisampleState inconsistent between guest and host\n");
}
- if (hasRasterization)
- {
- unmarshal_VkPipelineMultisampleStateCreateInfo(vkStream, rootType, (VkPipelineMultisampleStateCreateInfo*)(forUnmarshaling->pMultisampleState));
- }
- else
- {
+ if (hasRasterization) {
+ unmarshal_VkPipelineMultisampleStateCreateInfo(
+ vkStream, rootType,
+ (VkPipelineMultisampleStateCreateInfo*)(forUnmarshaling->pMultisampleState));
+ } else {
forUnmarshaling->pMultisampleState = 0;
}
}
// WARNING PTR CHECK
const VkPipelineDepthStencilStateCreateInfo* check_pDepthStencilState;
- check_pDepthStencilState = (const VkPipelineDepthStencilStateCreateInfo*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pDepthStencilState)
- {
- if (!(check_pDepthStencilState))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pDepthStencilState inconsistent between guest and host\n");
+ check_pDepthStencilState =
+ (const VkPipelineDepthStencilStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pDepthStencilState) {
+ if (!(check_pDepthStencilState)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pDepthStencilState inconsistent between guest and host\n");
}
- if (hasRasterization)
- {
- unmarshal_VkPipelineDepthStencilStateCreateInfo(vkStream, rootType, (VkPipelineDepthStencilStateCreateInfo*)(forUnmarshaling->pDepthStencilState));
- }
- else
- {
+ if (hasRasterization) {
+ unmarshal_VkPipelineDepthStencilStateCreateInfo(
+ vkStream, rootType,
+ (VkPipelineDepthStencilStateCreateInfo*)(forUnmarshaling->pDepthStencilState));
+ } else {
forUnmarshaling->pDepthStencilState = 0;
}
}
// WARNING PTR CHECK
const VkPipelineColorBlendStateCreateInfo* check_pColorBlendState;
- check_pColorBlendState = (const VkPipelineColorBlendStateCreateInfo*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pColorBlendState)
- {
- if (!(check_pColorBlendState))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pColorBlendState inconsistent between guest and host\n");
+ check_pColorBlendState =
+ (const VkPipelineColorBlendStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pColorBlendState) {
+ if (!(check_pColorBlendState)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pColorBlendState inconsistent between guest and host\n");
}
- if (hasRasterization)
- {
- unmarshal_VkPipelineColorBlendStateCreateInfo(vkStream, rootType, (VkPipelineColorBlendStateCreateInfo*)(forUnmarshaling->pColorBlendState));
- }
- else
- {
+ if (hasRasterization) {
+ unmarshal_VkPipelineColorBlendStateCreateInfo(
+ vkStream, rootType,
+ (VkPipelineColorBlendStateCreateInfo*)(forUnmarshaling->pColorBlendState));
+ } else {
forUnmarshaling->pColorBlendState = 0;
}
}
// WARNING PTR CHECK
const VkPipelineDynamicStateCreateInfo* check_pDynamicState;
check_pDynamicState = (const VkPipelineDynamicStateCreateInfo*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pDynamicState)
- {
- if (!(check_pDynamicState))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pDynamicState inconsistent between guest and host\n");
+ if (forUnmarshaling->pDynamicState) {
+ if (!(check_pDynamicState)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pDynamicState inconsistent between guest and host\n");
}
- unmarshal_VkPipelineDynamicStateCreateInfo(vkStream, rootType, (VkPipelineDynamicStateCreateInfo*)(forUnmarshaling->pDynamicState));
+ unmarshal_VkPipelineDynamicStateCreateInfo(
+ vkStream, rootType,
+ (VkPipelineDynamicStateCreateInfo*)(forUnmarshaling->pDynamicState));
}
uint64_t cgen_var_6;
vkStream->read((uint64_t*)&cgen_var_6, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_6, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(
+ &cgen_var_6, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
uint64_t cgen_var_7;
vkStream->read((uint64_t*)&cgen_var_7, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_7, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkRenderPass(
+ &cgen_var_7, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
vkStream->read((uint32_t*)&forUnmarshaling->subpass, sizeof(uint32_t));
uint64_t cgen_var_8;
vkStream->read((uint64_t*)&cgen_var_8, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_8, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkPipeline(
+ &cgen_var_8, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
vkStream->read((int32_t*)&forUnmarshaling->basePipelineIndex, sizeof(int32_t));
}
-void marshal_VkPushConstantRange(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPushConstantRange* forMarshaling)
-{
+void marshal_VkPushConstantRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPushConstantRange* forMarshaling) {
(void)rootType;
vkStream->write((VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
vkStream->write((uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->size, sizeof(uint32_t));
}
-void unmarshal_VkPushConstantRange(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPushConstantRange* forUnmarshaling)
-{
+void unmarshal_VkPushConstantRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPushConstantRange* forUnmarshaling) {
(void)rootType;
vkStream->read((VkShaderStageFlags*)&forUnmarshaling->stageFlags, sizeof(VkShaderStageFlags));
vkStream->read((uint32_t*)&forUnmarshaling->offset, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->size, sizeof(uint32_t));
}
-void marshal_VkPipelineLayoutCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineLayoutCreateInfo* forMarshaling)
-{
+void marshal_VkPipelineLayoutCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineLayoutCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineLayoutCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineLayoutCreateFlags));
+ vkStream->write((VkPipelineLayoutCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineLayoutCreateFlags));
vkStream->write((uint32_t*)&forMarshaling->setLayoutCount, sizeof(uint32_t));
- if (forMarshaling->setLayoutCount)
- {
+ if (forMarshaling->setLayoutCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forMarshaling->setLayoutCount * 8);
- vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(forMarshaling->pSetLayouts, cgen_var_0, forMarshaling->setLayoutCount);
+ vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(
+ forMarshaling->pSetLayouts, cgen_var_0, forMarshaling->setLayoutCount);
vkStream->write((uint64_t*)cgen_var_0, forMarshaling->setLayoutCount * 8);
}
vkStream->write((uint32_t*)&forMarshaling->pushConstantRangeCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->pushConstantRangeCount; ++i)
- {
- marshal_VkPushConstantRange(vkStream, rootType, (const VkPushConstantRange*)(forMarshaling->pPushConstantRanges + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->pushConstantRangeCount; ++i) {
+ marshal_VkPushConstantRange(
+ vkStream, rootType,
+ (const VkPushConstantRange*)(forMarshaling->pPushConstantRanges + i));
}
}
}
-void unmarshal_VkPipelineLayoutCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineLayoutCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkPipelineLayoutCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineLayoutCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineLayoutCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineLayoutCreateFlags));
+ vkStream->read((VkPipelineLayoutCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkPipelineLayoutCreateFlags));
vkStream->read((uint32_t*)&forUnmarshaling->setLayoutCount, sizeof(uint32_t));
- if (forUnmarshaling->setLayoutCount)
- {
+ if (forUnmarshaling->setLayoutCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->setLayoutCount * 8);
vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->setLayoutCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(cgen_var_0, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts, forUnmarshaling->setLayoutCount);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(
+ cgen_var_0, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts,
+ forUnmarshaling->setLayoutCount);
}
vkStream->read((uint32_t*)&forUnmarshaling->pushConstantRangeCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->pushConstantRangeCount; ++i)
- {
- unmarshal_VkPushConstantRange(vkStream, rootType, (VkPushConstantRange*)(forUnmarshaling->pPushConstantRanges + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->pushConstantRangeCount; ++i) {
+ unmarshal_VkPushConstantRange(
+ vkStream, rootType,
+ (VkPushConstantRange*)(forUnmarshaling->pPushConstantRanges + i));
}
}
}
-void marshal_VkSamplerCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerCreateInfo* forMarshaling)
-{
+void marshal_VkSamplerCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -3529,9 +3207,12 @@
vkStream->write((VkFilter*)&forMarshaling->magFilter, sizeof(VkFilter));
vkStream->write((VkFilter*)&forMarshaling->minFilter, sizeof(VkFilter));
vkStream->write((VkSamplerMipmapMode*)&forMarshaling->mipmapMode, sizeof(VkSamplerMipmapMode));
- vkStream->write((VkSamplerAddressMode*)&forMarshaling->addressModeU, sizeof(VkSamplerAddressMode));
- vkStream->write((VkSamplerAddressMode*)&forMarshaling->addressModeV, sizeof(VkSamplerAddressMode));
- vkStream->write((VkSamplerAddressMode*)&forMarshaling->addressModeW, sizeof(VkSamplerAddressMode));
+ vkStream->write((VkSamplerAddressMode*)&forMarshaling->addressModeU,
+ sizeof(VkSamplerAddressMode));
+ vkStream->write((VkSamplerAddressMode*)&forMarshaling->addressModeV,
+ sizeof(VkSamplerAddressMode));
+ vkStream->write((VkSamplerAddressMode*)&forMarshaling->addressModeW,
+ sizeof(VkSamplerAddressMode));
vkStream->write((float*)&forMarshaling->mipLodBias, sizeof(float));
vkStream->write((VkBool32*)&forMarshaling->anisotropyEnable, sizeof(VkBool32));
vkStream->write((float*)&forMarshaling->maxAnisotropy, sizeof(float));
@@ -3543,15 +3224,11 @@
vkStream->write((VkBool32*)&forMarshaling->unnormalizedCoordinates, sizeof(VkBool32));
}
-void unmarshal_VkSamplerCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSamplerCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkSamplerCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSamplerCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -3559,9 +3236,12 @@
vkStream->read((VkFilter*)&forUnmarshaling->magFilter, sizeof(VkFilter));
vkStream->read((VkFilter*)&forUnmarshaling->minFilter, sizeof(VkFilter));
vkStream->read((VkSamplerMipmapMode*)&forUnmarshaling->mipmapMode, sizeof(VkSamplerMipmapMode));
- vkStream->read((VkSamplerAddressMode*)&forUnmarshaling->addressModeU, sizeof(VkSamplerAddressMode));
- vkStream->read((VkSamplerAddressMode*)&forUnmarshaling->addressModeV, sizeof(VkSamplerAddressMode));
- vkStream->read((VkSamplerAddressMode*)&forUnmarshaling->addressModeW, sizeof(VkSamplerAddressMode));
+ vkStream->read((VkSamplerAddressMode*)&forUnmarshaling->addressModeU,
+ sizeof(VkSamplerAddressMode));
+ vkStream->read((VkSamplerAddressMode*)&forUnmarshaling->addressModeV,
+ sizeof(VkSamplerAddressMode));
+ vkStream->read((VkSamplerAddressMode*)&forUnmarshaling->addressModeW,
+ sizeof(VkSamplerAddressMode));
vkStream->read((float*)&forUnmarshaling->mipLodBias, sizeof(float));
vkStream->read((VkBool32*)&forUnmarshaling->anisotropyEnable, sizeof(VkBool32));
vkStream->read((float*)&forUnmarshaling->maxAnisotropy, sizeof(float));
@@ -3573,61 +3253,54 @@
vkStream->read((VkBool32*)&forUnmarshaling->unnormalizedCoordinates, sizeof(VkBool32));
}
-void marshal_VkCopyDescriptorSet(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyDescriptorSet* forMarshaling)
-{
+void marshal_VkCopyDescriptorSet(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyDescriptorSet* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->srcSet, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->srcSet, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->srcBinding, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->srcArrayElement, sizeof(uint32_t));
uint64_t cgen_var_1;
- vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_1, 1);
+ vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_1,
+ 1);
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->dstBinding, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->dstArrayElement, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
}
-void unmarshal_VkCopyDescriptorSet(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCopyDescriptorSet* forUnmarshaling)
-{
+void unmarshal_VkCopyDescriptorSet(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyDescriptorSet* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_0, (VkDescriptorSet*)&forUnmarshaling->srcSet, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(
+ &cgen_var_0, (VkDescriptorSet*)&forUnmarshaling->srcSet, 1);
vkStream->read((uint32_t*)&forUnmarshaling->srcBinding, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->srcArrayElement, sizeof(uint32_t));
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_1, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(
+ &cgen_var_1, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
vkStream->read((uint32_t*)&forUnmarshaling->dstBinding, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->dstArrayElement, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
}
-void marshal_VkDescriptorBufferInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorBufferInfo* forMarshaling)
-{
+void marshal_VkDescriptorBufferInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorBufferInfo* forMarshaling) {
(void)rootType;
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
@@ -3636,172 +3309,145 @@
vkStream->write((VkDeviceSize*)&forMarshaling->range, sizeof(VkDeviceSize));
}
-void unmarshal_VkDescriptorBufferInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorBufferInfo* forUnmarshaling)
-{
+void unmarshal_VkDescriptorBufferInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDescriptorBufferInfo* forUnmarshaling) {
(void)rootType;
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+ (VkBuffer*)&forUnmarshaling->buffer, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->range, sizeof(VkDeviceSize));
}
-void marshal_VkDescriptorImageInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorImageInfo* forMarshaling)
-{
+void marshal_VkDescriptorImageInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorImageInfo* forMarshaling) {
(void)rootType;
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkSampler_u64(&forMarshaling->sampler, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
uint64_t cgen_var_1;
- vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_1, 1);
+ vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_1,
+ 1);
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
vkStream->write((VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
}
-void unmarshal_VkDescriptorImageInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorImageInfo* forUnmarshaling)
-{
+void unmarshal_VkDescriptorImageInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDescriptorImageInfo* forUnmarshaling) {
(void)rootType;
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_0, (VkSampler*)&forUnmarshaling->sampler, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_0,
+ (VkSampler*)&forUnmarshaling->sampler, 1);
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_1, (VkImageView*)&forUnmarshaling->imageView, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImageView(
+ &cgen_var_1, (VkImageView*)&forUnmarshaling->imageView, 1);
vkStream->read((VkImageLayout*)&forUnmarshaling->imageLayout, sizeof(VkImageLayout));
}
-void marshal_VkDescriptorPoolSize(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorPoolSize* forMarshaling)
-{
+void marshal_VkDescriptorPoolSize(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorPoolSize* forMarshaling) {
(void)rootType;
vkStream->write((VkDescriptorType*)&forMarshaling->type, sizeof(VkDescriptorType));
vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
}
-void unmarshal_VkDescriptorPoolSize(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorPoolSize* forUnmarshaling)
-{
+void unmarshal_VkDescriptorPoolSize(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDescriptorPoolSize* forUnmarshaling) {
(void)rootType;
vkStream->read((VkDescriptorType*)&forUnmarshaling->type, sizeof(VkDescriptorType));
vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
}
-void marshal_VkDescriptorPoolCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorPoolCreateInfo* forMarshaling)
-{
+void marshal_VkDescriptorPoolCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorPoolCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDescriptorPoolCreateFlags*)&forMarshaling->flags, sizeof(VkDescriptorPoolCreateFlags));
+ vkStream->write((VkDescriptorPoolCreateFlags*)&forMarshaling->flags,
+ sizeof(VkDescriptorPoolCreateFlags));
vkStream->write((uint32_t*)&forMarshaling->maxSets, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->poolSizeCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->poolSizeCount; ++i)
- {
- marshal_VkDescriptorPoolSize(vkStream, rootType, (const VkDescriptorPoolSize*)(forMarshaling->pPoolSizes + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->poolSizeCount; ++i) {
+ marshal_VkDescriptorPoolSize(
+ vkStream, rootType, (const VkDescriptorPoolSize*)(forMarshaling->pPoolSizes + i));
}
}
}
-void unmarshal_VkDescriptorPoolCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorPoolCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkDescriptorPoolCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDescriptorPoolCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDescriptorPoolCreateFlags*)&forUnmarshaling->flags, sizeof(VkDescriptorPoolCreateFlags));
+ vkStream->read((VkDescriptorPoolCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkDescriptorPoolCreateFlags));
vkStream->read((uint32_t*)&forUnmarshaling->maxSets, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->poolSizeCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->poolSizeCount; ++i)
- {
- unmarshal_VkDescriptorPoolSize(vkStream, rootType, (VkDescriptorPoolSize*)(forUnmarshaling->pPoolSizes + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->poolSizeCount; ++i) {
+ unmarshal_VkDescriptorPoolSize(
+ vkStream, rootType, (VkDescriptorPoolSize*)(forUnmarshaling->pPoolSizes + i));
}
}
}
-void marshal_VkDescriptorSetAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetAllocateInfo* forMarshaling)
-{
+void marshal_VkDescriptorSetAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorSetAllocateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&forMarshaling->descriptorPool, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&forMarshaling->descriptorPool,
+ &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->descriptorSetCount, sizeof(uint32_t));
- if (forMarshaling->descriptorSetCount)
- {
+ if (forMarshaling->descriptorSetCount) {
uint64_t* cgen_var_1;
vkStream->alloc((void**)&cgen_var_1, forMarshaling->descriptorSetCount * 8);
- vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(forMarshaling->pSetLayouts, cgen_var_1, forMarshaling->descriptorSetCount);
+ vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(
+ forMarshaling->pSetLayouts, cgen_var_1, forMarshaling->descriptorSetCount);
vkStream->write((uint64_t*)cgen_var_1, forMarshaling->descriptorSetCount * 8);
}
}
-void unmarshal_VkDescriptorSetAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorSetAllocateInfo* forUnmarshaling)
-{
+void unmarshal_VkDescriptorSetAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDescriptorSetAllocateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorPool(&cgen_var_0, (VkDescriptorPool*)&forUnmarshaling->descriptorPool, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorPool(
+ &cgen_var_0, (VkDescriptorPool*)&forUnmarshaling->descriptorPool, 1);
vkStream->read((uint32_t*)&forUnmarshaling->descriptorSetCount, sizeof(uint32_t));
- if (forUnmarshaling->descriptorSetCount)
- {
+ if (forUnmarshaling->descriptorSetCount) {
uint64_t* cgen_var_1;
vkStream->alloc((void**)&cgen_var_1, forUnmarshaling->descriptorSetCount * 8);
vkStream->read((uint64_t*)cgen_var_1, forUnmarshaling->descriptorSetCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(cgen_var_1, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts, forUnmarshaling->descriptorSetCount);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(
+ cgen_var_1, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts,
+ forUnmarshaling->descriptorSetCount);
}
}
-void marshal_VkDescriptorSetLayoutBinding(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetLayoutBinding* forMarshaling)
-{
+void marshal_VkDescriptorSetLayoutBinding(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorSetLayoutBinding* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
vkStream->write((VkDescriptorType*)&forMarshaling->descriptorType, sizeof(VkDescriptorType));
@@ -3810,23 +3456,19 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pImmutableSamplers;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pImmutableSamplers)
- {
- if (forMarshaling->descriptorCount)
- {
+ if (forMarshaling->pImmutableSamplers) {
+ if (forMarshaling->descriptorCount) {
uint64_t* cgen_var_0_0;
vkStream->alloc((void**)&cgen_var_0_0, forMarshaling->descriptorCount * 8);
- vkStream->handleMapping()->mapHandles_VkSampler_u64(forMarshaling->pImmutableSamplers, cgen_var_0_0, forMarshaling->descriptorCount);
+ vkStream->handleMapping()->mapHandles_VkSampler_u64(
+ forMarshaling->pImmutableSamplers, cgen_var_0_0, forMarshaling->descriptorCount);
vkStream->write((uint64_t*)cgen_var_0_0, forMarshaling->descriptorCount * 8);
}
}
}
-void unmarshal_VkDescriptorSetLayoutBinding(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorSetLayoutBinding* forUnmarshaling)
-{
+void unmarshal_VkDescriptorSetLayoutBinding(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDescriptorSetLayoutBinding* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->binding, sizeof(uint32_t));
vkStream->read((VkDescriptorType*)&forUnmarshaling->descriptorType, sizeof(VkDescriptorType));
@@ -3835,82 +3477,75 @@
// WARNING PTR CHECK
const VkSampler* check_pImmutableSamplers;
check_pImmutableSamplers = (const VkSampler*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pImmutableSamplers)
- {
- if (!(check_pImmutableSamplers))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pImmutableSamplers inconsistent between guest and host\n");
+ if (forUnmarshaling->pImmutableSamplers) {
+ if (!(check_pImmutableSamplers)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pImmutableSamplers inconsistent between guest and host\n");
}
- if (forUnmarshaling->descriptorCount)
- {
+ if (forUnmarshaling->descriptorCount) {
uint64_t* cgen_var_0_0;
vkStream->alloc((void**)&cgen_var_0_0, forUnmarshaling->descriptorCount * 8);
vkStream->read((uint64_t*)cgen_var_0_0, forUnmarshaling->descriptorCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSampler(cgen_var_0_0, (VkSampler*)forUnmarshaling->pImmutableSamplers, forUnmarshaling->descriptorCount);
+ vkStream->handleMapping()->mapHandles_u64_VkSampler(
+ cgen_var_0_0, (VkSampler*)forUnmarshaling->pImmutableSamplers,
+ forUnmarshaling->descriptorCount);
}
}
}
-void marshal_VkDescriptorSetLayoutCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetLayoutCreateInfo* forMarshaling)
-{
+void marshal_VkDescriptorSetLayoutCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorSetLayoutCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDescriptorSetLayoutCreateFlags*)&forMarshaling->flags, sizeof(VkDescriptorSetLayoutCreateFlags));
+ vkStream->write((VkDescriptorSetLayoutCreateFlags*)&forMarshaling->flags,
+ sizeof(VkDescriptorSetLayoutCreateFlags));
vkStream->write((uint32_t*)&forMarshaling->bindingCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindingCount; ++i)
- {
- marshal_VkDescriptorSetLayoutBinding(vkStream, rootType, (const VkDescriptorSetLayoutBinding*)(forMarshaling->pBindings + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindingCount; ++i) {
+ marshal_VkDescriptorSetLayoutBinding(
+ vkStream, rootType,
+ (const VkDescriptorSetLayoutBinding*)(forMarshaling->pBindings + i));
}
}
}
-void unmarshal_VkDescriptorSetLayoutCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorSetLayoutCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkDescriptorSetLayoutCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkDescriptorSetLayoutCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDescriptorSetLayoutCreateFlags*)&forUnmarshaling->flags, sizeof(VkDescriptorSetLayoutCreateFlags));
+ vkStream->read((VkDescriptorSetLayoutCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkDescriptorSetLayoutCreateFlags));
vkStream->read((uint32_t*)&forUnmarshaling->bindingCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindingCount; ++i)
- {
- unmarshal_VkDescriptorSetLayoutBinding(vkStream, rootType, (VkDescriptorSetLayoutBinding*)(forUnmarshaling->pBindings + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bindingCount; ++i) {
+ unmarshal_VkDescriptorSetLayoutBinding(
+ vkStream, rootType,
+ (VkDescriptorSetLayoutBinding*)(forUnmarshaling->pBindings + i));
}
}
}
-void marshal_VkWriteDescriptorSet(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWriteDescriptorSet* forMarshaling)
-{
+void marshal_VkWriteDescriptorSet(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWriteDescriptorSet* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->dstBinding, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->dstArrayElement, sizeof(uint32_t));
@@ -3919,15 +3554,18 @@
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pImageInfo;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pImageInfo)
- {
- if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_SAMPLER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT == forMarshaling->descriptorType))))
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i)
- {
- marshal_VkDescriptorImageInfo(vkStream, rootType, (const VkDescriptorImageInfo*)(forMarshaling->pImageInfo + i));
+ if (forMarshaling->pImageInfo) {
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ ((VK_DESCRIPTOR_TYPE_SAMPLER == forMarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER == forMarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE == forMarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE == forMarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT == forMarshaling->descriptorType)))) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i) {
+ marshal_VkDescriptorImageInfo(
+ vkStream, rootType,
+ (const VkDescriptorImageInfo*)(forMarshaling->pImageInfo + i));
}
}
}
@@ -3935,15 +3573,17 @@
// WARNING PTR CHECK
uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pBufferInfo;
vkStream->putBe64(cgen_var_2);
- if (forMarshaling->pBufferInfo)
- {
- if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == forMarshaling->descriptorType))))
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i)
- {
- marshal_VkDescriptorBufferInfo(vkStream, rootType, (const VkDescriptorBufferInfo*)(forMarshaling->pBufferInfo + i));
+ if (forMarshaling->pBufferInfo) {
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ ((VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER == forMarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == forMarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == forMarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == forMarshaling->descriptorType)))) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i) {
+ marshal_VkDescriptorBufferInfo(
+ vkStream, rootType,
+ (const VkDescriptorBufferInfo*)(forMarshaling->pBufferInfo + i));
}
}
}
@@ -3951,36 +3591,33 @@
// WARNING PTR CHECK
uint64_t cgen_var_3 = (uint64_t)(uintptr_t)forMarshaling->pTexelBufferView;
vkStream->putBe64(cgen_var_3);
- if (forMarshaling->pTexelBufferView)
- {
- if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER == forMarshaling->descriptorType))))
- {
- if (forMarshaling->descriptorCount)
- {
+ if (forMarshaling->pTexelBufferView) {
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ ((VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER == forMarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER == forMarshaling->descriptorType)))) {
+ if (forMarshaling->descriptorCount) {
uint64_t* cgen_var_3_0;
vkStream->alloc((void**)&cgen_var_3_0, forMarshaling->descriptorCount * 8);
- vkStream->handleMapping()->mapHandles_VkBufferView_u64(forMarshaling->pTexelBufferView, cgen_var_3_0, forMarshaling->descriptorCount);
+ vkStream->handleMapping()->mapHandles_VkBufferView_u64(
+ forMarshaling->pTexelBufferView, cgen_var_3_0, forMarshaling->descriptorCount);
vkStream->write((uint64_t*)cgen_var_3_0, forMarshaling->descriptorCount * 8);
}
}
}
}
-void unmarshal_VkWriteDescriptorSet(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkWriteDescriptorSet* forUnmarshaling)
-{
+void unmarshal_VkWriteDescriptorSet(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkWriteDescriptorSet* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_0, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(
+ &cgen_var_0, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
vkStream->read((uint32_t*)&forUnmarshaling->dstBinding, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->dstArrayElement, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
@@ -3988,594 +3625,557 @@
// WARNING PTR CHECK
const VkDescriptorImageInfo* check_pImageInfo;
check_pImageInfo = (const VkDescriptorImageInfo*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pImageInfo)
- {
- if (!(check_pImageInfo))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pImageInfo inconsistent between guest and host\n");
+ if (forUnmarshaling->pImageInfo) {
+ if (!(check_pImageInfo)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pImageInfo inconsistent between guest and host\n");
}
- if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_SAMPLER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT == forUnmarshaling->descriptorType))))
- {
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorCount; ++i)
- {
- unmarshal_VkDescriptorImageInfo(vkStream, rootType, (VkDescriptorImageInfo*)(forUnmarshaling->pImageInfo + i));
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ ((VK_DESCRIPTOR_TYPE_SAMPLER == forUnmarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER == forUnmarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE == forUnmarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE == forUnmarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT == forUnmarshaling->descriptorType)))) {
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorCount; ++i) {
+ unmarshal_VkDescriptorImageInfo(
+ vkStream, rootType,
+ (VkDescriptorImageInfo*)(forUnmarshaling->pImageInfo + i));
}
}
- }
- else
- {
+ } else {
forUnmarshaling->pImageInfo = 0;
}
}
// WARNING PTR CHECK
const VkDescriptorBufferInfo* check_pBufferInfo;
check_pBufferInfo = (const VkDescriptorBufferInfo*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pBufferInfo)
- {
- if (!(check_pBufferInfo))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pBufferInfo inconsistent between guest and host\n");
+ if (forUnmarshaling->pBufferInfo) {
+ if (!(check_pBufferInfo)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pBufferInfo inconsistent between guest and host\n");
}
- if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == forUnmarshaling->descriptorType))))
- {
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorCount; ++i)
- {
- unmarshal_VkDescriptorBufferInfo(vkStream, rootType, (VkDescriptorBufferInfo*)(forUnmarshaling->pBufferInfo + i));
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ ((VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER == forUnmarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == forUnmarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == forUnmarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == forUnmarshaling->descriptorType)))) {
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorCount; ++i) {
+ unmarshal_VkDescriptorBufferInfo(
+ vkStream, rootType,
+ (VkDescriptorBufferInfo*)(forUnmarshaling->pBufferInfo + i));
}
}
- }
- else
- {
+ } else {
forUnmarshaling->pBufferInfo = 0;
}
}
// WARNING PTR CHECK
const VkBufferView* check_pTexelBufferView;
check_pTexelBufferView = (const VkBufferView*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pTexelBufferView)
- {
- if (!(check_pTexelBufferView))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pTexelBufferView inconsistent between guest and host\n");
+ if (forUnmarshaling->pTexelBufferView) {
+ if (!(check_pTexelBufferView)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pTexelBufferView inconsistent between guest and host\n");
}
- if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER == forUnmarshaling->descriptorType))))
- {
- if (forUnmarshaling->descriptorCount)
- {
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ ((VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER == forUnmarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER == forUnmarshaling->descriptorType)))) {
+ if (forUnmarshaling->descriptorCount) {
uint64_t* cgen_var_3_0;
vkStream->alloc((void**)&cgen_var_3_0, forUnmarshaling->descriptorCount * 8);
vkStream->read((uint64_t*)cgen_var_3_0, forUnmarshaling->descriptorCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBufferView(cgen_var_3_0, (VkBufferView*)forUnmarshaling->pTexelBufferView, forUnmarshaling->descriptorCount);
+ vkStream->handleMapping()->mapHandles_u64_VkBufferView(
+ cgen_var_3_0, (VkBufferView*)forUnmarshaling->pTexelBufferView,
+ forUnmarshaling->descriptorCount);
}
- }
- else
- {
+ } else {
forUnmarshaling->pTexelBufferView = 0;
}
}
}
-void marshal_VkAttachmentDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentDescription* forMarshaling)
-{
+void marshal_VkAttachmentDescription(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentDescription* forMarshaling) {
(void)rootType;
- vkStream->write((VkAttachmentDescriptionFlags*)&forMarshaling->flags, sizeof(VkAttachmentDescriptionFlags));
+ vkStream->write((VkAttachmentDescriptionFlags*)&forMarshaling->flags,
+ sizeof(VkAttachmentDescriptionFlags));
vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
vkStream->write((VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
vkStream->write((VkAttachmentLoadOp*)&forMarshaling->loadOp, sizeof(VkAttachmentLoadOp));
vkStream->write((VkAttachmentStoreOp*)&forMarshaling->storeOp, sizeof(VkAttachmentStoreOp));
vkStream->write((VkAttachmentLoadOp*)&forMarshaling->stencilLoadOp, sizeof(VkAttachmentLoadOp));
- vkStream->write((VkAttachmentStoreOp*)&forMarshaling->stencilStoreOp, sizeof(VkAttachmentStoreOp));
+ vkStream->write((VkAttachmentStoreOp*)&forMarshaling->stencilStoreOp,
+ sizeof(VkAttachmentStoreOp));
vkStream->write((VkImageLayout*)&forMarshaling->initialLayout, sizeof(VkImageLayout));
vkStream->write((VkImageLayout*)&forMarshaling->finalLayout, sizeof(VkImageLayout));
}
-void unmarshal_VkAttachmentDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAttachmentDescription* forUnmarshaling)
-{
+void unmarshal_VkAttachmentDescription(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAttachmentDescription* forUnmarshaling) {
(void)rootType;
- vkStream->read((VkAttachmentDescriptionFlags*)&forUnmarshaling->flags, sizeof(VkAttachmentDescriptionFlags));
+ vkStream->read((VkAttachmentDescriptionFlags*)&forUnmarshaling->flags,
+ sizeof(VkAttachmentDescriptionFlags));
vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
- vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples, sizeof(VkSampleCountFlagBits));
+ vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples,
+ sizeof(VkSampleCountFlagBits));
vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->loadOp, sizeof(VkAttachmentLoadOp));
vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->storeOp, sizeof(VkAttachmentStoreOp));
- vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->stencilLoadOp, sizeof(VkAttachmentLoadOp));
- vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->stencilStoreOp, sizeof(VkAttachmentStoreOp));
+ vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->stencilLoadOp,
+ sizeof(VkAttachmentLoadOp));
+ vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->stencilStoreOp,
+ sizeof(VkAttachmentStoreOp));
vkStream->read((VkImageLayout*)&forUnmarshaling->initialLayout, sizeof(VkImageLayout));
vkStream->read((VkImageLayout*)&forUnmarshaling->finalLayout, sizeof(VkImageLayout));
}
-void marshal_VkAttachmentReference(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentReference* forMarshaling)
-{
+void marshal_VkAttachmentReference(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentReference* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->attachment, sizeof(uint32_t));
vkStream->write((VkImageLayout*)&forMarshaling->layout, sizeof(VkImageLayout));
}
-void unmarshal_VkAttachmentReference(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAttachmentReference* forUnmarshaling)
-{
+void unmarshal_VkAttachmentReference(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAttachmentReference* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->attachment, sizeof(uint32_t));
vkStream->read((VkImageLayout*)&forUnmarshaling->layout, sizeof(VkImageLayout));
}
-void marshal_VkFramebufferCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFramebufferCreateInfo* forMarshaling)
-{
+void marshal_VkFramebufferCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFramebufferCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkFramebufferCreateFlags*)&forMarshaling->flags, sizeof(VkFramebufferCreateFlags));
+ vkStream->write((VkFramebufferCreateFlags*)&forMarshaling->flags,
+ sizeof(VkFramebufferCreateFlags));
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
- if (forMarshaling->attachmentCount)
- {
- uint64_t* cgen_var_1;
- vkStream->alloc((void**)&cgen_var_1, forMarshaling->attachmentCount * 8);
- vkStream->handleMapping()->mapHandles_VkImageView_u64(forMarshaling->pAttachments, cgen_var_1, forMarshaling->attachmentCount);
- vkStream->write((uint64_t*)cgen_var_1, forMarshaling->attachmentCount * 8);
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ (((forMarshaling->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT) == 0)))) {
+ if (forMarshaling->attachmentCount) {
+ uint64_t* cgen_var_0_0;
+ vkStream->alloc((void**)&cgen_var_0_0, forMarshaling->attachmentCount * 8);
+ vkStream->handleMapping()->mapHandles_VkImageView_u64(
+ forMarshaling->pAttachments, cgen_var_0_0, forMarshaling->attachmentCount);
+ vkStream->write((uint64_t*)cgen_var_0_0, forMarshaling->attachmentCount * 8);
+ }
}
vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->layers, sizeof(uint32_t));
}
-void unmarshal_VkFramebufferCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkFramebufferCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkFramebufferCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkFramebufferCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkFramebufferCreateFlags*)&forUnmarshaling->flags, sizeof(VkFramebufferCreateFlags));
+ vkStream->read((VkFramebufferCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkFramebufferCreateFlags));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_0, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkRenderPass(
+ &cgen_var_0, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
- if (forUnmarshaling->attachmentCount)
- {
- uint64_t* cgen_var_1;
- vkStream->alloc((void**)&cgen_var_1, forUnmarshaling->attachmentCount * 8);
- vkStream->read((uint64_t*)cgen_var_1, forUnmarshaling->attachmentCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImageView(cgen_var_1, (VkImageView*)forUnmarshaling->pAttachments, forUnmarshaling->attachmentCount);
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ (((forUnmarshaling->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT) == 0)))) {
+ if (forUnmarshaling->attachmentCount) {
+ uint64_t* cgen_var_0_0;
+ vkStream->alloc((void**)&cgen_var_0_0, forUnmarshaling->attachmentCount * 8);
+ vkStream->read((uint64_t*)cgen_var_0_0, forUnmarshaling->attachmentCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkImageView(
+ cgen_var_0_0, (VkImageView*)forUnmarshaling->pAttachments,
+ forUnmarshaling->attachmentCount);
+ }
+ } else {
+ forUnmarshaling->pAttachments = 0;
}
vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->layers, sizeof(uint32_t));
}
-void marshal_VkSubpassDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassDescription* forMarshaling)
-{
+void marshal_VkSubpassDescription(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassDescription* forMarshaling) {
(void)rootType;
- vkStream->write((VkSubpassDescriptionFlags*)&forMarshaling->flags, sizeof(VkSubpassDescriptionFlags));
- vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ vkStream->write((VkSubpassDescriptionFlags*)&forMarshaling->flags,
+ sizeof(VkSubpassDescriptionFlags));
+ vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
vkStream->write((uint32_t*)&forMarshaling->inputAttachmentCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->inputAttachmentCount; ++i)
- {
- marshal_VkAttachmentReference(vkStream, rootType, (const VkAttachmentReference*)(forMarshaling->pInputAttachments + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->inputAttachmentCount; ++i) {
+ marshal_VkAttachmentReference(
+ vkStream, rootType,
+ (const VkAttachmentReference*)(forMarshaling->pInputAttachments + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
- {
- marshal_VkAttachmentReference(vkStream, rootType, (const VkAttachmentReference*)(forMarshaling->pColorAttachments + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
+ marshal_VkAttachmentReference(
+ vkStream, rootType,
+ (const VkAttachmentReference*)(forMarshaling->pColorAttachments + i));
}
}
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pResolveAttachments)
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
- {
- marshal_VkAttachmentReference(vkStream, rootType, (const VkAttachmentReference*)(forMarshaling->pResolveAttachments + i));
+ if (forMarshaling->pResolveAttachments) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
+ marshal_VkAttachmentReference(
+ vkStream, rootType,
+ (const VkAttachmentReference*)(forMarshaling->pResolveAttachments + i));
}
}
}
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pDepthStencilAttachment)
- {
- marshal_VkAttachmentReference(vkStream, rootType, (const VkAttachmentReference*)(forMarshaling->pDepthStencilAttachment));
+ if (forMarshaling->pDepthStencilAttachment) {
+ marshal_VkAttachmentReference(
+ vkStream, rootType,
+ (const VkAttachmentReference*)(forMarshaling->pDepthStencilAttachment));
}
vkStream->write((uint32_t*)&forMarshaling->preserveAttachmentCount, sizeof(uint32_t));
- vkStream->write((const uint32_t*)forMarshaling->pPreserveAttachments, forMarshaling->preserveAttachmentCount * sizeof(const uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pPreserveAttachments,
+ forMarshaling->preserveAttachmentCount * sizeof(const uint32_t));
}
-void unmarshal_VkSubpassDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubpassDescription* forUnmarshaling)
-{
+void unmarshal_VkSubpassDescription(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubpassDescription* forUnmarshaling) {
(void)rootType;
- vkStream->read((VkSubpassDescriptionFlags*)&forUnmarshaling->flags, sizeof(VkSubpassDescriptionFlags));
- vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ vkStream->read((VkSubpassDescriptionFlags*)&forUnmarshaling->flags,
+ sizeof(VkSubpassDescriptionFlags));
+ vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
vkStream->read((uint32_t*)&forUnmarshaling->inputAttachmentCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->inputAttachmentCount; ++i)
- {
- unmarshal_VkAttachmentReference(vkStream, rootType, (VkAttachmentReference*)(forUnmarshaling->pInputAttachments + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->inputAttachmentCount; ++i) {
+ unmarshal_VkAttachmentReference(
+ vkStream, rootType,
+ (VkAttachmentReference*)(forUnmarshaling->pInputAttachments + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i)
- {
- unmarshal_VkAttachmentReference(vkStream, rootType, (VkAttachmentReference*)(forUnmarshaling->pColorAttachments + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i) {
+ unmarshal_VkAttachmentReference(
+ vkStream, rootType,
+ (VkAttachmentReference*)(forUnmarshaling->pColorAttachments + i));
}
}
// WARNING PTR CHECK
const VkAttachmentReference* check_pResolveAttachments;
check_pResolveAttachments = (const VkAttachmentReference*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pResolveAttachments)
- {
- if (!(check_pResolveAttachments))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pResolveAttachments inconsistent between guest and host\n");
+ if (forUnmarshaling->pResolveAttachments) {
+ if (!(check_pResolveAttachments)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pResolveAttachments inconsistent between guest and "
+ "host\n");
}
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i)
- {
- unmarshal_VkAttachmentReference(vkStream, rootType, (VkAttachmentReference*)(forUnmarshaling->pResolveAttachments + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i) {
+ unmarshal_VkAttachmentReference(
+ vkStream, rootType,
+ (VkAttachmentReference*)(forUnmarshaling->pResolveAttachments + i));
}
}
}
// WARNING PTR CHECK
const VkAttachmentReference* check_pDepthStencilAttachment;
check_pDepthStencilAttachment = (const VkAttachmentReference*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pDepthStencilAttachment)
- {
- if (!(check_pDepthStencilAttachment))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pDepthStencilAttachment inconsistent between guest and host\n");
+ if (forUnmarshaling->pDepthStencilAttachment) {
+ if (!(check_pDepthStencilAttachment)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pDepthStencilAttachment inconsistent between guest "
+ "and host\n");
}
- unmarshal_VkAttachmentReference(vkStream, rootType, (VkAttachmentReference*)(forUnmarshaling->pDepthStencilAttachment));
+ unmarshal_VkAttachmentReference(
+ vkStream, rootType, (VkAttachmentReference*)(forUnmarshaling->pDepthStencilAttachment));
}
vkStream->read((uint32_t*)&forUnmarshaling->preserveAttachmentCount, sizeof(uint32_t));
- vkStream->read((uint32_t*)forUnmarshaling->pPreserveAttachments, forUnmarshaling->preserveAttachmentCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pPreserveAttachments,
+ forUnmarshaling->preserveAttachmentCount * sizeof(const uint32_t));
}
-void marshal_VkSubpassDependency(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassDependency* forMarshaling)
-{
+void marshal_VkSubpassDependency(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassDependency* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->srcSubpass, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->dstSubpass, sizeof(uint32_t));
- vkStream->write((VkPipelineStageFlags*)&forMarshaling->srcStageMask, sizeof(VkPipelineStageFlags));
- vkStream->write((VkPipelineStageFlags*)&forMarshaling->dstStageMask, sizeof(VkPipelineStageFlags));
+ vkStream->write((VkPipelineStageFlags*)&forMarshaling->srcStageMask,
+ sizeof(VkPipelineStageFlags));
+ vkStream->write((VkPipelineStageFlags*)&forMarshaling->dstStageMask,
+ sizeof(VkPipelineStageFlags));
vkStream->write((VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
vkStream->write((VkDependencyFlags*)&forMarshaling->dependencyFlags, sizeof(VkDependencyFlags));
}
-void unmarshal_VkSubpassDependency(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubpassDependency* forUnmarshaling)
-{
+void unmarshal_VkSubpassDependency(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubpassDependency* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->srcSubpass, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->dstSubpass, sizeof(uint32_t));
- vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->srcStageMask, sizeof(VkPipelineStageFlags));
- vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->dstStageMask, sizeof(VkPipelineStageFlags));
+ vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->srcStageMask,
+ sizeof(VkPipelineStageFlags));
+ vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->dstStageMask,
+ sizeof(VkPipelineStageFlags));
vkStream->read((VkAccessFlags*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags));
vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
- vkStream->read((VkDependencyFlags*)&forUnmarshaling->dependencyFlags, sizeof(VkDependencyFlags));
+ vkStream->read((VkDependencyFlags*)&forUnmarshaling->dependencyFlags,
+ sizeof(VkDependencyFlags));
}
-void marshal_VkRenderPassCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassCreateInfo* forMarshaling)
-{
+void marshal_VkRenderPassCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkRenderPassCreateFlags*)&forMarshaling->flags, sizeof(VkRenderPassCreateFlags));
+ vkStream->write((VkRenderPassCreateFlags*)&forMarshaling->flags,
+ sizeof(VkRenderPassCreateFlags));
vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i)
- {
- marshal_VkAttachmentDescription(vkStream, rootType, (const VkAttachmentDescription*)(forMarshaling->pAttachments + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i) {
+ marshal_VkAttachmentDescription(
+ vkStream, rootType,
+ (const VkAttachmentDescription*)(forMarshaling->pAttachments + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->subpassCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->subpassCount; ++i)
- {
- marshal_VkSubpassDescription(vkStream, rootType, (const VkSubpassDescription*)(forMarshaling->pSubpasses + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->subpassCount; ++i) {
+ marshal_VkSubpassDescription(
+ vkStream, rootType, (const VkSubpassDescription*)(forMarshaling->pSubpasses + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->dependencyCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->dependencyCount; ++i)
- {
- marshal_VkSubpassDependency(vkStream, rootType, (const VkSubpassDependency*)(forMarshaling->pDependencies + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->dependencyCount; ++i) {
+ marshal_VkSubpassDependency(
+ vkStream, rootType, (const VkSubpassDependency*)(forMarshaling->pDependencies + i));
}
}
}
-void unmarshal_VkRenderPassCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRenderPassCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkRenderPassCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderPassCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkRenderPassCreateFlags*)&forUnmarshaling->flags, sizeof(VkRenderPassCreateFlags));
+ vkStream->read((VkRenderPassCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkRenderPassCreateFlags));
vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentCount; ++i)
- {
- unmarshal_VkAttachmentDescription(vkStream, rootType, (VkAttachmentDescription*)(forUnmarshaling->pAttachments + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentCount; ++i) {
+ unmarshal_VkAttachmentDescription(
+ vkStream, rootType, (VkAttachmentDescription*)(forUnmarshaling->pAttachments + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->subpassCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->subpassCount; ++i)
- {
- unmarshal_VkSubpassDescription(vkStream, rootType, (VkSubpassDescription*)(forUnmarshaling->pSubpasses + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->subpassCount; ++i) {
+ unmarshal_VkSubpassDescription(
+ vkStream, rootType, (VkSubpassDescription*)(forUnmarshaling->pSubpasses + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->dependencyCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->dependencyCount; ++i)
- {
- unmarshal_VkSubpassDependency(vkStream, rootType, (VkSubpassDependency*)(forUnmarshaling->pDependencies + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->dependencyCount; ++i) {
+ unmarshal_VkSubpassDependency(
+ vkStream, rootType, (VkSubpassDependency*)(forUnmarshaling->pDependencies + i));
}
}
}
-void marshal_VkCommandPoolCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandPoolCreateInfo* forMarshaling)
-{
+void marshal_VkCommandPoolCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandPoolCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkCommandPoolCreateFlags*)&forMarshaling->flags, sizeof(VkCommandPoolCreateFlags));
+ vkStream->write((VkCommandPoolCreateFlags*)&forMarshaling->flags,
+ sizeof(VkCommandPoolCreateFlags));
vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
}
-void unmarshal_VkCommandPoolCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCommandPoolCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkCommandPoolCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCommandPoolCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkCommandPoolCreateFlags*)&forUnmarshaling->flags, sizeof(VkCommandPoolCreateFlags));
+ vkStream->read((VkCommandPoolCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkCommandPoolCreateFlags));
vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndex, sizeof(uint32_t));
}
-void marshal_VkCommandBufferAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferAllocateInfo* forMarshaling)
-{
+void marshal_VkCommandBufferAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferAllocateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkCommandPool_u64(&forMarshaling->commandPool, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkCommandPool_u64(&forMarshaling->commandPool,
+ &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((VkCommandBufferLevel*)&forMarshaling->level, sizeof(VkCommandBufferLevel));
vkStream->write((uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
}
-void unmarshal_VkCommandBufferAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCommandBufferAllocateInfo* forUnmarshaling)
-{
+void unmarshal_VkCommandBufferAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCommandBufferAllocateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkCommandPool(&cgen_var_0, (VkCommandPool*)&forUnmarshaling->commandPool, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkCommandPool(
+ &cgen_var_0, (VkCommandPool*)&forUnmarshaling->commandPool, 1);
vkStream->read((VkCommandBufferLevel*)&forUnmarshaling->level, sizeof(VkCommandBufferLevel));
vkStream->read((uint32_t*)&forUnmarshaling->commandBufferCount, sizeof(uint32_t));
}
-void marshal_VkCommandBufferInheritanceInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferInheritanceInfo* forMarshaling)
-{
+void marshal_VkCommandBufferInheritanceInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferInheritanceInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
uint64_t cgen_var_1;
- vkStream->handleMapping()->mapHandles_VkFramebuffer_u64(&forMarshaling->framebuffer, &cgen_var_1, 1);
+ vkStream->handleMapping()->mapHandles_VkFramebuffer_u64(&forMarshaling->framebuffer,
+ &cgen_var_1, 1);
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
vkStream->write((VkBool32*)&forMarshaling->occlusionQueryEnable, sizeof(VkBool32));
vkStream->write((VkQueryControlFlags*)&forMarshaling->queryFlags, sizeof(VkQueryControlFlags));
- vkStream->write((VkQueryPipelineStatisticFlags*)&forMarshaling->pipelineStatistics, sizeof(VkQueryPipelineStatisticFlags));
+ vkStream->write((VkQueryPipelineStatisticFlags*)&forMarshaling->pipelineStatistics,
+ sizeof(VkQueryPipelineStatisticFlags));
}
-void unmarshal_VkCommandBufferInheritanceInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCommandBufferInheritanceInfo* forUnmarshaling)
-{
+void unmarshal_VkCommandBufferInheritanceInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCommandBufferInheritanceInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_0, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkRenderPass(
+ &cgen_var_0, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
vkStream->read((uint32_t*)&forUnmarshaling->subpass, sizeof(uint32_t));
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_1, (VkFramebuffer*)&forUnmarshaling->framebuffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkFramebuffer(
+ &cgen_var_1, (VkFramebuffer*)&forUnmarshaling->framebuffer, 1);
vkStream->read((VkBool32*)&forUnmarshaling->occlusionQueryEnable, sizeof(VkBool32));
vkStream->read((VkQueryControlFlags*)&forUnmarshaling->queryFlags, sizeof(VkQueryControlFlags));
- vkStream->read((VkQueryPipelineStatisticFlags*)&forUnmarshaling->pipelineStatistics, sizeof(VkQueryPipelineStatisticFlags));
+ vkStream->read((VkQueryPipelineStatisticFlags*)&forUnmarshaling->pipelineStatistics,
+ sizeof(VkQueryPipelineStatisticFlags));
}
-void marshal_VkCommandBufferBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferBeginInfo* forMarshaling)
-{
+void marshal_VkCommandBufferBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferBeginInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkCommandBufferUsageFlags*)&forMarshaling->flags, sizeof(VkCommandBufferUsageFlags));
+ vkStream->write((VkCommandBufferUsageFlags*)&forMarshaling->flags,
+ sizeof(VkCommandBufferUsageFlags));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pInheritanceInfo;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pInheritanceInfo)
- {
- marshal_VkCommandBufferInheritanceInfo(vkStream, rootType, (const VkCommandBufferInheritanceInfo*)(forMarshaling->pInheritanceInfo));
+ if (forMarshaling->pInheritanceInfo) {
+ marshal_VkCommandBufferInheritanceInfo(
+ vkStream, rootType,
+ (const VkCommandBufferInheritanceInfo*)(forMarshaling->pInheritanceInfo));
}
}
-void unmarshal_VkCommandBufferBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCommandBufferBeginInfo* forUnmarshaling)
-{
+void unmarshal_VkCommandBufferBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCommandBufferBeginInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkCommandBufferUsageFlags*)&forUnmarshaling->flags, sizeof(VkCommandBufferUsageFlags));
+ vkStream->read((VkCommandBufferUsageFlags*)&forUnmarshaling->flags,
+ sizeof(VkCommandBufferUsageFlags));
// WARNING PTR CHECK
const VkCommandBufferInheritanceInfo* check_pInheritanceInfo;
check_pInheritanceInfo = (const VkCommandBufferInheritanceInfo*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pInheritanceInfo)
- {
- if (!(check_pInheritanceInfo))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pInheritanceInfo inconsistent between guest and host\n");
+ if (forUnmarshaling->pInheritanceInfo) {
+ if (!(check_pInheritanceInfo)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pInheritanceInfo inconsistent between guest and host\n");
}
- unmarshal_VkCommandBufferInheritanceInfo(vkStream, rootType, (VkCommandBufferInheritanceInfo*)(forUnmarshaling->pInheritanceInfo));
+ unmarshal_VkCommandBufferInheritanceInfo(
+ vkStream, rootType,
+ (VkCommandBufferInheritanceInfo*)(forUnmarshaling->pInheritanceInfo));
}
}
-void marshal_VkBufferCopy(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCopy* forMarshaling)
-{
+void marshal_VkBufferCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCopy* forMarshaling) {
(void)rootType;
vkStream->write((VkDeviceSize*)&forMarshaling->srcOffset, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->dstOffset, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
}
-void unmarshal_VkBufferCopy(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferCopy* forUnmarshaling)
-{
+void unmarshal_VkBufferCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferCopy* forUnmarshaling) {
(void)rootType;
vkStream->read((VkDeviceSize*)&forUnmarshaling->srcOffset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->dstOffset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
}
-void marshal_VkImageSubresourceLayers(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageSubresourceLayers* forMarshaling)
-{
+void marshal_VkImageSubresourceLayers(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSubresourceLayers* forMarshaling) {
(void)rootType;
vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
vkStream->write((uint32_t*)&forMarshaling->mipLevel, sizeof(uint32_t));
@@ -4583,11 +4183,8 @@
vkStream->write((uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
}
-void unmarshal_VkImageSubresourceLayers(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageSubresourceLayers* forUnmarshaling)
-{
+void unmarshal_VkImageSubresourceLayers(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageSubresourceLayers* forUnmarshaling) {
(void)rootType;
vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
vkStream->read((uint32_t*)&forUnmarshaling->mipLevel, sizeof(uint32_t));
@@ -4595,291 +4192,239 @@
vkStream->read((uint32_t*)&forUnmarshaling->layerCount, sizeof(uint32_t));
}
-void marshal_VkBufferImageCopy(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferImageCopy* forMarshaling)
-{
+void marshal_VkBufferImageCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferImageCopy* forMarshaling) {
(void)rootType;
vkStream->write((VkDeviceSize*)&forMarshaling->bufferOffset, sizeof(VkDeviceSize));
vkStream->write((uint32_t*)&forMarshaling->bufferRowLength, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->bufferImageHeight, sizeof(uint32_t));
- marshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource));
+ marshal_VkImageSubresourceLayers(vkStream, rootType,
+ (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource));
marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset));
marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent));
}
-void unmarshal_VkBufferImageCopy(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferImageCopy* forUnmarshaling)
-{
+void unmarshal_VkBufferImageCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferImageCopy* forUnmarshaling) {
(void)rootType;
vkStream->read((VkDeviceSize*)&forUnmarshaling->bufferOffset, sizeof(VkDeviceSize));
vkStream->read((uint32_t*)&forUnmarshaling->bufferRowLength, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->bufferImageHeight, sizeof(uint32_t));
- unmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource));
+ unmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource));
unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->imageOffset));
unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageExtent));
}
-void marshal_VkClearColorValue(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkClearColorValue* forMarshaling)
-{
+void marshal_VkClearColorValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkClearColorValue* forMarshaling) {
(void)rootType;
vkStream->write((float*)forMarshaling->float32, 4 * sizeof(float));
}
-void unmarshal_VkClearColorValue(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkClearColorValue* forUnmarshaling)
-{
+void unmarshal_VkClearColorValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkClearColorValue* forUnmarshaling) {
(void)rootType;
vkStream->read((float*)forUnmarshaling->float32, 4 * sizeof(float));
}
-void marshal_VkClearDepthStencilValue(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkClearDepthStencilValue* forMarshaling)
-{
+void marshal_VkClearDepthStencilValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkClearDepthStencilValue* forMarshaling) {
(void)rootType;
vkStream->write((float*)&forMarshaling->depth, sizeof(float));
vkStream->write((uint32_t*)&forMarshaling->stencil, sizeof(uint32_t));
}
-void unmarshal_VkClearDepthStencilValue(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkClearDepthStencilValue* forUnmarshaling)
-{
+void unmarshal_VkClearDepthStencilValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkClearDepthStencilValue* forUnmarshaling) {
(void)rootType;
vkStream->read((float*)&forUnmarshaling->depth, sizeof(float));
vkStream->read((uint32_t*)&forUnmarshaling->stencil, sizeof(uint32_t));
}
-void marshal_VkClearValue(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkClearValue* forMarshaling)
-{
+void marshal_VkClearValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkClearValue* forMarshaling) {
(void)rootType;
marshal_VkClearColorValue(vkStream, rootType, (VkClearColorValue*)(&forMarshaling->color));
}
-void unmarshal_VkClearValue(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkClearValue* forUnmarshaling)
-{
+void unmarshal_VkClearValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkClearValue* forUnmarshaling) {
(void)rootType;
unmarshal_VkClearColorValue(vkStream, rootType, (VkClearColorValue*)(&forUnmarshaling->color));
}
-void marshal_VkClearAttachment(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkClearAttachment* forMarshaling)
-{
+void marshal_VkClearAttachment(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkClearAttachment* forMarshaling) {
(void)rootType;
vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
vkStream->write((uint32_t*)&forMarshaling->colorAttachment, sizeof(uint32_t));
marshal_VkClearValue(vkStream, rootType, (VkClearValue*)(&forMarshaling->clearValue));
}
-void unmarshal_VkClearAttachment(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkClearAttachment* forUnmarshaling)
-{
+void unmarshal_VkClearAttachment(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkClearAttachment* forUnmarshaling) {
(void)rootType;
vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
vkStream->read((uint32_t*)&forUnmarshaling->colorAttachment, sizeof(uint32_t));
unmarshal_VkClearValue(vkStream, rootType, (VkClearValue*)(&forUnmarshaling->clearValue));
}
-void marshal_VkClearRect(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkClearRect* forMarshaling)
-{
+void marshal_VkClearRect(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkClearRect* forMarshaling) {
(void)rootType;
marshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->rect));
vkStream->write((uint32_t*)&forMarshaling->baseArrayLayer, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
}
-void unmarshal_VkClearRect(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkClearRect* forUnmarshaling)
-{
+void unmarshal_VkClearRect(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkClearRect* forUnmarshaling) {
(void)rootType;
unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forUnmarshaling->rect));
vkStream->read((uint32_t*)&forUnmarshaling->baseArrayLayer, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->layerCount, sizeof(uint32_t));
}
-void marshal_VkImageBlit(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageBlit* forMarshaling)
-{
+void marshal_VkImageBlit(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageBlit* forMarshaling) {
(void)rootType;
- marshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ marshal_VkImageSubresourceLayers(vkStream, rootType,
+ (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->srcOffsets + i));
}
- marshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ marshal_VkImageSubresourceLayers(vkStream, rootType,
+ (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->dstOffsets + i));
}
}
-void unmarshal_VkImageBlit(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageBlit* forUnmarshaling)
-{
+void unmarshal_VkImageBlit(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageBlit* forUnmarshaling) {
(void)rootType;
- unmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ unmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forUnmarshaling->srcOffsets + i));
}
- unmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ unmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forUnmarshaling->dstOffsets + i));
}
}
-void marshal_VkImageCopy(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageCopy* forMarshaling)
-{
+void marshal_VkImageCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageCopy* forMarshaling) {
(void)rootType;
- marshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
+ marshal_VkImageSubresourceLayers(vkStream, rootType,
+ (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset));
- marshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
+ marshal_VkImageSubresourceLayers(vkStream, rootType,
+ (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->dstOffset));
marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent));
}
-void unmarshal_VkImageCopy(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageCopy* forUnmarshaling)
-{
+void unmarshal_VkImageCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageCopy* forUnmarshaling) {
(void)rootType;
- unmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
+ unmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->srcOffset));
- unmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
+ unmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->dstOffset));
unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->extent));
}
-void marshal_VkImageResolve(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageResolve* forMarshaling)
-{
+void marshal_VkImageResolve(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageResolve* forMarshaling) {
(void)rootType;
- marshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
+ marshal_VkImageSubresourceLayers(vkStream, rootType,
+ (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset));
- marshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
+ marshal_VkImageSubresourceLayers(vkStream, rootType,
+ (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->dstOffset));
marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent));
}
-void unmarshal_VkImageResolve(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageResolve* forUnmarshaling)
-{
+void unmarshal_VkImageResolve(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageResolve* forUnmarshaling) {
(void)rootType;
- unmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
+ unmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->srcOffset));
- unmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
+ unmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->dstOffset));
unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->extent));
}
-void marshal_VkRenderPassBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassBeginInfo* forMarshaling)
-{
+void marshal_VkRenderPassBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassBeginInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
uint64_t cgen_var_1;
- vkStream->handleMapping()->mapHandles_VkFramebuffer_u64(&forMarshaling->framebuffer, &cgen_var_1, 1);
+ vkStream->handleMapping()->mapHandles_VkFramebuffer_u64(&forMarshaling->framebuffer,
+ &cgen_var_1, 1);
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
marshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->renderArea));
vkStream->write((uint32_t*)&forMarshaling->clearValueCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pClearValues;
vkStream->putBe64(cgen_var_2);
- if (forMarshaling->pClearValues)
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->clearValueCount; ++i)
- {
- marshal_VkClearValue(vkStream, rootType, (const VkClearValue*)(forMarshaling->pClearValues + i));
+ if (forMarshaling->pClearValues) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->clearValueCount; ++i) {
+ marshal_VkClearValue(vkStream, rootType,
+ (const VkClearValue*)(forMarshaling->pClearValues + i));
}
}
}
}
-void unmarshal_VkRenderPassBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRenderPassBeginInfo* forUnmarshaling)
-{
+void unmarshal_VkRenderPassBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderPassBeginInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_0, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkRenderPass(
+ &cgen_var_0, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_1, (VkFramebuffer*)&forUnmarshaling->framebuffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkFramebuffer(
+ &cgen_var_1, (VkFramebuffer*)&forUnmarshaling->framebuffer, 1);
unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forUnmarshaling->renderArea));
vkStream->read((uint32_t*)&forUnmarshaling->clearValueCount, sizeof(uint32_t));
// WARNING PTR CHECK
const VkClearValue* check_pClearValues;
check_pClearValues = (const VkClearValue*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pClearValues)
- {
- if (!(check_pClearValues))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pClearValues inconsistent between guest and host\n");
+ if (forUnmarshaling->pClearValues) {
+ if (!(check_pClearValues)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pClearValues inconsistent between guest and host\n");
}
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->clearValueCount; ++i)
- {
- unmarshal_VkClearValue(vkStream, rootType, (VkClearValue*)(forUnmarshaling->pClearValues + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->clearValueCount; ++i) {
+ unmarshal_VkClearValue(vkStream, rootType,
+ (VkClearValue*)(forUnmarshaling->pClearValues + i));
}
}
}
@@ -4888,50 +4433,44 @@
#endif
#ifdef VK_VERSION_1_1
void marshal_VkPhysicalDeviceSubgroupProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSubgroupProperties* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSubgroupProperties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->subgroupSize, sizeof(uint32_t));
- vkStream->write((VkShaderStageFlags*)&forMarshaling->supportedStages, sizeof(VkShaderStageFlags));
- vkStream->write((VkSubgroupFeatureFlags*)&forMarshaling->supportedOperations, sizeof(VkSubgroupFeatureFlags));
+ vkStream->write((VkShaderStageFlags*)&forMarshaling->supportedStages,
+ sizeof(VkShaderStageFlags));
+ vkStream->write((VkSubgroupFeatureFlags*)&forMarshaling->supportedOperations,
+ sizeof(VkSubgroupFeatureFlags));
vkStream->write((VkBool32*)&forMarshaling->quadOperationsInAllStages, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceSubgroupProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceSubgroupProperties* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceSubgroupProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->subgroupSize, sizeof(uint32_t));
- vkStream->read((VkShaderStageFlags*)&forUnmarshaling->supportedStages, sizeof(VkShaderStageFlags));
- vkStream->read((VkSubgroupFeatureFlags*)&forUnmarshaling->supportedOperations, sizeof(VkSubgroupFeatureFlags));
+ vkStream->read((VkShaderStageFlags*)&forUnmarshaling->supportedStages,
+ sizeof(VkShaderStageFlags));
+ vkStream->read((VkSubgroupFeatureFlags*)&forUnmarshaling->supportedOperations,
+ sizeof(VkSubgroupFeatureFlags));
vkStream->read((VkBool32*)&forUnmarshaling->quadOperationsInAllStages, sizeof(VkBool32));
}
-void marshal_VkBindBufferMemoryInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindBufferMemoryInfo* forMarshaling)
-{
+void marshal_VkBindBufferMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindBufferMemoryInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -4939,41 +4478,36 @@
vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
uint64_t cgen_var_1;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_1, 1);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_1,
+ 1);
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
}
-void unmarshal_VkBindBufferMemoryInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBindBufferMemoryInfo* forUnmarshaling)
-{
+void unmarshal_VkBindBufferMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBindBufferMemoryInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+ (VkBuffer*)&forUnmarshaling->buffer, 1);
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_1, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+ &cgen_var_1, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
}
-void marshal_VkBindImageMemoryInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindImageMemoryInfo* forMarshaling)
-{
+void marshal_VkBindImageMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindImageMemoryInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -4981,77 +4515,68 @@
vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
uint64_t cgen_var_1;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_1, 1);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_1,
+ 1);
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
}
-void unmarshal_VkBindImageMemoryInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBindImageMemoryInfo* forUnmarshaling)
-{
+void unmarshal_VkBindImageMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBindImageMemoryInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0, (VkImage*)&forUnmarshaling->image, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+ (VkImage*)&forUnmarshaling->image, 1);
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_1, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+ &cgen_var_1, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
}
void marshal_VkPhysicalDevice16BitStorageFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevice16BitStorageFeatures* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevice16BitStorageFeatures* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->storageBuffer16BitAccess, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->uniformAndStorageBuffer16BitAccess, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->uniformAndStorageBuffer16BitAccess,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->storagePushConstant16, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->storageInputOutput16, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDevice16BitStorageFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDevice16BitStorageFeatures* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevice16BitStorageFeatures* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->storageBuffer16BitAccess, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->uniformAndStorageBuffer16BitAccess, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->uniformAndStorageBuffer16BitAccess,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->storagePushConstant16, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->storageInputOutput16, sizeof(VkBool32));
}
-void marshal_VkMemoryDedicatedRequirements(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryDedicatedRequirements* forMarshaling)
-{
+void marshal_VkMemoryDedicatedRequirements(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryDedicatedRequirements* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -5059,15 +4584,11 @@
vkStream->write((VkBool32*)&forMarshaling->requiresDedicatedAllocation, sizeof(VkBool32));
}
-void unmarshal_VkMemoryDedicatedRequirements(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryDedicatedRequirements* forUnmarshaling)
-{
+void unmarshal_VkMemoryDedicatedRequirements(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryDedicatedRequirements* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -5075,15 +4596,11 @@
vkStream->read((VkBool32*)&forUnmarshaling->requiresDedicatedAllocation, sizeof(VkBool32));
}
-void marshal_VkMemoryDedicatedAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryDedicatedAllocateInfo* forMarshaling)
-{
+void marshal_VkMemoryDedicatedAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryDedicatedAllocateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -5095,35 +4612,29 @@
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
}
-void unmarshal_VkMemoryDedicatedAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryDedicatedAllocateInfo* forUnmarshaling)
-{
+void unmarshal_VkMemoryDedicatedAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryDedicatedAllocateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0, (VkImage*)&forUnmarshaling->image, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+ (VkImage*)&forUnmarshaling->image, 1);
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_1, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_1,
+ (VkBuffer*)&forUnmarshaling->buffer, 1);
}
-void marshal_VkMemoryAllocateFlagsInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryAllocateFlagsInfo* forMarshaling)
-{
+void marshal_VkMemoryAllocateFlagsInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryAllocateFlagsInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -5131,15 +4642,11 @@
vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
}
-void unmarshal_VkMemoryAllocateFlagsInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryAllocateFlagsInfo* forUnmarshaling)
-{
+void unmarshal_VkMemoryAllocateFlagsInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryAllocateFlagsInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -5148,60 +4655,49 @@
}
void marshal_VkDeviceGroupRenderPassBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupRenderPassBeginInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupRenderPassBeginInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->deviceRenderAreaCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->deviceRenderAreaCount; ++i)
- {
- marshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pDeviceRenderAreas + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->deviceRenderAreaCount; ++i) {
+ marshal_VkRect2D(vkStream, rootType,
+ (const VkRect2D*)(forMarshaling->pDeviceRenderAreas + i));
}
}
}
-void unmarshal_VkDeviceGroupRenderPassBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceGroupRenderPassBeginInfo* forUnmarshaling)
-{
+void unmarshal_VkDeviceGroupRenderPassBeginInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkDeviceGroupRenderPassBeginInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->deviceRenderAreaCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->deviceRenderAreaCount; ++i)
- {
- unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(forUnmarshaling->pDeviceRenderAreas + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->deviceRenderAreaCount; ++i) {
+ unmarshal_VkRect2D(vkStream, rootType,
+ (VkRect2D*)(forUnmarshaling->pDeviceRenderAreas + i));
}
}
}
void marshal_VkDeviceGroupCommandBufferBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupCommandBufferBeginInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupCommandBufferBeginInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -5209,69 +4705,60 @@
}
void unmarshal_VkDeviceGroupCommandBufferBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceGroupCommandBufferBeginInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceGroupCommandBufferBeginInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
}
-void marshal_VkDeviceGroupSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupSubmitInfo* forMarshaling)
-{
+void marshal_VkDeviceGroupSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupSubmitInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
- vkStream->write((const uint32_t*)forMarshaling->pWaitSemaphoreDeviceIndices, forMarshaling->waitSemaphoreCount * sizeof(const uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pWaitSemaphoreDeviceIndices,
+ forMarshaling->waitSemaphoreCount * sizeof(const uint32_t));
vkStream->write((uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
- vkStream->write((const uint32_t*)forMarshaling->pCommandBufferDeviceMasks, forMarshaling->commandBufferCount * sizeof(const uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pCommandBufferDeviceMasks,
+ forMarshaling->commandBufferCount * sizeof(const uint32_t));
vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
- vkStream->write((const uint32_t*)forMarshaling->pSignalSemaphoreDeviceIndices, forMarshaling->signalSemaphoreCount * sizeof(const uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pSignalSemaphoreDeviceIndices,
+ forMarshaling->signalSemaphoreCount * sizeof(const uint32_t));
}
-void unmarshal_VkDeviceGroupSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceGroupSubmitInfo* forUnmarshaling)
-{
+void unmarshal_VkDeviceGroupSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceGroupSubmitInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
- vkStream->read((uint32_t*)forUnmarshaling->pWaitSemaphoreDeviceIndices, forUnmarshaling->waitSemaphoreCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pWaitSemaphoreDeviceIndices,
+ forUnmarshaling->waitSemaphoreCount * sizeof(const uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->commandBufferCount, sizeof(uint32_t));
- vkStream->read((uint32_t*)forUnmarshaling->pCommandBufferDeviceMasks, forUnmarshaling->commandBufferCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pCommandBufferDeviceMasks,
+ forUnmarshaling->commandBufferCount * sizeof(const uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreCount, sizeof(uint32_t));
- vkStream->read((uint32_t*)forUnmarshaling->pSignalSemaphoreDeviceIndices, forUnmarshaling->signalSemaphoreCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pSignalSemaphoreDeviceIndices,
+ forUnmarshaling->signalSemaphoreCount * sizeof(const uint32_t));
}
-void marshal_VkDeviceGroupBindSparseInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupBindSparseInfo* forMarshaling)
-{
+void marshal_VkDeviceGroupBindSparseInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupBindSparseInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -5279,15 +4766,11 @@
vkStream->write((uint32_t*)&forMarshaling->memoryDeviceIndex, sizeof(uint32_t));
}
-void unmarshal_VkDeviceGroupBindSparseInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceGroupBindSparseInfo* forUnmarshaling)
-{
+void unmarshal_VkDeviceGroupBindSparseInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceGroupBindSparseInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -5296,172 +4779,146 @@
}
void marshal_VkBindBufferMemoryDeviceGroupInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindBufferMemoryDeviceGroupInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindBufferMemoryDeviceGroupInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->deviceIndexCount, sizeof(uint32_t));
- vkStream->write((const uint32_t*)forMarshaling->pDeviceIndices, forMarshaling->deviceIndexCount * sizeof(const uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pDeviceIndices,
+ forMarshaling->deviceIndexCount * sizeof(const uint32_t));
}
void unmarshal_VkBindBufferMemoryDeviceGroupInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBindBufferMemoryDeviceGroupInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBindBufferMemoryDeviceGroupInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->deviceIndexCount, sizeof(uint32_t));
- vkStream->read((uint32_t*)forUnmarshaling->pDeviceIndices, forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pDeviceIndices,
+ forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
}
void marshal_VkBindImageMemoryDeviceGroupInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindImageMemoryDeviceGroupInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindImageMemoryDeviceGroupInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->deviceIndexCount, sizeof(uint32_t));
- vkStream->write((const uint32_t*)forMarshaling->pDeviceIndices, forMarshaling->deviceIndexCount * sizeof(const uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pDeviceIndices,
+ forMarshaling->deviceIndexCount * sizeof(const uint32_t));
vkStream->write((uint32_t*)&forMarshaling->splitInstanceBindRegionCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->splitInstanceBindRegionCount; ++i)
- {
- marshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pSplitInstanceBindRegions + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->splitInstanceBindRegionCount; ++i) {
+ marshal_VkRect2D(vkStream, rootType,
+ (const VkRect2D*)(forMarshaling->pSplitInstanceBindRegions + i));
}
}
}
-void unmarshal_VkBindImageMemoryDeviceGroupInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBindImageMemoryDeviceGroupInfo* forUnmarshaling)
-{
+void unmarshal_VkBindImageMemoryDeviceGroupInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkBindImageMemoryDeviceGroupInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->deviceIndexCount, sizeof(uint32_t));
- vkStream->read((uint32_t*)forUnmarshaling->pDeviceIndices, forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pDeviceIndices,
+ forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->splitInstanceBindRegionCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->splitInstanceBindRegionCount; ++i)
- {
- unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(forUnmarshaling->pSplitInstanceBindRegions + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->splitInstanceBindRegionCount; ++i) {
+ unmarshal_VkRect2D(vkStream, rootType,
+ (VkRect2D*)(forUnmarshaling->pSplitInstanceBindRegions + i));
}
}
}
-void marshal_VkPhysicalDeviceGroupProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceGroupProperties* forMarshaling)
-{
+void marshal_VkPhysicalDeviceGroupProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceGroupProperties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->physicalDeviceCount, sizeof(uint32_t));
- vkStream->write((VkPhysicalDevice*)forMarshaling->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice));
+ vkStream->write((VkPhysicalDevice*)forMarshaling->physicalDevices,
+ VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice));
vkStream->write((VkBool32*)&forMarshaling->subsetAllocation, sizeof(VkBool32));
}
-void unmarshal_VkPhysicalDeviceGroupProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceGroupProperties* forUnmarshaling)
-{
+void unmarshal_VkPhysicalDeviceGroupProperties(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPhysicalDeviceGroupProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->physicalDeviceCount, sizeof(uint32_t));
- vkStream->read((VkPhysicalDevice*)forUnmarshaling->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice));
+ vkStream->read((VkPhysicalDevice*)forUnmarshaling->physicalDevices,
+ VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice));
vkStream->read((VkBool32*)&forUnmarshaling->subsetAllocation, sizeof(VkBool32));
}
-void marshal_VkDeviceGroupDeviceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupDeviceCreateInfo* forMarshaling)
-{
+void marshal_VkDeviceGroupDeviceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupDeviceCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->physicalDeviceCount, sizeof(uint32_t));
- if (forMarshaling->physicalDeviceCount)
- {
+ if (forMarshaling->physicalDeviceCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forMarshaling->physicalDeviceCount * 8);
- vkStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(forMarshaling->pPhysicalDevices, cgen_var_0, forMarshaling->physicalDeviceCount);
+ vkStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(
+ forMarshaling->pPhysicalDevices, cgen_var_0, forMarshaling->physicalDeviceCount);
vkStream->write((uint64_t*)cgen_var_0, forMarshaling->physicalDeviceCount * 8);
}
}
-void unmarshal_VkDeviceGroupDeviceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceGroupDeviceCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkDeviceGroupDeviceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceGroupDeviceCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->physicalDeviceCount, sizeof(uint32_t));
- if (forUnmarshaling->physicalDeviceCount)
- {
+ if (forUnmarshaling->physicalDeviceCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->physicalDeviceCount * 8);
vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->physicalDeviceCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPhysicalDevice(cgen_var_0, (VkPhysicalDevice*)forUnmarshaling->pPhysicalDevices, forUnmarshaling->physicalDeviceCount);
+ vkStream->handleMapping()->mapHandles_u64_VkPhysicalDevice(
+ cgen_var_0, (VkPhysicalDevice*)forUnmarshaling->pPhysicalDevices,
+ forUnmarshaling->physicalDeviceCount);
}
}
-void marshal_VkBufferMemoryRequirementsInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferMemoryRequirementsInfo2* forMarshaling)
-{
+void marshal_VkBufferMemoryRequirementsInfo2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferMemoryRequirementsInfo2* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -5470,32 +4927,26 @@
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}
-void unmarshal_VkBufferMemoryRequirementsInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferMemoryRequirementsInfo2* forUnmarshaling)
-{
+void unmarshal_VkBufferMemoryRequirementsInfo2(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkBufferMemoryRequirementsInfo2* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+ (VkBuffer*)&forUnmarshaling->buffer, 1);
}
-void marshal_VkImageMemoryRequirementsInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageMemoryRequirementsInfo2* forMarshaling)
-{
+void marshal_VkImageMemoryRequirementsInfo2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageMemoryRequirementsInfo2* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -5504,32 +4955,26 @@
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}
-void unmarshal_VkImageMemoryRequirementsInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageMemoryRequirementsInfo2* forUnmarshaling)
-{
+void unmarshal_VkImageMemoryRequirementsInfo2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageMemoryRequirementsInfo2* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0, (VkImage*)&forUnmarshaling->image, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+ (VkImage*)&forUnmarshaling->image, 1);
}
void marshal_VkImageSparseMemoryRequirementsInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageSparseMemoryRequirementsInfo2* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSparseMemoryRequirementsInfo2* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -5539,211 +4984,173 @@
}
void unmarshal_VkImageSparseMemoryRequirementsInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageSparseMemoryRequirementsInfo2* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageSparseMemoryRequirementsInfo2* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0, (VkImage*)&forUnmarshaling->image, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+ (VkImage*)&forUnmarshaling->image, 1);
}
-void marshal_VkMemoryRequirements2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryRequirements2* forMarshaling)
-{
+void marshal_VkMemoryRequirements2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryRequirements2* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkMemoryRequirements(vkStream, rootType, (VkMemoryRequirements*)(&forMarshaling->memoryRequirements));
+ marshal_VkMemoryRequirements(vkStream, rootType,
+ (VkMemoryRequirements*)(&forMarshaling->memoryRequirements));
}
-void unmarshal_VkMemoryRequirements2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryRequirements2* forUnmarshaling)
-{
+void unmarshal_VkMemoryRequirements2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryRequirements2* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkMemoryRequirements(vkStream, rootType, (VkMemoryRequirements*)(&forUnmarshaling->memoryRequirements));
+ unmarshal_VkMemoryRequirements(vkStream, rootType,
+ (VkMemoryRequirements*)(&forUnmarshaling->memoryRequirements));
}
void marshal_VkSparseImageMemoryRequirements2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageMemoryRequirements2* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageMemoryRequirements2* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkSparseImageMemoryRequirements(vkStream, rootType, (VkSparseImageMemoryRequirements*)(&forMarshaling->memoryRequirements));
+ marshal_VkSparseImageMemoryRequirements(
+ vkStream, rootType, (VkSparseImageMemoryRequirements*)(&forMarshaling->memoryRequirements));
}
-void unmarshal_VkSparseImageMemoryRequirements2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSparseImageMemoryRequirements2* forUnmarshaling)
-{
+void unmarshal_VkSparseImageMemoryRequirements2(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkSparseImageMemoryRequirements2* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkSparseImageMemoryRequirements(vkStream, rootType, (VkSparseImageMemoryRequirements*)(&forUnmarshaling->memoryRequirements));
+ unmarshal_VkSparseImageMemoryRequirements(
+ vkStream, rootType,
+ (VkSparseImageMemoryRequirements*)(&forUnmarshaling->memoryRequirements));
}
-void marshal_VkPhysicalDeviceFeatures2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFeatures2* forMarshaling)
-{
+void marshal_VkPhysicalDeviceFeatures2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFeatures2* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkPhysicalDeviceFeatures(vkStream, rootType, (VkPhysicalDeviceFeatures*)(&forMarshaling->features));
+ marshal_VkPhysicalDeviceFeatures(vkStream, rootType,
+ (VkPhysicalDeviceFeatures*)(&forMarshaling->features));
}
-void unmarshal_VkPhysicalDeviceFeatures2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceFeatures2* forUnmarshaling)
-{
+void unmarshal_VkPhysicalDeviceFeatures2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceFeatures2* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkPhysicalDeviceFeatures(vkStream, rootType, (VkPhysicalDeviceFeatures*)(&forUnmarshaling->features));
+ unmarshal_VkPhysicalDeviceFeatures(vkStream, rootType,
+ (VkPhysicalDeviceFeatures*)(&forUnmarshaling->features));
}
-void marshal_VkPhysicalDeviceProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceProperties2* forMarshaling)
-{
+void marshal_VkPhysicalDeviceProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceProperties2* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkPhysicalDeviceProperties(vkStream, rootType, (VkPhysicalDeviceProperties*)(&forMarshaling->properties));
+ marshal_VkPhysicalDeviceProperties(vkStream, rootType,
+ (VkPhysicalDeviceProperties*)(&forMarshaling->properties));
}
-void unmarshal_VkPhysicalDeviceProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceProperties2* forUnmarshaling)
-{
+void unmarshal_VkPhysicalDeviceProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceProperties2* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkPhysicalDeviceProperties(vkStream, rootType, (VkPhysicalDeviceProperties*)(&forUnmarshaling->properties));
+ unmarshal_VkPhysicalDeviceProperties(
+ vkStream, rootType, (VkPhysicalDeviceProperties*)(&forUnmarshaling->properties));
}
-void marshal_VkFormatProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFormatProperties2* forMarshaling)
-{
+void marshal_VkFormatProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFormatProperties2* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkFormatProperties(vkStream, rootType, (VkFormatProperties*)(&forMarshaling->formatProperties));
+ marshal_VkFormatProperties(vkStream, rootType,
+ (VkFormatProperties*)(&forMarshaling->formatProperties));
}
-void unmarshal_VkFormatProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkFormatProperties2* forUnmarshaling)
-{
+void unmarshal_VkFormatProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkFormatProperties2* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkFormatProperties(vkStream, rootType, (VkFormatProperties*)(&forUnmarshaling->formatProperties));
+ unmarshal_VkFormatProperties(vkStream, rootType,
+ (VkFormatProperties*)(&forUnmarshaling->formatProperties));
}
-void marshal_VkImageFormatProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageFormatProperties2* forMarshaling)
-{
+void marshal_VkImageFormatProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageFormatProperties2* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkImageFormatProperties(vkStream, rootType, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties));
+ marshal_VkImageFormatProperties(
+ vkStream, rootType, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties));
}
-void unmarshal_VkImageFormatProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageFormatProperties2* forUnmarshaling)
-{
+void unmarshal_VkImageFormatProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageFormatProperties2* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkImageFormatProperties(vkStream, rootType, (VkImageFormatProperties*)(&forUnmarshaling->imageFormatProperties));
+ unmarshal_VkImageFormatProperties(
+ vkStream, rootType, (VkImageFormatProperties*)(&forUnmarshaling->imageFormatProperties));
}
void marshal_VkPhysicalDeviceImageFormatInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceImageFormatInfo2* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceImageFormatInfo2* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -5754,15 +5161,12 @@
vkStream->write((VkImageCreateFlags*)&forMarshaling->flags, sizeof(VkImageCreateFlags));
}
-void unmarshal_VkPhysicalDeviceImageFormatInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceImageFormatInfo2* forUnmarshaling)
-{
+void unmarshal_VkPhysicalDeviceImageFormatInfo2(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPhysicalDeviceImageFormatInfo2* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -5773,105 +5177,87 @@
vkStream->read((VkImageCreateFlags*)&forUnmarshaling->flags, sizeof(VkImageCreateFlags));
}
-void marshal_VkQueueFamilyProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueueFamilyProperties2* forMarshaling)
-{
+void marshal_VkQueueFamilyProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyProperties2* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkQueueFamilyProperties(vkStream, rootType, (VkQueueFamilyProperties*)(&forMarshaling->queueFamilyProperties));
+ marshal_VkQueueFamilyProperties(
+ vkStream, rootType, (VkQueueFamilyProperties*)(&forMarshaling->queueFamilyProperties));
}
-void unmarshal_VkQueueFamilyProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkQueueFamilyProperties2* forUnmarshaling)
-{
+void unmarshal_VkQueueFamilyProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkQueueFamilyProperties2* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkQueueFamilyProperties(vkStream, rootType, (VkQueueFamilyProperties*)(&forUnmarshaling->queueFamilyProperties));
+ unmarshal_VkQueueFamilyProperties(
+ vkStream, rootType, (VkQueueFamilyProperties*)(&forUnmarshaling->queueFamilyProperties));
}
void marshal_VkPhysicalDeviceMemoryProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryProperties2* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryProperties2* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkPhysicalDeviceMemoryProperties(vkStream, rootType, (VkPhysicalDeviceMemoryProperties*)(&forMarshaling->memoryProperties));
+ marshal_VkPhysicalDeviceMemoryProperties(
+ vkStream, rootType, (VkPhysicalDeviceMemoryProperties*)(&forMarshaling->memoryProperties));
}
void unmarshal_VkPhysicalDeviceMemoryProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceMemoryProperties2* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMemoryProperties2* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkPhysicalDeviceMemoryProperties(vkStream, rootType, (VkPhysicalDeviceMemoryProperties*)(&forUnmarshaling->memoryProperties));
+ unmarshal_VkPhysicalDeviceMemoryProperties(
+ vkStream, rootType,
+ (VkPhysicalDeviceMemoryProperties*)(&forUnmarshaling->memoryProperties));
}
-void marshal_VkSparseImageFormatProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageFormatProperties2* forMarshaling)
-{
+void marshal_VkSparseImageFormatProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageFormatProperties2* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkSparseImageFormatProperties(vkStream, rootType, (VkSparseImageFormatProperties*)(&forMarshaling->properties));
+ marshal_VkSparseImageFormatProperties(
+ vkStream, rootType, (VkSparseImageFormatProperties*)(&forMarshaling->properties));
}
-void unmarshal_VkSparseImageFormatProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSparseImageFormatProperties2* forUnmarshaling)
-{
+void unmarshal_VkSparseImageFormatProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSparseImageFormatProperties2* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkSparseImageFormatProperties(vkStream, rootType, (VkSparseImageFormatProperties*)(&forUnmarshaling->properties));
+ unmarshal_VkSparseImageFormatProperties(
+ vkStream, rootType, (VkSparseImageFormatProperties*)(&forUnmarshaling->properties));
}
void marshal_VkPhysicalDeviceSparseImageFormatInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSparseImageFormatInfo2* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSparseImageFormatInfo2* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -5883,70 +5269,60 @@
}
void unmarshal_VkPhysicalDeviceSparseImageFormatInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceSparseImageFormatInfo2* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceSparseImageFormatInfo2* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
vkStream->read((VkImageType*)&forUnmarshaling->type, sizeof(VkImageType));
- vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples, sizeof(VkSampleCountFlagBits));
+ vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples,
+ sizeof(VkSampleCountFlagBits));
vkStream->read((VkImageUsageFlags*)&forUnmarshaling->usage, sizeof(VkImageUsageFlags));
vkStream->read((VkImageTiling*)&forUnmarshaling->tiling, sizeof(VkImageTiling));
}
void marshal_VkPhysicalDevicePointClippingProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePointClippingProperties* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePointClippingProperties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPointClippingBehavior*)&forMarshaling->pointClippingBehavior, sizeof(VkPointClippingBehavior));
+ vkStream->write((VkPointClippingBehavior*)&forMarshaling->pointClippingBehavior,
+ sizeof(VkPointClippingBehavior));
}
void unmarshal_VkPhysicalDevicePointClippingProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDevicePointClippingProperties* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePointClippingProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPointClippingBehavior*)&forUnmarshaling->pointClippingBehavior, sizeof(VkPointClippingBehavior));
+ vkStream->read((VkPointClippingBehavior*)&forUnmarshaling->pointClippingBehavior,
+ sizeof(VkPointClippingBehavior));
}
void marshal_VkInputAttachmentAspectReference(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkInputAttachmentAspectReference* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkInputAttachmentAspectReference* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->inputAttachmentIndex, sizeof(uint32_t));
vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
}
-void unmarshal_VkInputAttachmentAspectReference(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkInputAttachmentAspectReference* forUnmarshaling)
-{
+void unmarshal_VkInputAttachmentAspectReference(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkInputAttachmentAspectReference* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->subpass, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->inputAttachmentIndex, sizeof(uint32_t));
@@ -5954,73 +5330,59 @@
}
void marshal_VkRenderPassInputAttachmentAspectCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassInputAttachmentAspectCreateInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassInputAttachmentAspectCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->aspectReferenceCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->aspectReferenceCount; ++i)
- {
- marshal_VkInputAttachmentAspectReference(vkStream, rootType, (const VkInputAttachmentAspectReference*)(forMarshaling->pAspectReferences + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->aspectReferenceCount; ++i) {
+ marshal_VkInputAttachmentAspectReference(
+ vkStream, rootType,
+ (const VkInputAttachmentAspectReference*)(forMarshaling->pAspectReferences + i));
}
}
}
void unmarshal_VkRenderPassInputAttachmentAspectCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRenderPassInputAttachmentAspectCreateInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderPassInputAttachmentAspectCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->aspectReferenceCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->aspectReferenceCount; ++i)
- {
- unmarshal_VkInputAttachmentAspectReference(vkStream, rootType, (VkInputAttachmentAspectReference*)(forUnmarshaling->pAspectReferences + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->aspectReferenceCount; ++i) {
+ unmarshal_VkInputAttachmentAspectReference(
+ vkStream, rootType,
+ (VkInputAttachmentAspectReference*)(forUnmarshaling->pAspectReferences + i));
}
}
}
-void marshal_VkImageViewUsageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageViewUsageCreateInfo* forMarshaling)
-{
+void marshal_VkImageViewUsageCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageViewUsageCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkImageUsageFlags*)&forMarshaling->usage, sizeof(VkImageUsageFlags));
}
-void unmarshal_VkImageViewUsageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageViewUsageCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkImageViewUsageCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageViewUsageCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -6028,84 +5390,76 @@
}
void marshal_VkPipelineTessellationDomainOriginStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineTessellationDomainOriginStateCreateInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineTessellationDomainOriginStateCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkTessellationDomainOrigin*)&forMarshaling->domainOrigin, sizeof(VkTessellationDomainOrigin));
+ vkStream->write((VkTessellationDomainOrigin*)&forMarshaling->domainOrigin,
+ sizeof(VkTessellationDomainOrigin));
}
void unmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineTessellationDomainOriginStateCreateInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineTessellationDomainOriginStateCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkTessellationDomainOrigin*)&forUnmarshaling->domainOrigin, sizeof(VkTessellationDomainOrigin));
+ vkStream->read((VkTessellationDomainOrigin*)&forUnmarshaling->domainOrigin,
+ sizeof(VkTessellationDomainOrigin));
}
-void marshal_VkRenderPassMultiviewCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassMultiviewCreateInfo* forMarshaling)
-{
+void marshal_VkRenderPassMultiviewCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassMultiviewCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->subpassCount, sizeof(uint32_t));
- vkStream->write((const uint32_t*)forMarshaling->pViewMasks, forMarshaling->subpassCount * sizeof(const uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pViewMasks,
+ forMarshaling->subpassCount * sizeof(const uint32_t));
vkStream->write((uint32_t*)&forMarshaling->dependencyCount, sizeof(uint32_t));
- vkStream->write((const int32_t*)forMarshaling->pViewOffsets, forMarshaling->dependencyCount * sizeof(const int32_t));
+ vkStream->write((const int32_t*)forMarshaling->pViewOffsets,
+ forMarshaling->dependencyCount * sizeof(const int32_t));
vkStream->write((uint32_t*)&forMarshaling->correlationMaskCount, sizeof(uint32_t));
- vkStream->write((const uint32_t*)forMarshaling->pCorrelationMasks, forMarshaling->correlationMaskCount * sizeof(const uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pCorrelationMasks,
+ forMarshaling->correlationMaskCount * sizeof(const uint32_t));
}
-void unmarshal_VkRenderPassMultiviewCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRenderPassMultiviewCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkRenderPassMultiviewCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkRenderPassMultiviewCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->subpassCount, sizeof(uint32_t));
- vkStream->read((uint32_t*)forUnmarshaling->pViewMasks, forUnmarshaling->subpassCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pViewMasks,
+ forUnmarshaling->subpassCount * sizeof(const uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->dependencyCount, sizeof(uint32_t));
- vkStream->read((int32_t*)forUnmarshaling->pViewOffsets, forUnmarshaling->dependencyCount * sizeof(const int32_t));
+ vkStream->read((int32_t*)forUnmarshaling->pViewOffsets,
+ forUnmarshaling->dependencyCount * sizeof(const int32_t));
vkStream->read((uint32_t*)&forUnmarshaling->correlationMaskCount, sizeof(uint32_t));
- vkStream->read((uint32_t*)forUnmarshaling->pCorrelationMasks, forUnmarshaling->correlationMaskCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pCorrelationMasks,
+ forUnmarshaling->correlationMaskCount * sizeof(const uint32_t));
}
void marshal_VkPhysicalDeviceMultiviewFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiviewFeatures* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMultiviewFeatures* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -6115,14 +5469,11 @@
}
void unmarshal_VkPhysicalDeviceMultiviewFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceMultiviewFeatures* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMultiviewFeatures* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -6132,14 +5483,11 @@
}
void marshal_VkPhysicalDeviceMultiviewProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiviewProperties* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMultiviewProperties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -6148,14 +5496,11 @@
}
void unmarshal_VkPhysicalDeviceMultiviewProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceMultiviewProperties* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMultiviewProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -6164,14 +5509,11 @@
}
void marshal_VkPhysicalDeviceVariablePointersFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVariablePointersFeatures* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVariablePointersFeatures* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -6180,14 +5522,11 @@
}
void unmarshal_VkPhysicalDeviceVariablePointersFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceVariablePointersFeatures* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceVariablePointersFeatures* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -6196,14 +5535,11 @@
}
void marshal_VkPhysicalDeviceProtectedMemoryFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceProtectedMemoryFeatures* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceProtectedMemoryFeatures* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -6211,14 +5547,11 @@
}
void unmarshal_VkPhysicalDeviceProtectedMemoryFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceProtectedMemoryFeatures* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceProtectedMemoryFeatures* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -6226,14 +5559,11 @@
}
void marshal_VkPhysicalDeviceProtectedMemoryProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceProtectedMemoryProperties* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceProtectedMemoryProperties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -6241,78 +5571,61 @@
}
void unmarshal_VkPhysicalDeviceProtectedMemoryProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceProtectedMemoryProperties* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceProtectedMemoryProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->protectedNoFault, sizeof(VkBool32));
}
-void marshal_VkDeviceQueueInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceQueueInfo2* forMarshaling)
-{
+void marshal_VkDeviceQueueInfo2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceQueueInfo2* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDeviceQueueCreateFlags*)&forMarshaling->flags, sizeof(VkDeviceQueueCreateFlags));
+ vkStream->write((VkDeviceQueueCreateFlags*)&forMarshaling->flags,
+ sizeof(VkDeviceQueueCreateFlags));
vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->queueIndex, sizeof(uint32_t));
}
-void unmarshal_VkDeviceQueueInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceQueueInfo2* forUnmarshaling)
-{
+void unmarshal_VkDeviceQueueInfo2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceQueueInfo2* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDeviceQueueCreateFlags*)&forUnmarshaling->flags, sizeof(VkDeviceQueueCreateFlags));
+ vkStream->read((VkDeviceQueueCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkDeviceQueueCreateFlags));
vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndex, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->queueIndex, sizeof(uint32_t));
}
-void marshal_VkProtectedSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkProtectedSubmitInfo* forMarshaling)
-{
+void marshal_VkProtectedSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkProtectedSubmitInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->protectedSubmit, sizeof(VkBool32));
}
-void unmarshal_VkProtectedSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkProtectedSubmitInfo* forUnmarshaling)
-{
+void unmarshal_VkProtectedSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkProtectedSubmitInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -6320,21 +5633,20 @@
}
void marshal_VkSamplerYcbcrConversionCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerYcbcrConversionCreateInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerYcbcrConversionCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
- vkStream->write((VkSamplerYcbcrModelConversion*)&forMarshaling->ycbcrModel, sizeof(VkSamplerYcbcrModelConversion));
+ vkStream->write((VkSamplerYcbcrModelConversion*)&forMarshaling->ycbcrModel,
+ sizeof(VkSamplerYcbcrModelConversion));
vkStream->write((VkSamplerYcbcrRange*)&forMarshaling->ycbcrRange, sizeof(VkSamplerYcbcrRange));
- marshal_VkComponentMapping(vkStream, rootType, (VkComponentMapping*)(&forMarshaling->components));
+ marshal_VkComponentMapping(vkStream, rootType,
+ (VkComponentMapping*)(&forMarshaling->components));
vkStream->write((VkChromaLocation*)&forMarshaling->xChromaOffset, sizeof(VkChromaLocation));
vkStream->write((VkChromaLocation*)&forMarshaling->yChromaOffset, sizeof(VkChromaLocation));
vkStream->write((VkFilter*)&forMarshaling->chromaFilter, sizeof(VkFilter));
@@ -6342,130 +5654,110 @@
}
void unmarshal_VkSamplerYcbcrConversionCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSamplerYcbcrConversionCreateInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSamplerYcbcrConversionCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
- vkStream->read((VkSamplerYcbcrModelConversion*)&forUnmarshaling->ycbcrModel, sizeof(VkSamplerYcbcrModelConversion));
+ vkStream->read((VkSamplerYcbcrModelConversion*)&forUnmarshaling->ycbcrModel,
+ sizeof(VkSamplerYcbcrModelConversion));
vkStream->read((VkSamplerYcbcrRange*)&forUnmarshaling->ycbcrRange, sizeof(VkSamplerYcbcrRange));
- unmarshal_VkComponentMapping(vkStream, rootType, (VkComponentMapping*)(&forUnmarshaling->components));
+ unmarshal_VkComponentMapping(vkStream, rootType,
+ (VkComponentMapping*)(&forUnmarshaling->components));
vkStream->read((VkChromaLocation*)&forUnmarshaling->xChromaOffset, sizeof(VkChromaLocation));
vkStream->read((VkChromaLocation*)&forUnmarshaling->yChromaOffset, sizeof(VkChromaLocation));
vkStream->read((VkFilter*)&forUnmarshaling->chromaFilter, sizeof(VkFilter));
vkStream->read((VkBool32*)&forUnmarshaling->forceExplicitReconstruction, sizeof(VkBool32));
}
-void marshal_VkSamplerYcbcrConversionInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerYcbcrConversionInfo* forMarshaling)
-{
+void marshal_VkSamplerYcbcrConversionInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerYcbcrConversionInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&forMarshaling->conversion, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&forMarshaling->conversion,
+ &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}
-void unmarshal_VkSamplerYcbcrConversionInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSamplerYcbcrConversionInfo* forUnmarshaling)
-{
+void unmarshal_VkSamplerYcbcrConversionInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSamplerYcbcrConversionInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_0, (VkSamplerYcbcrConversion*)&forUnmarshaling->conversion, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(
+ &cgen_var_0, (VkSamplerYcbcrConversion*)&forUnmarshaling->conversion, 1);
}
-void marshal_VkBindImagePlaneMemoryInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindImagePlaneMemoryInfo* forMarshaling)
-{
+void marshal_VkBindImagePlaneMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindImagePlaneMemoryInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkImageAspectFlagBits*)&forMarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
+ vkStream->write((VkImageAspectFlagBits*)&forMarshaling->planeAspect,
+ sizeof(VkImageAspectFlagBits));
}
-void unmarshal_VkBindImagePlaneMemoryInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBindImagePlaneMemoryInfo* forUnmarshaling)
-{
+void unmarshal_VkBindImagePlaneMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBindImagePlaneMemoryInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
+ vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->planeAspect,
+ sizeof(VkImageAspectFlagBits));
}
void marshal_VkImagePlaneMemoryRequirementsInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImagePlaneMemoryRequirementsInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImagePlaneMemoryRequirementsInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkImageAspectFlagBits*)&forMarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
+ vkStream->write((VkImageAspectFlagBits*)&forMarshaling->planeAspect,
+ sizeof(VkImageAspectFlagBits));
}
void unmarshal_VkImagePlaneMemoryRequirementsInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImagePlaneMemoryRequirementsInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImagePlaneMemoryRequirementsInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
+ vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->planeAspect,
+ sizeof(VkImageAspectFlagBits));
}
void marshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSamplerYcbcrConversionFeatures* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSamplerYcbcrConversionFeatures* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -6473,14 +5765,11 @@
}
void unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceSamplerYcbcrConversionFeatures* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceSamplerYcbcrConversionFeatures* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -6488,40 +5777,33 @@
}
void marshal_VkSamplerYcbcrConversionImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerYcbcrConversionImageFormatProperties* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerYcbcrConversionImageFormatProperties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((uint32_t*)&forMarshaling->combinedImageSamplerDescriptorCount, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->combinedImageSamplerDescriptorCount,
+ sizeof(uint32_t));
}
void unmarshal_VkSamplerYcbcrConversionImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSamplerYcbcrConversionImageFormatProperties* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSamplerYcbcrConversionImageFormatProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((uint32_t*)&forUnmarshaling->combinedImageSamplerDescriptorCount, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->combinedImageSamplerDescriptorCount,
+ sizeof(uint32_t));
}
-void marshal_VkDescriptorUpdateTemplateEntry(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorUpdateTemplateEntry* forMarshaling)
-{
+void marshal_VkDescriptorUpdateTemplateEntry(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorUpdateTemplateEntry* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->dstBinding, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->dstArrayElement, sizeof(uint32_t));
@@ -6533,11 +5815,9 @@
vkStream->putBe64(cgen_var_1);
}
-void unmarshal_VkDescriptorUpdateTemplateEntry(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorUpdateTemplateEntry* forUnmarshaling)
-{
+void unmarshal_VkDescriptorUpdateTemplateEntry(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkDescriptorUpdateTemplateEntry* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->dstBinding, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->dstArrayElement, sizeof(uint32_t));
@@ -6548,224 +5828,211 @@
}
void marshal_VkDescriptorUpdateTemplateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorUpdateTemplateCreateInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorUpdateTemplateCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDescriptorUpdateTemplateCreateFlags*)&forMarshaling->flags, sizeof(VkDescriptorUpdateTemplateCreateFlags));
+ vkStream->write((VkDescriptorUpdateTemplateCreateFlags*)&forMarshaling->flags,
+ sizeof(VkDescriptorUpdateTemplateCreateFlags));
vkStream->write((uint32_t*)&forMarshaling->descriptorUpdateEntryCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorUpdateEntryCount; ++i)
- {
- marshal_VkDescriptorUpdateTemplateEntry(vkStream, rootType, (const VkDescriptorUpdateTemplateEntry*)(forMarshaling->pDescriptorUpdateEntries + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorUpdateEntryCount; ++i) {
+ marshal_VkDescriptorUpdateTemplateEntry(
+ vkStream, rootType,
+ (const VkDescriptorUpdateTemplateEntry*)(forMarshaling->pDescriptorUpdateEntries +
+ i));
}
}
- vkStream->write((VkDescriptorUpdateTemplateType*)&forMarshaling->templateType, sizeof(VkDescriptorUpdateTemplateType));
+ vkStream->write((VkDescriptorUpdateTemplateType*)&forMarshaling->templateType,
+ sizeof(VkDescriptorUpdateTemplateType));
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(&forMarshaling->descriptorSetLayout, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(
+ &forMarshaling->descriptorSetLayout, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
uint64_t cgen_var_1;
- vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_1, 1);
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout,
+ &cgen_var_1, 1);
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->set, sizeof(uint32_t));
}
void unmarshal_VkDescriptorUpdateTemplateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorUpdateTemplateCreateInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDescriptorUpdateTemplateCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDescriptorUpdateTemplateCreateFlags*)&forUnmarshaling->flags, sizeof(VkDescriptorUpdateTemplateCreateFlags));
+ vkStream->read((VkDescriptorUpdateTemplateCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkDescriptorUpdateTemplateCreateFlags));
vkStream->read((uint32_t*)&forUnmarshaling->descriptorUpdateEntryCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorUpdateEntryCount; ++i)
- {
- unmarshal_VkDescriptorUpdateTemplateEntry(vkStream, rootType, (VkDescriptorUpdateTemplateEntry*)(forUnmarshaling->pDescriptorUpdateEntries + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorUpdateEntryCount; ++i) {
+ unmarshal_VkDescriptorUpdateTemplateEntry(
+ vkStream, rootType,
+ (VkDescriptorUpdateTemplateEntry*)(forUnmarshaling->pDescriptorUpdateEntries + i));
}
}
- vkStream->read((VkDescriptorUpdateTemplateType*)&forUnmarshaling->templateType, sizeof(VkDescriptorUpdateTemplateType));
+ vkStream->read((VkDescriptorUpdateTemplateType*)&forUnmarshaling->templateType,
+ sizeof(VkDescriptorUpdateTemplateType));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(&cgen_var_0, (VkDescriptorSetLayout*)&forUnmarshaling->descriptorSetLayout, 1);
- vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(
+ &cgen_var_0, (VkDescriptorSetLayout*)&forUnmarshaling->descriptorSetLayout, 1);
+ vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_1, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(
+ &cgen_var_1, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
vkStream->read((uint32_t*)&forUnmarshaling->set, sizeof(uint32_t));
}
-void marshal_VkExternalMemoryProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalMemoryProperties* forMarshaling)
-{
+void marshal_VkExternalMemoryProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalMemoryProperties* forMarshaling) {
(void)rootType;
- vkStream->write((VkExternalMemoryFeatureFlags*)&forMarshaling->externalMemoryFeatures, sizeof(VkExternalMemoryFeatureFlags));
- vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
- vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->compatibleHandleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+ vkStream->write((VkExternalMemoryFeatureFlags*)&forMarshaling->externalMemoryFeatures,
+ sizeof(VkExternalMemoryFeatureFlags));
+ vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlags));
+ vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->compatibleHandleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlags));
}
-void unmarshal_VkExternalMemoryProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExternalMemoryProperties* forUnmarshaling)
-{
+void unmarshal_VkExternalMemoryProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExternalMemoryProperties* forUnmarshaling) {
(void)rootType;
- vkStream->read((VkExternalMemoryFeatureFlags*)&forUnmarshaling->externalMemoryFeatures, sizeof(VkExternalMemoryFeatureFlags));
- vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->exportFromImportedHandleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
- vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->compatibleHandleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+ vkStream->read((VkExternalMemoryFeatureFlags*)&forUnmarshaling->externalMemoryFeatures,
+ sizeof(VkExternalMemoryFeatureFlags));
+ vkStream->read(
+ (VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->exportFromImportedHandleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlags));
+ vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->compatibleHandleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlags));
}
void marshal_VkPhysicalDeviceExternalImageFormatInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalImageFormatInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExternalImageFormatInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
}
void unmarshal_VkPhysicalDeviceExternalImageFormatInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceExternalImageFormatInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceExternalImageFormatInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
}
-void marshal_VkExternalImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalImageFormatProperties* forMarshaling)
-{
+void marshal_VkExternalImageFormatProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalImageFormatProperties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkExternalMemoryProperties(vkStream, rootType, (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties));
+ marshal_VkExternalMemoryProperties(
+ vkStream, rootType,
+ (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties));
}
-void unmarshal_VkExternalImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExternalImageFormatProperties* forUnmarshaling)
-{
+void unmarshal_VkExternalImageFormatProperties(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkExternalImageFormatProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkExternalMemoryProperties(vkStream, rootType, (VkExternalMemoryProperties*)(&forUnmarshaling->externalMemoryProperties));
+ unmarshal_VkExternalMemoryProperties(
+ vkStream, rootType,
+ (VkExternalMemoryProperties*)(&forUnmarshaling->externalMemoryProperties));
}
void marshal_VkPhysicalDeviceExternalBufferInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalBufferInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExternalBufferInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBufferCreateFlags*)&forMarshaling->flags, sizeof(VkBufferCreateFlags));
vkStream->write((VkBufferUsageFlags*)&forMarshaling->usage, sizeof(VkBufferUsageFlags));
- vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
}
void unmarshal_VkPhysicalDeviceExternalBufferInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceExternalBufferInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceExternalBufferInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBufferCreateFlags*)&forUnmarshaling->flags, sizeof(VkBufferCreateFlags));
vkStream->read((VkBufferUsageFlags*)&forUnmarshaling->usage, sizeof(VkBufferUsageFlags));
- vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
}
-void marshal_VkExternalBufferProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalBufferProperties* forMarshaling)
-{
+void marshal_VkExternalBufferProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalBufferProperties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkExternalMemoryProperties(vkStream, rootType, (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties));
+ marshal_VkExternalMemoryProperties(
+ vkStream, rootType,
+ (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties));
}
-void unmarshal_VkExternalBufferProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExternalBufferProperties* forUnmarshaling)
-{
+void unmarshal_VkExternalBufferProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExternalBufferProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkExternalMemoryProperties(vkStream, rootType, (VkExternalMemoryProperties*)(&forUnmarshaling->externalMemoryProperties));
+ unmarshal_VkExternalMemoryProperties(
+ vkStream, rootType,
+ (VkExternalMemoryProperties*)(&forUnmarshaling->externalMemoryProperties));
}
-void marshal_VkPhysicalDeviceIDProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceIDProperties* forMarshaling)
-{
+void marshal_VkPhysicalDeviceIDProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceIDProperties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -6776,15 +6043,11 @@
vkStream->write((VkBool32*)&forMarshaling->deviceLUIDValid, sizeof(VkBool32));
}
-void unmarshal_VkPhysicalDeviceIDProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceIDProperties* forUnmarshaling)
-{
+void unmarshal_VkPhysicalDeviceIDProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceIDProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -6795,293 +6058,253 @@
vkStream->read((VkBool32*)&forUnmarshaling->deviceLUIDValid, sizeof(VkBool32));
}
-void marshal_VkExternalMemoryImageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalMemoryImageCreateInfo* forMarshaling)
-{
+void marshal_VkExternalMemoryImageCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalMemoryImageCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+ vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlags));
}
-void unmarshal_VkExternalMemoryImageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExternalMemoryImageCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkExternalMemoryImageCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkExternalMemoryImageCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+ vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->handleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlags));
}
void marshal_VkExternalMemoryBufferCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalMemoryBufferCreateInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalMemoryBufferCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+ vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlags));
}
-void unmarshal_VkExternalMemoryBufferCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExternalMemoryBufferCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkExternalMemoryBufferCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkExternalMemoryBufferCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+ vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->handleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlags));
}
-void marshal_VkExportMemoryAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportMemoryAllocateInfo* forMarshaling)
-{
+void marshal_VkExportMemoryAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportMemoryAllocateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+ vkStream->write((VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlags));
}
-void unmarshal_VkExportMemoryAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExportMemoryAllocateInfo* forUnmarshaling)
-{
+void unmarshal_VkExportMemoryAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExportMemoryAllocateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+ vkStream->read((VkExternalMemoryHandleTypeFlags*)&forUnmarshaling->handleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlags));
}
void marshal_VkPhysicalDeviceExternalFenceInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalFenceInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExternalFenceInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+ vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalFenceHandleTypeFlagBits));
}
void unmarshal_VkPhysicalDeviceExternalFenceInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceExternalFenceInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceExternalFenceInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+ vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalFenceHandleTypeFlagBits));
}
-void marshal_VkExternalFenceProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalFenceProperties* forMarshaling)
-{
+void marshal_VkExternalFenceProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalFenceProperties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkExternalFenceHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes, sizeof(VkExternalFenceHandleTypeFlags));
- vkStream->write((VkExternalFenceHandleTypeFlags*)&forMarshaling->compatibleHandleTypes, sizeof(VkExternalFenceHandleTypeFlags));
- vkStream->write((VkExternalFenceFeatureFlags*)&forMarshaling->externalFenceFeatures, sizeof(VkExternalFenceFeatureFlags));
+ vkStream->write((VkExternalFenceHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes,
+ sizeof(VkExternalFenceHandleTypeFlags));
+ vkStream->write((VkExternalFenceHandleTypeFlags*)&forMarshaling->compatibleHandleTypes,
+ sizeof(VkExternalFenceHandleTypeFlags));
+ vkStream->write((VkExternalFenceFeatureFlags*)&forMarshaling->externalFenceFeatures,
+ sizeof(VkExternalFenceFeatureFlags));
}
-void unmarshal_VkExternalFenceProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExternalFenceProperties* forUnmarshaling)
-{
+void unmarshal_VkExternalFenceProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExternalFenceProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkExternalFenceHandleTypeFlags*)&forUnmarshaling->exportFromImportedHandleTypes, sizeof(VkExternalFenceHandleTypeFlags));
- vkStream->read((VkExternalFenceHandleTypeFlags*)&forUnmarshaling->compatibleHandleTypes, sizeof(VkExternalFenceHandleTypeFlags));
- vkStream->read((VkExternalFenceFeatureFlags*)&forUnmarshaling->externalFenceFeatures, sizeof(VkExternalFenceFeatureFlags));
+ vkStream->read((VkExternalFenceHandleTypeFlags*)&forUnmarshaling->exportFromImportedHandleTypes,
+ sizeof(VkExternalFenceHandleTypeFlags));
+ vkStream->read((VkExternalFenceHandleTypeFlags*)&forUnmarshaling->compatibleHandleTypes,
+ sizeof(VkExternalFenceHandleTypeFlags));
+ vkStream->read((VkExternalFenceFeatureFlags*)&forUnmarshaling->externalFenceFeatures,
+ sizeof(VkExternalFenceFeatureFlags));
}
-void marshal_VkExportFenceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportFenceCreateInfo* forMarshaling)
-{
+void marshal_VkExportFenceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportFenceCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkExternalFenceHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalFenceHandleTypeFlags));
+ vkStream->write((VkExternalFenceHandleTypeFlags*)&forMarshaling->handleTypes,
+ sizeof(VkExternalFenceHandleTypeFlags));
}
-void unmarshal_VkExportFenceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExportFenceCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkExportFenceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExportFenceCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkExternalFenceHandleTypeFlags*)&forUnmarshaling->handleTypes, sizeof(VkExternalFenceHandleTypeFlags));
+ vkStream->read((VkExternalFenceHandleTypeFlags*)&forUnmarshaling->handleTypes,
+ sizeof(VkExternalFenceHandleTypeFlags));
}
-void marshal_VkExportSemaphoreCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportSemaphoreCreateInfo* forMarshaling)
-{
+void marshal_VkExportSemaphoreCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportSemaphoreCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
+ vkStream->write((VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->handleTypes,
+ sizeof(VkExternalSemaphoreHandleTypeFlags));
}
-void unmarshal_VkExportSemaphoreCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExportSemaphoreCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkExportSemaphoreCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExportSemaphoreCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkExternalSemaphoreHandleTypeFlags*)&forUnmarshaling->handleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
+ vkStream->read((VkExternalSemaphoreHandleTypeFlags*)&forUnmarshaling->handleTypes,
+ sizeof(VkExternalSemaphoreHandleTypeFlags));
}
void marshal_VkPhysicalDeviceExternalSemaphoreInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalSemaphoreInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExternalSemaphoreInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}
void unmarshal_VkPhysicalDeviceExternalSemaphoreInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceExternalSemaphoreInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceExternalSemaphoreInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}
-void marshal_VkExternalSemaphoreProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalSemaphoreProperties* forMarshaling)
-{
+void marshal_VkExternalSemaphoreProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalSemaphoreProperties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
- vkStream->write((VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->compatibleHandleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
- vkStream->write((VkExternalSemaphoreFeatureFlags*)&forMarshaling->externalSemaphoreFeatures, sizeof(VkExternalSemaphoreFeatureFlags));
+ vkStream->write(
+ (VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes,
+ sizeof(VkExternalSemaphoreHandleTypeFlags));
+ vkStream->write((VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->compatibleHandleTypes,
+ sizeof(VkExternalSemaphoreHandleTypeFlags));
+ vkStream->write((VkExternalSemaphoreFeatureFlags*)&forMarshaling->externalSemaphoreFeatures,
+ sizeof(VkExternalSemaphoreFeatureFlags));
}
-void unmarshal_VkExternalSemaphoreProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExternalSemaphoreProperties* forUnmarshaling)
-{
+void unmarshal_VkExternalSemaphoreProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExternalSemaphoreProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkExternalSemaphoreHandleTypeFlags*)&forUnmarshaling->exportFromImportedHandleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
- vkStream->read((VkExternalSemaphoreHandleTypeFlags*)&forUnmarshaling->compatibleHandleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
- vkStream->read((VkExternalSemaphoreFeatureFlags*)&forUnmarshaling->externalSemaphoreFeatures, sizeof(VkExternalSemaphoreFeatureFlags));
+ vkStream->read(
+ (VkExternalSemaphoreHandleTypeFlags*)&forUnmarshaling->exportFromImportedHandleTypes,
+ sizeof(VkExternalSemaphoreHandleTypeFlags));
+ vkStream->read((VkExternalSemaphoreHandleTypeFlags*)&forUnmarshaling->compatibleHandleTypes,
+ sizeof(VkExternalSemaphoreHandleTypeFlags));
+ vkStream->read((VkExternalSemaphoreFeatureFlags*)&forUnmarshaling->externalSemaphoreFeatures,
+ sizeof(VkExternalSemaphoreFeatureFlags));
}
void marshal_VkPhysicalDeviceMaintenance3Properties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMaintenance3Properties* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance3Properties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -7090,14 +6313,11 @@
}
void unmarshal_VkPhysicalDeviceMaintenance3Properties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceMaintenance3Properties* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMaintenance3Properties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -7105,30 +6325,22 @@
vkStream->read((VkDeviceSize*)&forUnmarshaling->maxMemoryAllocationSize, sizeof(VkDeviceSize));
}
-void marshal_VkDescriptorSetLayoutSupport(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetLayoutSupport* forMarshaling)
-{
+void marshal_VkDescriptorSetLayoutSupport(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorSetLayoutSupport* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->supported, sizeof(VkBool32));
}
-void unmarshal_VkDescriptorSetLayoutSupport(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorSetLayoutSupport* forUnmarshaling)
-{
+void unmarshal_VkDescriptorSetLayoutSupport(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDescriptorSetLayoutSupport* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -7136,14 +6348,11 @@
}
void marshal_VkPhysicalDeviceShaderDrawParametersFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderDrawParametersFeatures* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderDrawParametersFeatures* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -7151,14 +6360,11 @@
}
void unmarshal_VkPhysicalDeviceShaderDrawParametersFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShaderDrawParametersFeatures* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderDrawParametersFeatures* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -7168,19 +6374,17 @@
#endif
#ifdef VK_VERSION_1_2
void marshal_VkPhysicalDeviceVulkan11Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan11Features* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan11Features* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->storageBuffer16BitAccess, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->uniformAndStorageBuffer16BitAccess, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->uniformAndStorageBuffer16BitAccess,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->storagePushConstant16, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->storageInputOutput16, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->multiview, sizeof(VkBool32));
@@ -7193,20 +6397,18 @@
vkStream->write((VkBool32*)&forMarshaling->shaderDrawParameters, sizeof(VkBool32));
}
-void unmarshal_VkPhysicalDeviceVulkan11Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceVulkan11Features* forUnmarshaling)
-{
+void unmarshal_VkPhysicalDeviceVulkan11Features(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPhysicalDeviceVulkan11Features* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->storageBuffer16BitAccess, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->uniformAndStorageBuffer16BitAccess, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->uniformAndStorageBuffer16BitAccess,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->storagePushConstant16, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->storageInputOutput16, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->multiview, sizeof(VkBool32));
@@ -7220,14 +6422,11 @@
}
void marshal_VkPhysicalDeviceVulkan11Properties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan11Properties* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan11Properties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -7237,10 +6436,13 @@
vkStream->write((uint32_t*)&forMarshaling->deviceNodeMask, sizeof(uint32_t));
vkStream->write((VkBool32*)&forMarshaling->deviceLUIDValid, sizeof(VkBool32));
vkStream->write((uint32_t*)&forMarshaling->subgroupSize, sizeof(uint32_t));
- vkStream->write((VkShaderStageFlags*)&forMarshaling->subgroupSupportedStages, sizeof(VkShaderStageFlags));
- vkStream->write((VkSubgroupFeatureFlags*)&forMarshaling->subgroupSupportedOperations, sizeof(VkSubgroupFeatureFlags));
+ vkStream->write((VkShaderStageFlags*)&forMarshaling->subgroupSupportedStages,
+ sizeof(VkShaderStageFlags));
+ vkStream->write((VkSubgroupFeatureFlags*)&forMarshaling->subgroupSupportedOperations,
+ sizeof(VkSubgroupFeatureFlags));
vkStream->write((VkBool32*)&forMarshaling->subgroupQuadOperationsInAllStages, sizeof(VkBool32));
- vkStream->write((VkPointClippingBehavior*)&forMarshaling->pointClippingBehavior, sizeof(VkPointClippingBehavior));
+ vkStream->write((VkPointClippingBehavior*)&forMarshaling->pointClippingBehavior,
+ sizeof(VkPointClippingBehavior));
vkStream->write((uint32_t*)&forMarshaling->maxMultiviewViewCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxMultiviewInstanceIndex, sizeof(uint32_t));
vkStream->write((VkBool32*)&forMarshaling->protectedNoFault, sizeof(VkBool32));
@@ -7249,14 +6451,11 @@
}
void unmarshal_VkPhysicalDeviceVulkan11Properties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceVulkan11Properties* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceVulkan11Properties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -7266,10 +6465,14 @@
vkStream->read((uint32_t*)&forUnmarshaling->deviceNodeMask, sizeof(uint32_t));
vkStream->read((VkBool32*)&forUnmarshaling->deviceLUIDValid, sizeof(VkBool32));
vkStream->read((uint32_t*)&forUnmarshaling->subgroupSize, sizeof(uint32_t));
- vkStream->read((VkShaderStageFlags*)&forUnmarshaling->subgroupSupportedStages, sizeof(VkShaderStageFlags));
- vkStream->read((VkSubgroupFeatureFlags*)&forUnmarshaling->subgroupSupportedOperations, sizeof(VkSubgroupFeatureFlags));
- vkStream->read((VkBool32*)&forUnmarshaling->subgroupQuadOperationsInAllStages, sizeof(VkBool32));
- vkStream->read((VkPointClippingBehavior*)&forUnmarshaling->pointClippingBehavior, sizeof(VkPointClippingBehavior));
+ vkStream->read((VkShaderStageFlags*)&forUnmarshaling->subgroupSupportedStages,
+ sizeof(VkShaderStageFlags));
+ vkStream->read((VkSubgroupFeatureFlags*)&forUnmarshaling->subgroupSupportedOperations,
+ sizeof(VkSubgroupFeatureFlags));
+ vkStream->read((VkBool32*)&forUnmarshaling->subgroupQuadOperationsInAllStages,
+ sizeof(VkBool32));
+ vkStream->read((VkPointClippingBehavior*)&forUnmarshaling->pointClippingBehavior,
+ sizeof(VkPointClippingBehavior));
vkStream->read((uint32_t*)&forUnmarshaling->maxMultiviewViewCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxMultiviewInstanceIndex, sizeof(uint32_t));
vkStream->read((VkBool32*)&forUnmarshaling->protectedNoFault, sizeof(VkBool32));
@@ -7278,14 +6481,11 @@
}
void marshal_VkPhysicalDeviceVulkan12Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan12Features* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan12Features* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -7299,25 +6499,43 @@
vkStream->write((VkBool32*)&forMarshaling->shaderFloat16, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderInt8, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->descriptorIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayDynamicIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUniformBufferUpdateAfterBind, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->descriptorBindingSampledImageUpdateAfterBind, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageImageUpdateAfterBind, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageBufferUpdateAfterBind, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUniformTexelBufferUpdateAfterBind, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageTexelBufferUpdateAfterBind, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUpdateUnusedWhilePending, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayDynamicIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayDynamicIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayDynamicIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUniformBufferUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingSampledImageUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageImageUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageBufferUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUniformTexelBufferUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageTexelBufferUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUpdateUnusedWhilePending,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->descriptorBindingPartiallyBound, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->descriptorBindingVariableDescriptorCount, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingVariableDescriptorCount,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->runtimeDescriptorArray, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->samplerFilterMinmax, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->scalarBlockLayout, sizeof(VkBool32));
@@ -7332,53 +6550,70 @@
vkStream->write((VkBool32*)&forMarshaling->bufferDeviceAddressMultiDevice, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->vulkanMemoryModel, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->vulkanMemoryModelDeviceScope, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->vulkanMemoryModelAvailabilityVisibilityChains, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->vulkanMemoryModelAvailabilityVisibilityChains,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderOutputViewportIndex, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderOutputLayer, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->subgroupBroadcastDynamicId, sizeof(VkBool32));
}
-void unmarshal_VkPhysicalDeviceVulkan12Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceVulkan12Features* forUnmarshaling)
-{
+void unmarshal_VkPhysicalDeviceVulkan12Features(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPhysicalDeviceVulkan12Features* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->samplerMirrorClampToEdge, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->drawIndirectCount, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->storageBuffer8BitAccess, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->uniformAndStorageBuffer8BitAccess, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->uniformAndStorageBuffer8BitAccess,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->storagePushConstant8, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderBufferInt64Atomics, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderSharedInt64Atomics, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderFloat16, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderInt8, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->descriptorIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayDynamicIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformTexelBufferArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageTexelBufferArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUniformBufferUpdateAfterBind, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingSampledImageUpdateAfterBind, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageImageUpdateAfterBind, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageBufferUpdateAfterBind, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUniformTexelBufferUpdateAfterBind, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageTexelBufferUpdateAfterBind, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUpdateUnusedWhilePending, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayDynamicIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformTexelBufferArrayDynamicIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageTexelBufferArrayDynamicIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformTexelBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageTexelBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUniformBufferUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingSampledImageUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageImageUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageBufferUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUniformTexelBufferUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageTexelBufferUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUpdateUnusedWhilePending,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingPartiallyBound, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingVariableDescriptorCount, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingVariableDescriptorCount,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->runtimeDescriptorArray, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->samplerFilterMinmax, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->scalarBlockLayout, sizeof(VkBool32));
@@ -7393,17 +6628,15 @@
vkStream->read((VkBool32*)&forUnmarshaling->bufferDeviceAddressMultiDevice, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->vulkanMemoryModel, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->vulkanMemoryModelDeviceScope, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->vulkanMemoryModelAvailabilityVisibilityChains, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->vulkanMemoryModelAvailabilityVisibilityChains,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderOutputViewportIndex, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderOutputLayer, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->subgroupBroadcastDynamicId, sizeof(VkBool32));
}
-void marshal_VkConformanceVersion(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkConformanceVersion* forMarshaling)
-{
+void marshal_VkConformanceVersion(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkConformanceVersion* forMarshaling) {
(void)rootType;
vkStream->write((uint8_t*)&forMarshaling->major, sizeof(uint8_t));
vkStream->write((uint8_t*)&forMarshaling->minor, sizeof(uint8_t));
@@ -7411,11 +6644,8 @@
vkStream->write((uint8_t*)&forMarshaling->patch, sizeof(uint8_t));
}
-void unmarshal_VkConformanceVersion(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkConformanceVersion* forUnmarshaling)
-{
+void unmarshal_VkConformanceVersion(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkConformanceVersion* forUnmarshaling) {
(void)rootType;
vkStream->read((uint8_t*)&forUnmarshaling->major, sizeof(uint8_t));
vkStream->read((uint8_t*)&forUnmarshaling->minor, sizeof(uint8_t));
@@ -7424,26 +6654,29 @@
}
void marshal_VkPhysicalDeviceVulkan12Properties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan12Properties* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan12Properties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDriverId*)&forMarshaling->driverID, sizeof(VkDriverId));
vkStream->write((char*)forMarshaling->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
vkStream->write((char*)forMarshaling->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
- marshal_VkConformanceVersion(vkStream, rootType, (VkConformanceVersion*)(&forMarshaling->conformanceVersion));
- vkStream->write((VkShaderFloatControlsIndependence*)&forMarshaling->denormBehaviorIndependence, sizeof(VkShaderFloatControlsIndependence));
- vkStream->write((VkShaderFloatControlsIndependence*)&forMarshaling->roundingModeIndependence, sizeof(VkShaderFloatControlsIndependence));
- vkStream->write((VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat16, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat32, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat64, sizeof(VkBool32));
+ marshal_VkConformanceVersion(vkStream, rootType,
+ (VkConformanceVersion*)(&forMarshaling->conformanceVersion));
+ vkStream->write((VkShaderFloatControlsIndependence*)&forMarshaling->denormBehaviorIndependence,
+ sizeof(VkShaderFloatControlsIndependence));
+ vkStream->write((VkShaderFloatControlsIndependence*)&forMarshaling->roundingModeIndependence,
+ sizeof(VkShaderFloatControlsIndependence));
+ vkStream->write((VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat16,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat32,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat64,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderDenormPreserveFloat16, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderDenormPreserveFloat32, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderDenormPreserveFloat64, sizeof(VkBool32));
@@ -7456,60 +6689,89 @@
vkStream->write((VkBool32*)&forMarshaling->shaderRoundingModeRTZFloat16, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderRoundingModeRTZFloat32, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderRoundingModeRTZFloat64, sizeof(VkBool32));
- vkStream->write((uint32_t*)&forMarshaling->maxUpdateAfterBindDescriptorsInAllPools, sizeof(uint32_t));
- vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexingNative, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexingNative, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexingNative, sizeof(VkBool32));
+ vkStream->write((uint32_t*)&forMarshaling->maxUpdateAfterBindDescriptorsInAllPools,
+ sizeof(uint32_t));
+ vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->robustBufferAccessUpdateAfterBind, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->quadDivergentImplicitLod, sizeof(VkBool32));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSamplers, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindUniformBuffers, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageBuffers, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSampledImages, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageImages, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInputAttachments, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageUpdateAfterBindResources, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSamplers, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffers, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffers, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSampledImages, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageImages, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInputAttachments, sizeof(uint32_t));
- vkStream->write((VkResolveModeFlags*)&forMarshaling->supportedDepthResolveModes, sizeof(VkResolveModeFlags));
- vkStream->write((VkResolveModeFlags*)&forMarshaling->supportedStencilResolveModes, sizeof(VkResolveModeFlags));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSamplers,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindUniformBuffers,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageBuffers,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSampledImages,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageImages,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInputAttachments,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageUpdateAfterBindResources,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSamplers,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffers,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffers,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSampledImages,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageImages,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInputAttachments,
+ sizeof(uint32_t));
+ vkStream->write((VkResolveModeFlags*)&forMarshaling->supportedDepthResolveModes,
+ sizeof(VkResolveModeFlags));
+ vkStream->write((VkResolveModeFlags*)&forMarshaling->supportedStencilResolveModes,
+ sizeof(VkResolveModeFlags));
vkStream->write((VkBool32*)&forMarshaling->independentResolveNone, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->independentResolve, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->filterMinmaxSingleComponentFormats, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->filterMinmaxSingleComponentFormats,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->filterMinmaxImageComponentMapping, sizeof(VkBool32));
- vkStream->write((uint64_t*)&forMarshaling->maxTimelineSemaphoreValueDifference, sizeof(uint64_t));
- vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferIntegerColorSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->write((uint64_t*)&forMarshaling->maxTimelineSemaphoreValueDifference,
+ sizeof(uint64_t));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->framebufferIntegerColorSampleCounts,
+ sizeof(VkSampleCountFlags));
}
void unmarshal_VkPhysicalDeviceVulkan12Properties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceVulkan12Properties* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceVulkan12Properties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkDriverId*)&forUnmarshaling->driverID, sizeof(VkDriverId));
vkStream->read((char*)forUnmarshaling->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
vkStream->read((char*)forUnmarshaling->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
- unmarshal_VkConformanceVersion(vkStream, rootType, (VkConformanceVersion*)(&forUnmarshaling->conformanceVersion));
- vkStream->read((VkShaderFloatControlsIndependence*)&forUnmarshaling->denormBehaviorIndependence, sizeof(VkShaderFloatControlsIndependence));
- vkStream->read((VkShaderFloatControlsIndependence*)&forUnmarshaling->roundingModeIndependence, sizeof(VkShaderFloatControlsIndependence));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderSignedZeroInfNanPreserveFloat16, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderSignedZeroInfNanPreserveFloat32, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderSignedZeroInfNanPreserveFloat64, sizeof(VkBool32));
+ unmarshal_VkConformanceVersion(vkStream, rootType,
+ (VkConformanceVersion*)(&forUnmarshaling->conformanceVersion));
+ vkStream->read((VkShaderFloatControlsIndependence*)&forUnmarshaling->denormBehaviorIndependence,
+ sizeof(VkShaderFloatControlsIndependence));
+ vkStream->read((VkShaderFloatControlsIndependence*)&forUnmarshaling->roundingModeIndependence,
+ sizeof(VkShaderFloatControlsIndependence));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderSignedZeroInfNanPreserveFloat16,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderSignedZeroInfNanPreserveFloat32,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderSignedZeroInfNanPreserveFloat64,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderDenormPreserveFloat16, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderDenormPreserveFloat32, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderDenormPreserveFloat64, sizeof(VkBool32));
@@ -7522,126 +6784,145 @@
vkStream->read((VkBool32*)&forUnmarshaling->shaderRoundingModeRTZFloat16, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderRoundingModeRTZFloat32, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderRoundingModeRTZFloat64, sizeof(VkBool32));
- vkStream->read((uint32_t*)&forUnmarshaling->maxUpdateAfterBindDescriptorsInAllPools, sizeof(uint32_t));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayNonUniformIndexingNative, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayNonUniformIndexingNative, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayNonUniformIndexingNative, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->robustBufferAccessUpdateAfterBind, sizeof(VkBool32));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxUpdateAfterBindDescriptorsInAllPools,
+ sizeof(uint32_t));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->robustBufferAccessUpdateAfterBind,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->quadDivergentImplicitLod, sizeof(VkBool32));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindSamplers, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindUniformBuffers, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindStorageBuffers, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindSampledImages, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindStorageImages, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindInputAttachments, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageUpdateAfterBindResources, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindSamplers, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindUniformBuffers, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageBuffers, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindSampledImages, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageImages, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindInputAttachments, sizeof(uint32_t));
- vkStream->read((VkResolveModeFlags*)&forUnmarshaling->supportedDepthResolveModes, sizeof(VkResolveModeFlags));
- vkStream->read((VkResolveModeFlags*)&forUnmarshaling->supportedStencilResolveModes, sizeof(VkResolveModeFlags));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindSamplers,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindUniformBuffers,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindStorageBuffers,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindSampledImages,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindStorageImages,
+ sizeof(uint32_t));
+ vkStream->read(
+ (uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindInputAttachments,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageUpdateAfterBindResources,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindSamplers,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindUniformBuffers,
+ sizeof(uint32_t));
+ vkStream->read(
+ (uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageBuffers,
+ sizeof(uint32_t));
+ vkStream->read(
+ (uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindSampledImages,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageImages,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindInputAttachments,
+ sizeof(uint32_t));
+ vkStream->read((VkResolveModeFlags*)&forUnmarshaling->supportedDepthResolveModes,
+ sizeof(VkResolveModeFlags));
+ vkStream->read((VkResolveModeFlags*)&forUnmarshaling->supportedStencilResolveModes,
+ sizeof(VkResolveModeFlags));
vkStream->read((VkBool32*)&forUnmarshaling->independentResolveNone, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->independentResolve, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->filterMinmaxSingleComponentFormats, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->filterMinmaxImageComponentMapping, sizeof(VkBool32));
- vkStream->read((uint64_t*)&forUnmarshaling->maxTimelineSemaphoreValueDifference, sizeof(uint64_t));
- vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferIntegerColorSampleCounts, sizeof(VkSampleCountFlags));
+ vkStream->read((VkBool32*)&forUnmarshaling->filterMinmaxSingleComponentFormats,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->filterMinmaxImageComponentMapping,
+ sizeof(VkBool32));
+ vkStream->read((uint64_t*)&forUnmarshaling->maxTimelineSemaphoreValueDifference,
+ sizeof(uint64_t));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->framebufferIntegerColorSampleCounts,
+ sizeof(VkSampleCountFlags));
}
-void marshal_VkImageFormatListCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageFormatListCreateInfo* forMarshaling)
-{
+void marshal_VkImageFormatListCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageFormatListCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->viewFormatCount, sizeof(uint32_t));
- vkStream->write((const VkFormat*)forMarshaling->pViewFormats, forMarshaling->viewFormatCount * sizeof(const VkFormat));
+ vkStream->write((const VkFormat*)forMarshaling->pViewFormats,
+ forMarshaling->viewFormatCount * sizeof(const VkFormat));
}
-void unmarshal_VkImageFormatListCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageFormatListCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkImageFormatListCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageFormatListCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->viewFormatCount, sizeof(uint32_t));
- vkStream->read((VkFormat*)forUnmarshaling->pViewFormats, forUnmarshaling->viewFormatCount * sizeof(const VkFormat));
+ vkStream->read((VkFormat*)forUnmarshaling->pViewFormats,
+ forUnmarshaling->viewFormatCount * sizeof(const VkFormat));
}
-void marshal_VkAttachmentDescription2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentDescription2* forMarshaling)
-{
+void marshal_VkAttachmentDescription2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentDescription2* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkAttachmentDescriptionFlags*)&forMarshaling->flags, sizeof(VkAttachmentDescriptionFlags));
+ vkStream->write((VkAttachmentDescriptionFlags*)&forMarshaling->flags,
+ sizeof(VkAttachmentDescriptionFlags));
vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
vkStream->write((VkSampleCountFlagBits*)&forMarshaling->samples, sizeof(VkSampleCountFlagBits));
vkStream->write((VkAttachmentLoadOp*)&forMarshaling->loadOp, sizeof(VkAttachmentLoadOp));
vkStream->write((VkAttachmentStoreOp*)&forMarshaling->storeOp, sizeof(VkAttachmentStoreOp));
vkStream->write((VkAttachmentLoadOp*)&forMarshaling->stencilLoadOp, sizeof(VkAttachmentLoadOp));
- vkStream->write((VkAttachmentStoreOp*)&forMarshaling->stencilStoreOp, sizeof(VkAttachmentStoreOp));
+ vkStream->write((VkAttachmentStoreOp*)&forMarshaling->stencilStoreOp,
+ sizeof(VkAttachmentStoreOp));
vkStream->write((VkImageLayout*)&forMarshaling->initialLayout, sizeof(VkImageLayout));
vkStream->write((VkImageLayout*)&forMarshaling->finalLayout, sizeof(VkImageLayout));
}
-void unmarshal_VkAttachmentDescription2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAttachmentDescription2* forUnmarshaling)
-{
+void unmarshal_VkAttachmentDescription2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAttachmentDescription2* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkAttachmentDescriptionFlags*)&forUnmarshaling->flags, sizeof(VkAttachmentDescriptionFlags));
+ vkStream->read((VkAttachmentDescriptionFlags*)&forUnmarshaling->flags,
+ sizeof(VkAttachmentDescriptionFlags));
vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
- vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples, sizeof(VkSampleCountFlagBits));
+ vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->samples,
+ sizeof(VkSampleCountFlagBits));
vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->loadOp, sizeof(VkAttachmentLoadOp));
vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->storeOp, sizeof(VkAttachmentStoreOp));
- vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->stencilLoadOp, sizeof(VkAttachmentLoadOp));
- vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->stencilStoreOp, sizeof(VkAttachmentStoreOp));
+ vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->stencilLoadOp,
+ sizeof(VkAttachmentLoadOp));
+ vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->stencilStoreOp,
+ sizeof(VkAttachmentStoreOp));
vkStream->read((VkImageLayout*)&forUnmarshaling->initialLayout, sizeof(VkImageLayout));
vkStream->read((VkImageLayout*)&forUnmarshaling->finalLayout, sizeof(VkImageLayout));
}
-void marshal_VkAttachmentReference2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentReference2* forMarshaling)
-{
+void marshal_VkAttachmentReference2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentReference2* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -7650,15 +6931,11 @@
vkStream->write((VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
}
-void unmarshal_VkAttachmentReference2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAttachmentReference2* forUnmarshaling)
-{
+void unmarshal_VkAttachmentReference2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAttachmentReference2* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -7667,317 +6944,287 @@
vkStream->read((VkImageAspectFlags*)&forUnmarshaling->aspectMask, sizeof(VkImageAspectFlags));
}
-void marshal_VkSubpassDescription2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassDescription2* forMarshaling)
-{
+void marshal_VkSubpassDescription2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassDescription2* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkSubpassDescriptionFlags*)&forMarshaling->flags, sizeof(VkSubpassDescriptionFlags));
- vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ vkStream->write((VkSubpassDescriptionFlags*)&forMarshaling->flags,
+ sizeof(VkSubpassDescriptionFlags));
+ vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
vkStream->write((uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->inputAttachmentCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->inputAttachmentCount; ++i)
- {
- marshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pInputAttachments + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->inputAttachmentCount; ++i) {
+ marshal_VkAttachmentReference2(
+ vkStream, rootType,
+ (const VkAttachmentReference2*)(forMarshaling->pInputAttachments + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
- {
- marshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pColorAttachments + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
+ marshal_VkAttachmentReference2(
+ vkStream, rootType,
+ (const VkAttachmentReference2*)(forMarshaling->pColorAttachments + i));
}
}
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pResolveAttachments)
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
- {
- marshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pResolveAttachments + i));
+ if (forMarshaling->pResolveAttachments) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
+ marshal_VkAttachmentReference2(
+ vkStream, rootType,
+ (const VkAttachmentReference2*)(forMarshaling->pResolveAttachments + i));
}
}
}
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pDepthStencilAttachment)
- {
- marshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pDepthStencilAttachment));
+ if (forMarshaling->pDepthStencilAttachment) {
+ marshal_VkAttachmentReference2(
+ vkStream, rootType,
+ (const VkAttachmentReference2*)(forMarshaling->pDepthStencilAttachment));
}
vkStream->write((uint32_t*)&forMarshaling->preserveAttachmentCount, sizeof(uint32_t));
- vkStream->write((const uint32_t*)forMarshaling->pPreserveAttachments, forMarshaling->preserveAttachmentCount * sizeof(const uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pPreserveAttachments,
+ forMarshaling->preserveAttachmentCount * sizeof(const uint32_t));
}
-void unmarshal_VkSubpassDescription2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubpassDescription2* forUnmarshaling)
-{
+void unmarshal_VkSubpassDescription2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubpassDescription2* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkSubpassDescriptionFlags*)&forUnmarshaling->flags, sizeof(VkSubpassDescriptionFlags));
- vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ vkStream->read((VkSubpassDescriptionFlags*)&forUnmarshaling->flags,
+ sizeof(VkSubpassDescriptionFlags));
+ vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
vkStream->read((uint32_t*)&forUnmarshaling->viewMask, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->inputAttachmentCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->inputAttachmentCount; ++i)
- {
- unmarshal_VkAttachmentReference2(vkStream, rootType, (VkAttachmentReference2*)(forUnmarshaling->pInputAttachments + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->inputAttachmentCount; ++i) {
+ unmarshal_VkAttachmentReference2(
+ vkStream, rootType,
+ (VkAttachmentReference2*)(forUnmarshaling->pInputAttachments + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i)
- {
- unmarshal_VkAttachmentReference2(vkStream, rootType, (VkAttachmentReference2*)(forUnmarshaling->pColorAttachments + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i) {
+ unmarshal_VkAttachmentReference2(
+ vkStream, rootType,
+ (VkAttachmentReference2*)(forUnmarshaling->pColorAttachments + i));
}
}
// WARNING PTR CHECK
const VkAttachmentReference2* check_pResolveAttachments;
check_pResolveAttachments = (const VkAttachmentReference2*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pResolveAttachments)
- {
- if (!(check_pResolveAttachments))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pResolveAttachments inconsistent between guest and host\n");
+ if (forUnmarshaling->pResolveAttachments) {
+ if (!(check_pResolveAttachments)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pResolveAttachments inconsistent between guest and "
+ "host\n");
}
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i)
- {
- unmarshal_VkAttachmentReference2(vkStream, rootType, (VkAttachmentReference2*)(forUnmarshaling->pResolveAttachments + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i) {
+ unmarshal_VkAttachmentReference2(
+ vkStream, rootType,
+ (VkAttachmentReference2*)(forUnmarshaling->pResolveAttachments + i));
}
}
}
// WARNING PTR CHECK
const VkAttachmentReference2* check_pDepthStencilAttachment;
check_pDepthStencilAttachment = (const VkAttachmentReference2*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pDepthStencilAttachment)
- {
- if (!(check_pDepthStencilAttachment))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pDepthStencilAttachment inconsistent between guest and host\n");
+ if (forUnmarshaling->pDepthStencilAttachment) {
+ if (!(check_pDepthStencilAttachment)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pDepthStencilAttachment inconsistent between guest "
+ "and host\n");
}
- unmarshal_VkAttachmentReference2(vkStream, rootType, (VkAttachmentReference2*)(forUnmarshaling->pDepthStencilAttachment));
+ unmarshal_VkAttachmentReference2(
+ vkStream, rootType,
+ (VkAttachmentReference2*)(forUnmarshaling->pDepthStencilAttachment));
}
vkStream->read((uint32_t*)&forUnmarshaling->preserveAttachmentCount, sizeof(uint32_t));
- vkStream->read((uint32_t*)forUnmarshaling->pPreserveAttachments, forUnmarshaling->preserveAttachmentCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pPreserveAttachments,
+ forUnmarshaling->preserveAttachmentCount * sizeof(const uint32_t));
}
-void marshal_VkSubpassDependency2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassDependency2* forMarshaling)
-{
+void marshal_VkSubpassDependency2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassDependency2* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->srcSubpass, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->dstSubpass, sizeof(uint32_t));
- vkStream->write((VkPipelineStageFlags*)&forMarshaling->srcStageMask, sizeof(VkPipelineStageFlags));
- vkStream->write((VkPipelineStageFlags*)&forMarshaling->dstStageMask, sizeof(VkPipelineStageFlags));
+ vkStream->write((VkPipelineStageFlags*)&forMarshaling->srcStageMask,
+ sizeof(VkPipelineStageFlags));
+ vkStream->write((VkPipelineStageFlags*)&forMarshaling->dstStageMask,
+ sizeof(VkPipelineStageFlags));
vkStream->write((VkAccessFlags*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags));
vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
vkStream->write((VkDependencyFlags*)&forMarshaling->dependencyFlags, sizeof(VkDependencyFlags));
vkStream->write((int32_t*)&forMarshaling->viewOffset, sizeof(int32_t));
}
-void unmarshal_VkSubpassDependency2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubpassDependency2* forUnmarshaling)
-{
+void unmarshal_VkSubpassDependency2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubpassDependency2* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->srcSubpass, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->dstSubpass, sizeof(uint32_t));
- vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->srcStageMask, sizeof(VkPipelineStageFlags));
- vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->dstStageMask, sizeof(VkPipelineStageFlags));
+ vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->srcStageMask,
+ sizeof(VkPipelineStageFlags));
+ vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->dstStageMask,
+ sizeof(VkPipelineStageFlags));
vkStream->read((VkAccessFlags*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags));
vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
- vkStream->read((VkDependencyFlags*)&forUnmarshaling->dependencyFlags, sizeof(VkDependencyFlags));
+ vkStream->read((VkDependencyFlags*)&forUnmarshaling->dependencyFlags,
+ sizeof(VkDependencyFlags));
vkStream->read((int32_t*)&forUnmarshaling->viewOffset, sizeof(int32_t));
}
-void marshal_VkRenderPassCreateInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassCreateInfo2* forMarshaling)
-{
+void marshal_VkRenderPassCreateInfo2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassCreateInfo2* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkRenderPassCreateFlags*)&forMarshaling->flags, sizeof(VkRenderPassCreateFlags));
+ vkStream->write((VkRenderPassCreateFlags*)&forMarshaling->flags,
+ sizeof(VkRenderPassCreateFlags));
vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i)
- {
- marshal_VkAttachmentDescription2(vkStream, rootType, (const VkAttachmentDescription2*)(forMarshaling->pAttachments + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i) {
+ marshal_VkAttachmentDescription2(
+ vkStream, rootType,
+ (const VkAttachmentDescription2*)(forMarshaling->pAttachments + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->subpassCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->subpassCount; ++i)
- {
- marshal_VkSubpassDescription2(vkStream, rootType, (const VkSubpassDescription2*)(forMarshaling->pSubpasses + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->subpassCount; ++i) {
+ marshal_VkSubpassDescription2(
+ vkStream, rootType, (const VkSubpassDescription2*)(forMarshaling->pSubpasses + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->dependencyCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->dependencyCount; ++i)
- {
- marshal_VkSubpassDependency2(vkStream, rootType, (const VkSubpassDependency2*)(forMarshaling->pDependencies + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->dependencyCount; ++i) {
+ marshal_VkSubpassDependency2(
+ vkStream, rootType,
+ (const VkSubpassDependency2*)(forMarshaling->pDependencies + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->correlatedViewMaskCount, sizeof(uint32_t));
- vkStream->write((const uint32_t*)forMarshaling->pCorrelatedViewMasks, forMarshaling->correlatedViewMaskCount * sizeof(const uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pCorrelatedViewMasks,
+ forMarshaling->correlatedViewMaskCount * sizeof(const uint32_t));
}
-void unmarshal_VkRenderPassCreateInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRenderPassCreateInfo2* forUnmarshaling)
-{
+void unmarshal_VkRenderPassCreateInfo2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderPassCreateInfo2* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkRenderPassCreateFlags*)&forUnmarshaling->flags, sizeof(VkRenderPassCreateFlags));
+ vkStream->read((VkRenderPassCreateFlags*)&forUnmarshaling->flags,
+ sizeof(VkRenderPassCreateFlags));
vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentCount; ++i)
- {
- unmarshal_VkAttachmentDescription2(vkStream, rootType, (VkAttachmentDescription2*)(forUnmarshaling->pAttachments + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentCount; ++i) {
+ unmarshal_VkAttachmentDescription2(
+ vkStream, rootType, (VkAttachmentDescription2*)(forUnmarshaling->pAttachments + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->subpassCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->subpassCount; ++i)
- {
- unmarshal_VkSubpassDescription2(vkStream, rootType, (VkSubpassDescription2*)(forUnmarshaling->pSubpasses + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->subpassCount; ++i) {
+ unmarshal_VkSubpassDescription2(
+ vkStream, rootType, (VkSubpassDescription2*)(forUnmarshaling->pSubpasses + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->dependencyCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->dependencyCount; ++i)
- {
- unmarshal_VkSubpassDependency2(vkStream, rootType, (VkSubpassDependency2*)(forUnmarshaling->pDependencies + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->dependencyCount; ++i) {
+ unmarshal_VkSubpassDependency2(
+ vkStream, rootType, (VkSubpassDependency2*)(forUnmarshaling->pDependencies + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->correlatedViewMaskCount, sizeof(uint32_t));
- vkStream->read((uint32_t*)forUnmarshaling->pCorrelatedViewMasks, forUnmarshaling->correlatedViewMaskCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pCorrelatedViewMasks,
+ forUnmarshaling->correlatedViewMaskCount * sizeof(const uint32_t));
}
-void marshal_VkSubpassBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassBeginInfo* forMarshaling)
-{
+void marshal_VkSubpassBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassBeginInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkSubpassContents*)&forMarshaling->contents, sizeof(VkSubpassContents));
}
-void unmarshal_VkSubpassBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubpassBeginInfo* forUnmarshaling)
-{
+void unmarshal_VkSubpassBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubpassBeginInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkSubpassContents*)&forUnmarshaling->contents, sizeof(VkSubpassContents));
}
-void marshal_VkSubpassEndInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassEndInfo* forMarshaling)
-{
+void marshal_VkSubpassEndInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassEndInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
}
-void unmarshal_VkSubpassEndInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubpassEndInfo* forUnmarshaling)
-{
+void unmarshal_VkSubpassEndInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubpassEndInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
}
void marshal_VkPhysicalDevice8BitStorageFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevice8BitStorageFeatures* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevice8BitStorageFeatures* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -7987,67 +7234,58 @@
}
void unmarshal_VkPhysicalDevice8BitStorageFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDevice8BitStorageFeatures* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevice8BitStorageFeatures* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->storageBuffer8BitAccess, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->uniformAndStorageBuffer8BitAccess, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->uniformAndStorageBuffer8BitAccess,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->storagePushConstant8, sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceDriverProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDriverProperties* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDriverProperties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDriverId*)&forMarshaling->driverID, sizeof(VkDriverId));
vkStream->write((char*)forMarshaling->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
vkStream->write((char*)forMarshaling->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
- marshal_VkConformanceVersion(vkStream, rootType, (VkConformanceVersion*)(&forMarshaling->conformanceVersion));
+ marshal_VkConformanceVersion(vkStream, rootType,
+ (VkConformanceVersion*)(&forMarshaling->conformanceVersion));
}
-void unmarshal_VkPhysicalDeviceDriverProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceDriverProperties* forUnmarshaling)
-{
+void unmarshal_VkPhysicalDeviceDriverProperties(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPhysicalDeviceDriverProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkDriverId*)&forUnmarshaling->driverID, sizeof(VkDriverId));
vkStream->read((char*)forUnmarshaling->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char));
vkStream->read((char*)forUnmarshaling->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
- unmarshal_VkConformanceVersion(vkStream, rootType, (VkConformanceVersion*)(&forUnmarshaling->conformanceVersion));
+ unmarshal_VkConformanceVersion(vkStream, rootType,
+ (VkConformanceVersion*)(&forUnmarshaling->conformanceVersion));
}
void marshal_VkPhysicalDeviceShaderAtomicInt64Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderAtomicInt64Features* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderAtomicInt64Features* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -8056,14 +7294,11 @@
}
void unmarshal_VkPhysicalDeviceShaderAtomicInt64Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShaderAtomicInt64Features* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderAtomicInt64Features* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -8072,14 +7307,11 @@
}
void marshal_VkPhysicalDeviceShaderFloat16Int8Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderFloat16Int8Features* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderFloat16Int8Features* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -8088,14 +7320,11 @@
}
void unmarshal_VkPhysicalDeviceShaderFloat16Int8Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShaderFloat16Int8Features* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderFloat16Int8Features* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -8104,22 +7333,24 @@
}
void marshal_VkPhysicalDeviceFloatControlsProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFloatControlsProperties* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFloatControlsProperties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkShaderFloatControlsIndependence*)&forMarshaling->denormBehaviorIndependence, sizeof(VkShaderFloatControlsIndependence));
- vkStream->write((VkShaderFloatControlsIndependence*)&forMarshaling->roundingModeIndependence, sizeof(VkShaderFloatControlsIndependence));
- vkStream->write((VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat16, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat32, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat64, sizeof(VkBool32));
+ vkStream->write((VkShaderFloatControlsIndependence*)&forMarshaling->denormBehaviorIndependence,
+ sizeof(VkShaderFloatControlsIndependence));
+ vkStream->write((VkShaderFloatControlsIndependence*)&forMarshaling->roundingModeIndependence,
+ sizeof(VkShaderFloatControlsIndependence));
+ vkStream->write((VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat16,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat32,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat64,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderDenormPreserveFloat16, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderDenormPreserveFloat32, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->shaderDenormPreserveFloat64, sizeof(VkBool32));
@@ -8135,22 +7366,24 @@
}
void unmarshal_VkPhysicalDeviceFloatControlsProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceFloatControlsProperties* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceFloatControlsProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkShaderFloatControlsIndependence*)&forUnmarshaling->denormBehaviorIndependence, sizeof(VkShaderFloatControlsIndependence));
- vkStream->read((VkShaderFloatControlsIndependence*)&forUnmarshaling->roundingModeIndependence, sizeof(VkShaderFloatControlsIndependence));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderSignedZeroInfNanPreserveFloat16, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderSignedZeroInfNanPreserveFloat32, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderSignedZeroInfNanPreserveFloat64, sizeof(VkBool32));
+ vkStream->read((VkShaderFloatControlsIndependence*)&forUnmarshaling->denormBehaviorIndependence,
+ sizeof(VkShaderFloatControlsIndependence));
+ vkStream->read((VkShaderFloatControlsIndependence*)&forUnmarshaling->roundingModeIndependence,
+ sizeof(VkShaderFloatControlsIndependence));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderSignedZeroInfNanPreserveFloat16,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderSignedZeroInfNanPreserveFloat32,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderSignedZeroInfNanPreserveFloat64,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderDenormPreserveFloat16, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderDenormPreserveFloat32, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->shaderDenormPreserveFloat64, sizeof(VkBool32));
@@ -8166,14 +7399,11 @@
}
void marshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetLayoutBindingFlagsCreateInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorSetLayoutBindingFlagsCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -8181,21 +7411,18 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pBindingFlags;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pBindingFlags)
- {
- vkStream->write((const VkDescriptorBindingFlags*)forMarshaling->pBindingFlags, forMarshaling->bindingCount * sizeof(const VkDescriptorBindingFlags));
+ if (forMarshaling->pBindingFlags) {
+ vkStream->write((const VkDescriptorBindingFlags*)forMarshaling->pBindingFlags,
+ forMarshaling->bindingCount * sizeof(const VkDescriptorBindingFlags));
}
}
void unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorSetLayoutBindingFlagsCreateInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDescriptorSetLayoutBindingFlagsCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -8203,199 +7430,262 @@
// WARNING PTR CHECK
const VkDescriptorBindingFlags* check_pBindingFlags;
check_pBindingFlags = (const VkDescriptorBindingFlags*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pBindingFlags)
- {
- if (!(check_pBindingFlags))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pBindingFlags inconsistent between guest and host\n");
+ if (forUnmarshaling->pBindingFlags) {
+ if (!(check_pBindingFlags)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pBindingFlags inconsistent between guest and host\n");
}
- vkStream->read((VkDescriptorBindingFlags*)forUnmarshaling->pBindingFlags, forUnmarshaling->bindingCount * sizeof(const VkDescriptorBindingFlags));
+ vkStream->read((VkDescriptorBindingFlags*)forUnmarshaling->pBindingFlags,
+ forUnmarshaling->bindingCount * sizeof(const VkDescriptorBindingFlags));
}
}
void marshal_VkPhysicalDeviceDescriptorIndexingFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDescriptorIndexingFeatures* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDescriptorIndexingFeatures* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayDynamicIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUniformBufferUpdateAfterBind, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->descriptorBindingSampledImageUpdateAfterBind, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageImageUpdateAfterBind, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageBufferUpdateAfterBind, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUniformTexelBufferUpdateAfterBind, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageTexelBufferUpdateAfterBind, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUpdateUnusedWhilePending, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayDynamicIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayDynamicIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayDynamicIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUniformBufferUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingSampledImageUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageImageUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageBufferUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUniformTexelBufferUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingStorageTexelBufferUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingUpdateUnusedWhilePending,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->descriptorBindingPartiallyBound, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->descriptorBindingVariableDescriptorCount, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingVariableDescriptorCount,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->runtimeDescriptorArray, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceDescriptorIndexingFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceDescriptorIndexingFeatures* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceDescriptorIndexingFeatures* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayDynamicIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformTexelBufferArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageTexelBufferArrayNonUniformIndexing, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUniformBufferUpdateAfterBind, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingSampledImageUpdateAfterBind, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageImageUpdateAfterBind, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageBufferUpdateAfterBind, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUniformTexelBufferUpdateAfterBind, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageTexelBufferUpdateAfterBind, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUpdateUnusedWhilePending, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayDynamicIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformTexelBufferArrayDynamicIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageTexelBufferArrayDynamicIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformTexelBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageTexelBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUniformBufferUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingSampledImageUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageImageUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageBufferUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUniformTexelBufferUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingStorageTexelBufferUpdateAfterBind,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingUpdateUnusedWhilePending,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingPartiallyBound, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingVariableDescriptorCount, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingVariableDescriptorCount,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->runtimeDescriptorArray, sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceDescriptorIndexingProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDescriptorIndexingProperties* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDescriptorIndexingProperties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((uint32_t*)&forMarshaling->maxUpdateAfterBindDescriptorsInAllPools, sizeof(uint32_t));
- vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexingNative, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexingNative, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexingNative, sizeof(VkBool32));
+ vkStream->write((uint32_t*)&forMarshaling->maxUpdateAfterBindDescriptorsInAllPools,
+ sizeof(uint32_t));
+ vkStream->write((VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->robustBufferAccessUpdateAfterBind, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->quadDivergentImplicitLod, sizeof(VkBool32));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSamplers, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindUniformBuffers, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageBuffers, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSampledImages, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageImages, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInputAttachments, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageUpdateAfterBindResources, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSamplers, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffers, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffers, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSampledImages, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageImages, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInputAttachments, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSamplers,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindUniformBuffers,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageBuffers,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSampledImages,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageImages,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInputAttachments,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageUpdateAfterBindResources,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSamplers,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffers,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffers,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSampledImages,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageImages,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInputAttachments,
+ sizeof(uint32_t));
}
void unmarshal_VkPhysicalDeviceDescriptorIndexingProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceDescriptorIndexingProperties* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceDescriptorIndexingProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((uint32_t*)&forUnmarshaling->maxUpdateAfterBindDescriptorsInAllPools, sizeof(uint32_t));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayNonUniformIndexingNative, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayNonUniformIndexingNative, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayNonUniformIndexingNative, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->robustBufferAccessUpdateAfterBind, sizeof(VkBool32));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxUpdateAfterBindDescriptorsInAllPools,
+ sizeof(uint32_t));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderUniformBufferArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderSampledImageArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageBufferArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderStorageImageArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderInputAttachmentArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->robustBufferAccessUpdateAfterBind,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->quadDivergentImplicitLod, sizeof(VkBool32));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindSamplers, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindUniformBuffers, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindStorageBuffers, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindSampledImages, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindStorageImages, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindInputAttachments, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageUpdateAfterBindResources, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindSamplers, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindUniformBuffers, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageBuffers, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindSampledImages, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageImages, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindInputAttachments, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindSamplers,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindUniformBuffers,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindStorageBuffers,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindSampledImages,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindStorageImages,
+ sizeof(uint32_t));
+ vkStream->read(
+ (uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindInputAttachments,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageUpdateAfterBindResources,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindSamplers,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindUniformBuffers,
+ sizeof(uint32_t));
+ vkStream->read(
+ (uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageBuffers,
+ sizeof(uint32_t));
+ vkStream->read(
+ (uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindSampledImages,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindStorageImages,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindInputAttachments,
+ sizeof(uint32_t));
}
void marshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetVariableDescriptorCountAllocateInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorSetVariableDescriptorCountAllocateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->descriptorSetCount, sizeof(uint32_t));
- vkStream->write((const uint32_t*)forMarshaling->pDescriptorCounts, forMarshaling->descriptorSetCount * sizeof(const uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pDescriptorCounts,
+ forMarshaling->descriptorSetCount * sizeof(const uint32_t));
}
void unmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorSetVariableDescriptorCountAllocateInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDescriptorSetVariableDescriptorCountAllocateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->descriptorSetCount, sizeof(uint32_t));
- vkStream->read((uint32_t*)forUnmarshaling->pDescriptorCounts, forUnmarshaling->descriptorSetCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pDescriptorCounts,
+ forUnmarshaling->descriptorSetCount * sizeof(const uint32_t));
}
void marshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetVariableDescriptorCountLayoutSupport* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorSetVariableDescriptorCountLayoutSupport* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -8403,14 +7693,11 @@
}
void unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorSetVariableDescriptorCountLayoutSupport* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDescriptorSetVariableDescriptorCountLayoutSupport* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -8418,100 +7705,97 @@
}
void marshal_VkSubpassDescriptionDepthStencilResolve(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassDescriptionDepthStencilResolve* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassDescriptionDepthStencilResolve* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkResolveModeFlagBits*)&forMarshaling->depthResolveMode, sizeof(VkResolveModeFlagBits));
- vkStream->write((VkResolveModeFlagBits*)&forMarshaling->stencilResolveMode, sizeof(VkResolveModeFlagBits));
+ vkStream->write((VkResolveModeFlagBits*)&forMarshaling->depthResolveMode,
+ sizeof(VkResolveModeFlagBits));
+ vkStream->write((VkResolveModeFlagBits*)&forMarshaling->stencilResolveMode,
+ sizeof(VkResolveModeFlagBits));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilResolveAttachment;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pDepthStencilResolveAttachment)
- {
- marshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pDepthStencilResolveAttachment));
+ if (forMarshaling->pDepthStencilResolveAttachment) {
+ marshal_VkAttachmentReference2(
+ vkStream, rootType,
+ (const VkAttachmentReference2*)(forMarshaling->pDepthStencilResolveAttachment));
}
}
void unmarshal_VkSubpassDescriptionDepthStencilResolve(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubpassDescriptionDepthStencilResolve* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubpassDescriptionDepthStencilResolve* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkResolveModeFlagBits*)&forUnmarshaling->depthResolveMode, sizeof(VkResolveModeFlagBits));
- vkStream->read((VkResolveModeFlagBits*)&forUnmarshaling->stencilResolveMode, sizeof(VkResolveModeFlagBits));
+ vkStream->read((VkResolveModeFlagBits*)&forUnmarshaling->depthResolveMode,
+ sizeof(VkResolveModeFlagBits));
+ vkStream->read((VkResolveModeFlagBits*)&forUnmarshaling->stencilResolveMode,
+ sizeof(VkResolveModeFlagBits));
// WARNING PTR CHECK
const VkAttachmentReference2* check_pDepthStencilResolveAttachment;
- check_pDepthStencilResolveAttachment = (const VkAttachmentReference2*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pDepthStencilResolveAttachment)
- {
- if (!(check_pDepthStencilResolveAttachment))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pDepthStencilResolveAttachment inconsistent between guest and host\n");
+ check_pDepthStencilResolveAttachment =
+ (const VkAttachmentReference2*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pDepthStencilResolveAttachment) {
+ if (!(check_pDepthStencilResolveAttachment)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pDepthStencilResolveAttachment inconsistent between "
+ "guest and host\n");
}
- unmarshal_VkAttachmentReference2(vkStream, rootType, (VkAttachmentReference2*)(forUnmarshaling->pDepthStencilResolveAttachment));
+ unmarshal_VkAttachmentReference2(
+ vkStream, rootType,
+ (VkAttachmentReference2*)(forUnmarshaling->pDepthStencilResolveAttachment));
}
}
void marshal_VkPhysicalDeviceDepthStencilResolveProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDepthStencilResolveProperties* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDepthStencilResolveProperties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkResolveModeFlags*)&forMarshaling->supportedDepthResolveModes, sizeof(VkResolveModeFlags));
- vkStream->write((VkResolveModeFlags*)&forMarshaling->supportedStencilResolveModes, sizeof(VkResolveModeFlags));
+ vkStream->write((VkResolveModeFlags*)&forMarshaling->supportedDepthResolveModes,
+ sizeof(VkResolveModeFlags));
+ vkStream->write((VkResolveModeFlags*)&forMarshaling->supportedStencilResolveModes,
+ sizeof(VkResolveModeFlags));
vkStream->write((VkBool32*)&forMarshaling->independentResolveNone, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->independentResolve, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceDepthStencilResolveProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceDepthStencilResolveProperties* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceDepthStencilResolveProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkResolveModeFlags*)&forUnmarshaling->supportedDepthResolveModes, sizeof(VkResolveModeFlags));
- vkStream->read((VkResolveModeFlags*)&forUnmarshaling->supportedStencilResolveModes, sizeof(VkResolveModeFlags));
+ vkStream->read((VkResolveModeFlags*)&forUnmarshaling->supportedDepthResolveModes,
+ sizeof(VkResolveModeFlags));
+ vkStream->read((VkResolveModeFlags*)&forUnmarshaling->supportedStencilResolveModes,
+ sizeof(VkResolveModeFlags));
vkStream->read((VkBool32*)&forUnmarshaling->independentResolveNone, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->independentResolve, sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceScalarBlockLayoutFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceScalarBlockLayoutFeatures* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceScalarBlockLayoutFeatures* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -8519,44 +7803,33 @@
}
void unmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceScalarBlockLayoutFeatures* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceScalarBlockLayoutFeatures* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->scalarBlockLayout, sizeof(VkBool32));
}
-void marshal_VkImageStencilUsageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageStencilUsageCreateInfo* forMarshaling)
-{
+void marshal_VkImageStencilUsageCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageStencilUsageCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkImageUsageFlags*)&forMarshaling->stencilUsage, sizeof(VkImageUsageFlags));
}
-void unmarshal_VkImageStencilUsageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageStencilUsageCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkImageStencilUsageCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageStencilUsageCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -8564,110 +7837,96 @@
}
void marshal_VkSamplerReductionModeCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerReductionModeCreateInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerReductionModeCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkSamplerReductionMode*)&forMarshaling->reductionMode, sizeof(VkSamplerReductionMode));
+ vkStream->write((VkSamplerReductionMode*)&forMarshaling->reductionMode,
+ sizeof(VkSamplerReductionMode));
}
-void unmarshal_VkSamplerReductionModeCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSamplerReductionModeCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkSamplerReductionModeCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkSamplerReductionModeCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkSamplerReductionMode*)&forUnmarshaling->reductionMode, sizeof(VkSamplerReductionMode));
+ vkStream->read((VkSamplerReductionMode*)&forUnmarshaling->reductionMode,
+ sizeof(VkSamplerReductionMode));
}
void marshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSamplerFilterMinmaxProperties* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSamplerFilterMinmaxProperties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkBool32*)&forMarshaling->filterMinmaxSingleComponentFormats, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->filterMinmaxSingleComponentFormats,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->filterMinmaxImageComponentMapping, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceSamplerFilterMinmaxProperties* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceSamplerFilterMinmaxProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkBool32*)&forUnmarshaling->filterMinmaxSingleComponentFormats, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->filterMinmaxImageComponentMapping, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->filterMinmaxSingleComponentFormats,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->filterMinmaxImageComponentMapping,
+ sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceVulkanMemoryModelFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkanMemoryModelFeatures* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVulkanMemoryModelFeatures* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->vulkanMemoryModel, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->vulkanMemoryModelDeviceScope, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->vulkanMemoryModelAvailabilityVisibilityChains, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->vulkanMemoryModelAvailabilityVisibilityChains,
+ sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceVulkanMemoryModelFeatures* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceVulkanMemoryModelFeatures* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->vulkanMemoryModel, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->vulkanMemoryModelDeviceScope, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->vulkanMemoryModelAvailabilityVisibilityChains, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->vulkanMemoryModelAvailabilityVisibilityChains,
+ sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceImagelessFramebufferFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceImagelessFramebufferFeatures* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceImagelessFramebufferFeatures* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -8675,14 +7934,11 @@
}
void unmarshal_VkPhysicalDeviceImagelessFramebufferFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceImagelessFramebufferFeatures* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceImagelessFramebufferFeatures* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -8690,14 +7946,11 @@
}
void marshal_VkFramebufferAttachmentImageInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFramebufferAttachmentImageInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFramebufferAttachmentImageInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -8707,18 +7960,16 @@
vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->viewFormatCount, sizeof(uint32_t));
- vkStream->write((const VkFormat*)forMarshaling->pViewFormats, forMarshaling->viewFormatCount * sizeof(const VkFormat));
+ vkStream->write((const VkFormat*)forMarshaling->pViewFormats,
+ forMarshaling->viewFormatCount * sizeof(const VkFormat));
}
-void unmarshal_VkFramebufferAttachmentImageInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkFramebufferAttachmentImageInfo* forUnmarshaling)
-{
+void unmarshal_VkFramebufferAttachmentImageInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkFramebufferAttachmentImageInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -8728,106 +7979,93 @@
vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->layerCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->viewFormatCount, sizeof(uint32_t));
- vkStream->read((VkFormat*)forUnmarshaling->pViewFormats, forUnmarshaling->viewFormatCount * sizeof(const VkFormat));
+ vkStream->read((VkFormat*)forUnmarshaling->pViewFormats,
+ forUnmarshaling->viewFormatCount * sizeof(const VkFormat));
}
void marshal_VkFramebufferAttachmentsCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFramebufferAttachmentsCreateInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFramebufferAttachmentsCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->attachmentImageInfoCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentImageInfoCount; ++i)
- {
- marshal_VkFramebufferAttachmentImageInfo(vkStream, rootType, (const VkFramebufferAttachmentImageInfo*)(forMarshaling->pAttachmentImageInfos + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentImageInfoCount; ++i) {
+ marshal_VkFramebufferAttachmentImageInfo(
+ vkStream, rootType,
+ (const VkFramebufferAttachmentImageInfo*)(forMarshaling->pAttachmentImageInfos +
+ i));
}
}
}
void unmarshal_VkFramebufferAttachmentsCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkFramebufferAttachmentsCreateInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkFramebufferAttachmentsCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->attachmentImageInfoCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentImageInfoCount; ++i)
- {
- unmarshal_VkFramebufferAttachmentImageInfo(vkStream, rootType, (VkFramebufferAttachmentImageInfo*)(forUnmarshaling->pAttachmentImageInfos + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentImageInfoCount; ++i) {
+ unmarshal_VkFramebufferAttachmentImageInfo(
+ vkStream, rootType,
+ (VkFramebufferAttachmentImageInfo*)(forUnmarshaling->pAttachmentImageInfos + i));
}
}
}
-void marshal_VkRenderPassAttachmentBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassAttachmentBeginInfo* forMarshaling)
-{
+void marshal_VkRenderPassAttachmentBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassAttachmentBeginInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
- if (forMarshaling->attachmentCount)
- {
+ if (forMarshaling->attachmentCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forMarshaling->attachmentCount * 8);
- vkStream->handleMapping()->mapHandles_VkImageView_u64(forMarshaling->pAttachments, cgen_var_0, forMarshaling->attachmentCount);
+ vkStream->handleMapping()->mapHandles_VkImageView_u64(
+ forMarshaling->pAttachments, cgen_var_0, forMarshaling->attachmentCount);
vkStream->write((uint64_t*)cgen_var_0, forMarshaling->attachmentCount * 8);
}
}
-void unmarshal_VkRenderPassAttachmentBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRenderPassAttachmentBeginInfo* forUnmarshaling)
-{
+void unmarshal_VkRenderPassAttachmentBeginInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkRenderPassAttachmentBeginInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
- if (forUnmarshaling->attachmentCount)
- {
+ if (forUnmarshaling->attachmentCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->attachmentCount * 8);
vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->attachmentCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImageView(cgen_var_0, (VkImageView*)forUnmarshaling->pAttachments, forUnmarshaling->attachmentCount);
+ vkStream->handleMapping()->mapHandles_u64_VkImageView(
+ cgen_var_0, (VkImageView*)forUnmarshaling->pAttachments,
+ forUnmarshaling->attachmentCount);
}
}
void marshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -8835,14 +8073,11 @@
}
void unmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceUniformBufferStandardLayoutFeatures* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceUniformBufferStandardLayoutFeatures* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -8850,14 +8085,11 @@
}
void marshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -8865,14 +8097,11 @@
}
void unmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -8880,14 +8109,11 @@
}
void marshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -8895,14 +8121,11 @@
}
void unmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -8910,14 +8133,11 @@
}
void marshal_VkAttachmentReferenceStencilLayout(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentReferenceStencilLayout* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentReferenceStencilLayout* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -8925,14 +8145,11 @@
}
void unmarshal_VkAttachmentReferenceStencilLayout(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAttachmentReferenceStencilLayout* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAttachmentReferenceStencilLayout* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -8940,14 +8157,11 @@
}
void marshal_VkAttachmentDescriptionStencilLayout(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentDescriptionStencilLayout* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentDescriptionStencilLayout* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -8956,14 +8170,11 @@
}
void unmarshal_VkAttachmentDescriptionStencilLayout(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAttachmentDescriptionStencilLayout* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAttachmentDescriptionStencilLayout* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -8972,14 +8183,11 @@
}
void marshal_VkPhysicalDeviceHostQueryResetFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceHostQueryResetFeatures* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceHostQueryResetFeatures* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -8987,14 +8195,11 @@
}
void unmarshal_VkPhysicalDeviceHostQueryResetFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceHostQueryResetFeatures* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceHostQueryResetFeatures* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -9002,14 +8207,11 @@
}
void marshal_VkPhysicalDeviceTimelineSemaphoreFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTimelineSemaphoreFeatures* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTimelineSemaphoreFeatures* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -9017,14 +8219,11 @@
}
void unmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceTimelineSemaphoreFeatures* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceTimelineSemaphoreFeatures* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -9032,44 +8231,36 @@
}
void marshal_VkPhysicalDeviceTimelineSemaphoreProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTimelineSemaphoreProperties* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTimelineSemaphoreProperties* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((uint64_t*)&forMarshaling->maxTimelineSemaphoreValueDifference, sizeof(uint64_t));
+ vkStream->write((uint64_t*)&forMarshaling->maxTimelineSemaphoreValueDifference,
+ sizeof(uint64_t));
}
void unmarshal_VkPhysicalDeviceTimelineSemaphoreProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceTimelineSemaphoreProperties* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceTimelineSemaphoreProperties* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((uint64_t*)&forUnmarshaling->maxTimelineSemaphoreValueDifference, sizeof(uint64_t));
+ vkStream->read((uint64_t*)&forUnmarshaling->maxTimelineSemaphoreValueDifference,
+ sizeof(uint64_t));
}
-void marshal_VkSemaphoreTypeCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreTypeCreateInfo* forMarshaling)
-{
+void marshal_VkSemaphoreTypeCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreTypeCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -9077,15 +8268,11 @@
vkStream->write((uint64_t*)&forMarshaling->initialValue, sizeof(uint64_t));
}
-void unmarshal_VkSemaphoreTypeCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSemaphoreTypeCreateInfo* forUnmarshaling)
-{
+void unmarshal_VkSemaphoreTypeCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSemaphoreTypeCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -9093,15 +8280,11 @@
vkStream->read((uint64_t*)&forUnmarshaling->initialValue, sizeof(uint64_t));
}
-void marshal_VkTimelineSemaphoreSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkTimelineSemaphoreSubmitInfo* forMarshaling)
-{
+void marshal_VkTimelineSemaphoreSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkTimelineSemaphoreSubmitInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -9109,29 +8292,25 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pWaitSemaphoreValues;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pWaitSemaphoreValues)
- {
- vkStream->write((const uint64_t*)forMarshaling->pWaitSemaphoreValues, forMarshaling->waitSemaphoreValueCount * sizeof(const uint64_t));
+ if (forMarshaling->pWaitSemaphoreValues) {
+ vkStream->write((const uint64_t*)forMarshaling->pWaitSemaphoreValues,
+ forMarshaling->waitSemaphoreValueCount * sizeof(const uint64_t));
}
vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreValueCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pSignalSemaphoreValues;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pSignalSemaphoreValues)
- {
- vkStream->write((const uint64_t*)forMarshaling->pSignalSemaphoreValues, forMarshaling->signalSemaphoreValueCount * sizeof(const uint64_t));
+ if (forMarshaling->pSignalSemaphoreValues) {
+ vkStream->write((const uint64_t*)forMarshaling->pSignalSemaphoreValues,
+ forMarshaling->signalSemaphoreValueCount * sizeof(const uint64_t));
}
}
-void unmarshal_VkTimelineSemaphoreSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkTimelineSemaphoreSubmitInfo* forUnmarshaling)
-{
+void unmarshal_VkTimelineSemaphoreSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkTimelineSemaphoreSubmitInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -9139,121 +8318,109 @@
// WARNING PTR CHECK
const uint64_t* check_pWaitSemaphoreValues;
check_pWaitSemaphoreValues = (const uint64_t*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pWaitSemaphoreValues)
- {
- if (!(check_pWaitSemaphoreValues))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pWaitSemaphoreValues inconsistent between guest and host\n");
+ if (forUnmarshaling->pWaitSemaphoreValues) {
+ if (!(check_pWaitSemaphoreValues)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pWaitSemaphoreValues inconsistent between guest and "
+ "host\n");
}
- vkStream->read((uint64_t*)forUnmarshaling->pWaitSemaphoreValues, forUnmarshaling->waitSemaphoreValueCount * sizeof(const uint64_t));
+ vkStream->read((uint64_t*)forUnmarshaling->pWaitSemaphoreValues,
+ forUnmarshaling->waitSemaphoreValueCount * sizeof(const uint64_t));
}
vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreValueCount, sizeof(uint32_t));
// WARNING PTR CHECK
const uint64_t* check_pSignalSemaphoreValues;
check_pSignalSemaphoreValues = (const uint64_t*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pSignalSemaphoreValues)
- {
- if (!(check_pSignalSemaphoreValues))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pSignalSemaphoreValues inconsistent between guest and host\n");
+ if (forUnmarshaling->pSignalSemaphoreValues) {
+ if (!(check_pSignalSemaphoreValues)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pSignalSemaphoreValues inconsistent between guest and "
+ "host\n");
}
- vkStream->read((uint64_t*)forUnmarshaling->pSignalSemaphoreValues, forUnmarshaling->signalSemaphoreValueCount * sizeof(const uint64_t));
+ vkStream->read((uint64_t*)forUnmarshaling->pSignalSemaphoreValues,
+ forUnmarshaling->signalSemaphoreValueCount * sizeof(const uint64_t));
}
}
-void marshal_VkSemaphoreWaitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreWaitInfo* forMarshaling)
-{
+void marshal_VkSemaphoreWaitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreWaitInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkSemaphoreWaitFlags*)&forMarshaling->flags, sizeof(VkSemaphoreWaitFlags));
vkStream->write((uint32_t*)&forMarshaling->semaphoreCount, sizeof(uint32_t));
- if (forMarshaling->semaphoreCount)
- {
+ if (forMarshaling->semaphoreCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forMarshaling->semaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pSemaphores, cgen_var_0, forMarshaling->semaphoreCount);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(
+ forMarshaling->pSemaphores, cgen_var_0, forMarshaling->semaphoreCount);
vkStream->write((uint64_t*)cgen_var_0, forMarshaling->semaphoreCount * 8);
}
- vkStream->write((const uint64_t*)forMarshaling->pValues, forMarshaling->semaphoreCount * sizeof(const uint64_t));
+ vkStream->write((const uint64_t*)forMarshaling->pValues,
+ forMarshaling->semaphoreCount * sizeof(const uint64_t));
}
-void unmarshal_VkSemaphoreWaitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSemaphoreWaitInfo* forUnmarshaling)
-{
+void unmarshal_VkSemaphoreWaitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSemaphoreWaitInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkSemaphoreWaitFlags*)&forUnmarshaling->flags, sizeof(VkSemaphoreWaitFlags));
vkStream->read((uint32_t*)&forUnmarshaling->semaphoreCount, sizeof(uint32_t));
- if (forUnmarshaling->semaphoreCount)
- {
+ if (forUnmarshaling->semaphoreCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->semaphoreCount * 8);
vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->semaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_0, (VkSemaphore*)forUnmarshaling->pSemaphores, forUnmarshaling->semaphoreCount);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
+ cgen_var_0, (VkSemaphore*)forUnmarshaling->pSemaphores,
+ forUnmarshaling->semaphoreCount);
}
- vkStream->read((uint64_t*)forUnmarshaling->pValues, forUnmarshaling->semaphoreCount * sizeof(const uint64_t));
+ vkStream->read((uint64_t*)forUnmarshaling->pValues,
+ forUnmarshaling->semaphoreCount * sizeof(const uint64_t));
}
-void marshal_VkSemaphoreSignalInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreSignalInfo* forMarshaling)
-{
+void marshal_VkSemaphoreSignalInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreSignalInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((uint64_t*)&forMarshaling->value, sizeof(uint64_t));
}
-void unmarshal_VkSemaphoreSignalInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSemaphoreSignalInfo* forUnmarshaling)
-{
+void unmarshal_VkSemaphoreSignalInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSemaphoreSignalInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
+ &cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
vkStream->read((uint64_t*)&forUnmarshaling->value, sizeof(uint64_t));
}
void marshal_VkPhysicalDeviceBufferDeviceAddressFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceBufferDeviceAddressFeatures* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceBufferDeviceAddressFeatures* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -9263,14 +8430,11 @@
}
void unmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceBufferDeviceAddressFeatures* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceBufferDeviceAddressFeatures* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -9279,15 +8443,11 @@
vkStream->read((VkBool32*)&forUnmarshaling->bufferDeviceAddressMultiDevice, sizeof(VkBool32));
}
-void marshal_VkBufferDeviceAddressInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferDeviceAddressInfo* forMarshaling)
-{
+void marshal_VkBufferDeviceAddressInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferDeviceAddressInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -9296,32 +8456,26 @@
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}
-void unmarshal_VkBufferDeviceAddressInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferDeviceAddressInfo* forUnmarshaling)
-{
+void unmarshal_VkBufferDeviceAddressInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferDeviceAddressInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+ (VkBuffer*)&forUnmarshaling->buffer, 1);
}
void marshal_VkBufferOpaqueCaptureAddressCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferOpaqueCaptureAddressCreateInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferOpaqueCaptureAddressCreateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -9329,14 +8483,11 @@
}
void unmarshal_VkBufferOpaqueCaptureAddressCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferOpaqueCaptureAddressCreateInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferOpaqueCaptureAddressCreateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -9344,14 +8495,11 @@
}
void marshal_VkMemoryOpaqueCaptureAddressAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryOpaqueCaptureAddressAllocateInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryOpaqueCaptureAddressAllocateInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -9359,14 +8507,11 @@
}
void unmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryOpaqueCaptureAddressAllocateInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryOpaqueCaptureAddressAllocateInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -9374,46 +8519,39 @@
}
void marshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceMemoryOpaqueCaptureAddressInfo* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceMemoryOpaqueCaptureAddressInfo* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}
void unmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceMemoryOpaqueCaptureAddressInfo* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceMemoryOpaqueCaptureAddressInfo* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+ &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
}
#endif
#ifdef VK_KHR_surface
-void marshal_VkSurfaceCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceCapabilitiesKHR* forMarshaling)
-{
+void marshal_VkSurfaceCapabilitiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceCapabilitiesKHR* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->minImageCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxImageCount, sizeof(uint32_t));
@@ -9421,17 +8559,18 @@
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minImageExtent));
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxImageExtent));
vkStream->write((uint32_t*)&forMarshaling->maxImageArrayLayers, sizeof(uint32_t));
- vkStream->write((VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
- vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->currentTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
- vkStream->write((VkCompositeAlphaFlagsKHR*)&forMarshaling->supportedCompositeAlpha, sizeof(VkCompositeAlphaFlagsKHR));
- vkStream->write((VkImageUsageFlags*)&forMarshaling->supportedUsageFlags, sizeof(VkImageUsageFlags));
+ vkStream->write((VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms,
+ sizeof(VkSurfaceTransformFlagsKHR));
+ vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->currentTransform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->write((VkCompositeAlphaFlagsKHR*)&forMarshaling->supportedCompositeAlpha,
+ sizeof(VkCompositeAlphaFlagsKHR));
+ vkStream->write((VkImageUsageFlags*)&forMarshaling->supportedUsageFlags,
+ sizeof(VkImageUsageFlags));
}
-void unmarshal_VkSurfaceCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSurfaceCapabilitiesKHR* forUnmarshaling)
-{
+void unmarshal_VkSurfaceCapabilitiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSurfaceCapabilitiesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->minImageCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxImageCount, sizeof(uint32_t));
@@ -9439,27 +8578,25 @@
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->minImageExtent));
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxImageExtent));
vkStream->read((uint32_t*)&forUnmarshaling->maxImageArrayLayers, sizeof(uint32_t));
- vkStream->read((VkSurfaceTransformFlagsKHR*)&forUnmarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
- vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->currentTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
- vkStream->read((VkCompositeAlphaFlagsKHR*)&forUnmarshaling->supportedCompositeAlpha, sizeof(VkCompositeAlphaFlagsKHR));
- vkStream->read((VkImageUsageFlags*)&forUnmarshaling->supportedUsageFlags, sizeof(VkImageUsageFlags));
+ vkStream->read((VkSurfaceTransformFlagsKHR*)&forUnmarshaling->supportedTransforms,
+ sizeof(VkSurfaceTransformFlagsKHR));
+ vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->currentTransform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->read((VkCompositeAlphaFlagsKHR*)&forUnmarshaling->supportedCompositeAlpha,
+ sizeof(VkCompositeAlphaFlagsKHR));
+ vkStream->read((VkImageUsageFlags*)&forUnmarshaling->supportedUsageFlags,
+ sizeof(VkImageUsageFlags));
}
-void marshal_VkSurfaceFormatKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceFormatKHR* forMarshaling)
-{
+void marshal_VkSurfaceFormatKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceFormatKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
vkStream->write((VkColorSpaceKHR*)&forMarshaling->colorSpace, sizeof(VkColorSpaceKHR));
}
-void unmarshal_VkSurfaceFormatKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSurfaceFormatKHR* forUnmarshaling)
-{
+void unmarshal_VkSurfaceFormatKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSurfaceFormatKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
vkStream->read((VkColorSpaceKHR*)&forUnmarshaling->colorSpace, sizeof(VkColorSpaceKHR));
@@ -9467,19 +8604,16 @@
#endif
#ifdef VK_KHR_swapchain
-void marshal_VkSwapchainCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSwapchainCreateInfoKHR* forMarshaling)
-{
+void marshal_VkSwapchainCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSwapchainCreateInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkSwapchainCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkSwapchainCreateFlagsKHR));
+ vkStream->write((VkSwapchainCreateFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkSwapchainCreateFlagsKHR));
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
@@ -9494,35 +8628,36 @@
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pQueueFamilyIndices)
- {
- vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices, forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ if (forMarshaling->pQueueFamilyIndices) {
+ vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices,
+ forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
}
- vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->preTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
- vkStream->write((VkCompositeAlphaFlagBitsKHR*)&forMarshaling->compositeAlpha, sizeof(VkCompositeAlphaFlagBitsKHR));
+ vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->preTransform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->write((VkCompositeAlphaFlagBitsKHR*)&forMarshaling->compositeAlpha,
+ sizeof(VkCompositeAlphaFlagBitsKHR));
vkStream->write((VkPresentModeKHR*)&forMarshaling->presentMode, sizeof(VkPresentModeKHR));
vkStream->write((VkBool32*)&forMarshaling->clipped, sizeof(VkBool32));
uint64_t cgen_var_2;
- vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->oldSwapchain, &cgen_var_2, 1);
+ vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->oldSwapchain,
+ &cgen_var_2, 1);
vkStream->write((uint64_t*)&cgen_var_2, 1 * 8);
}
-void unmarshal_VkSwapchainCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSwapchainCreateInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkSwapchainCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSwapchainCreateInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkSwapchainCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkSwapchainCreateFlagsKHR));
+ vkStream->read((VkSwapchainCreateFlagsKHR*)&forUnmarshaling->flags,
+ sizeof(VkSwapchainCreateFlagsKHR));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_0, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkSurfaceKHR(
+ &cgen_var_0, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
vkStream->read((uint32_t*)&forUnmarshaling->minImageCount, sizeof(uint32_t));
vkStream->read((VkFormat*)&forUnmarshaling->imageFormat, sizeof(VkFormat));
vkStream->read((VkColorSpaceKHR*)&forUnmarshaling->imageColorSpace, sizeof(VkColorSpaceKHR));
@@ -9534,191 +8669,179 @@
// WARNING PTR CHECK
const uint32_t* check_pQueueFamilyIndices;
check_pQueueFamilyIndices = (const uint32_t*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pQueueFamilyIndices)
- {
- if (!(check_pQueueFamilyIndices))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pQueueFamilyIndices inconsistent between guest and host\n");
+ if (forUnmarshaling->pQueueFamilyIndices) {
+ if (!(check_pQueueFamilyIndices)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pQueueFamilyIndices inconsistent between guest and "
+ "host\n");
}
- vkStream->read((uint32_t*)forUnmarshaling->pQueueFamilyIndices, forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pQueueFamilyIndices,
+ forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
}
- vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->preTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
- vkStream->read((VkCompositeAlphaFlagBitsKHR*)&forUnmarshaling->compositeAlpha, sizeof(VkCompositeAlphaFlagBitsKHR));
+ vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->preTransform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->read((VkCompositeAlphaFlagBitsKHR*)&forUnmarshaling->compositeAlpha,
+ sizeof(VkCompositeAlphaFlagBitsKHR));
vkStream->read((VkPresentModeKHR*)&forUnmarshaling->presentMode, sizeof(VkPresentModeKHR));
vkStream->read((VkBool32*)&forUnmarshaling->clipped, sizeof(VkBool32));
uint64_t cgen_var_2;
vkStream->read((uint64_t*)&cgen_var_2, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_2, (VkSwapchainKHR*)&forUnmarshaling->oldSwapchain, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(
+ &cgen_var_2, (VkSwapchainKHR*)&forUnmarshaling->oldSwapchain, 1);
}
-void marshal_VkPresentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentInfoKHR* forMarshaling)
-{
+void marshal_VkPresentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
- if (forMarshaling->waitSemaphoreCount)
- {
+ if (forMarshaling->waitSemaphoreCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forMarshaling->waitSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pWaitSemaphores, cgen_var_0, forMarshaling->waitSemaphoreCount);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(
+ forMarshaling->pWaitSemaphores, cgen_var_0, forMarshaling->waitSemaphoreCount);
vkStream->write((uint64_t*)cgen_var_0, forMarshaling->waitSemaphoreCount * 8);
}
vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
- if (forMarshaling->swapchainCount)
- {
+ if (forMarshaling->swapchainCount) {
uint64_t* cgen_var_1;
vkStream->alloc((void**)&cgen_var_1, forMarshaling->swapchainCount * 8);
- vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(forMarshaling->pSwapchains, cgen_var_1, forMarshaling->swapchainCount);
+ vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(
+ forMarshaling->pSwapchains, cgen_var_1, forMarshaling->swapchainCount);
vkStream->write((uint64_t*)cgen_var_1, forMarshaling->swapchainCount * 8);
}
- vkStream->write((const uint32_t*)forMarshaling->pImageIndices, forMarshaling->swapchainCount * sizeof(const uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pImageIndices,
+ forMarshaling->swapchainCount * sizeof(const uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pResults;
vkStream->putBe64(cgen_var_2);
- if (forMarshaling->pResults)
- {
- vkStream->write((VkResult*)forMarshaling->pResults, forMarshaling->swapchainCount * sizeof(VkResult));
+ if (forMarshaling->pResults) {
+ vkStream->write((VkResult*)forMarshaling->pResults,
+ forMarshaling->swapchainCount * sizeof(VkResult));
}
}
-void unmarshal_VkPresentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPresentInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkPresentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPresentInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
- if (forUnmarshaling->waitSemaphoreCount)
- {
+ if (forUnmarshaling->waitSemaphoreCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->waitSemaphoreCount * 8);
vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->waitSemaphoreCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_0, (VkSemaphore*)forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
+ cgen_var_0, (VkSemaphore*)forUnmarshaling->pWaitSemaphores,
+ forUnmarshaling->waitSemaphoreCount);
}
vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
- if (forUnmarshaling->swapchainCount)
- {
+ if (forUnmarshaling->swapchainCount) {
uint64_t* cgen_var_1;
vkStream->alloc((void**)&cgen_var_1, forUnmarshaling->swapchainCount * 8);
vkStream->read((uint64_t*)cgen_var_1, forUnmarshaling->swapchainCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(cgen_var_1, (VkSwapchainKHR*)forUnmarshaling->pSwapchains, forUnmarshaling->swapchainCount);
+ vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(
+ cgen_var_1, (VkSwapchainKHR*)forUnmarshaling->pSwapchains,
+ forUnmarshaling->swapchainCount);
}
- vkStream->read((uint32_t*)forUnmarshaling->pImageIndices, forUnmarshaling->swapchainCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pImageIndices,
+ forUnmarshaling->swapchainCount * sizeof(const uint32_t));
// WARNING PTR CHECK
VkResult* check_pResults;
check_pResults = (VkResult*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pResults)
- {
- if (!(check_pResults))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pResults inconsistent between guest and host\n");
+ if (forUnmarshaling->pResults) {
+ if (!(check_pResults)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pResults inconsistent between guest and host\n");
}
- vkStream->read((VkResult*)forUnmarshaling->pResults, forUnmarshaling->swapchainCount * sizeof(VkResult));
+ vkStream->read((VkResult*)forUnmarshaling->pResults,
+ forUnmarshaling->swapchainCount * sizeof(VkResult));
}
}
-void marshal_VkImageSwapchainCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageSwapchainCreateInfoKHR* forMarshaling)
-{
+void marshal_VkImageSwapchainCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSwapchainCreateInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}
-void unmarshal_VkImageSwapchainCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageSwapchainCreateInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkImageSwapchainCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageSwapchainCreateInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_0, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(
+ &cgen_var_0, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
}
void marshal_VkBindImageMemorySwapchainInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindImageMemorySwapchainInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindImageMemorySwapchainInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->imageIndex, sizeof(uint32_t));
}
void unmarshal_VkBindImageMemorySwapchainInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBindImageMemorySwapchainInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBindImageMemorySwapchainInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_0, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(
+ &cgen_var_0, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
vkStream->read((uint32_t*)&forUnmarshaling->imageIndex, sizeof(uint32_t));
}
-void marshal_VkAcquireNextImageInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAcquireNextImageInfoKHR* forMarshaling)
-{
+void marshal_VkAcquireNextImageInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAcquireNextImageInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((uint64_t*)&forMarshaling->timeout, sizeof(uint64_t));
uint64_t cgen_var_1;
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_1, 1);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_1,
+ 1);
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
uint64_t cgen_var_2;
vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_2, 1);
@@ -9726,212 +8849,187 @@
vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
}
-void unmarshal_VkAcquireNextImageInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAcquireNextImageInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkAcquireNextImageInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAcquireNextImageInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_0, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(
+ &cgen_var_0, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
vkStream->read((uint64_t*)&forUnmarshaling->timeout, sizeof(uint64_t));
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_1, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
+ &cgen_var_1, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
uint64_t cgen_var_2;
vkStream->read((uint64_t*)&cgen_var_2, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_2, (VkFence*)&forUnmarshaling->fence, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_2,
+ (VkFence*)&forUnmarshaling->fence, 1);
vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
}
void marshal_VkDeviceGroupPresentCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupPresentCapabilitiesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupPresentCapabilitiesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((uint32_t*)forMarshaling->presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t));
- vkStream->write((VkDeviceGroupPresentModeFlagsKHR*)&forMarshaling->modes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+ vkStream->write((uint32_t*)forMarshaling->presentMask,
+ VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t));
+ vkStream->write((VkDeviceGroupPresentModeFlagsKHR*)&forMarshaling->modes,
+ sizeof(VkDeviceGroupPresentModeFlagsKHR));
}
void unmarshal_VkDeviceGroupPresentCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceGroupPresentCapabilitiesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceGroupPresentCapabilitiesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((uint32_t*)forUnmarshaling->presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t));
- vkStream->read((VkDeviceGroupPresentModeFlagsKHR*)&forUnmarshaling->modes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+ vkStream->read((uint32_t*)forUnmarshaling->presentMask,
+ VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t));
+ vkStream->read((VkDeviceGroupPresentModeFlagsKHR*)&forUnmarshaling->modes,
+ sizeof(VkDeviceGroupPresentModeFlagsKHR));
}
-void marshal_VkDeviceGroupPresentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupPresentInfoKHR* forMarshaling)
-{
+void marshal_VkDeviceGroupPresentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupPresentInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
- vkStream->write((const uint32_t*)forMarshaling->pDeviceMasks, forMarshaling->swapchainCount * sizeof(const uint32_t));
- vkStream->write((VkDeviceGroupPresentModeFlagBitsKHR*)&forMarshaling->mode, sizeof(VkDeviceGroupPresentModeFlagBitsKHR));
+ vkStream->write((const uint32_t*)forMarshaling->pDeviceMasks,
+ forMarshaling->swapchainCount * sizeof(const uint32_t));
+ vkStream->write((VkDeviceGroupPresentModeFlagBitsKHR*)&forMarshaling->mode,
+ sizeof(VkDeviceGroupPresentModeFlagBitsKHR));
}
-void unmarshal_VkDeviceGroupPresentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceGroupPresentInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkDeviceGroupPresentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceGroupPresentInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
- vkStream->read((uint32_t*)forUnmarshaling->pDeviceMasks, forUnmarshaling->swapchainCount * sizeof(const uint32_t));
- vkStream->read((VkDeviceGroupPresentModeFlagBitsKHR*)&forUnmarshaling->mode, sizeof(VkDeviceGroupPresentModeFlagBitsKHR));
+ vkStream->read((uint32_t*)forUnmarshaling->pDeviceMasks,
+ forUnmarshaling->swapchainCount * sizeof(const uint32_t));
+ vkStream->read((VkDeviceGroupPresentModeFlagBitsKHR*)&forUnmarshaling->mode,
+ sizeof(VkDeviceGroupPresentModeFlagBitsKHR));
}
void marshal_VkDeviceGroupSwapchainCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupSwapchainCreateInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupSwapchainCreateInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDeviceGroupPresentModeFlagsKHR*)&forMarshaling->modes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+ vkStream->write((VkDeviceGroupPresentModeFlagsKHR*)&forMarshaling->modes,
+ sizeof(VkDeviceGroupPresentModeFlagsKHR));
}
void unmarshal_VkDeviceGroupSwapchainCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceGroupSwapchainCreateInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceGroupSwapchainCreateInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDeviceGroupPresentModeFlagsKHR*)&forUnmarshaling->modes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+ vkStream->read((VkDeviceGroupPresentModeFlagsKHR*)&forUnmarshaling->modes,
+ sizeof(VkDeviceGroupPresentModeFlagsKHR));
}
#endif
#ifdef VK_KHR_display
-void marshal_VkDisplayModeParametersKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayModeParametersKHR* forMarshaling)
-{
+void marshal_VkDisplayModeParametersKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayModeParametersKHR* forMarshaling) {
(void)rootType;
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->visibleRegion));
vkStream->write((uint32_t*)&forMarshaling->refreshRate, sizeof(uint32_t));
}
-void unmarshal_VkDisplayModeParametersKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayModeParametersKHR* forUnmarshaling)
-{
+void unmarshal_VkDisplayModeParametersKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayModeParametersKHR* forUnmarshaling) {
(void)rootType;
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->visibleRegion));
vkStream->read((uint32_t*)&forUnmarshaling->refreshRate, sizeof(uint32_t));
}
-void marshal_VkDisplayModeCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayModeCreateInfoKHR* forMarshaling)
-{
+void marshal_VkDisplayModeCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayModeCreateInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDisplayModeCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkDisplayModeCreateFlagsKHR));
- marshal_VkDisplayModeParametersKHR(vkStream, rootType, (VkDisplayModeParametersKHR*)(&forMarshaling->parameters));
+ vkStream->write((VkDisplayModeCreateFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkDisplayModeCreateFlagsKHR));
+ marshal_VkDisplayModeParametersKHR(vkStream, rootType,
+ (VkDisplayModeParametersKHR*)(&forMarshaling->parameters));
}
-void unmarshal_VkDisplayModeCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayModeCreateInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkDisplayModeCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayModeCreateInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDisplayModeCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkDisplayModeCreateFlagsKHR));
- unmarshal_VkDisplayModeParametersKHR(vkStream, rootType, (VkDisplayModeParametersKHR*)(&forUnmarshaling->parameters));
+ vkStream->read((VkDisplayModeCreateFlagsKHR*)&forUnmarshaling->flags,
+ sizeof(VkDisplayModeCreateFlagsKHR));
+ unmarshal_VkDisplayModeParametersKHR(
+ vkStream, rootType, (VkDisplayModeParametersKHR*)(&forUnmarshaling->parameters));
}
-void marshal_VkDisplayModePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayModePropertiesKHR* forMarshaling)
-{
+void marshal_VkDisplayModePropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayModePropertiesKHR* forMarshaling) {
(void)rootType;
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode,
+ &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- marshal_VkDisplayModeParametersKHR(vkStream, rootType, (VkDisplayModeParametersKHR*)(&forMarshaling->parameters));
+ marshal_VkDisplayModeParametersKHR(vkStream, rootType,
+ (VkDisplayModeParametersKHR*)(&forMarshaling->parameters));
}
-void unmarshal_VkDisplayModePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayModePropertiesKHR* forUnmarshaling)
-{
+void unmarshal_VkDisplayModePropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayModePropertiesKHR* forUnmarshaling) {
(void)rootType;
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_0, (VkDisplayModeKHR*)&forUnmarshaling->displayMode, 1);
- unmarshal_VkDisplayModeParametersKHR(vkStream, rootType, (VkDisplayModeParametersKHR*)(&forUnmarshaling->parameters));
+ vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(
+ &cgen_var_0, (VkDisplayModeKHR*)&forUnmarshaling->displayMode, 1);
+ unmarshal_VkDisplayModeParametersKHR(
+ vkStream, rootType, (VkDisplayModeParametersKHR*)(&forUnmarshaling->parameters));
}
-void marshal_VkDisplayPlaneCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPlaneCapabilitiesKHR* forMarshaling)
-{
+void marshal_VkDisplayPlaneCapabilitiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPlaneCapabilitiesKHR* forMarshaling) {
(void)rootType;
- vkStream->write((VkDisplayPlaneAlphaFlagsKHR*)&forMarshaling->supportedAlpha, sizeof(VkDisplayPlaneAlphaFlagsKHR));
+ vkStream->write((VkDisplayPlaneAlphaFlagsKHR*)&forMarshaling->supportedAlpha,
+ sizeof(VkDisplayPlaneAlphaFlagsKHR));
marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->minSrcPosition));
marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->maxSrcPosition));
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minSrcExtent));
@@ -9942,13 +9040,11 @@
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxDstExtent));
}
-void unmarshal_VkDisplayPlaneCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayPlaneCapabilitiesKHR* forUnmarshaling)
-{
+void unmarshal_VkDisplayPlaneCapabilitiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayPlaneCapabilitiesKHR* forUnmarshaling) {
(void)rootType;
- vkStream->read((VkDisplayPlaneAlphaFlagsKHR*)&forUnmarshaling->supportedAlpha, sizeof(VkDisplayPlaneAlphaFlagsKHR));
+ vkStream->read((VkDisplayPlaneAlphaFlagsKHR*)&forUnmarshaling->supportedAlpha,
+ sizeof(VkDisplayPlaneAlphaFlagsKHR));
unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->minSrcPosition));
unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->maxSrcPosition));
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->minSrcExtent));
@@ -9959,35 +9055,28 @@
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxDstExtent));
}
-void marshal_VkDisplayPlanePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPlanePropertiesKHR* forMarshaling)
-{
+void marshal_VkDisplayPlanePropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPlanePropertiesKHR* forMarshaling) {
(void)rootType;
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&forMarshaling->currentDisplay, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&forMarshaling->currentDisplay,
+ &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->currentStackIndex, sizeof(uint32_t));
}
-void unmarshal_VkDisplayPlanePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayPlanePropertiesKHR* forUnmarshaling)
-{
+void unmarshal_VkDisplayPlanePropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayPlanePropertiesKHR* forUnmarshaling) {
(void)rootType;
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_0, (VkDisplayKHR*)&forUnmarshaling->currentDisplay, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkDisplayKHR(
+ &cgen_var_0, (VkDisplayKHR*)&forUnmarshaling->currentDisplay, 1);
vkStream->read((uint32_t*)&forUnmarshaling->currentStackIndex, sizeof(uint32_t));
}
-void marshal_VkDisplayPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPropertiesKHR* forMarshaling)
-{
+void marshal_VkDisplayPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPropertiesKHR* forMarshaling) {
(void)rootType;
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&forMarshaling->display, &cgen_var_0, 1);
@@ -9995,87 +9084,83 @@
vkStream->putString(forMarshaling->displayName);
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->physicalDimensions));
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->physicalResolution));
- vkStream->write((VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
+ vkStream->write((VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms,
+ sizeof(VkSurfaceTransformFlagsKHR));
vkStream->write((VkBool32*)&forMarshaling->planeReorderPossible, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->persistentContent, sizeof(VkBool32));
}
-void unmarshal_VkDisplayPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayPropertiesKHR* forUnmarshaling)
-{
+void unmarshal_VkDisplayPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayPropertiesKHR* forUnmarshaling) {
(void)rootType;
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_0, (VkDisplayKHR*)&forUnmarshaling->display, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkDisplayKHR(
+ &cgen_var_0, (VkDisplayKHR*)&forUnmarshaling->display, 1);
vkStream->loadStringInPlace((char**)&forUnmarshaling->displayName);
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->physicalDimensions));
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->physicalResolution));
- vkStream->read((VkSurfaceTransformFlagsKHR*)&forUnmarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
+ vkStream->read((VkSurfaceTransformFlagsKHR*)&forUnmarshaling->supportedTransforms,
+ sizeof(VkSurfaceTransformFlagsKHR));
vkStream->read((VkBool32*)&forUnmarshaling->planeReorderPossible, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->persistentContent, sizeof(VkBool32));
}
-void marshal_VkDisplaySurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplaySurfaceCreateInfoKHR* forMarshaling)
-{
+void marshal_VkDisplaySurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplaySurfaceCreateInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDisplaySurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkDisplaySurfaceCreateFlagsKHR));
+ vkStream->write((VkDisplaySurfaceCreateFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkDisplaySurfaceCreateFlagsKHR));
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode,
+ &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->planeIndex, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->planeStackIndex, sizeof(uint32_t));
- vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
vkStream->write((float*)&forMarshaling->globalAlpha, sizeof(float));
- vkStream->write((VkDisplayPlaneAlphaFlagBitsKHR*)&forMarshaling->alphaMode, sizeof(VkDisplayPlaneAlphaFlagBitsKHR));
+ vkStream->write((VkDisplayPlaneAlphaFlagBitsKHR*)&forMarshaling->alphaMode,
+ sizeof(VkDisplayPlaneAlphaFlagBitsKHR));
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->imageExtent));
}
-void unmarshal_VkDisplaySurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplaySurfaceCreateInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkDisplaySurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplaySurfaceCreateInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDisplaySurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkDisplaySurfaceCreateFlagsKHR));
+ vkStream->read((VkDisplaySurfaceCreateFlagsKHR*)&forUnmarshaling->flags,
+ sizeof(VkDisplaySurfaceCreateFlagsKHR));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_0, (VkDisplayModeKHR*)&forUnmarshaling->displayMode, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(
+ &cgen_var_0, (VkDisplayModeKHR*)&forUnmarshaling->displayMode, 1);
vkStream->read((uint32_t*)&forUnmarshaling->planeIndex, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->planeStackIndex, sizeof(uint32_t));
- vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->transform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
vkStream->read((float*)&forUnmarshaling->globalAlpha, sizeof(float));
- vkStream->read((VkDisplayPlaneAlphaFlagBitsKHR*)&forUnmarshaling->alphaMode, sizeof(VkDisplayPlaneAlphaFlagBitsKHR));
+ vkStream->read((VkDisplayPlaneAlphaFlagBitsKHR*)&forUnmarshaling->alphaMode,
+ sizeof(VkDisplayPlaneAlphaFlagBitsKHR));
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->imageExtent));
}
#endif
#ifdef VK_KHR_display_swapchain
-void marshal_VkDisplayPresentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPresentInfoKHR* forMarshaling)
-{
+void marshal_VkDisplayPresentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPresentInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -10084,15 +9169,11 @@
vkStream->write((VkBool32*)&forMarshaling->persistent, sizeof(VkBool32));
}
-void unmarshal_VkDisplayPresentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayPresentInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkDisplayPresentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayPresentInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -10103,49 +9184,40 @@
#endif
#ifdef VK_KHR_xlib_surface
-void marshal_VkXlibSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkXlibSurfaceCreateInfoKHR* forMarshaling)
-{
+void marshal_VkXlibSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkXlibSurfaceCreateInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkXlibSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkXlibSurfaceCreateFlagsKHR));
+ vkStream->write((VkXlibSurfaceCreateFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkXlibSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->dpy;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->dpy)
- {
+ if (forMarshaling->dpy) {
vkStream->write((Display*)forMarshaling->dpy, sizeof(Display));
}
vkStream->write((Window*)&forMarshaling->window, sizeof(Window));
}
-void unmarshal_VkXlibSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkXlibSurfaceCreateInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkXlibSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkXlibSurfaceCreateInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkXlibSurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkXlibSurfaceCreateFlagsKHR));
+ vkStream->read((VkXlibSurfaceCreateFlagsKHR*)&forUnmarshaling->flags,
+ sizeof(VkXlibSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
Display* check_dpy;
check_dpy = (Display*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->dpy)
- {
- if (!(check_dpy))
- {
+ if (forUnmarshaling->dpy) {
+ if (!(check_dpy)) {
fprintf(stderr, "fatal: forUnmarshaling->dpy inconsistent between guest and host\n");
}
vkStream->read((Display*)forUnmarshaling->dpy, sizeof(Display));
@@ -10155,93 +9227,75 @@
#endif
#ifdef VK_KHR_xcb_surface
-void marshal_VkXcbSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkXcbSurfaceCreateInfoKHR* forMarshaling)
-{
+void marshal_VkXcbSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkXcbSurfaceCreateInfoKHR* forMarshaling) {
(void)rootType;
-
+
// This struct should never be marshaled / unmarshaled.
__builtin_trap();
-
}
-void unmarshal_VkXcbSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkXcbSurfaceCreateInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkXcbSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkXcbSurfaceCreateInfoKHR* forUnmarshaling) {
(void)rootType;
-
+
// This struct should never be marshaled / unmarshaled.
__builtin_trap();
-
}
#endif
#ifdef VK_KHR_wayland_surface
-void marshal_VkWaylandSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWaylandSurfaceCreateInfoKHR* forMarshaling)
-{
+void marshal_VkWaylandSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWaylandSurfaceCreateInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkWaylandSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkWaylandSurfaceCreateFlagsKHR));
+ vkStream->write((VkWaylandSurfaceCreateFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkWaylandSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->display;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->display)
- {
+ if (forMarshaling->display) {
vkStream->write((wl_display*)forMarshaling->display, sizeof(wl_display));
}
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->surface;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->surface)
- {
+ if (forMarshaling->surface) {
vkStream->write((wl_surface*)forMarshaling->surface, sizeof(wl_surface));
}
}
-void unmarshal_VkWaylandSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkWaylandSurfaceCreateInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkWaylandSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkWaylandSurfaceCreateInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkWaylandSurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkWaylandSurfaceCreateFlagsKHR));
+ vkStream->read((VkWaylandSurfaceCreateFlagsKHR*)&forUnmarshaling->flags,
+ sizeof(VkWaylandSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
wl_display* check_display;
check_display = (wl_display*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->display)
- {
- if (!(check_display))
- {
- fprintf(stderr, "fatal: forUnmarshaling->display inconsistent between guest and host\n");
+ if (forUnmarshaling->display) {
+ if (!(check_display)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->display inconsistent between guest and host\n");
}
vkStream->read((wl_display*)forUnmarshaling->display, sizeof(wl_display));
}
// WARNING PTR CHECK
wl_surface* check_surface;
check_surface = (wl_surface*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->surface)
- {
- if (!(check_surface))
- {
- fprintf(stderr, "fatal: forUnmarshaling->surface inconsistent between guest and host\n");
+ if (forUnmarshaling->surface) {
+ if (!(check_surface)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->surface inconsistent between guest and host\n");
}
vkStream->read((wl_surface*)forUnmarshaling->surface, sizeof(wl_surface));
}
@@ -10249,48 +9303,39 @@
#endif
#ifdef VK_KHR_android_surface
-void marshal_VkAndroidSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAndroidSurfaceCreateInfoKHR* forMarshaling)
-{
+void marshal_VkAndroidSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAndroidSurfaceCreateInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkAndroidSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkAndroidSurfaceCreateFlagsKHR));
+ vkStream->write((VkAndroidSurfaceCreateFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkAndroidSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->window;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->window)
- {
+ if (forMarshaling->window) {
vkStream->write((ANativeWindow*)forMarshaling->window, sizeof(ANativeWindow));
}
}
-void unmarshal_VkAndroidSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAndroidSurfaceCreateInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkAndroidSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAndroidSurfaceCreateInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkAndroidSurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkAndroidSurfaceCreateFlagsKHR));
+ vkStream->read((VkAndroidSurfaceCreateFlagsKHR*)&forUnmarshaling->flags,
+ sizeof(VkAndroidSurfaceCreateFlagsKHR));
// WARNING PTR CHECK
ANativeWindow* check_window;
check_window = (ANativeWindow*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->window)
- {
- if (!(check_window))
- {
+ if (forUnmarshaling->window) {
+ if (!(check_window)) {
fprintf(stderr, "fatal: forUnmarshaling->window inconsistent between guest and host\n");
}
vkStream->read((ANativeWindow*)forUnmarshaling->window, sizeof(ANativeWindow));
@@ -10299,36 +9344,30 @@
#endif
#ifdef VK_KHR_win32_surface
-void marshal_VkWin32SurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWin32SurfaceCreateInfoKHR* forMarshaling)
-{
+void marshal_VkWin32SurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWin32SurfaceCreateInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkWin32SurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkWin32SurfaceCreateFlagsKHR));
+ vkStream->write((VkWin32SurfaceCreateFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkWin32SurfaceCreateFlagsKHR));
vkStream->write((HINSTANCE*)&forMarshaling->hinstance, sizeof(HINSTANCE));
vkStream->write((HWND*)&forMarshaling->hwnd, sizeof(HWND));
}
-void unmarshal_VkWin32SurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkWin32SurfaceCreateInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkWin32SurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkWin32SurfaceCreateInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkWin32SurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkWin32SurfaceCreateFlagsKHR));
+ vkStream->read((VkWin32SurfaceCreateFlagsKHR*)&forUnmarshaling->flags,
+ sizeof(VkWin32SurfaceCreateFlagsKHR));
vkStream->read((HINSTANCE*)&forUnmarshaling->hinstance, sizeof(HINSTANCE));
vkStream->read((HWND*)&forUnmarshaling->hwnd, sizeof(HWND));
}
@@ -10338,141 +9377,131 @@
#endif
#ifdef VK_KHR_video_queue
void marshal_VkVideoQueueFamilyProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoQueueFamilyProperties2KHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoQueueFamilyProperties2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkVideoCodecOperationFlagsKHR*)&forMarshaling->videoCodecOperations, sizeof(VkVideoCodecOperationFlagsKHR));
+ vkStream->write((VkVideoCodecOperationFlagsKHR*)&forMarshaling->videoCodecOperations,
+ sizeof(VkVideoCodecOperationFlagsKHR));
}
-void unmarshal_VkVideoQueueFamilyProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoQueueFamilyProperties2KHR* forUnmarshaling)
-{
+void unmarshal_VkVideoQueueFamilyProperties2KHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoQueueFamilyProperties2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkVideoCodecOperationFlagsKHR*)&forUnmarshaling->videoCodecOperations, sizeof(VkVideoCodecOperationFlagsKHR));
+ vkStream->read((VkVideoCodecOperationFlagsKHR*)&forUnmarshaling->videoCodecOperations,
+ sizeof(VkVideoCodecOperationFlagsKHR));
}
-void marshal_VkVideoProfileKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoProfileKHR* forMarshaling)
-{
+void marshal_VkVideoProfileKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoProfileKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkVideoCodecOperationFlagBitsKHR*)&forMarshaling->videoCodecOperation, sizeof(VkVideoCodecOperationFlagBitsKHR));
- vkStream->write((VkVideoChromaSubsamplingFlagsKHR*)&forMarshaling->chromaSubsampling, sizeof(VkVideoChromaSubsamplingFlagsKHR));
- vkStream->write((VkVideoComponentBitDepthFlagsKHR*)&forMarshaling->lumaBitDepth, sizeof(VkVideoComponentBitDepthFlagsKHR));
- vkStream->write((VkVideoComponentBitDepthFlagsKHR*)&forMarshaling->chromaBitDepth, sizeof(VkVideoComponentBitDepthFlagsKHR));
+ vkStream->write((VkVideoCodecOperationFlagBitsKHR*)&forMarshaling->videoCodecOperation,
+ sizeof(VkVideoCodecOperationFlagBitsKHR));
+ vkStream->write((VkVideoChromaSubsamplingFlagsKHR*)&forMarshaling->chromaSubsampling,
+ sizeof(VkVideoChromaSubsamplingFlagsKHR));
+ vkStream->write((VkVideoComponentBitDepthFlagsKHR*)&forMarshaling->lumaBitDepth,
+ sizeof(VkVideoComponentBitDepthFlagsKHR));
+ vkStream->write((VkVideoComponentBitDepthFlagsKHR*)&forMarshaling->chromaBitDepth,
+ sizeof(VkVideoComponentBitDepthFlagsKHR));
}
-void unmarshal_VkVideoProfileKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoProfileKHR* forUnmarshaling)
-{
+void unmarshal_VkVideoProfileKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoProfileKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkVideoCodecOperationFlagBitsKHR*)&forUnmarshaling->videoCodecOperation, sizeof(VkVideoCodecOperationFlagBitsKHR));
- vkStream->read((VkVideoChromaSubsamplingFlagsKHR*)&forUnmarshaling->chromaSubsampling, sizeof(VkVideoChromaSubsamplingFlagsKHR));
- vkStream->read((VkVideoComponentBitDepthFlagsKHR*)&forUnmarshaling->lumaBitDepth, sizeof(VkVideoComponentBitDepthFlagsKHR));
- vkStream->read((VkVideoComponentBitDepthFlagsKHR*)&forUnmarshaling->chromaBitDepth, sizeof(VkVideoComponentBitDepthFlagsKHR));
+ vkStream->read((VkVideoCodecOperationFlagBitsKHR*)&forUnmarshaling->videoCodecOperation,
+ sizeof(VkVideoCodecOperationFlagBitsKHR));
+ vkStream->read((VkVideoChromaSubsamplingFlagsKHR*)&forUnmarshaling->chromaSubsampling,
+ sizeof(VkVideoChromaSubsamplingFlagsKHR));
+ vkStream->read((VkVideoComponentBitDepthFlagsKHR*)&forUnmarshaling->lumaBitDepth,
+ sizeof(VkVideoComponentBitDepthFlagsKHR));
+ vkStream->read((VkVideoComponentBitDepthFlagsKHR*)&forUnmarshaling->chromaBitDepth,
+ sizeof(VkVideoComponentBitDepthFlagsKHR));
}
-void marshal_VkVideoProfilesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoProfilesKHR* forMarshaling)
-{
+void marshal_VkVideoProfilesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoProfilesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->profileCount, sizeof(uint32_t));
- marshal_VkVideoProfileKHR(vkStream, rootType, (const VkVideoProfileKHR*)(forMarshaling->pProfiles));
+ marshal_VkVideoProfileKHR(vkStream, rootType,
+ (const VkVideoProfileKHR*)(forMarshaling->pProfiles));
}
-void unmarshal_VkVideoProfilesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoProfilesKHR* forUnmarshaling)
-{
+void unmarshal_VkVideoProfilesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoProfilesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->profileCount, sizeof(uint32_t));
- unmarshal_VkVideoProfileKHR(vkStream, rootType, (VkVideoProfileKHR*)(forUnmarshaling->pProfiles));
+ unmarshal_VkVideoProfileKHR(vkStream, rootType,
+ (VkVideoProfileKHR*)(forUnmarshaling->pProfiles));
}
-void marshal_VkVideoCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoCapabilitiesKHR* forMarshaling)
-{
+void marshal_VkVideoCapabilitiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoCapabilitiesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkVideoCapabilityFlagsKHR*)&forMarshaling->capabilityFlags, sizeof(VkVideoCapabilityFlagsKHR));
- vkStream->write((VkDeviceSize*)&forMarshaling->minBitstreamBufferOffsetAlignment, sizeof(VkDeviceSize));
- vkStream->write((VkDeviceSize*)&forMarshaling->minBitstreamBufferSizeAlignment, sizeof(VkDeviceSize));
- marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->videoPictureExtentGranularity));
+ vkStream->write((VkVideoCapabilityFlagsKHR*)&forMarshaling->capabilityFlags,
+ sizeof(VkVideoCapabilityFlagsKHR));
+ vkStream->write((VkDeviceSize*)&forMarshaling->minBitstreamBufferOffsetAlignment,
+ sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->minBitstreamBufferSizeAlignment,
+ sizeof(VkDeviceSize));
+ marshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->videoPictureExtentGranularity));
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minExtent));
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxExtent));
vkStream->write((uint32_t*)&forMarshaling->maxReferencePicturesSlotsCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxReferencePicturesActiveCount, sizeof(uint32_t));
}
-void unmarshal_VkVideoCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoCapabilitiesKHR* forUnmarshaling)
-{
+void unmarshal_VkVideoCapabilitiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoCapabilitiesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkVideoCapabilityFlagsKHR*)&forUnmarshaling->capabilityFlags, sizeof(VkVideoCapabilityFlagsKHR));
- vkStream->read((VkDeviceSize*)&forUnmarshaling->minBitstreamBufferOffsetAlignment, sizeof(VkDeviceSize));
- vkStream->read((VkDeviceSize*)&forUnmarshaling->minBitstreamBufferSizeAlignment, sizeof(VkDeviceSize));
- unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->videoPictureExtentGranularity));
+ vkStream->read((VkVideoCapabilityFlagsKHR*)&forUnmarshaling->capabilityFlags,
+ sizeof(VkVideoCapabilityFlagsKHR));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->minBitstreamBufferOffsetAlignment,
+ sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->minBitstreamBufferSizeAlignment,
+ sizeof(VkDeviceSize));
+ unmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forUnmarshaling->videoPictureExtentGranularity));
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->minExtent));
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxExtent));
vkStream->read((uint32_t*)&forUnmarshaling->maxReferencePicturesSlotsCount, sizeof(uint32_t));
@@ -10480,76 +9509,60 @@
}
void marshal_VkPhysicalDeviceVideoFormatInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVideoFormatInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVideoFormatInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkImageUsageFlags*)&forMarshaling->imageUsage, sizeof(VkImageUsageFlags));
- marshal_VkVideoProfilesKHR(vkStream, rootType, (const VkVideoProfilesKHR*)(forMarshaling->pVideoProfiles));
+ marshal_VkVideoProfilesKHR(vkStream, rootType,
+ (const VkVideoProfilesKHR*)(forMarshaling->pVideoProfiles));
}
void unmarshal_VkPhysicalDeviceVideoFormatInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceVideoFormatInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceVideoFormatInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkImageUsageFlags*)&forUnmarshaling->imageUsage, sizeof(VkImageUsageFlags));
- unmarshal_VkVideoProfilesKHR(vkStream, rootType, (VkVideoProfilesKHR*)(forUnmarshaling->pVideoProfiles));
+ unmarshal_VkVideoProfilesKHR(vkStream, rootType,
+ (VkVideoProfilesKHR*)(forUnmarshaling->pVideoProfiles));
}
-void marshal_VkVideoFormatPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoFormatPropertiesKHR* forMarshaling)
-{
+void marshal_VkVideoFormatPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoFormatPropertiesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
}
-void unmarshal_VkVideoFormatPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoFormatPropertiesKHR* forUnmarshaling)
-{
+void unmarshal_VkVideoFormatPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoFormatPropertiesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
}
-void marshal_VkVideoPictureResourceKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoPictureResourceKHR* forMarshaling)
-{
+void marshal_VkVideoPictureResourceKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoPictureResourceKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -10557,19 +9570,16 @@
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->codedExtent));
vkStream->write((uint32_t*)&forMarshaling->baseArrayLayer, sizeof(uint32_t));
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageViewBinding, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageViewBinding,
+ &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}
-void unmarshal_VkVideoPictureResourceKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoPictureResourceKHR* forUnmarshaling)
-{
+void unmarshal_VkVideoPictureResourceKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoPictureResourceKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -10578,128 +9588,109 @@
vkStream->read((uint32_t*)&forUnmarshaling->baseArrayLayer, sizeof(uint32_t));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_0, (VkImageView*)&forUnmarshaling->imageViewBinding, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImageView(
+ &cgen_var_0, (VkImageView*)&forUnmarshaling->imageViewBinding, 1);
}
-void marshal_VkVideoReferenceSlotKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoReferenceSlotKHR* forMarshaling)
-{
+void marshal_VkVideoReferenceSlotKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoReferenceSlotKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((int8_t*)&forMarshaling->slotIndex, sizeof(int8_t));
- marshal_VkVideoPictureResourceKHR(vkStream, rootType, (const VkVideoPictureResourceKHR*)(forMarshaling->pPictureResource));
+ marshal_VkVideoPictureResourceKHR(
+ vkStream, rootType, (const VkVideoPictureResourceKHR*)(forMarshaling->pPictureResource));
}
-void unmarshal_VkVideoReferenceSlotKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoReferenceSlotKHR* forUnmarshaling)
-{
+void unmarshal_VkVideoReferenceSlotKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoReferenceSlotKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((int8_t*)&forUnmarshaling->slotIndex, sizeof(int8_t));
- unmarshal_VkVideoPictureResourceKHR(vkStream, rootType, (VkVideoPictureResourceKHR*)(forUnmarshaling->pPictureResource));
+ unmarshal_VkVideoPictureResourceKHR(
+ vkStream, rootType, (VkVideoPictureResourceKHR*)(forUnmarshaling->pPictureResource));
}
-void marshal_VkVideoGetMemoryPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoGetMemoryPropertiesKHR* forMarshaling)
-{
+void marshal_VkVideoGetMemoryPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoGetMemoryPropertiesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->memoryBindIndex, sizeof(uint32_t));
- marshal_VkMemoryRequirements2(vkStream, rootType, (VkMemoryRequirements2*)(forMarshaling->pMemoryRequirements));
+ marshal_VkMemoryRequirements2(vkStream, rootType,
+ (VkMemoryRequirements2*)(forMarshaling->pMemoryRequirements));
}
-void unmarshal_VkVideoGetMemoryPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoGetMemoryPropertiesKHR* forUnmarshaling)
-{
+void unmarshal_VkVideoGetMemoryPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoGetMemoryPropertiesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->memoryBindIndex, sizeof(uint32_t));
- unmarshal_VkMemoryRequirements2(vkStream, rootType, (VkMemoryRequirements2*)(forUnmarshaling->pMemoryRequirements));
+ unmarshal_VkMemoryRequirements2(vkStream, rootType,
+ (VkMemoryRequirements2*)(forUnmarshaling->pMemoryRequirements));
}
-void marshal_VkVideoBindMemoryKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoBindMemoryKHR* forMarshaling)
-{
+void marshal_VkVideoBindMemoryKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoBindMemoryKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->memoryBindIndex, sizeof(uint32_t));
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->memorySize, sizeof(VkDeviceSize));
}
-void unmarshal_VkVideoBindMemoryKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoBindMemoryKHR* forUnmarshaling)
-{
+void unmarshal_VkVideoBindMemoryKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoBindMemoryKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->memoryBindIndex, sizeof(uint32_t));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+ &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->memorySize, sizeof(VkDeviceSize));
}
-void marshal_VkVideoSessionCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoSessionCreateInfoKHR* forMarshaling)
-{
+void marshal_VkVideoSessionCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoSessionCreateInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
- vkStream->write((VkVideoSessionCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkVideoSessionCreateFlagsKHR));
- marshal_VkVideoProfileKHR(vkStream, rootType, (const VkVideoProfileKHR*)(forMarshaling->pVideoProfile));
+ vkStream->write((VkVideoSessionCreateFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkVideoSessionCreateFlagsKHR));
+ marshal_VkVideoProfileKHR(vkStream, rootType,
+ (const VkVideoProfileKHR*)(forMarshaling->pVideoProfile));
vkStream->write((VkFormat*)&forMarshaling->pictureFormat, sizeof(VkFormat));
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxCodedExtent));
vkStream->write((VkFormat*)&forMarshaling->referencePicturesFormat, sizeof(VkFormat));
@@ -10707,21 +9698,19 @@
vkStream->write((uint32_t*)&forMarshaling->maxReferencePicturesActiveCount, sizeof(uint32_t));
}
-void unmarshal_VkVideoSessionCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoSessionCreateInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkVideoSessionCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoSessionCreateInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndex, sizeof(uint32_t));
- vkStream->read((VkVideoSessionCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkVideoSessionCreateFlagsKHR));
- unmarshal_VkVideoProfileKHR(vkStream, rootType, (VkVideoProfileKHR*)(forUnmarshaling->pVideoProfile));
+ vkStream->read((VkVideoSessionCreateFlagsKHR*)&forUnmarshaling->flags,
+ sizeof(VkVideoSessionCreateFlagsKHR));
+ unmarshal_VkVideoProfileKHR(vkStream, rootType,
+ (VkVideoProfileKHR*)(forUnmarshaling->pVideoProfile));
vkStream->read((VkFormat*)&forUnmarshaling->pictureFormat, sizeof(VkFormat));
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxCodedExtent));
vkStream->read((VkFormat*)&forUnmarshaling->referencePicturesFormat, sizeof(VkFormat));
@@ -10730,14 +9719,11 @@
}
void marshal_VkVideoSessionParametersCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoSessionParametersCreateInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoSessionParametersCreateInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -10748,30 +9734,25 @@
}
void unmarshal_VkVideoSessionParametersCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoSessionParametersCreateInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoSessionParametersCreateInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- forUnmarshaling->videoSessionParametersTemplate = (VkVideoSessionParametersKHR)vkStream->getBe64();
+ forUnmarshaling->videoSessionParametersTemplate =
+ (VkVideoSessionParametersKHR)vkStream->getBe64();
forUnmarshaling->videoSession = (VkVideoSessionKHR)vkStream->getBe64();
}
void marshal_VkVideoSessionParametersUpdateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoSessionParametersUpdateInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoSessionParametersUpdateInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -10779,145 +9760,122 @@
}
void unmarshal_VkVideoSessionParametersUpdateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoSessionParametersUpdateInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoSessionParametersUpdateInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->updateSequenceCount, sizeof(uint32_t));
}
-void marshal_VkVideoBeginCodingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoBeginCodingInfoKHR* forMarshaling)
-{
+void marshal_VkVideoBeginCodingInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoBeginCodingInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkVideoBeginCodingFlagsKHR*)&forMarshaling->flags, sizeof(VkVideoBeginCodingFlagsKHR));
- vkStream->write((VkVideoCodingQualityPresetFlagsKHR*)&forMarshaling->codecQualityPreset, sizeof(VkVideoCodingQualityPresetFlagsKHR));
+ vkStream->write((VkVideoBeginCodingFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkVideoBeginCodingFlagsKHR));
+ vkStream->write((VkVideoCodingQualityPresetFlagsKHR*)&forMarshaling->codecQualityPreset,
+ sizeof(VkVideoCodingQualityPresetFlagsKHR));
uint64_t cgen_var_0 = (uint64_t)forMarshaling->videoSession;
vkStream->putBe64(cgen_var_0);
uint64_t cgen_var_1 = (uint64_t)forMarshaling->videoSessionParameters;
vkStream->putBe64(cgen_var_1);
vkStream->write((uint32_t*)&forMarshaling->referenceSlotCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i)
- {
- marshal_VkVideoReferenceSlotKHR(vkStream, rootType, (const VkVideoReferenceSlotKHR*)(forMarshaling->pReferenceSlots + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i) {
+ marshal_VkVideoReferenceSlotKHR(
+ vkStream, rootType,
+ (const VkVideoReferenceSlotKHR*)(forMarshaling->pReferenceSlots + i));
}
}
}
-void unmarshal_VkVideoBeginCodingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoBeginCodingInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkVideoBeginCodingInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoBeginCodingInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkVideoBeginCodingFlagsKHR*)&forUnmarshaling->flags, sizeof(VkVideoBeginCodingFlagsKHR));
- vkStream->read((VkVideoCodingQualityPresetFlagsKHR*)&forUnmarshaling->codecQualityPreset, sizeof(VkVideoCodingQualityPresetFlagsKHR));
+ vkStream->read((VkVideoBeginCodingFlagsKHR*)&forUnmarshaling->flags,
+ sizeof(VkVideoBeginCodingFlagsKHR));
+ vkStream->read((VkVideoCodingQualityPresetFlagsKHR*)&forUnmarshaling->codecQualityPreset,
+ sizeof(VkVideoCodingQualityPresetFlagsKHR));
forUnmarshaling->videoSession = (VkVideoSessionKHR)vkStream->getBe64();
forUnmarshaling->videoSessionParameters = (VkVideoSessionParametersKHR)vkStream->getBe64();
vkStream->read((uint32_t*)&forUnmarshaling->referenceSlotCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceSlotCount; ++i)
- {
- unmarshal_VkVideoReferenceSlotKHR(vkStream, rootType, (VkVideoReferenceSlotKHR*)(forUnmarshaling->pReferenceSlots + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceSlotCount; ++i) {
+ unmarshal_VkVideoReferenceSlotKHR(
+ vkStream, rootType,
+ (VkVideoReferenceSlotKHR*)(forUnmarshaling->pReferenceSlots + i));
}
}
}
-void marshal_VkVideoEndCodingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEndCodingInfoKHR* forMarshaling)
-{
+void marshal_VkVideoEndCodingInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEndCodingInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkVideoEndCodingFlagsKHR*)&forMarshaling->flags, sizeof(VkVideoEndCodingFlagsKHR));
+ vkStream->write((VkVideoEndCodingFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkVideoEndCodingFlagsKHR));
}
-void unmarshal_VkVideoEndCodingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEndCodingInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkVideoEndCodingInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEndCodingInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkVideoEndCodingFlagsKHR*)&forUnmarshaling->flags, sizeof(VkVideoEndCodingFlagsKHR));
+ vkStream->read((VkVideoEndCodingFlagsKHR*)&forUnmarshaling->flags,
+ sizeof(VkVideoEndCodingFlagsKHR));
}
-void marshal_VkVideoCodingControlInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoCodingControlInfoKHR* forMarshaling)
-{
+void marshal_VkVideoCodingControlInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoCodingControlInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkVideoCodingControlFlagsKHR*)&forMarshaling->flags, sizeof(VkVideoCodingControlFlagsKHR));
+ vkStream->write((VkVideoCodingControlFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkVideoCodingControlFlagsKHR));
}
-void unmarshal_VkVideoCodingControlInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoCodingControlInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkVideoCodingControlInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoCodingControlInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkVideoCodingControlFlagsKHR*)&forUnmarshaling->flags, sizeof(VkVideoCodingControlFlagsKHR));
+ vkStream->read((VkVideoCodingControlFlagsKHR*)&forUnmarshaling->flags,
+ sizeof(VkVideoCodingControlFlagsKHR));
}
#endif
#ifdef VK_KHR_video_decode_queue
-void marshal_VkVideoDecodeInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeInfoKHR* forMarshaling)
-{
+void marshal_VkVideoDecodeInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -10929,27 +9887,25 @@
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->srcBufferOffset, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->srcBufferRange, sizeof(VkDeviceSize));
- marshal_VkVideoPictureResourceKHR(vkStream, rootType, (VkVideoPictureResourceKHR*)(&forMarshaling->dstPictureResource));
- marshal_VkVideoReferenceSlotKHR(vkStream, rootType, (const VkVideoReferenceSlotKHR*)(forMarshaling->pSetupReferenceSlot));
+ marshal_VkVideoPictureResourceKHR(
+ vkStream, rootType, (VkVideoPictureResourceKHR*)(&forMarshaling->dstPictureResource));
+ marshal_VkVideoReferenceSlotKHR(
+ vkStream, rootType, (const VkVideoReferenceSlotKHR*)(forMarshaling->pSetupReferenceSlot));
vkStream->write((uint32_t*)&forMarshaling->referenceSlotCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i)
- {
- marshal_VkVideoReferenceSlotKHR(vkStream, rootType, (const VkVideoReferenceSlotKHR*)(forMarshaling->pReferenceSlots + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i) {
+ marshal_VkVideoReferenceSlotKHR(
+ vkStream, rootType,
+ (const VkVideoReferenceSlotKHR*)(forMarshaling->pReferenceSlots + i));
}
}
}
-void unmarshal_VkVideoDecodeInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkVideoDecodeInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoDecodeInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -10958,42 +9914,44 @@
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->codedExtent));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0, (VkBuffer*)&forUnmarshaling->srcBuffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+ (VkBuffer*)&forUnmarshaling->srcBuffer, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->srcBufferOffset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->srcBufferRange, sizeof(VkDeviceSize));
- unmarshal_VkVideoPictureResourceKHR(vkStream, rootType, (VkVideoPictureResourceKHR*)(&forUnmarshaling->dstPictureResource));
- unmarshal_VkVideoReferenceSlotKHR(vkStream, rootType, (VkVideoReferenceSlotKHR*)(forUnmarshaling->pSetupReferenceSlot));
+ unmarshal_VkVideoPictureResourceKHR(
+ vkStream, rootType, (VkVideoPictureResourceKHR*)(&forUnmarshaling->dstPictureResource));
+ unmarshal_VkVideoReferenceSlotKHR(
+ vkStream, rootType, (VkVideoReferenceSlotKHR*)(forUnmarshaling->pSetupReferenceSlot));
vkStream->read((uint32_t*)&forUnmarshaling->referenceSlotCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceSlotCount; ++i)
- {
- unmarshal_VkVideoReferenceSlotKHR(vkStream, rootType, (VkVideoReferenceSlotKHR*)(forUnmarshaling->pReferenceSlots + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceSlotCount; ++i) {
+ unmarshal_VkVideoReferenceSlotKHR(
+ vkStream, rootType,
+ (VkVideoReferenceSlotKHR*)(forUnmarshaling->pReferenceSlots + i));
}
}
}
#endif
#ifdef VK_KHR_dynamic_rendering
-void marshal_VkRenderingAttachmentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderingAttachmentInfoKHR* forMarshaling)
-{
+void marshal_VkRenderingAttachmentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingAttachmentInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
- vkStream->write((VkResolveModeFlagBits*)&forMarshaling->resolveMode, sizeof(VkResolveModeFlagBits));
+ vkStream->write((VkResolveModeFlagBits*)&forMarshaling->resolveMode,
+ sizeof(VkResolveModeFlagBits));
uint64_t cgen_var_1;
- vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->resolveImageView, &cgen_var_1, 1);
+ vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->resolveImageView,
+ &cgen_var_1, 1);
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
vkStream->write((VkImageLayout*)&forMarshaling->resolveImageLayout, sizeof(VkImageLayout));
vkStream->write((VkAttachmentLoadOp*)&forMarshaling->loadOp, sizeof(VkAttachmentLoadOp));
@@ -11001,41 +9959,36 @@
marshal_VkClearValue(vkStream, rootType, (VkClearValue*)(&forMarshaling->clearValue));
}
-void unmarshal_VkRenderingAttachmentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRenderingAttachmentInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkRenderingAttachmentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderingAttachmentInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_0, (VkImageView*)&forUnmarshaling->imageView, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImageView(
+ &cgen_var_0, (VkImageView*)&forUnmarshaling->imageView, 1);
vkStream->read((VkImageLayout*)&forUnmarshaling->imageLayout, sizeof(VkImageLayout));
- vkStream->read((VkResolveModeFlagBits*)&forUnmarshaling->resolveMode, sizeof(VkResolveModeFlagBits));
+ vkStream->read((VkResolveModeFlagBits*)&forUnmarshaling->resolveMode,
+ sizeof(VkResolveModeFlagBits));
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_1, (VkImageView*)&forUnmarshaling->resolveImageView, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImageView(
+ &cgen_var_1, (VkImageView*)&forUnmarshaling->resolveImageView, 1);
vkStream->read((VkImageLayout*)&forUnmarshaling->resolveImageLayout, sizeof(VkImageLayout));
vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->loadOp, sizeof(VkAttachmentLoadOp));
vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->storeOp, sizeof(VkAttachmentStoreOp));
unmarshal_VkClearValue(vkStream, rootType, (VkClearValue*)(&forUnmarshaling->clearValue));
}
-void marshal_VkRenderingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderingInfoKHR* forMarshaling)
-{
+void marshal_VkRenderingInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -11044,38 +9997,36 @@
vkStream->write((uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
- {
- marshal_VkRenderingAttachmentInfoKHR(vkStream, rootType, (const VkRenderingAttachmentInfoKHR*)(forMarshaling->pColorAttachments + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
+ marshal_VkRenderingAttachmentInfoKHR(
+ vkStream, rootType,
+ (const VkRenderingAttachmentInfoKHR*)(forMarshaling->pColorAttachments + i));
}
}
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pDepthAttachment;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pDepthAttachment)
- {
- marshal_VkRenderingAttachmentInfoKHR(vkStream, rootType, (const VkRenderingAttachmentInfoKHR*)(forMarshaling->pDepthAttachment));
+ if (forMarshaling->pDepthAttachment) {
+ marshal_VkRenderingAttachmentInfoKHR(
+ vkStream, rootType,
+ (const VkRenderingAttachmentInfoKHR*)(forMarshaling->pDepthAttachment));
}
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pStencilAttachment;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pStencilAttachment)
- {
- marshal_VkRenderingAttachmentInfoKHR(vkStream, rootType, (const VkRenderingAttachmentInfoKHR*)(forMarshaling->pStencilAttachment));
+ if (forMarshaling->pStencilAttachment) {
+ marshal_VkRenderingAttachmentInfoKHR(
+ vkStream, rootType,
+ (const VkRenderingAttachmentInfoKHR*)(forMarshaling->pStencilAttachment));
}
}
-void unmarshal_VkRenderingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRenderingInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkRenderingInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderingInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -11084,84 +10035,80 @@
vkStream->read((uint32_t*)&forUnmarshaling->layerCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->viewMask, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i)
- {
- unmarshal_VkRenderingAttachmentInfoKHR(vkStream, rootType, (VkRenderingAttachmentInfoKHR*)(forUnmarshaling->pColorAttachments + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i) {
+ unmarshal_VkRenderingAttachmentInfoKHR(
+ vkStream, rootType,
+ (VkRenderingAttachmentInfoKHR*)(forUnmarshaling->pColorAttachments + i));
}
}
// WARNING PTR CHECK
const VkRenderingAttachmentInfoKHR* check_pDepthAttachment;
check_pDepthAttachment = (const VkRenderingAttachmentInfoKHR*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pDepthAttachment)
- {
- if (!(check_pDepthAttachment))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pDepthAttachment inconsistent between guest and host\n");
+ if (forUnmarshaling->pDepthAttachment) {
+ if (!(check_pDepthAttachment)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pDepthAttachment inconsistent between guest and host\n");
}
- unmarshal_VkRenderingAttachmentInfoKHR(vkStream, rootType, (VkRenderingAttachmentInfoKHR*)(forUnmarshaling->pDepthAttachment));
+ unmarshal_VkRenderingAttachmentInfoKHR(
+ vkStream, rootType, (VkRenderingAttachmentInfoKHR*)(forUnmarshaling->pDepthAttachment));
}
// WARNING PTR CHECK
const VkRenderingAttachmentInfoKHR* check_pStencilAttachment;
check_pStencilAttachment = (const VkRenderingAttachmentInfoKHR*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pStencilAttachment)
- {
- if (!(check_pStencilAttachment))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pStencilAttachment inconsistent between guest and host\n");
+ if (forUnmarshaling->pStencilAttachment) {
+ if (!(check_pStencilAttachment)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pStencilAttachment inconsistent between guest and host\n");
}
- unmarshal_VkRenderingAttachmentInfoKHR(vkStream, rootType, (VkRenderingAttachmentInfoKHR*)(forUnmarshaling->pStencilAttachment));
+ unmarshal_VkRenderingAttachmentInfoKHR(
+ vkStream, rootType,
+ (VkRenderingAttachmentInfoKHR*)(forUnmarshaling->pStencilAttachment));
}
}
void marshal_VkPipelineRenderingCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRenderingCreateInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRenderingCreateInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
- vkStream->write((const VkFormat*)forMarshaling->pColorAttachmentFormats, forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
+ vkStream->write((const VkFormat*)forMarshaling->pColorAttachmentFormats,
+ forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
vkStream->write((VkFormat*)&forMarshaling->depthAttachmentFormat, sizeof(VkFormat));
vkStream->write((VkFormat*)&forMarshaling->stencilAttachmentFormat, sizeof(VkFormat));
}
-void unmarshal_VkPipelineRenderingCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineRenderingCreateInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkPipelineRenderingCreateInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPipelineRenderingCreateInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->viewMask, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
- vkStream->read((VkFormat*)forUnmarshaling->pColorAttachmentFormats, forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
+ vkStream->read((VkFormat*)forUnmarshaling->pColorAttachmentFormats,
+ forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
vkStream->read((VkFormat*)&forUnmarshaling->depthAttachmentFormat, sizeof(VkFormat));
vkStream->read((VkFormat*)&forUnmarshaling->stencilAttachmentFormat, sizeof(VkFormat));
}
void marshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDynamicRenderingFeaturesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDynamicRenderingFeaturesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -11169,14 +10116,11 @@
}
void unmarshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceDynamicRenderingFeaturesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceDynamicRenderingFeaturesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -11184,130 +10128,118 @@
}
void marshal_VkCommandBufferInheritanceRenderingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferInheritanceRenderingInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferInheritanceRenderingInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkRenderingFlagsKHR*)&forMarshaling->flags, sizeof(VkRenderingFlagsKHR));
vkStream->write((uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
- vkStream->write((const VkFormat*)forMarshaling->pColorAttachmentFormats, forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
+ vkStream->write((const VkFormat*)forMarshaling->pColorAttachmentFormats,
+ forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
vkStream->write((VkFormat*)&forMarshaling->depthAttachmentFormat, sizeof(VkFormat));
vkStream->write((VkFormat*)&forMarshaling->stencilAttachmentFormat, sizeof(VkFormat));
- vkStream->write((VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples, sizeof(VkSampleCountFlagBits));
+ vkStream->write((VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples,
+ sizeof(VkSampleCountFlagBits));
}
void unmarshal_VkCommandBufferInheritanceRenderingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCommandBufferInheritanceRenderingInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCommandBufferInheritanceRenderingInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkRenderingFlagsKHR*)&forUnmarshaling->flags, sizeof(VkRenderingFlagsKHR));
vkStream->read((uint32_t*)&forUnmarshaling->viewMask, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
- vkStream->read((VkFormat*)forUnmarshaling->pColorAttachmentFormats, forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
+ vkStream->read((VkFormat*)forUnmarshaling->pColorAttachmentFormats,
+ forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
vkStream->read((VkFormat*)&forUnmarshaling->depthAttachmentFormat, sizeof(VkFormat));
vkStream->read((VkFormat*)&forUnmarshaling->stencilAttachmentFormat, sizeof(VkFormat));
- vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->rasterizationSamples, sizeof(VkSampleCountFlagBits));
+ vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->rasterizationSamples,
+ sizeof(VkSampleCountFlagBits));
}
void marshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderingFragmentShadingRateAttachmentInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingFragmentShadingRateAttachmentInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
- marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->shadingRateAttachmentTexelSize));
+ marshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->shadingRateAttachmentTexelSize));
}
void unmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRenderingFragmentShadingRateAttachmentInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderingFragmentShadingRateAttachmentInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_0, (VkImageView*)&forUnmarshaling->imageView, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImageView(
+ &cgen_var_0, (VkImageView*)&forUnmarshaling->imageView, 1);
vkStream->read((VkImageLayout*)&forUnmarshaling->imageLayout, sizeof(VkImageLayout));
- unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->shadingRateAttachmentTexelSize));
+ unmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forUnmarshaling->shadingRateAttachmentTexelSize));
}
void marshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderingFragmentDensityMapAttachmentInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingFragmentDensityMapAttachmentInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
}
void unmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRenderingFragmentDensityMapAttachmentInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderingFragmentDensityMapAttachmentInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_0, (VkImageView*)&forUnmarshaling->imageView, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImageView(
+ &cgen_var_0, (VkImageView*)&forUnmarshaling->imageView, 1);
vkStream->read((VkImageLayout*)&forUnmarshaling->imageLayout, sizeof(VkImageLayout));
}
-void marshal_VkAttachmentSampleCountInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentSampleCountInfoAMD* forMarshaling)
-{
+void marshal_VkAttachmentSampleCountInfoAMD(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentSampleCountInfoAMD* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -11315,22 +10247,19 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pColorAttachmentSamples;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pColorAttachmentSamples)
- {
- vkStream->write((const VkSampleCountFlagBits*)forMarshaling->pColorAttachmentSamples, forMarshaling->colorAttachmentCount * sizeof(const VkSampleCountFlagBits));
+ if (forMarshaling->pColorAttachmentSamples) {
+ vkStream->write((const VkSampleCountFlagBits*)forMarshaling->pColorAttachmentSamples,
+ forMarshaling->colorAttachmentCount * sizeof(const VkSampleCountFlagBits));
}
- vkStream->write((VkSampleCountFlagBits*)&forMarshaling->depthStencilAttachmentSamples, sizeof(VkSampleCountFlagBits));
+ vkStream->write((VkSampleCountFlagBits*)&forMarshaling->depthStencilAttachmentSamples,
+ sizeof(VkSampleCountFlagBits));
}
-void unmarshal_VkAttachmentSampleCountInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAttachmentSampleCountInfoAMD* forUnmarshaling)
-{
+void unmarshal_VkAttachmentSampleCountInfoAMD(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAttachmentSampleCountInfoAMD* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -11338,26 +10267,25 @@
// WARNING PTR CHECK
const VkSampleCountFlagBits* check_pColorAttachmentSamples;
check_pColorAttachmentSamples = (const VkSampleCountFlagBits*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pColorAttachmentSamples)
- {
- if (!(check_pColorAttachmentSamples))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pColorAttachmentSamples inconsistent between guest and host\n");
+ if (forUnmarshaling->pColorAttachmentSamples) {
+ if (!(check_pColorAttachmentSamples)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pColorAttachmentSamples inconsistent between guest "
+ "and host\n");
}
- vkStream->read((VkSampleCountFlagBits*)forUnmarshaling->pColorAttachmentSamples, forUnmarshaling->colorAttachmentCount * sizeof(const VkSampleCountFlagBits));
+ vkStream->read((VkSampleCountFlagBits*)forUnmarshaling->pColorAttachmentSamples,
+ forUnmarshaling->colorAttachmentCount * sizeof(const VkSampleCountFlagBits));
}
- vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->depthStencilAttachmentSamples, sizeof(VkSampleCountFlagBits));
+ vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->depthStencilAttachmentSamples,
+ sizeof(VkSampleCountFlagBits));
}
void marshal_VkMultiviewPerViewAttributesInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMultiviewPerViewAttributesInfoNVX* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMultiviewPerViewAttributesInfoNVX* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -11366,14 +10294,11 @@
}
void unmarshal_VkMultiviewPerViewAttributesInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMultiviewPerViewAttributesInfoNVX* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMultiviewPerViewAttributesInfoNVX* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -11400,321 +10325,285 @@
#endif
#ifdef VK_KHR_external_memory_win32
void marshal_VkImportMemoryWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportMemoryWin32HandleInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportMemoryWin32HandleInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
}
-void unmarshal_VkImportMemoryWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportMemoryWin32HandleInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkImportMemoryWin32HandleInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkImportMemoryWin32HandleInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
}
void marshal_VkExportMemoryWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportMemoryWin32HandleInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportMemoryWin32HandleInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pAttributes)
- {
- vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ if (forMarshaling->pAttributes) {
+ vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes,
+ sizeof(const SECURITY_ATTRIBUTES));
}
vkStream->write((DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
}
-void unmarshal_VkExportMemoryWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExportMemoryWin32HandleInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkExportMemoryWin32HandleInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkExportMemoryWin32HandleInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
// WARNING PTR CHECK
const SECURITY_ATTRIBUTES* check_pAttributes;
check_pAttributes = (const SECURITY_ATTRIBUTES*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pAttributes)
- {
- if (!(check_pAttributes))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pAttributes inconsistent between guest and host\n");
+ if (forUnmarshaling->pAttributes) {
+ if (!(check_pAttributes)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pAttributes inconsistent between guest and host\n");
}
- vkStream->read((SECURITY_ATTRIBUTES*)forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ vkStream->read((SECURITY_ATTRIBUTES*)forUnmarshaling->pAttributes,
+ sizeof(const SECURITY_ATTRIBUTES));
}
vkStream->read((DWORD*)&forUnmarshaling->dwAccess, sizeof(DWORD));
vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
}
void marshal_VkMemoryWin32HandlePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryWin32HandlePropertiesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryWin32HandlePropertiesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
}
-void unmarshal_VkMemoryWin32HandlePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryWin32HandlePropertiesKHR* forUnmarshaling)
-{
+void unmarshal_VkMemoryWin32HandlePropertiesKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkMemoryWin32HandlePropertiesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
}
-void marshal_VkMemoryGetWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryGetWin32HandleInfoKHR* forMarshaling)
-{
+void marshal_VkMemoryGetWin32HandleInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryGetWin32HandleInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
}
-void unmarshal_VkMemoryGetWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryGetWin32HandleInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkMemoryGetWin32HandleInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryGetWin32HandleInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
- vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+ &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
}
#endif
#ifdef VK_KHR_external_memory_fd
-void marshal_VkImportMemoryFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportMemoryFdInfoKHR* forMarshaling)
-{
+void marshal_VkImportMemoryFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportMemoryFdInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
vkStream->write((int*)&forMarshaling->fd, sizeof(int));
}
-void unmarshal_VkImportMemoryFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportMemoryFdInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkImportMemoryFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImportMemoryFdInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
vkStream->read((int*)&forUnmarshaling->fd, sizeof(int));
}
-void marshal_VkMemoryFdPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryFdPropertiesKHR* forMarshaling)
-{
+void marshal_VkMemoryFdPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryFdPropertiesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
}
-void unmarshal_VkMemoryFdPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryFdPropertiesKHR* forUnmarshaling)
-{
+void unmarshal_VkMemoryFdPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryFdPropertiesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
}
-void marshal_VkMemoryGetFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryGetFdInfoKHR* forMarshaling)
-{
+void marshal_VkMemoryGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryGetFdInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
}
-void unmarshal_VkMemoryGetFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryGetFdInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkMemoryGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryGetFdInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
- vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+ &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
}
#endif
#ifdef VK_KHR_win32_keyed_mutex
void marshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWin32KeyedMutexAcquireReleaseInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWin32KeyedMutexAcquireReleaseInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->acquireCount, sizeof(uint32_t));
- if (forMarshaling->acquireCount)
- {
+ if (forMarshaling->acquireCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forMarshaling->acquireCount * 8);
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pAcquireSyncs, cgen_var_0, forMarshaling->acquireCount);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(
+ forMarshaling->pAcquireSyncs, cgen_var_0, forMarshaling->acquireCount);
vkStream->write((uint64_t*)cgen_var_0, forMarshaling->acquireCount * 8);
}
- vkStream->write((const uint64_t*)forMarshaling->pAcquireKeys, forMarshaling->acquireCount * sizeof(const uint64_t));
- vkStream->write((const uint32_t*)forMarshaling->pAcquireTimeouts, forMarshaling->acquireCount * sizeof(const uint32_t));
+ vkStream->write((const uint64_t*)forMarshaling->pAcquireKeys,
+ forMarshaling->acquireCount * sizeof(const uint64_t));
+ vkStream->write((const uint32_t*)forMarshaling->pAcquireTimeouts,
+ forMarshaling->acquireCount * sizeof(const uint32_t));
vkStream->write((uint32_t*)&forMarshaling->releaseCount, sizeof(uint32_t));
- if (forMarshaling->releaseCount)
- {
+ if (forMarshaling->releaseCount) {
uint64_t* cgen_var_1;
vkStream->alloc((void**)&cgen_var_1, forMarshaling->releaseCount * 8);
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pReleaseSyncs, cgen_var_1, forMarshaling->releaseCount);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(
+ forMarshaling->pReleaseSyncs, cgen_var_1, forMarshaling->releaseCount);
vkStream->write((uint64_t*)cgen_var_1, forMarshaling->releaseCount * 8);
}
- vkStream->write((const uint64_t*)forMarshaling->pReleaseKeys, forMarshaling->releaseCount * sizeof(const uint64_t));
+ vkStream->write((const uint64_t*)forMarshaling->pReleaseKeys,
+ forMarshaling->releaseCount * sizeof(const uint64_t));
}
void unmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkWin32KeyedMutexAcquireReleaseInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkWin32KeyedMutexAcquireReleaseInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->acquireCount, sizeof(uint32_t));
- if (forUnmarshaling->acquireCount)
- {
+ if (forUnmarshaling->acquireCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->acquireCount * 8);
vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->acquireCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_0, (VkDeviceMemory*)forUnmarshaling->pAcquireSyncs, forUnmarshaling->acquireCount);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+ cgen_var_0, (VkDeviceMemory*)forUnmarshaling->pAcquireSyncs,
+ forUnmarshaling->acquireCount);
}
- vkStream->read((uint64_t*)forUnmarshaling->pAcquireKeys, forUnmarshaling->acquireCount * sizeof(const uint64_t));
- vkStream->read((uint32_t*)forUnmarshaling->pAcquireTimeouts, forUnmarshaling->acquireCount * sizeof(const uint32_t));
+ vkStream->read((uint64_t*)forUnmarshaling->pAcquireKeys,
+ forUnmarshaling->acquireCount * sizeof(const uint64_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pAcquireTimeouts,
+ forUnmarshaling->acquireCount * sizeof(const uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->releaseCount, sizeof(uint32_t));
- if (forUnmarshaling->releaseCount)
- {
+ if (forUnmarshaling->releaseCount) {
uint64_t* cgen_var_1;
vkStream->alloc((void**)&cgen_var_1, forUnmarshaling->releaseCount * 8);
vkStream->read((uint64_t*)cgen_var_1, forUnmarshaling->releaseCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_1, (VkDeviceMemory*)forUnmarshaling->pReleaseSyncs, forUnmarshaling->releaseCount);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+ cgen_var_1, (VkDeviceMemory*)forUnmarshaling->pReleaseSyncs,
+ forUnmarshaling->releaseCount);
}
- vkStream->read((uint64_t*)forUnmarshaling->pReleaseKeys, forUnmarshaling->releaseCount * sizeof(const uint64_t));
+ vkStream->read((uint64_t*)forUnmarshaling->pReleaseKeys,
+ forUnmarshaling->releaseCount * sizeof(const uint64_t));
}
#endif
@@ -11724,106 +10613,95 @@
#endif
#ifdef VK_KHR_external_semaphore_win32
void marshal_VkImportSemaphoreWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportSemaphoreWin32HandleInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportSemaphoreWin32HandleInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((VkSemaphoreImportFlags*)&forMarshaling->flags, sizeof(VkSemaphoreImportFlags));
- vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
}
void unmarshal_VkImportSemaphoreWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportSemaphoreWin32HandleInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImportSemaphoreWin32HandleInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
- vkStream->read((VkSemaphoreImportFlags*)&forUnmarshaling->flags, sizeof(VkSemaphoreImportFlags));
- vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
+ &cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ vkStream->read((VkSemaphoreImportFlags*)&forUnmarshaling->flags,
+ sizeof(VkSemaphoreImportFlags));
+ vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
}
void marshal_VkExportSemaphoreWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportSemaphoreWin32HandleInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportSemaphoreWin32HandleInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pAttributes)
- {
- vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ if (forMarshaling->pAttributes) {
+ vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes,
+ sizeof(const SECURITY_ATTRIBUTES));
}
vkStream->write((DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
}
void unmarshal_VkExportSemaphoreWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExportSemaphoreWin32HandleInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExportSemaphoreWin32HandleInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
// WARNING PTR CHECK
const SECURITY_ATTRIBUTES* check_pAttributes;
check_pAttributes = (const SECURITY_ATTRIBUTES*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pAttributes)
- {
- if (!(check_pAttributes))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pAttributes inconsistent between guest and host\n");
+ if (forUnmarshaling->pAttributes) {
+ if (!(check_pAttributes)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pAttributes inconsistent between guest and host\n");
}
- vkStream->read((SECURITY_ATTRIBUTES*)forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ vkStream->read((SECURITY_ATTRIBUTES*)forUnmarshaling->pAttributes,
+ sizeof(const SECURITY_ATTRIBUTES));
}
vkStream->read((DWORD*)&forUnmarshaling->dwAccess, sizeof(DWORD));
vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
}
-void marshal_VkD3D12FenceSubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkD3D12FenceSubmitInfoKHR* forMarshaling)
-{
+void marshal_VkD3D12FenceSubmitInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkD3D12FenceSubmitInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -11831,29 +10709,25 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pWaitSemaphoreValues;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pWaitSemaphoreValues)
- {
- vkStream->write((const uint64_t*)forMarshaling->pWaitSemaphoreValues, forMarshaling->waitSemaphoreValuesCount * sizeof(const uint64_t));
+ if (forMarshaling->pWaitSemaphoreValues) {
+ vkStream->write((const uint64_t*)forMarshaling->pWaitSemaphoreValues,
+ forMarshaling->waitSemaphoreValuesCount * sizeof(const uint64_t));
}
vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreValuesCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pSignalSemaphoreValues;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pSignalSemaphoreValues)
- {
- vkStream->write((const uint64_t*)forMarshaling->pSignalSemaphoreValues, forMarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t));
+ if (forMarshaling->pSignalSemaphoreValues) {
+ vkStream->write((const uint64_t*)forMarshaling->pSignalSemaphoreValues,
+ forMarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t));
}
}
-void unmarshal_VkD3D12FenceSubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkD3D12FenceSubmitInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkD3D12FenceSubmitInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkD3D12FenceSubmitInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -11861,153 +10735,143 @@
// WARNING PTR CHECK
const uint64_t* check_pWaitSemaphoreValues;
check_pWaitSemaphoreValues = (const uint64_t*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pWaitSemaphoreValues)
- {
- if (!(check_pWaitSemaphoreValues))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pWaitSemaphoreValues inconsistent between guest and host\n");
+ if (forUnmarshaling->pWaitSemaphoreValues) {
+ if (!(check_pWaitSemaphoreValues)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pWaitSemaphoreValues inconsistent between guest and "
+ "host\n");
}
- vkStream->read((uint64_t*)forUnmarshaling->pWaitSemaphoreValues, forUnmarshaling->waitSemaphoreValuesCount * sizeof(const uint64_t));
+ vkStream->read((uint64_t*)forUnmarshaling->pWaitSemaphoreValues,
+ forUnmarshaling->waitSemaphoreValuesCount * sizeof(const uint64_t));
}
vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreValuesCount, sizeof(uint32_t));
// WARNING PTR CHECK
const uint64_t* check_pSignalSemaphoreValues;
check_pSignalSemaphoreValues = (const uint64_t*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pSignalSemaphoreValues)
- {
- if (!(check_pSignalSemaphoreValues))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pSignalSemaphoreValues inconsistent between guest and host\n");
+ if (forUnmarshaling->pSignalSemaphoreValues) {
+ if (!(check_pSignalSemaphoreValues)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pSignalSemaphoreValues inconsistent between guest and "
+ "host\n");
}
- vkStream->read((uint64_t*)forUnmarshaling->pSignalSemaphoreValues, forUnmarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t));
+ vkStream->read((uint64_t*)forUnmarshaling->pSignalSemaphoreValues,
+ forUnmarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t));
}
}
void marshal_VkSemaphoreGetWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreGetWin32HandleInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreGetWin32HandleInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}
-void unmarshal_VkSemaphoreGetWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSemaphoreGetWin32HandleInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkSemaphoreGetWin32HandleInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkSemaphoreGetWin32HandleInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
- vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
+ &cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}
#endif
#ifdef VK_KHR_external_semaphore_fd
-void marshal_VkImportSemaphoreFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportSemaphoreFdInfoKHR* forMarshaling)
-{
+void marshal_VkImportSemaphoreFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportSemaphoreFdInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((VkSemaphoreImportFlags*)&forMarshaling->flags, sizeof(VkSemaphoreImportFlags));
- vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
vkStream->write((int*)&forMarshaling->fd, sizeof(int));
}
-void unmarshal_VkImportSemaphoreFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportSemaphoreFdInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkImportSemaphoreFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImportSemaphoreFdInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
- vkStream->read((VkSemaphoreImportFlags*)&forUnmarshaling->flags, sizeof(VkSemaphoreImportFlags));
- vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
+ &cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ vkStream->read((VkSemaphoreImportFlags*)&forUnmarshaling->flags,
+ sizeof(VkSemaphoreImportFlags));
+ vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
vkStream->read((int*)&forUnmarshaling->fd, sizeof(int));
}
-void marshal_VkSemaphoreGetFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreGetFdInfoKHR* forMarshaling)
-{
+void marshal_VkSemaphoreGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreGetFdInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}
-void unmarshal_VkSemaphoreGetFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSemaphoreGetFdInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkSemaphoreGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSemaphoreGetFdInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
- vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
+ &cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}
#endif
#ifdef VK_KHR_push_descriptor
void marshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePushDescriptorPropertiesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePushDescriptorPropertiesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -12015,14 +10879,11 @@
}
void unmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDevicePushDescriptorPropertiesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePushDescriptorPropertiesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -12035,85 +10896,65 @@
#ifdef VK_KHR_16bit_storage
#endif
#ifdef VK_KHR_incremental_present
-void marshal_VkRectLayerKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRectLayerKHR* forMarshaling)
-{
+void marshal_VkRectLayerKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRectLayerKHR* forMarshaling) {
(void)rootType;
marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->offset));
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->extent));
vkStream->write((uint32_t*)&forMarshaling->layer, sizeof(uint32_t));
}
-void unmarshal_VkRectLayerKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRectLayerKHR* forUnmarshaling)
-{
+void unmarshal_VkRectLayerKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRectLayerKHR* forUnmarshaling) {
(void)rootType;
unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->offset));
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->extent));
vkStream->read((uint32_t*)&forUnmarshaling->layer, sizeof(uint32_t));
}
-void marshal_VkPresentRegionKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentRegionKHR* forMarshaling)
-{
+void marshal_VkPresentRegionKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentRegionKHR* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->rectangleCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pRectangles;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pRectangles)
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->rectangleCount; ++i)
- {
- marshal_VkRectLayerKHR(vkStream, rootType, (const VkRectLayerKHR*)(forMarshaling->pRectangles + i));
+ if (forMarshaling->pRectangles) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->rectangleCount; ++i) {
+ marshal_VkRectLayerKHR(vkStream, rootType,
+ (const VkRectLayerKHR*)(forMarshaling->pRectangles + i));
}
}
}
}
-void unmarshal_VkPresentRegionKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPresentRegionKHR* forUnmarshaling)
-{
+void unmarshal_VkPresentRegionKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPresentRegionKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->rectangleCount, sizeof(uint32_t));
// WARNING PTR CHECK
const VkRectLayerKHR* check_pRectangles;
check_pRectangles = (const VkRectLayerKHR*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pRectangles)
- {
- if (!(check_pRectangles))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pRectangles inconsistent between guest and host\n");
+ if (forUnmarshaling->pRectangles) {
+ if (!(check_pRectangles)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pRectangles inconsistent between guest and host\n");
}
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->rectangleCount; ++i)
- {
- unmarshal_VkRectLayerKHR(vkStream, rootType, (VkRectLayerKHR*)(forUnmarshaling->pRectangles + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->rectangleCount; ++i) {
+ unmarshal_VkRectLayerKHR(vkStream, rootType,
+ (VkRectLayerKHR*)(forUnmarshaling->pRectangles + i));
}
}
}
}
-void marshal_VkPresentRegionsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentRegionsKHR* forMarshaling)
-{
+void marshal_VkPresentRegionsKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentRegionsKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -12121,27 +10962,21 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pRegions;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pRegions)
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i)
- {
- marshal_VkPresentRegionKHR(vkStream, rootType, (const VkPresentRegionKHR*)(forMarshaling->pRegions + i));
+ if (forMarshaling->pRegions) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i) {
+ marshal_VkPresentRegionKHR(
+ vkStream, rootType, (const VkPresentRegionKHR*)(forMarshaling->pRegions + i));
}
}
}
}
-void unmarshal_VkPresentRegionsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPresentRegionsKHR* forUnmarshaling)
-{
+void unmarshal_VkPresentRegionsKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPresentRegionsKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -12149,17 +10984,15 @@
// WARNING PTR CHECK
const VkPresentRegionKHR* check_pRegions;
check_pRegions = (const VkPresentRegionKHR*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pRegions)
- {
- if (!(check_pRegions))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pRegions inconsistent between guest and host\n");
+ if (forUnmarshaling->pRegions) {
+ if (!(check_pRegions)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pRegions inconsistent between guest and host\n");
}
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->swapchainCount; ++i)
- {
- unmarshal_VkPresentRegionKHR(vkStream, rootType, (VkPresentRegionKHR*)(forUnmarshaling->pRegions + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->swapchainCount; ++i) {
+ unmarshal_VkPresentRegionKHR(vkStream, rootType,
+ (VkPresentRegionKHR*)(forUnmarshaling->pRegions + i));
}
}
}
@@ -12174,33 +11007,29 @@
#endif
#ifdef VK_KHR_shared_presentable_image
void marshal_VkSharedPresentSurfaceCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSharedPresentSurfaceCapabilitiesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSharedPresentSurfaceCapabilitiesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkImageUsageFlags*)&forMarshaling->sharedPresentSupportedUsageFlags, sizeof(VkImageUsageFlags));
+ vkStream->write((VkImageUsageFlags*)&forMarshaling->sharedPresentSupportedUsageFlags,
+ sizeof(VkImageUsageFlags));
}
void unmarshal_VkSharedPresentSurfaceCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSharedPresentSurfaceCapabilitiesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSharedPresentSurfaceCapabilitiesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkImageUsageFlags*)&forUnmarshaling->sharedPresentSupportedUsageFlags, sizeof(VkImageUsageFlags));
+ vkStream->read((VkImageUsageFlags*)&forUnmarshaling->sharedPresentSupportedUsageFlags,
+ sizeof(VkImageUsageFlags));
}
#endif
@@ -12209,15 +11038,11 @@
#ifdef VK_KHR_external_fence
#endif
#ifdef VK_KHR_external_fence_win32
-void marshal_VkImportFenceWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportFenceWin32HandleInfoKHR* forMarshaling)
-{
+void marshal_VkImportFenceWin32HandleInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportFenceWin32HandleInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -12225,129 +11050,113 @@
vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((VkFenceImportFlags*)&forMarshaling->flags, sizeof(VkFenceImportFlags));
- vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+ vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalFenceHandleTypeFlagBits));
vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
}
-void unmarshal_VkImportFenceWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportFenceWin32HandleInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkImportFenceWin32HandleInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkImportFenceWin32HandleInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_0, (VkFence*)&forUnmarshaling->fence, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_0,
+ (VkFence*)&forUnmarshaling->fence, 1);
vkStream->read((VkFenceImportFlags*)&forUnmarshaling->flags, sizeof(VkFenceImportFlags));
- vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+ vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalFenceHandleTypeFlagBits));
vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
}
-void marshal_VkExportFenceWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportFenceWin32HandleInfoKHR* forMarshaling)
-{
+void marshal_VkExportFenceWin32HandleInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportFenceWin32HandleInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pAttributes)
- {
- vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ if (forMarshaling->pAttributes) {
+ vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes,
+ sizeof(const SECURITY_ATTRIBUTES));
}
vkStream->write((DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
vkStream->write((LPCWSTR*)&forMarshaling->name, sizeof(LPCWSTR));
}
-void unmarshal_VkExportFenceWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExportFenceWin32HandleInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkExportFenceWin32HandleInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkExportFenceWin32HandleInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
// WARNING PTR CHECK
const SECURITY_ATTRIBUTES* check_pAttributes;
check_pAttributes = (const SECURITY_ATTRIBUTES*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pAttributes)
- {
- if (!(check_pAttributes))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pAttributes inconsistent between guest and host\n");
+ if (forUnmarshaling->pAttributes) {
+ if (!(check_pAttributes)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pAttributes inconsistent between guest and host\n");
}
- vkStream->read((SECURITY_ATTRIBUTES*)forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ vkStream->read((SECURITY_ATTRIBUTES*)forUnmarshaling->pAttributes,
+ sizeof(const SECURITY_ATTRIBUTES));
}
vkStream->read((DWORD*)&forUnmarshaling->dwAccess, sizeof(DWORD));
vkStream->read((LPCWSTR*)&forUnmarshaling->name, sizeof(LPCWSTR));
}
-void marshal_VkFenceGetWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFenceGetWin32HandleInfoKHR* forMarshaling)
-{
+void marshal_VkFenceGetWin32HandleInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFenceGetWin32HandleInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+ vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalFenceHandleTypeFlagBits));
}
-void unmarshal_VkFenceGetWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkFenceGetWin32HandleInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkFenceGetWin32HandleInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkFenceGetWin32HandleInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_0, (VkFence*)&forUnmarshaling->fence, 1);
- vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+ vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_0,
+ (VkFence*)&forUnmarshaling->fence, 1);
+ vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalFenceHandleTypeFlagBits));
}
#endif
#ifdef VK_KHR_external_fence_fd
-void marshal_VkImportFenceFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportFenceFdInfoKHR* forMarshaling)
-{
+void marshal_VkImportFenceFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportFenceFdInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -12355,109 +11164,96 @@
vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((VkFenceImportFlags*)&forMarshaling->flags, sizeof(VkFenceImportFlags));
- vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+ vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalFenceHandleTypeFlagBits));
vkStream->write((int*)&forMarshaling->fd, sizeof(int));
}
-void unmarshal_VkImportFenceFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportFenceFdInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkImportFenceFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImportFenceFdInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_0, (VkFence*)&forUnmarshaling->fence, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_0,
+ (VkFence*)&forUnmarshaling->fence, 1);
vkStream->read((VkFenceImportFlags*)&forUnmarshaling->flags, sizeof(VkFenceImportFlags));
- vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+ vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalFenceHandleTypeFlagBits));
vkStream->read((int*)&forUnmarshaling->fd, sizeof(int));
}
-void marshal_VkFenceGetFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFenceGetFdInfoKHR* forMarshaling)
-{
+void marshal_VkFenceGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFenceGetFdInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+ vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalFenceHandleTypeFlagBits));
}
-void unmarshal_VkFenceGetFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkFenceGetFdInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkFenceGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkFenceGetFdInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_0, (VkFence*)&forUnmarshaling->fence, 1);
- vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+ vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_0,
+ (VkFence*)&forUnmarshaling->fence, 1);
+ vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalFenceHandleTypeFlagBits));
}
#endif
#ifdef VK_KHR_performance_query
void marshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePerformanceQueryFeaturesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePerformanceQueryFeaturesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->performanceCounterQueryPools, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->performanceCounterMultipleQueryPools, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->performanceCounterMultipleQueryPools,
+ sizeof(VkBool32));
}
void unmarshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDevicePerformanceQueryFeaturesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePerformanceQueryFeaturesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->performanceCounterQueryPools, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->performanceCounterMultipleQueryPools, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->performanceCounterMultipleQueryPools,
+ sizeof(VkBool32));
}
void marshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePerformanceQueryPropertiesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePerformanceQueryPropertiesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -12465,200 +11261,168 @@
}
void unmarshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDevicePerformanceQueryPropertiesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePerformanceQueryPropertiesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->allowCommandBufferQueryCopies, sizeof(VkBool32));
}
-void marshal_VkPerformanceCounterKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceCounterKHR* forMarshaling)
-{
+void marshal_VkPerformanceCounterKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceCounterKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPerformanceCounterUnitKHR*)&forMarshaling->unit, sizeof(VkPerformanceCounterUnitKHR));
- vkStream->write((VkPerformanceCounterScopeKHR*)&forMarshaling->scope, sizeof(VkPerformanceCounterScopeKHR));
- vkStream->write((VkPerformanceCounterStorageKHR*)&forMarshaling->storage, sizeof(VkPerformanceCounterStorageKHR));
+ vkStream->write((VkPerformanceCounterUnitKHR*)&forMarshaling->unit,
+ sizeof(VkPerformanceCounterUnitKHR));
+ vkStream->write((VkPerformanceCounterScopeKHR*)&forMarshaling->scope,
+ sizeof(VkPerformanceCounterScopeKHR));
+ vkStream->write((VkPerformanceCounterStorageKHR*)&forMarshaling->storage,
+ sizeof(VkPerformanceCounterStorageKHR));
vkStream->write((uint8_t*)forMarshaling->uuid, VK_UUID_SIZE * sizeof(uint8_t));
}
-void unmarshal_VkPerformanceCounterKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPerformanceCounterKHR* forUnmarshaling)
-{
+void unmarshal_VkPerformanceCounterKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPerformanceCounterKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPerformanceCounterUnitKHR*)&forUnmarshaling->unit, sizeof(VkPerformanceCounterUnitKHR));
- vkStream->read((VkPerformanceCounterScopeKHR*)&forUnmarshaling->scope, sizeof(VkPerformanceCounterScopeKHR));
- vkStream->read((VkPerformanceCounterStorageKHR*)&forUnmarshaling->storage, sizeof(VkPerformanceCounterStorageKHR));
+ vkStream->read((VkPerformanceCounterUnitKHR*)&forUnmarshaling->unit,
+ sizeof(VkPerformanceCounterUnitKHR));
+ vkStream->read((VkPerformanceCounterScopeKHR*)&forUnmarshaling->scope,
+ sizeof(VkPerformanceCounterScopeKHR));
+ vkStream->read((VkPerformanceCounterStorageKHR*)&forUnmarshaling->storage,
+ sizeof(VkPerformanceCounterStorageKHR));
vkStream->read((uint8_t*)forUnmarshaling->uuid, VK_UUID_SIZE * sizeof(uint8_t));
}
void marshal_VkPerformanceCounterDescriptionKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceCounterDescriptionKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceCounterDescriptionKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPerformanceCounterDescriptionFlagsKHR*)&forMarshaling->flags, sizeof(VkPerformanceCounterDescriptionFlagsKHR));
+ vkStream->write((VkPerformanceCounterDescriptionFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkPerformanceCounterDescriptionFlagsKHR));
vkStream->write((char*)forMarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
vkStream->write((char*)forMarshaling->category, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
}
void unmarshal_VkPerformanceCounterDescriptionKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPerformanceCounterDescriptionKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPerformanceCounterDescriptionKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPerformanceCounterDescriptionFlagsKHR*)&forUnmarshaling->flags, sizeof(VkPerformanceCounterDescriptionFlagsKHR));
+ vkStream->read((VkPerformanceCounterDescriptionFlagsKHR*)&forUnmarshaling->flags,
+ sizeof(VkPerformanceCounterDescriptionFlagsKHR));
vkStream->read((char*)forUnmarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
vkStream->read((char*)forUnmarshaling->category, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
}
void marshal_VkQueryPoolPerformanceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueryPoolPerformanceCreateInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueryPoolPerformanceCreateInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->counterIndexCount, sizeof(uint32_t));
- vkStream->write((const uint32_t*)forMarshaling->pCounterIndices, forMarshaling->counterIndexCount * sizeof(const uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pCounterIndices,
+ forMarshaling->counterIndexCount * sizeof(const uint32_t));
}
void unmarshal_VkQueryPoolPerformanceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkQueryPoolPerformanceCreateInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkQueryPoolPerformanceCreateInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndex, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->counterIndexCount, sizeof(uint32_t));
- vkStream->read((uint32_t*)forUnmarshaling->pCounterIndices, forUnmarshaling->counterIndexCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pCounterIndices,
+ forUnmarshaling->counterIndexCount * sizeof(const uint32_t));
}
-void marshal_VkPerformanceCounterResultKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceCounterResultKHR* forMarshaling)
-{
+void marshal_VkPerformanceCounterResultKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceCounterResultKHR* forMarshaling) {
(void)rootType;
vkStream->write((int32_t*)&forMarshaling->int32, sizeof(int32_t));
}
-void unmarshal_VkPerformanceCounterResultKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPerformanceCounterResultKHR* forUnmarshaling)
-{
+void unmarshal_VkPerformanceCounterResultKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPerformanceCounterResultKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((int32_t*)&forUnmarshaling->int32, sizeof(int32_t));
}
-void marshal_VkAcquireProfilingLockInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAcquireProfilingLockInfoKHR* forMarshaling)
-{
+void marshal_VkAcquireProfilingLockInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAcquireProfilingLockInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkAcquireProfilingLockFlagsKHR*)&forMarshaling->flags, sizeof(VkAcquireProfilingLockFlagsKHR));
+ vkStream->write((VkAcquireProfilingLockFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkAcquireProfilingLockFlagsKHR));
vkStream->write((uint64_t*)&forMarshaling->timeout, sizeof(uint64_t));
}
-void unmarshal_VkAcquireProfilingLockInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAcquireProfilingLockInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkAcquireProfilingLockInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAcquireProfilingLockInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkAcquireProfilingLockFlagsKHR*)&forUnmarshaling->flags, sizeof(VkAcquireProfilingLockFlagsKHR));
+ vkStream->read((VkAcquireProfilingLockFlagsKHR*)&forUnmarshaling->flags,
+ sizeof(VkAcquireProfilingLockFlagsKHR));
vkStream->read((uint64_t*)&forUnmarshaling->timeout, sizeof(uint64_t));
}
-void marshal_VkPerformanceQuerySubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceQuerySubmitInfoKHR* forMarshaling)
-{
+void marshal_VkPerformanceQuerySubmitInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceQuerySubmitInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->counterPassIndex, sizeof(uint32_t));
}
-void unmarshal_VkPerformanceQuerySubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPerformanceQuerySubmitInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkPerformanceQuerySubmitInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPerformanceQuerySubmitInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -12669,15 +11433,11 @@
#ifdef VK_KHR_maintenance2
#endif
#ifdef VK_KHR_get_surface_capabilities2
-void marshal_VkPhysicalDeviceSurfaceInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSurfaceInfo2KHR* forMarshaling)
-{
+void marshal_VkPhysicalDeviceSurfaceInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSurfaceInfo2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -12686,241 +11446,198 @@
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}
-void unmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceSurfaceInfo2KHR* forUnmarshaling)
-{
+void unmarshal_VkPhysicalDeviceSurfaceInfo2KHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPhysicalDeviceSurfaceInfo2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_0, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkSurfaceKHR(
+ &cgen_var_0, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
}
-void marshal_VkSurfaceCapabilities2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceCapabilities2KHR* forMarshaling)
-{
+void marshal_VkSurfaceCapabilities2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceCapabilities2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkSurfaceCapabilitiesKHR(vkStream, rootType, (VkSurfaceCapabilitiesKHR*)(&forMarshaling->surfaceCapabilities));
+ marshal_VkSurfaceCapabilitiesKHR(
+ vkStream, rootType, (VkSurfaceCapabilitiesKHR*)(&forMarshaling->surfaceCapabilities));
}
-void unmarshal_VkSurfaceCapabilities2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSurfaceCapabilities2KHR* forUnmarshaling)
-{
+void unmarshal_VkSurfaceCapabilities2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSurfaceCapabilities2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkSurfaceCapabilitiesKHR(vkStream, rootType, (VkSurfaceCapabilitiesKHR*)(&forUnmarshaling->surfaceCapabilities));
+ unmarshal_VkSurfaceCapabilitiesKHR(
+ vkStream, rootType, (VkSurfaceCapabilitiesKHR*)(&forUnmarshaling->surfaceCapabilities));
}
-void marshal_VkSurfaceFormat2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceFormat2KHR* forMarshaling)
-{
+void marshal_VkSurfaceFormat2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceFormat2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkSurfaceFormatKHR(vkStream, rootType, (VkSurfaceFormatKHR*)(&forMarshaling->surfaceFormat));
+ marshal_VkSurfaceFormatKHR(vkStream, rootType,
+ (VkSurfaceFormatKHR*)(&forMarshaling->surfaceFormat));
}
-void unmarshal_VkSurfaceFormat2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSurfaceFormat2KHR* forUnmarshaling)
-{
+void unmarshal_VkSurfaceFormat2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSurfaceFormat2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkSurfaceFormatKHR(vkStream, rootType, (VkSurfaceFormatKHR*)(&forUnmarshaling->surfaceFormat));
+ unmarshal_VkSurfaceFormatKHR(vkStream, rootType,
+ (VkSurfaceFormatKHR*)(&forUnmarshaling->surfaceFormat));
}
#endif
#ifdef VK_KHR_variable_pointers
#endif
#ifdef VK_KHR_get_display_properties2
-void marshal_VkDisplayProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayProperties2KHR* forMarshaling)
-{
+void marshal_VkDisplayProperties2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayProperties2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkDisplayPropertiesKHR(vkStream, rootType, (VkDisplayPropertiesKHR*)(&forMarshaling->displayProperties));
+ marshal_VkDisplayPropertiesKHR(vkStream, rootType,
+ (VkDisplayPropertiesKHR*)(&forMarshaling->displayProperties));
}
-void unmarshal_VkDisplayProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayProperties2KHR* forUnmarshaling)
-{
+void unmarshal_VkDisplayProperties2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayProperties2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkDisplayPropertiesKHR(vkStream, rootType, (VkDisplayPropertiesKHR*)(&forUnmarshaling->displayProperties));
+ unmarshal_VkDisplayPropertiesKHR(
+ vkStream, rootType, (VkDisplayPropertiesKHR*)(&forUnmarshaling->displayProperties));
}
-void marshal_VkDisplayPlaneProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPlaneProperties2KHR* forMarshaling)
-{
+void marshal_VkDisplayPlaneProperties2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPlaneProperties2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkDisplayPlanePropertiesKHR(vkStream, rootType, (VkDisplayPlanePropertiesKHR*)(&forMarshaling->displayPlaneProperties));
+ marshal_VkDisplayPlanePropertiesKHR(
+ vkStream, rootType, (VkDisplayPlanePropertiesKHR*)(&forMarshaling->displayPlaneProperties));
}
-void unmarshal_VkDisplayPlaneProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayPlaneProperties2KHR* forUnmarshaling)
-{
+void unmarshal_VkDisplayPlaneProperties2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayPlaneProperties2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkDisplayPlanePropertiesKHR(vkStream, rootType, (VkDisplayPlanePropertiesKHR*)(&forUnmarshaling->displayPlaneProperties));
+ unmarshal_VkDisplayPlanePropertiesKHR(
+ vkStream, rootType,
+ (VkDisplayPlanePropertiesKHR*)(&forUnmarshaling->displayPlaneProperties));
}
-void marshal_VkDisplayModeProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayModeProperties2KHR* forMarshaling)
-{
+void marshal_VkDisplayModeProperties2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayModeProperties2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkDisplayModePropertiesKHR(vkStream, rootType, (VkDisplayModePropertiesKHR*)(&forMarshaling->displayModeProperties));
+ marshal_VkDisplayModePropertiesKHR(
+ vkStream, rootType, (VkDisplayModePropertiesKHR*)(&forMarshaling->displayModeProperties));
}
-void unmarshal_VkDisplayModeProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayModeProperties2KHR* forUnmarshaling)
-{
+void unmarshal_VkDisplayModeProperties2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayModeProperties2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkDisplayModePropertiesKHR(vkStream, rootType, (VkDisplayModePropertiesKHR*)(&forUnmarshaling->displayModeProperties));
+ unmarshal_VkDisplayModePropertiesKHR(
+ vkStream, rootType, (VkDisplayModePropertiesKHR*)(&forUnmarshaling->displayModeProperties));
}
-void marshal_VkDisplayPlaneInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPlaneInfo2KHR* forMarshaling)
-{
+void marshal_VkDisplayPlaneInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPlaneInfo2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->mode, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->mode, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->planeIndex, sizeof(uint32_t));
}
-void unmarshal_VkDisplayPlaneInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayPlaneInfo2KHR* forUnmarshaling)
-{
+void unmarshal_VkDisplayPlaneInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayPlaneInfo2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_0, (VkDisplayModeKHR*)&forUnmarshaling->mode, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(
+ &cgen_var_0, (VkDisplayModeKHR*)&forUnmarshaling->mode, 1);
vkStream->read((uint32_t*)&forUnmarshaling->planeIndex, sizeof(uint32_t));
}
-void marshal_VkDisplayPlaneCapabilities2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPlaneCapabilities2KHR* forMarshaling)
-{
+void marshal_VkDisplayPlaneCapabilities2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPlaneCapabilities2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkDisplayPlaneCapabilitiesKHR(vkStream, rootType, (VkDisplayPlaneCapabilitiesKHR*)(&forMarshaling->capabilities));
+ marshal_VkDisplayPlaneCapabilitiesKHR(
+ vkStream, rootType, (VkDisplayPlaneCapabilitiesKHR*)(&forMarshaling->capabilities));
}
-void unmarshal_VkDisplayPlaneCapabilities2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayPlaneCapabilities2KHR* forUnmarshaling)
-{
+void unmarshal_VkDisplayPlaneCapabilities2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayPlaneCapabilities2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkDisplayPlaneCapabilitiesKHR(vkStream, rootType, (VkDisplayPlaneCapabilitiesKHR*)(&forUnmarshaling->capabilities));
+ unmarshal_VkDisplayPlaneCapabilitiesKHR(
+ vkStream, rootType, (VkDisplayPlaneCapabilitiesKHR*)(&forUnmarshaling->capabilities));
}
#endif
@@ -12940,14 +11657,11 @@
#endif
#ifdef VK_KHR_portability_subset
void marshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePortabilitySubsetFeaturesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePortabilitySubsetFeaturesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -12961,7 +11675,8 @@
vkStream->write((VkBool32*)&forMarshaling->pointPolygons, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->samplerMipLodBias, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->separateStencilMaskRef, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->shaderSampleRateInterpolationFunctions, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderSampleRateInterpolationFunctions,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->tessellationIsolines, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->tessellationPointMode, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->triangleFans, sizeof(VkBool32));
@@ -12969,14 +11684,11 @@
}
void unmarshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDevicePortabilitySubsetFeaturesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePortabilitySubsetFeaturesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -12990,41 +11702,39 @@
vkStream->read((VkBool32*)&forUnmarshaling->pointPolygons, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->samplerMipLodBias, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->separateStencilMaskRef, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderSampleRateInterpolationFunctions, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderSampleRateInterpolationFunctions,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->tessellationIsolines, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->tessellationPointMode, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->triangleFans, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->vertexAttributeAccessBeyondStride, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->vertexAttributeAccessBeyondStride,
+ sizeof(VkBool32));
}
void marshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePortabilitySubsetPropertiesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePortabilitySubsetPropertiesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((uint32_t*)&forMarshaling->minVertexInputBindingStrideAlignment, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->minVertexInputBindingStrideAlignment,
+ sizeof(uint32_t));
}
void unmarshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDevicePortabilitySubsetPropertiesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePortabilitySubsetPropertiesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((uint32_t*)&forUnmarshaling->minVertexInputBindingStrideAlignment, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->minVertexInputBindingStrideAlignment,
+ sizeof(uint32_t));
}
#endif
@@ -13040,14 +11750,11 @@
#endif
#ifdef VK_KHR_shader_clock
void marshal_VkPhysicalDeviceShaderClockFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderClockFeaturesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderClockFeaturesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -13056,14 +11763,11 @@
}
void unmarshal_VkPhysicalDeviceShaderClockFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShaderClockFeaturesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderClockFeaturesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -13086,14 +11790,11 @@
#endif
#ifdef VK_KHR_shader_terminate_invocation
void marshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -13101,14 +11802,11 @@
}
void unmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -13118,94 +11816,87 @@
#endif
#ifdef VK_KHR_fragment_shading_rate
void marshal_VkFragmentShadingRateAttachmentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFragmentShadingRateAttachmentInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFragmentShadingRateAttachmentInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pFragmentShadingRateAttachment;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pFragmentShadingRateAttachment)
- {
- marshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pFragmentShadingRateAttachment));
+ if (forMarshaling->pFragmentShadingRateAttachment) {
+ marshal_VkAttachmentReference2(
+ vkStream, rootType,
+ (const VkAttachmentReference2*)(forMarshaling->pFragmentShadingRateAttachment));
}
- marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->shadingRateAttachmentTexelSize));
+ marshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->shadingRateAttachmentTexelSize));
}
void unmarshal_VkFragmentShadingRateAttachmentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkFragmentShadingRateAttachmentInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkFragmentShadingRateAttachmentInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
// WARNING PTR CHECK
const VkAttachmentReference2* check_pFragmentShadingRateAttachment;
- check_pFragmentShadingRateAttachment = (const VkAttachmentReference2*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pFragmentShadingRateAttachment)
- {
- if (!(check_pFragmentShadingRateAttachment))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pFragmentShadingRateAttachment inconsistent between guest and host\n");
+ check_pFragmentShadingRateAttachment =
+ (const VkAttachmentReference2*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pFragmentShadingRateAttachment) {
+ if (!(check_pFragmentShadingRateAttachment)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pFragmentShadingRateAttachment inconsistent between "
+ "guest and host\n");
}
- unmarshal_VkAttachmentReference2(vkStream, rootType, (VkAttachmentReference2*)(forUnmarshaling->pFragmentShadingRateAttachment));
+ unmarshal_VkAttachmentReference2(
+ vkStream, rootType,
+ (VkAttachmentReference2*)(forUnmarshaling->pFragmentShadingRateAttachment));
}
- unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->shadingRateAttachmentTexelSize));
+ unmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forUnmarshaling->shadingRateAttachmentTexelSize));
}
void marshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineFragmentShadingRateStateCreateInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineFragmentShadingRateStateCreateInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->fragmentSize));
- vkStream->write((VkFragmentShadingRateCombinerOpKHR*)forMarshaling->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
+ vkStream->write((VkFragmentShadingRateCombinerOpKHR*)forMarshaling->combinerOps,
+ 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
}
void unmarshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineFragmentShadingRateStateCreateInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineFragmentShadingRateStateCreateInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->fragmentSize));
- vkStream->read((VkFragmentShadingRateCombinerOpKHR*)forUnmarshaling->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
+ vkStream->read((VkFragmentShadingRateCombinerOpKHR*)forUnmarshaling->combinerOps,
+ 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
}
void marshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -13215,14 +11906,11 @@
}
void unmarshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceFragmentShadingRateFeaturesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceFragmentShadingRateFeaturesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -13232,76 +11920,99 @@
}
void marshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minFragmentShadingRateAttachmentTexelSize));
- marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxFragmentShadingRateAttachmentTexelSize));
- vkStream->write((uint32_t*)&forMarshaling->maxFragmentShadingRateAttachmentTexelSizeAspectRatio, sizeof(uint32_t));
- vkStream->write((VkBool32*)&forMarshaling->primitiveFragmentShadingRateWithMultipleViewports, sizeof(VkBool32));
+ marshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->minFragmentShadingRateAttachmentTexelSize));
+ marshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->maxFragmentShadingRateAttachmentTexelSize));
+ vkStream->write((uint32_t*)&forMarshaling->maxFragmentShadingRateAttachmentTexelSizeAspectRatio,
+ sizeof(uint32_t));
+ vkStream->write((VkBool32*)&forMarshaling->primitiveFragmentShadingRateWithMultipleViewports,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->layeredShadingRateAttachments, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateNonTrivialCombinerOps, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateNonTrivialCombinerOps,
+ sizeof(VkBool32));
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxFragmentSize));
vkStream->write((uint32_t*)&forMarshaling->maxFragmentSizeAspectRatio, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxFragmentShadingRateCoverageSamples, sizeof(uint32_t));
- vkStream->write((VkSampleCountFlagBits*)&forMarshaling->maxFragmentShadingRateRasterizationSamples, sizeof(VkSampleCountFlagBits));
- vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateWithShaderDepthStencilWrites, sizeof(VkBool32));
+ vkStream->write((uint32_t*)&forMarshaling->maxFragmentShadingRateCoverageSamples,
+ sizeof(uint32_t));
+ vkStream->write(
+ (VkSampleCountFlagBits*)&forMarshaling->maxFragmentShadingRateRasterizationSamples,
+ sizeof(VkSampleCountFlagBits));
+ vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateWithShaderDepthStencilWrites,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateWithSampleMask, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateWithShaderSampleMask, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateWithConservativeRasterization, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateWithFragmentShaderInterlock, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateWithCustomSampleLocations, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateStrictMultiplyCombiner, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateWithShaderSampleMask,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateWithConservativeRasterization,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateWithFragmentShaderInterlock,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateWithCustomSampleLocations,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->fragmentShadingRateStrictMultiplyCombiner,
+ sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceFragmentShadingRatePropertiesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceFragmentShadingRatePropertiesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->minFragmentShadingRateAttachmentTexelSize));
- unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxFragmentShadingRateAttachmentTexelSize));
- vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentShadingRateAttachmentTexelSizeAspectRatio, sizeof(uint32_t));
- vkStream->read((VkBool32*)&forUnmarshaling->primitiveFragmentShadingRateWithMultipleViewports, sizeof(VkBool32));
+ unmarshal_VkExtent2D(
+ vkStream, rootType,
+ (VkExtent2D*)(&forUnmarshaling->minFragmentShadingRateAttachmentTexelSize));
+ unmarshal_VkExtent2D(
+ vkStream, rootType,
+ (VkExtent2D*)(&forUnmarshaling->maxFragmentShadingRateAttachmentTexelSize));
+ vkStream->read(
+ (uint32_t*)&forUnmarshaling->maxFragmentShadingRateAttachmentTexelSizeAspectRatio,
+ sizeof(uint32_t));
+ vkStream->read((VkBool32*)&forUnmarshaling->primitiveFragmentShadingRateWithMultipleViewports,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->layeredShadingRateAttachments, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateNonTrivialCombinerOps, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateNonTrivialCombinerOps,
+ sizeof(VkBool32));
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxFragmentSize));
vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentSizeAspectRatio, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentShadingRateCoverageSamples, sizeof(uint32_t));
- vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->maxFragmentShadingRateRasterizationSamples, sizeof(VkSampleCountFlagBits));
- vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateWithShaderDepthStencilWrites, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateWithSampleMask, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateWithShaderSampleMask, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateWithConservativeRasterization, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateWithFragmentShaderInterlock, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateWithCustomSampleLocations, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateStrictMultiplyCombiner, sizeof(VkBool32));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxFragmentShadingRateCoverageSamples,
+ sizeof(uint32_t));
+ vkStream->read(
+ (VkSampleCountFlagBits*)&forUnmarshaling->maxFragmentShadingRateRasterizationSamples,
+ sizeof(VkSampleCountFlagBits));
+ vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateWithShaderDepthStencilWrites,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateWithSampleMask,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateWithShaderSampleMask,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateWithConservativeRasterization,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateWithFragmentShaderInterlock,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateWithCustomSampleLocations,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->fragmentShadingRateStrictMultiplyCombiner,
+ sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceFragmentShadingRateKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRateKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -13310,14 +12021,11 @@
}
void unmarshal_VkPhysicalDeviceFragmentShadingRateKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceFragmentShadingRateKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceFragmentShadingRateKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -13330,14 +12038,11 @@
#endif
#ifdef VK_KHR_surface_protected_capabilities
void marshal_VkSurfaceProtectedCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceProtectedCapabilitiesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceProtectedCapabilitiesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -13345,14 +12050,11 @@
}
void unmarshal_VkSurfaceProtectedCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSurfaceProtectedCapabilitiesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSurfaceProtectedCapabilitiesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -13364,14 +12066,11 @@
#endif
#ifdef VK_KHR_present_wait
void marshal_VkPhysicalDevicePresentWaitFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePresentWaitFeaturesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePresentWaitFeaturesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -13379,14 +12078,11 @@
}
void unmarshal_VkPhysicalDevicePresentWaitFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDevicePresentWaitFeaturesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePresentWaitFeaturesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -13402,14 +12098,11 @@
#endif
#ifdef VK_KHR_pipeline_executable_properties
void marshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -13417,29 +12110,22 @@
}
void unmarshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->pipelineExecutableInfo, sizeof(VkBool32));
}
-void marshal_VkPipelineInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineInfoKHR* forMarshaling)
-{
+void marshal_VkPipelineInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -13448,32 +12134,26 @@
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}
-void unmarshal_VkPipelineInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkPipelineInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_0, (VkPipeline*)&forUnmarshaling->pipeline, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkPipeline(
+ &cgen_var_0, (VkPipeline*)&forUnmarshaling->pipeline, 1);
}
void marshal_VkPipelineExecutablePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineExecutablePropertiesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineExecutablePropertiesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -13484,14 +12164,11 @@
}
void unmarshal_VkPipelineExecutablePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineExecutablePropertiesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineExecutablePropertiesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -13501,15 +12178,11 @@
vkStream->read((uint32_t*)&forUnmarshaling->subgroupSize, sizeof(uint32_t));
}
-void marshal_VkPipelineExecutableInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineExecutableInfoKHR* forMarshaling)
-{
+void marshal_VkPipelineExecutableInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineExecutableInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -13519,87 +12192,75 @@
vkStream->write((uint32_t*)&forMarshaling->executableIndex, sizeof(uint32_t));
}
-void unmarshal_VkPipelineExecutableInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineExecutableInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkPipelineExecutableInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineExecutableInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_0, (VkPipeline*)&forUnmarshaling->pipeline, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkPipeline(
+ &cgen_var_0, (VkPipeline*)&forUnmarshaling->pipeline, 1);
vkStream->read((uint32_t*)&forUnmarshaling->executableIndex, sizeof(uint32_t));
}
void marshal_VkPipelineExecutableStatisticValueKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineExecutableStatisticValueKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineExecutableStatisticValueKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkBool32*)&forMarshaling->b32, sizeof(VkBool32));
}
void unmarshal_VkPipelineExecutableStatisticValueKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineExecutableStatisticValueKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineExecutableStatisticValueKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkBool32*)&forUnmarshaling->b32, sizeof(VkBool32));
}
void marshal_VkPipelineExecutableStatisticKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineExecutableStatisticKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineExecutableStatisticKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((char*)forMarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
- vkStream->write((VkPipelineExecutableStatisticFormatKHR*)&forMarshaling->format, sizeof(VkPipelineExecutableStatisticFormatKHR));
- marshal_VkPipelineExecutableStatisticValueKHR(vkStream, rootType, (VkPipelineExecutableStatisticValueKHR*)(&forMarshaling->value));
+ vkStream->write((VkPipelineExecutableStatisticFormatKHR*)&forMarshaling->format,
+ sizeof(VkPipelineExecutableStatisticFormatKHR));
+ marshal_VkPipelineExecutableStatisticValueKHR(
+ vkStream, rootType, (VkPipelineExecutableStatisticValueKHR*)(&forMarshaling->value));
}
-void unmarshal_VkPipelineExecutableStatisticKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineExecutableStatisticKHR* forUnmarshaling)
-{
+void unmarshal_VkPipelineExecutableStatisticKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPipelineExecutableStatisticKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((char*)forUnmarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
- vkStream->read((VkPipelineExecutableStatisticFormatKHR*)&forUnmarshaling->format, sizeof(VkPipelineExecutableStatisticFormatKHR));
- unmarshal_VkPipelineExecutableStatisticValueKHR(vkStream, rootType, (VkPipelineExecutableStatisticValueKHR*)(&forUnmarshaling->value));
+ vkStream->read((VkPipelineExecutableStatisticFormatKHR*)&forUnmarshaling->format,
+ sizeof(VkPipelineExecutableStatisticFormatKHR));
+ unmarshal_VkPipelineExecutableStatisticValueKHR(
+ vkStream, rootType, (VkPipelineExecutableStatisticValueKHR*)(&forUnmarshaling->value));
}
void marshal_VkPipelineExecutableInternalRepresentationKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineExecutableInternalRepresentationKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineExecutableInternalRepresentationKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -13611,21 +12272,17 @@
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pData;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pData)
- {
+ if (forMarshaling->pData) {
vkStream->write((void*)forMarshaling->pData, forMarshaling->dataSize * sizeof(uint8_t));
}
}
void unmarshal_VkPipelineExecutableInternalRepresentationKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineExecutableInternalRepresentationKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineExecutableInternalRepresentationKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -13636,10 +12293,8 @@
// WARNING PTR CHECK
void* check_pData;
check_pData = (void*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pData)
- {
- if (!(check_pData))
- {
+ if (forUnmarshaling->pData) {
+ if (!(check_pData)) {
fprintf(stderr, "fatal: forUnmarshaling->pData inconsistent between guest and host\n");
}
vkStream->read((void*)forUnmarshaling->pData, forUnmarshaling->dataSize * sizeof(uint8_t));
@@ -13649,14 +12304,11 @@
#endif
#ifdef VK_KHR_shader_integer_dot_product
void marshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -13664,14 +12316,11 @@
}
void unmarshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -13679,136 +12328,216 @@
}
void marshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitUnsignedAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitSignedAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitMixedSignednessAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedUnsignedAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedSignedAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedMixedSignednessAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitUnsignedAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitSignedAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitMixedSignednessAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitUnsignedAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitSignedAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitMixedSignednessAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitUnsignedAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitSignedAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitMixedSignednessAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating8BitSignedAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating16BitSignedAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating32BitSignedAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating64BitSignedAccelerated, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitUnsignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitSignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedUnsignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedSignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->write(
+ (VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedMixedSignednessAccelerated,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitUnsignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitSignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitUnsignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitSignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitUnsignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitSignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
+ vkStream->write(
+ (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->write(
+ (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating8BitSignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling
+ ->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling
+ ->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling
+ ->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->write(
+ (VkBool32*)&forMarshaling
+ ->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated,
+ sizeof(VkBool32));
+ vkStream->write(
+ (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->write(
+ (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating16BitSignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling
+ ->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
+ vkStream->write(
+ (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->write(
+ (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating32BitSignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling
+ ->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
+ vkStream->write(
+ (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->write(
+ (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating64BitSignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling
+ ->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitUnsignedAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitSignedAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitMixedSignednessAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedUnsignedAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedSignedAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedMixedSignednessAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitUnsignedAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitSignedAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitMixedSignednessAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitUnsignedAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitSignedAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitMixedSignednessAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitUnsignedAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitSignedAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitMixedSignednessAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitSignedAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating16BitSignedAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating32BitSignedAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating64BitSignedAccelerated, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitUnsignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitSignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedUnsignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedSignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->read(
+ (VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedMixedSignednessAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitUnsignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitSignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitUnsignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitSignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitUnsignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitSignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
+ vkStream->read(
+ (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->read(
+ (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitSignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling
+ ->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling
+ ->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling
+ ->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->read(
+ (VkBool32*)&forUnmarshaling
+ ->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling
+ ->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->read(
+ (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating16BitSignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling
+ ->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling
+ ->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->read(
+ (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating32BitSignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling
+ ->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling
+ ->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->read(
+ (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating64BitSignedAccelerated,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling
+ ->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
}
#endif
#ifdef VK_KHR_pipeline_library
-void marshal_VkPipelineLibraryCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineLibraryCreateInfoKHR* forMarshaling)
-{
+void marshal_VkPipelineLibraryCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineLibraryCreateInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->libraryCount, sizeof(uint32_t));
- if (forMarshaling->libraryCount)
- {
+ if (forMarshaling->libraryCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forMarshaling->libraryCount * 8);
- vkStream->handleMapping()->mapHandles_VkPipeline_u64(forMarshaling->pLibraries, cgen_var_0, forMarshaling->libraryCount);
+ vkStream->handleMapping()->mapHandles_VkPipeline_u64(forMarshaling->pLibraries, cgen_var_0,
+ forMarshaling->libraryCount);
vkStream->write((uint64_t*)cgen_var_0, forMarshaling->libraryCount * 8);
}
}
-void unmarshal_VkPipelineLibraryCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineLibraryCreateInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkPipelineLibraryCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineLibraryCreateInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->libraryCount, sizeof(uint32_t));
- if (forUnmarshaling->libraryCount)
- {
+ if (forUnmarshaling->libraryCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->libraryCount * 8);
vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->libraryCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_0, (VkPipeline*)forUnmarshaling->pLibraries, forUnmarshaling->libraryCount);
+ vkStream->handleMapping()->mapHandles_u64_VkPipeline(
+ cgen_var_0, (VkPipeline*)forUnmarshaling->pLibraries, forUnmarshaling->libraryCount);
}
}
@@ -13816,15 +12545,11 @@
#ifdef VK_KHR_shader_non_semantic_info
#endif
#ifdef VK_KHR_present_id
-void marshal_VkPresentIdKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentIdKHR* forMarshaling)
-{
+void marshal_VkPresentIdKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentIdKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -13832,21 +12557,17 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pPresentIds;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pPresentIds)
- {
- vkStream->write((const uint64_t*)forMarshaling->pPresentIds, forMarshaling->swapchainCount * sizeof(const uint64_t));
+ if (forMarshaling->pPresentIds) {
+ vkStream->write((const uint64_t*)forMarshaling->pPresentIds,
+ forMarshaling->swapchainCount * sizeof(const uint64_t));
}
}
-void unmarshal_VkPresentIdKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPresentIdKHR* forUnmarshaling)
-{
+void unmarshal_VkPresentIdKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPresentIdKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -13854,25 +12575,22 @@
// WARNING PTR CHECK
const uint64_t* check_pPresentIds;
check_pPresentIds = (const uint64_t*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pPresentIds)
- {
- if (!(check_pPresentIds))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pPresentIds inconsistent between guest and host\n");
+ if (forUnmarshaling->pPresentIds) {
+ if (!(check_pPresentIds)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pPresentIds inconsistent between guest and host\n");
}
- vkStream->read((uint64_t*)forUnmarshaling->pPresentIds, forUnmarshaling->swapchainCount * sizeof(const uint64_t));
+ vkStream->read((uint64_t*)forUnmarshaling->pPresentIds,
+ forUnmarshaling->swapchainCount * sizeof(const uint64_t));
}
}
void marshal_VkPhysicalDevicePresentIdFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePresentIdFeaturesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePresentIdFeaturesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -13880,14 +12598,11 @@
}
void unmarshal_VkPhysicalDevicePresentIdFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDevicePresentIdFeaturesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePresentIdFeaturesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -13896,15 +12611,11 @@
#endif
#ifdef VK_KHR_video_encode_queue
-void marshal_VkVideoEncodeInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeInfoKHR* forMarshaling)
-{
+void marshal_VkVideoEncodeInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -13912,31 +12623,31 @@
vkStream->write((uint32_t*)&forMarshaling->qualityLevel, sizeof(uint32_t));
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->codedExtent));
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->dstBitstreamBuffer, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->dstBitstreamBuffer,
+ &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->dstBitstreamBufferOffset, sizeof(VkDeviceSize));
- vkStream->write((VkDeviceSize*)&forMarshaling->dstBitstreamBufferMaxRange, sizeof(VkDeviceSize));
- marshal_VkVideoPictureResourceKHR(vkStream, rootType, (VkVideoPictureResourceKHR*)(&forMarshaling->srcPictureResource));
- marshal_VkVideoReferenceSlotKHR(vkStream, rootType, (const VkVideoReferenceSlotKHR*)(forMarshaling->pSetupReferenceSlot));
+ vkStream->write((VkDeviceSize*)&forMarshaling->dstBitstreamBufferMaxRange,
+ sizeof(VkDeviceSize));
+ marshal_VkVideoPictureResourceKHR(
+ vkStream, rootType, (VkVideoPictureResourceKHR*)(&forMarshaling->srcPictureResource));
+ marshal_VkVideoReferenceSlotKHR(
+ vkStream, rootType, (const VkVideoReferenceSlotKHR*)(forMarshaling->pSetupReferenceSlot));
vkStream->write((uint32_t*)&forMarshaling->referenceSlotCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i)
- {
- marshal_VkVideoReferenceSlotKHR(vkStream, rootType, (const VkVideoReferenceSlotKHR*)(forMarshaling->pReferenceSlots + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i) {
+ marshal_VkVideoReferenceSlotKHR(
+ vkStream, rootType,
+ (const VkVideoReferenceSlotKHR*)(forMarshaling->pReferenceSlots + i));
}
}
}
-void unmarshal_VkVideoEncodeInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkVideoEncodeInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEncodeInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -13945,35 +12656,37 @@
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->codedExtent));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0, (VkBuffer*)&forUnmarshaling->dstBitstreamBuffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(
+ &cgen_var_0, (VkBuffer*)&forUnmarshaling->dstBitstreamBuffer, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->dstBitstreamBufferOffset, sizeof(VkDeviceSize));
- vkStream->read((VkDeviceSize*)&forUnmarshaling->dstBitstreamBufferMaxRange, sizeof(VkDeviceSize));
- unmarshal_VkVideoPictureResourceKHR(vkStream, rootType, (VkVideoPictureResourceKHR*)(&forUnmarshaling->srcPictureResource));
- unmarshal_VkVideoReferenceSlotKHR(vkStream, rootType, (VkVideoReferenceSlotKHR*)(forUnmarshaling->pSetupReferenceSlot));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->dstBitstreamBufferMaxRange,
+ sizeof(VkDeviceSize));
+ unmarshal_VkVideoPictureResourceKHR(
+ vkStream, rootType, (VkVideoPictureResourceKHR*)(&forUnmarshaling->srcPictureResource));
+ unmarshal_VkVideoReferenceSlotKHR(
+ vkStream, rootType, (VkVideoReferenceSlotKHR*)(forUnmarshaling->pSetupReferenceSlot));
vkStream->read((uint32_t*)&forUnmarshaling->referenceSlotCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceSlotCount; ++i)
- {
- unmarshal_VkVideoReferenceSlotKHR(vkStream, rootType, (VkVideoReferenceSlotKHR*)(forUnmarshaling->pReferenceSlots + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceSlotCount; ++i) {
+ unmarshal_VkVideoReferenceSlotKHR(
+ vkStream, rootType,
+ (VkVideoReferenceSlotKHR*)(forUnmarshaling->pReferenceSlots + i));
}
}
}
-void marshal_VkVideoEncodeRateControlInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeRateControlInfoKHR* forMarshaling)
-{
+void marshal_VkVideoEncodeRateControlInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeRateControlInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkVideoEncodeRateControlFlagsKHR*)&forMarshaling->flags, sizeof(VkVideoEncodeRateControlFlagsKHR));
- vkStream->write((VkVideoEncodeRateControlModeFlagBitsKHR*)&forMarshaling->rateControlMode, sizeof(VkVideoEncodeRateControlModeFlagBitsKHR));
+ vkStream->write((VkVideoEncodeRateControlFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkVideoEncodeRateControlFlagsKHR));
+ vkStream->write((VkVideoEncodeRateControlModeFlagBitsKHR*)&forMarshaling->rateControlMode,
+ sizeof(VkVideoEncodeRateControlModeFlagBitsKHR));
vkStream->write((uint32_t*)&forMarshaling->averageBitrate, sizeof(uint32_t));
vkStream->write((uint16_t*)&forMarshaling->peakToAverageBitrateRatio, sizeof(uint16_t));
vkStream->write((uint16_t*)&forMarshaling->frameRateNumerator, sizeof(uint16_t));
@@ -13981,20 +12694,19 @@
vkStream->write((uint32_t*)&forMarshaling->virtualBufferSizeInMs, sizeof(uint32_t));
}
-void unmarshal_VkVideoEncodeRateControlInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeRateControlInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkVideoEncodeRateControlInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoEncodeRateControlInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkVideoEncodeRateControlFlagsKHR*)&forUnmarshaling->flags, sizeof(VkVideoEncodeRateControlFlagsKHR));
- vkStream->read((VkVideoEncodeRateControlModeFlagBitsKHR*)&forUnmarshaling->rateControlMode, sizeof(VkVideoEncodeRateControlModeFlagBitsKHR));
+ vkStream->read((VkVideoEncodeRateControlFlagsKHR*)&forUnmarshaling->flags,
+ sizeof(VkVideoEncodeRateControlFlagsKHR));
+ vkStream->read((VkVideoEncodeRateControlModeFlagBitsKHR*)&forUnmarshaling->rateControlMode,
+ sizeof(VkVideoEncodeRateControlModeFlagBitsKHR));
vkStream->read((uint32_t*)&forUnmarshaling->averageBitrate, sizeof(uint32_t));
vkStream->read((uint16_t*)&forUnmarshaling->peakToAverageBitrateRatio, sizeof(uint16_t));
vkStream->read((uint16_t*)&forUnmarshaling->frameRateNumerator, sizeof(uint16_t));
@@ -14004,57 +12716,51 @@
#endif
#ifdef VK_KHR_synchronization2
-void marshal_VkMemoryBarrier2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryBarrier2KHR* forMarshaling)
-{
+void marshal_VkMemoryBarrier2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryBarrier2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->srcStageMask, sizeof(VkPipelineStageFlags2KHR));
+ vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->srcStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
vkStream->write((VkAccessFlags2KHR*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags2KHR));
- vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->dstStageMask, sizeof(VkPipelineStageFlags2KHR));
+ vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->dstStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
vkStream->write((VkAccessFlags2KHR*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags2KHR));
}
-void unmarshal_VkMemoryBarrier2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryBarrier2KHR* forUnmarshaling)
-{
+void unmarshal_VkMemoryBarrier2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryBarrier2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->srcStageMask, sizeof(VkPipelineStageFlags2KHR));
+ vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->srcStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
vkStream->read((VkAccessFlags2KHR*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags2KHR));
- vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->dstStageMask, sizeof(VkPipelineStageFlags2KHR));
+ vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->dstStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
vkStream->read((VkAccessFlags2KHR*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags2KHR));
}
-void marshal_VkBufferMemoryBarrier2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferMemoryBarrier2KHR* forMarshaling)
-{
+void marshal_VkBufferMemoryBarrier2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferMemoryBarrier2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->srcStageMask, sizeof(VkPipelineStageFlags2KHR));
+ vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->srcStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
vkStream->write((VkAccessFlags2KHR*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags2KHR));
- vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->dstStageMask, sizeof(VkPipelineStageFlags2KHR));
+ vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->dstStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
vkStream->write((VkAccessFlags2KHR*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags2KHR));
vkStream->write((uint32_t*)&forMarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
@@ -14065,46 +12771,43 @@
vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
}
-void unmarshal_VkBufferMemoryBarrier2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferMemoryBarrier2KHR* forUnmarshaling)
-{
+void unmarshal_VkBufferMemoryBarrier2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferMemoryBarrier2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->srcStageMask, sizeof(VkPipelineStageFlags2KHR));
+ vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->srcStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
vkStream->read((VkAccessFlags2KHR*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags2KHR));
- vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->dstStageMask, sizeof(VkPipelineStageFlags2KHR));
+ vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->dstStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
vkStream->read((VkAccessFlags2KHR*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags2KHR));
vkStream->read((uint32_t*)&forUnmarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+ (VkBuffer*)&forUnmarshaling->buffer, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
}
-void marshal_VkImageMemoryBarrier2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageMemoryBarrier2KHR* forMarshaling)
-{
+void marshal_VkImageMemoryBarrier2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageMemoryBarrier2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->srcStageMask, sizeof(VkPipelineStageFlags2KHR));
+ vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->srcStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
vkStream->write((VkAccessFlags2KHR*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags2KHR));
- vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->dstStageMask, sizeof(VkPipelineStageFlags2KHR));
+ vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->dstStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
vkStream->write((VkAccessFlags2KHR*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags2KHR));
vkStream->write((VkImageLayout*)&forMarshaling->oldLayout, sizeof(VkImageLayout));
vkStream->write((VkImageLayout*)&forMarshaling->newLayout, sizeof(VkImageLayout));
@@ -14113,24 +12816,23 @@
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- marshal_VkImageSubresourceRange(vkStream, rootType, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
+ marshal_VkImageSubresourceRange(vkStream, rootType,
+ (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
}
-void unmarshal_VkImageMemoryBarrier2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageMemoryBarrier2KHR* forUnmarshaling)
-{
+void unmarshal_VkImageMemoryBarrier2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageMemoryBarrier2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->srcStageMask, sizeof(VkPipelineStageFlags2KHR));
+ vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->srcStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
vkStream->read((VkAccessFlags2KHR*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags2KHR));
- vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->dstStageMask, sizeof(VkPipelineStageFlags2KHR));
+ vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->dstStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
vkStream->read((VkAccessFlags2KHR*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags2KHR));
vkStream->read((VkImageLayout*)&forUnmarshaling->oldLayout, sizeof(VkImageLayout));
vkStream->read((VkImageLayout*)&forUnmarshaling->newLayout, sizeof(VkImageLayout));
@@ -14138,251 +12840,224 @@
vkStream->read((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0, (VkImage*)&forUnmarshaling->image, 1);
- unmarshal_VkImageSubresourceRange(vkStream, rootType, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+ (VkImage*)&forUnmarshaling->image, 1);
+ unmarshal_VkImageSubresourceRange(
+ vkStream, rootType, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
}
-void marshal_VkDependencyInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDependencyInfoKHR* forMarshaling)
-{
+void marshal_VkDependencyInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDependencyInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDependencyFlags*)&forMarshaling->dependencyFlags, sizeof(VkDependencyFlags));
vkStream->write((uint32_t*)&forMarshaling->memoryBarrierCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->memoryBarrierCount; ++i)
- {
- marshal_VkMemoryBarrier2KHR(vkStream, rootType, (const VkMemoryBarrier2KHR*)(forMarshaling->pMemoryBarriers + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->memoryBarrierCount; ++i) {
+ marshal_VkMemoryBarrier2KHR(
+ vkStream, rootType,
+ (const VkMemoryBarrier2KHR*)(forMarshaling->pMemoryBarriers + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->bufferMemoryBarrierCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->bufferMemoryBarrierCount; ++i)
- {
- marshal_VkBufferMemoryBarrier2KHR(vkStream, rootType, (const VkBufferMemoryBarrier2KHR*)(forMarshaling->pBufferMemoryBarriers + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->bufferMemoryBarrierCount; ++i) {
+ marshal_VkBufferMemoryBarrier2KHR(
+ vkStream, rootType,
+ (const VkBufferMemoryBarrier2KHR*)(forMarshaling->pBufferMemoryBarriers + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->imageMemoryBarrierCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageMemoryBarrierCount; ++i)
- {
- marshal_VkImageMemoryBarrier2KHR(vkStream, rootType, (const VkImageMemoryBarrier2KHR*)(forMarshaling->pImageMemoryBarriers + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageMemoryBarrierCount; ++i) {
+ marshal_VkImageMemoryBarrier2KHR(
+ vkStream, rootType,
+ (const VkImageMemoryBarrier2KHR*)(forMarshaling->pImageMemoryBarriers + i));
}
}
}
-void unmarshal_VkDependencyInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDependencyInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkDependencyInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDependencyInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDependencyFlags*)&forUnmarshaling->dependencyFlags, sizeof(VkDependencyFlags));
+ vkStream->read((VkDependencyFlags*)&forUnmarshaling->dependencyFlags,
+ sizeof(VkDependencyFlags));
vkStream->read((uint32_t*)&forUnmarshaling->memoryBarrierCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->memoryBarrierCount; ++i)
- {
- unmarshal_VkMemoryBarrier2KHR(vkStream, rootType, (VkMemoryBarrier2KHR*)(forUnmarshaling->pMemoryBarriers + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->memoryBarrierCount; ++i) {
+ unmarshal_VkMemoryBarrier2KHR(
+ vkStream, rootType, (VkMemoryBarrier2KHR*)(forUnmarshaling->pMemoryBarriers + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->bufferMemoryBarrierCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bufferMemoryBarrierCount; ++i)
- {
- unmarshal_VkBufferMemoryBarrier2KHR(vkStream, rootType, (VkBufferMemoryBarrier2KHR*)(forUnmarshaling->pBufferMemoryBarriers + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bufferMemoryBarrierCount; ++i) {
+ unmarshal_VkBufferMemoryBarrier2KHR(
+ vkStream, rootType,
+ (VkBufferMemoryBarrier2KHR*)(forUnmarshaling->pBufferMemoryBarriers + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->imageMemoryBarrierCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->imageMemoryBarrierCount; ++i)
- {
- unmarshal_VkImageMemoryBarrier2KHR(vkStream, rootType, (VkImageMemoryBarrier2KHR*)(forUnmarshaling->pImageMemoryBarriers + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->imageMemoryBarrierCount; ++i) {
+ unmarshal_VkImageMemoryBarrier2KHR(
+ vkStream, rootType,
+ (VkImageMemoryBarrier2KHR*)(forUnmarshaling->pImageMemoryBarriers + i));
}
}
}
-void marshal_VkSemaphoreSubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreSubmitInfoKHR* forMarshaling)
-{
+void marshal_VkSemaphoreSubmitInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreSubmitInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((uint64_t*)&forMarshaling->value, sizeof(uint64_t));
- vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->stageMask, sizeof(VkPipelineStageFlags2KHR));
+ vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->stageMask,
+ sizeof(VkPipelineStageFlags2KHR));
vkStream->write((uint32_t*)&forMarshaling->deviceIndex, sizeof(uint32_t));
}
-void unmarshal_VkSemaphoreSubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSemaphoreSubmitInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkSemaphoreSubmitInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSemaphoreSubmitInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
+ &cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
vkStream->read((uint64_t*)&forUnmarshaling->value, sizeof(uint64_t));
- vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->stageMask, sizeof(VkPipelineStageFlags2KHR));
+ vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->stageMask,
+ sizeof(VkPipelineStageFlags2KHR));
vkStream->read((uint32_t*)&forUnmarshaling->deviceIndex, sizeof(uint32_t));
}
-void marshal_VkCommandBufferSubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferSubmitInfoKHR* forMarshaling)
-{
+void marshal_VkCommandBufferSubmitInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferSubmitInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&forMarshaling->commandBuffer, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&forMarshaling->commandBuffer,
+ &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
}
-void unmarshal_VkCommandBufferSubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCommandBufferSubmitInfoKHR* forUnmarshaling)
-{
+void unmarshal_VkCommandBufferSubmitInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCommandBufferSubmitInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkCommandBuffer(&cgen_var_0, (VkCommandBuffer*)&forUnmarshaling->commandBuffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkCommandBuffer(
+ &cgen_var_0, (VkCommandBuffer*)&forUnmarshaling->commandBuffer, 1);
vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
}
-void marshal_VkSubmitInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubmitInfo2KHR* forMarshaling)
-{
+void marshal_VkSubmitInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubmitInfo2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkSubmitFlagsKHR*)&forMarshaling->flags, sizeof(VkSubmitFlagsKHR));
vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreInfoCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->waitSemaphoreInfoCount; ++i)
- {
- marshal_VkSemaphoreSubmitInfoKHR(vkStream, rootType, (const VkSemaphoreSubmitInfoKHR*)(forMarshaling->pWaitSemaphoreInfos + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->waitSemaphoreInfoCount; ++i) {
+ marshal_VkSemaphoreSubmitInfoKHR(
+ vkStream, rootType,
+ (const VkSemaphoreSubmitInfoKHR*)(forMarshaling->pWaitSemaphoreInfos + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->commandBufferInfoCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->commandBufferInfoCount; ++i)
- {
- marshal_VkCommandBufferSubmitInfoKHR(vkStream, rootType, (const VkCommandBufferSubmitInfoKHR*)(forMarshaling->pCommandBufferInfos + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->commandBufferInfoCount; ++i) {
+ marshal_VkCommandBufferSubmitInfoKHR(
+ vkStream, rootType,
+ (const VkCommandBufferSubmitInfoKHR*)(forMarshaling->pCommandBufferInfos + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreInfoCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->signalSemaphoreInfoCount; ++i)
- {
- marshal_VkSemaphoreSubmitInfoKHR(vkStream, rootType, (const VkSemaphoreSubmitInfoKHR*)(forMarshaling->pSignalSemaphoreInfos + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->signalSemaphoreInfoCount; ++i) {
+ marshal_VkSemaphoreSubmitInfoKHR(
+ vkStream, rootType,
+ (const VkSemaphoreSubmitInfoKHR*)(forMarshaling->pSignalSemaphoreInfos + i));
}
}
}
-void unmarshal_VkSubmitInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubmitInfo2KHR* forUnmarshaling)
-{
+void unmarshal_VkSubmitInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubmitInfo2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkSubmitFlagsKHR*)&forUnmarshaling->flags, sizeof(VkSubmitFlagsKHR));
vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreInfoCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->waitSemaphoreInfoCount; ++i)
- {
- unmarshal_VkSemaphoreSubmitInfoKHR(vkStream, rootType, (VkSemaphoreSubmitInfoKHR*)(forUnmarshaling->pWaitSemaphoreInfos + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->waitSemaphoreInfoCount; ++i) {
+ unmarshal_VkSemaphoreSubmitInfoKHR(
+ vkStream, rootType,
+ (VkSemaphoreSubmitInfoKHR*)(forUnmarshaling->pWaitSemaphoreInfos + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->commandBufferInfoCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->commandBufferInfoCount; ++i)
- {
- unmarshal_VkCommandBufferSubmitInfoKHR(vkStream, rootType, (VkCommandBufferSubmitInfoKHR*)(forUnmarshaling->pCommandBufferInfos + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->commandBufferInfoCount; ++i) {
+ unmarshal_VkCommandBufferSubmitInfoKHR(
+ vkStream, rootType,
+ (VkCommandBufferSubmitInfoKHR*)(forUnmarshaling->pCommandBufferInfos + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreInfoCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->signalSemaphoreInfoCount; ++i)
- {
- unmarshal_VkSemaphoreSubmitInfoKHR(vkStream, rootType, (VkSemaphoreSubmitInfoKHR*)(forUnmarshaling->pSignalSemaphoreInfos + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->signalSemaphoreInfoCount; ++i) {
+ unmarshal_VkSemaphoreSubmitInfoKHR(
+ vkStream, rootType,
+ (VkSemaphoreSubmitInfoKHR*)(forUnmarshaling->pSignalSemaphoreInfos + i));
}
}
}
void marshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSynchronization2FeaturesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSynchronization2FeaturesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -14390,14 +13065,11 @@
}
void unmarshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceSynchronization2FeaturesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceSynchronization2FeaturesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -14405,78 +13077,67 @@
}
void marshal_VkQueueFamilyCheckpointProperties2NV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueueFamilyCheckpointProperties2NV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyCheckpointProperties2NV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->checkpointExecutionStageMask, sizeof(VkPipelineStageFlags2KHR));
+ vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->checkpointExecutionStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
}
void unmarshal_VkQueueFamilyCheckpointProperties2NV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkQueueFamilyCheckpointProperties2NV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkQueueFamilyCheckpointProperties2NV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->checkpointExecutionStageMask, sizeof(VkPipelineStageFlags2KHR));
+ vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->checkpointExecutionStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
}
-void marshal_VkCheckpointData2NV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCheckpointData2NV* forMarshaling)
-{
+void marshal_VkCheckpointData2NV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCheckpointData2NV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->stage, sizeof(VkPipelineStageFlags2KHR));
+ vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->stage,
+ sizeof(VkPipelineStageFlags2KHR));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pCheckpointMarker;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pCheckpointMarker)
- {
+ if (forMarshaling->pCheckpointMarker) {
vkStream->write((void*)forMarshaling->pCheckpointMarker, sizeof(uint8_t));
}
}
-void unmarshal_VkCheckpointData2NV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCheckpointData2NV* forUnmarshaling)
-{
+void unmarshal_VkCheckpointData2NV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCheckpointData2NV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->stage, sizeof(VkPipelineStageFlags2KHR));
+ vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->stage,
+ sizeof(VkPipelineStageFlags2KHR));
// WARNING PTR CHECK
void* check_pCheckpointMarker;
check_pCheckpointMarker = (void*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pCheckpointMarker)
- {
- if (!(check_pCheckpointMarker))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pCheckpointMarker inconsistent between guest and host\n");
+ if (forUnmarshaling->pCheckpointMarker) {
+ if (!(check_pCheckpointMarker)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pCheckpointMarker inconsistent between guest and host\n");
}
vkStream->read((void*)forUnmarshaling->pCheckpointMarker, sizeof(uint8_t));
}
@@ -14485,14 +13146,11 @@
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
void marshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -14500,14 +13158,11 @@
}
void unmarshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -14517,84 +13172,76 @@
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
void marshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkBool32*)&forMarshaling->shaderZeroInitializeWorkgroupMemory, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->shaderZeroInitializeWorkgroupMemory,
+ sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkBool32*)&forUnmarshaling->shaderZeroInitializeWorkgroupMemory, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->shaderZeroInitializeWorkgroupMemory,
+ sizeof(VkBool32));
}
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
void marshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->workgroupMemoryExplicitLayout, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->workgroupMemoryExplicitLayoutScalarBlockLayout, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->workgroupMemoryExplicitLayout8BitAccess, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->workgroupMemoryExplicitLayout16BitAccess, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->workgroupMemoryExplicitLayoutScalarBlockLayout,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->workgroupMemoryExplicitLayout8BitAccess,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->workgroupMemoryExplicitLayout16BitAccess,
+ sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->workgroupMemoryExplicitLayout, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->workgroupMemoryExplicitLayoutScalarBlockLayout, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->workgroupMemoryExplicitLayout8BitAccess, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->workgroupMemoryExplicitLayout16BitAccess, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->workgroupMemoryExplicitLayoutScalarBlockLayout,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->workgroupMemoryExplicitLayout8BitAccess,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->workgroupMemoryExplicitLayout16BitAccess,
+ sizeof(VkBool32));
}
#endif
#ifdef VK_KHR_copy_commands2
-void marshal_VkBufferCopy2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCopy2KHR* forMarshaling)
-{
+void marshal_VkBufferCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCopy2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -14603,15 +13250,11 @@
vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
}
-void unmarshal_VkBufferCopy2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferCopy2KHR* forUnmarshaling)
-{
+void unmarshal_VkBufferCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferCopy2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -14620,15 +13263,11 @@
vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
}
-void marshal_VkCopyBufferInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyBufferInfo2KHR* forMarshaling)
-{
+void marshal_VkCopyBufferInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyBufferInfo2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -14639,90 +13278,78 @@
vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->dstBuffer, &cgen_var_1, 1);
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
- {
- marshal_VkBufferCopy2KHR(vkStream, rootType, (const VkBufferCopy2KHR*)(forMarshaling->pRegions + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+ marshal_VkBufferCopy2KHR(vkStream, rootType,
+ (const VkBufferCopy2KHR*)(forMarshaling->pRegions + i));
}
}
}
-void unmarshal_VkCopyBufferInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCopyBufferInfo2KHR* forUnmarshaling)
-{
+void unmarshal_VkCopyBufferInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyBufferInfo2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0, (VkBuffer*)&forUnmarshaling->srcBuffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+ (VkBuffer*)&forUnmarshaling->srcBuffer, 1);
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_1, (VkBuffer*)&forUnmarshaling->dstBuffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_1,
+ (VkBuffer*)&forUnmarshaling->dstBuffer, 1);
vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i)
- {
- unmarshal_VkBufferCopy2KHR(vkStream, rootType, (VkBufferCopy2KHR*)(forUnmarshaling->pRegions + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+ unmarshal_VkBufferCopy2KHR(vkStream, rootType,
+ (VkBufferCopy2KHR*)(forUnmarshaling->pRegions + i));
}
}
}
-void marshal_VkImageCopy2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageCopy2KHR* forMarshaling)
-{
+void marshal_VkImageCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageCopy2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
+ marshal_VkImageSubresourceLayers(vkStream, rootType,
+ (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset));
- marshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
+ marshal_VkImageSubresourceLayers(vkStream, rootType,
+ (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->dstOffset));
marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent));
}
-void unmarshal_VkImageCopy2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageCopy2KHR* forUnmarshaling)
-{
+void unmarshal_VkImageCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageCopy2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
+ unmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->srcOffset));
- unmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
+ unmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->dstOffset));
unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->extent));
}
-void marshal_VkCopyImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyImageInfo2KHR* forMarshaling)
-{
+void marshal_VkCopyImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyImageInfo2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -14735,94 +13362,80 @@
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
- {
- marshal_VkImageCopy2KHR(vkStream, rootType, (const VkImageCopy2KHR*)(forMarshaling->pRegions + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+ marshal_VkImageCopy2KHR(vkStream, rootType,
+ (const VkImageCopy2KHR*)(forMarshaling->pRegions + i));
}
}
}
-void unmarshal_VkCopyImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCopyImageInfo2KHR* forUnmarshaling)
-{
+void unmarshal_VkCopyImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyImageInfo2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0, (VkImage*)&forUnmarshaling->srcImage, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+ (VkImage*)&forUnmarshaling->srcImage, 1);
vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1, (VkImage*)&forUnmarshaling->dstImage, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1,
+ (VkImage*)&forUnmarshaling->dstImage, 1);
vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i)
- {
- unmarshal_VkImageCopy2KHR(vkStream, rootType, (VkImageCopy2KHR*)(forUnmarshaling->pRegions + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+ unmarshal_VkImageCopy2KHR(vkStream, rootType,
+ (VkImageCopy2KHR*)(forUnmarshaling->pRegions + i));
}
}
}
-void marshal_VkBufferImageCopy2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferImageCopy2KHR* forMarshaling)
-{
+void marshal_VkBufferImageCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferImageCopy2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDeviceSize*)&forMarshaling->bufferOffset, sizeof(VkDeviceSize));
vkStream->write((uint32_t*)&forMarshaling->bufferRowLength, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->bufferImageHeight, sizeof(uint32_t));
- marshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource));
+ marshal_VkImageSubresourceLayers(vkStream, rootType,
+ (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource));
marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset));
marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent));
}
-void unmarshal_VkBufferImageCopy2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferImageCopy2KHR* forUnmarshaling)
-{
+void unmarshal_VkBufferImageCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferImageCopy2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkDeviceSize*)&forUnmarshaling->bufferOffset, sizeof(VkDeviceSize));
vkStream->read((uint32_t*)&forUnmarshaling->bufferRowLength, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->bufferImageHeight, sizeof(uint32_t));
- unmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource));
+ unmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource));
unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->imageOffset));
unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageExtent));
}
-void marshal_VkCopyBufferToImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyBufferToImageInfo2KHR* forMarshaling)
-{
+void marshal_VkCopyBufferToImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyBufferToImageInfo2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -14834,53 +13447,45 @@
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
- {
- marshal_VkBufferImageCopy2KHR(vkStream, rootType, (const VkBufferImageCopy2KHR*)(forMarshaling->pRegions + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+ marshal_VkBufferImageCopy2KHR(
+ vkStream, rootType, (const VkBufferImageCopy2KHR*)(forMarshaling->pRegions + i));
}
}
}
-void unmarshal_VkCopyBufferToImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCopyBufferToImageInfo2KHR* forUnmarshaling)
-{
+void unmarshal_VkCopyBufferToImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyBufferToImageInfo2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0, (VkBuffer*)&forUnmarshaling->srcBuffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+ (VkBuffer*)&forUnmarshaling->srcBuffer, 1);
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1, (VkImage*)&forUnmarshaling->dstImage, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1,
+ (VkImage*)&forUnmarshaling->dstImage, 1);
vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i)
- {
- unmarshal_VkBufferImageCopy2KHR(vkStream, rootType, (VkBufferImageCopy2KHR*)(forUnmarshaling->pRegions + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+ unmarshal_VkBufferImageCopy2KHR(
+ vkStream, rootType, (VkBufferImageCopy2KHR*)(forUnmarshaling->pRegions + i));
}
}
}
-void marshal_VkCopyImageToBufferInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyImageToBufferInfo2KHR* forMarshaling)
-{
+void marshal_VkCopyImageToBufferInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyImageToBufferInfo2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -14892,101 +13497,85 @@
vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->dstBuffer, &cgen_var_1, 1);
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
- {
- marshal_VkBufferImageCopy2KHR(vkStream, rootType, (const VkBufferImageCopy2KHR*)(forMarshaling->pRegions + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+ marshal_VkBufferImageCopy2KHR(
+ vkStream, rootType, (const VkBufferImageCopy2KHR*)(forMarshaling->pRegions + i));
}
}
}
-void unmarshal_VkCopyImageToBufferInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCopyImageToBufferInfo2KHR* forUnmarshaling)
-{
+void unmarshal_VkCopyImageToBufferInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyImageToBufferInfo2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0, (VkImage*)&forUnmarshaling->srcImage, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+ (VkImage*)&forUnmarshaling->srcImage, 1);
vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_1, (VkBuffer*)&forUnmarshaling->dstBuffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_1,
+ (VkBuffer*)&forUnmarshaling->dstBuffer, 1);
vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i)
- {
- unmarshal_VkBufferImageCopy2KHR(vkStream, rootType, (VkBufferImageCopy2KHR*)(forUnmarshaling->pRegions + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+ unmarshal_VkBufferImageCopy2KHR(
+ vkStream, rootType, (VkBufferImageCopy2KHR*)(forUnmarshaling->pRegions + i));
}
}
}
-void marshal_VkImageBlit2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageBlit2KHR* forMarshaling)
-{
+void marshal_VkImageBlit2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageBlit2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ marshal_VkImageSubresourceLayers(vkStream, rootType,
+ (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->srcOffsets + i));
}
- marshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ marshal_VkImageSubresourceLayers(vkStream, rootType,
+ (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->dstOffsets + i));
}
}
-void unmarshal_VkImageBlit2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageBlit2KHR* forUnmarshaling)
-{
+void unmarshal_VkImageBlit2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageBlit2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ unmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forUnmarshaling->srcOffsets + i));
}
- unmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ unmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forUnmarshaling->dstOffsets + i));
}
}
-void marshal_VkBlitImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBlitImageInfo2KHR* forMarshaling)
-{
+void marshal_VkBlitImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBlitImageInfo2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -14999,94 +13588,82 @@
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
- {
- marshal_VkImageBlit2KHR(vkStream, rootType, (const VkImageBlit2KHR*)(forMarshaling->pRegions + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+ marshal_VkImageBlit2KHR(vkStream, rootType,
+ (const VkImageBlit2KHR*)(forMarshaling->pRegions + i));
}
}
vkStream->write((VkFilter*)&forMarshaling->filter, sizeof(VkFilter));
}
-void unmarshal_VkBlitImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBlitImageInfo2KHR* forUnmarshaling)
-{
+void unmarshal_VkBlitImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBlitImageInfo2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0, (VkImage*)&forUnmarshaling->srcImage, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+ (VkImage*)&forUnmarshaling->srcImage, 1);
vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1, (VkImage*)&forUnmarshaling->dstImage, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1,
+ (VkImage*)&forUnmarshaling->dstImage, 1);
vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i)
- {
- unmarshal_VkImageBlit2KHR(vkStream, rootType, (VkImageBlit2KHR*)(forUnmarshaling->pRegions + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+ unmarshal_VkImageBlit2KHR(vkStream, rootType,
+ (VkImageBlit2KHR*)(forUnmarshaling->pRegions + i));
}
}
vkStream->read((VkFilter*)&forUnmarshaling->filter, sizeof(VkFilter));
}
-void marshal_VkImageResolve2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageResolve2KHR* forMarshaling)
-{
+void marshal_VkImageResolve2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageResolve2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
+ marshal_VkImageSubresourceLayers(vkStream, rootType,
+ (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset));
- marshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
+ marshal_VkImageSubresourceLayers(vkStream, rootType,
+ (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->dstOffset));
marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent));
}
-void unmarshal_VkImageResolve2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageResolve2KHR* forUnmarshaling)
-{
+void unmarshal_VkImageResolve2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageResolve2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
+ unmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->srcOffset));
- unmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
+ unmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->dstOffset));
unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->extent));
}
-void marshal_VkResolveImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkResolveImageInfo2KHR* forMarshaling)
-{
+void marshal_VkResolveImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkResolveImageInfo2KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -15099,92 +13676,83 @@
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
- {
- marshal_VkImageResolve2KHR(vkStream, rootType, (const VkImageResolve2KHR*)(forMarshaling->pRegions + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+ marshal_VkImageResolve2KHR(vkStream, rootType,
+ (const VkImageResolve2KHR*)(forMarshaling->pRegions + i));
}
}
}
-void unmarshal_VkResolveImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkResolveImageInfo2KHR* forUnmarshaling)
-{
+void unmarshal_VkResolveImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkResolveImageInfo2KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0, (VkImage*)&forUnmarshaling->srcImage, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+ (VkImage*)&forUnmarshaling->srcImage, 1);
vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1, (VkImage*)&forUnmarshaling->dstImage, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1,
+ (VkImage*)&forUnmarshaling->dstImage, 1);
vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i)
- {
- unmarshal_VkImageResolve2KHR(vkStream, rootType, (VkImageResolve2KHR*)(forUnmarshaling->pRegions + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+ unmarshal_VkImageResolve2KHR(vkStream, rootType,
+ (VkImageResolve2KHR*)(forUnmarshaling->pRegions + i));
}
}
}
#endif
#ifdef VK_KHR_format_feature_flags2
-void marshal_VkFormatProperties3KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFormatProperties3KHR* forMarshaling)
-{
+void marshal_VkFormatProperties3KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFormatProperties3KHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkFormatFeatureFlags2KHR*)&forMarshaling->linearTilingFeatures, sizeof(VkFormatFeatureFlags2KHR));
- vkStream->write((VkFormatFeatureFlags2KHR*)&forMarshaling->optimalTilingFeatures, sizeof(VkFormatFeatureFlags2KHR));
- vkStream->write((VkFormatFeatureFlags2KHR*)&forMarshaling->bufferFeatures, sizeof(VkFormatFeatureFlags2KHR));
+ vkStream->write((VkFormatFeatureFlags2KHR*)&forMarshaling->linearTilingFeatures,
+ sizeof(VkFormatFeatureFlags2KHR));
+ vkStream->write((VkFormatFeatureFlags2KHR*)&forMarshaling->optimalTilingFeatures,
+ sizeof(VkFormatFeatureFlags2KHR));
+ vkStream->write((VkFormatFeatureFlags2KHR*)&forMarshaling->bufferFeatures,
+ sizeof(VkFormatFeatureFlags2KHR));
}
-void unmarshal_VkFormatProperties3KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkFormatProperties3KHR* forUnmarshaling)
-{
+void unmarshal_VkFormatProperties3KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkFormatProperties3KHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkFormatFeatureFlags2KHR*)&forUnmarshaling->linearTilingFeatures, sizeof(VkFormatFeatureFlags2KHR));
- vkStream->read((VkFormatFeatureFlags2KHR*)&forUnmarshaling->optimalTilingFeatures, sizeof(VkFormatFeatureFlags2KHR));
- vkStream->read((VkFormatFeatureFlags2KHR*)&forUnmarshaling->bufferFeatures, sizeof(VkFormatFeatureFlags2KHR));
+ vkStream->read((VkFormatFeatureFlags2KHR*)&forUnmarshaling->linearTilingFeatures,
+ sizeof(VkFormatFeatureFlags2KHR));
+ vkStream->read((VkFormatFeatureFlags2KHR*)&forUnmarshaling->optimalTilingFeatures,
+ sizeof(VkFormatFeatureFlags2KHR));
+ vkStream->read((VkFormatFeatureFlags2KHR*)&forUnmarshaling->bufferFeatures,
+ sizeof(VkFormatFeatureFlags2KHR));
}
#endif
#ifdef VK_KHR_maintenance4
void marshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMaintenance4FeaturesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance4FeaturesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -15192,14 +13760,11 @@
}
void unmarshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceMaintenance4FeaturesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMaintenance4FeaturesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -15207,14 +13772,11 @@
}
void marshal_VkPhysicalDeviceMaintenance4PropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMaintenance4PropertiesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance4PropertiesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -15222,14 +13784,11 @@
}
void unmarshal_VkPhysicalDeviceMaintenance4PropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceMaintenance4PropertiesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMaintenance4PropertiesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -15237,86 +13796,75 @@
}
void marshal_VkDeviceBufferMemoryRequirementsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceBufferMemoryRequirementsKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceBufferMemoryRequirementsKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkBufferCreateInfo(vkStream, rootType, (const VkBufferCreateInfo*)(forMarshaling->pCreateInfo));
+ marshal_VkBufferCreateInfo(vkStream, rootType,
+ (const VkBufferCreateInfo*)(forMarshaling->pCreateInfo));
}
void unmarshal_VkDeviceBufferMemoryRequirementsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceBufferMemoryRequirementsKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceBufferMemoryRequirementsKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkBufferCreateInfo(vkStream, rootType, (VkBufferCreateInfo*)(forUnmarshaling->pCreateInfo));
+ unmarshal_VkBufferCreateInfo(vkStream, rootType,
+ (VkBufferCreateInfo*)(forUnmarshaling->pCreateInfo));
}
void marshal_VkDeviceImageMemoryRequirementsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceImageMemoryRequirementsKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceImageMemoryRequirementsKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkImageCreateInfo(vkStream, rootType, (const VkImageCreateInfo*)(forMarshaling->pCreateInfo));
- vkStream->write((VkImageAspectFlagBits*)&forMarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
+ marshal_VkImageCreateInfo(vkStream, rootType,
+ (const VkImageCreateInfo*)(forMarshaling->pCreateInfo));
+ vkStream->write((VkImageAspectFlagBits*)&forMarshaling->planeAspect,
+ sizeof(VkImageAspectFlagBits));
}
void unmarshal_VkDeviceImageMemoryRequirementsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceImageMemoryRequirementsKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceImageMemoryRequirementsKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkImageCreateInfo(vkStream, rootType, (VkImageCreateInfo*)(forUnmarshaling->pCreateInfo));
- vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
+ unmarshal_VkImageCreateInfo(vkStream, rootType,
+ (VkImageCreateInfo*)(forUnmarshaling->pCreateInfo));
+ vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->planeAspect,
+ sizeof(VkImageAspectFlagBits));
}
#endif
#ifdef VK_ANDROID_native_buffer
-void marshal_VkNativeBufferANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkNativeBufferANDROID* forMarshaling)
-{
+void marshal_VkNativeBufferANDROID(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkNativeBufferANDROID* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->handle;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->handle)
- {
+ if (forMarshaling->handle) {
vkStream->write((const uint32_t*)forMarshaling->handle, sizeof(const uint32_t));
}
vkStream->write((int*)&forMarshaling->stride, sizeof(int));
@@ -15326,25 +13874,19 @@
vkStream->write((uint64_t*)&forMarshaling->producer, sizeof(uint64_t));
}
-void unmarshal_VkNativeBufferANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkNativeBufferANDROID* forUnmarshaling)
-{
+void unmarshal_VkNativeBufferANDROID(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkNativeBufferANDROID* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
// WARNING PTR CHECK
const uint32_t* check_handle;
check_handle = (const uint32_t*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->handle)
- {
- if (!(check_handle))
- {
+ if (forUnmarshaling->handle) {
+ if (!(check_handle)) {
fprintf(stderr, "fatal: forUnmarshaling->handle inconsistent between guest and host\n");
}
vkStream->read((uint32_t*)forUnmarshaling->handle, sizeof(const uint32_t));
@@ -15359,14 +13901,11 @@
#endif
#ifdef VK_EXT_debug_report
void marshal_VkDebugReportCallbackCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugReportCallbackCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugReportCallbackCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -15376,21 +13915,17 @@
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pUserData)
- {
+ if (forMarshaling->pUserData) {
vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
}
}
void unmarshal_VkDebugReportCallbackCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDebugReportCallbackCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDebugReportCallbackCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -15399,11 +13934,10 @@
// WARNING PTR CHECK
void* check_pUserData;
check_pUserData = (void*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pUserData)
- {
- if (!(check_pUserData))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pUserData inconsistent between guest and host\n");
+ if (forUnmarshaling->pUserData) {
+ if (!(check_pUserData)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pUserData inconsistent between guest and host\n");
}
vkStream->read((void*)forUnmarshaling->pUserData, sizeof(uint8_t));
}
@@ -15418,33 +13952,29 @@
#endif
#ifdef VK_AMD_rasterization_order
void marshal_VkPipelineRasterizationStateRasterizationOrderAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationStateRasterizationOrderAMD* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationStateRasterizationOrderAMD* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkRasterizationOrderAMD*)&forMarshaling->rasterizationOrder, sizeof(VkRasterizationOrderAMD));
+ vkStream->write((VkRasterizationOrderAMD*)&forMarshaling->rasterizationOrder,
+ sizeof(VkRasterizationOrderAMD));
}
void unmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineRasterizationStateRasterizationOrderAMD* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineRasterizationStateRasterizationOrderAMD* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkRasterizationOrderAMD*)&forUnmarshaling->rasterizationOrder, sizeof(VkRasterizationOrderAMD));
+ vkStream->read((VkRasterizationOrderAMD*)&forUnmarshaling->rasterizationOrder,
+ sizeof(VkRasterizationOrderAMD));
}
#endif
@@ -15453,88 +13983,73 @@
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
-void marshal_VkDebugMarkerObjectNameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugMarkerObjectNameInfoEXT* forMarshaling)
-{
+void marshal_VkDebugMarkerObjectNameInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugMarkerObjectNameInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDebugReportObjectTypeEXT*)&forMarshaling->objectType, sizeof(VkDebugReportObjectTypeEXT));
+ vkStream->write((VkDebugReportObjectTypeEXT*)&forMarshaling->objectType,
+ sizeof(VkDebugReportObjectTypeEXT));
vkStream->write((uint64_t*)&forMarshaling->object, sizeof(uint64_t));
vkStream->putString(forMarshaling->pObjectName);
}
-void unmarshal_VkDebugMarkerObjectNameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDebugMarkerObjectNameInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkDebugMarkerObjectNameInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDebugMarkerObjectNameInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDebugReportObjectTypeEXT*)&forUnmarshaling->objectType, sizeof(VkDebugReportObjectTypeEXT));
+ vkStream->read((VkDebugReportObjectTypeEXT*)&forUnmarshaling->objectType,
+ sizeof(VkDebugReportObjectTypeEXT));
vkStream->read((uint64_t*)&forUnmarshaling->object, sizeof(uint64_t));
vkStream->loadStringInPlace((char**)&forUnmarshaling->pObjectName);
}
-void marshal_VkDebugMarkerObjectTagInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugMarkerObjectTagInfoEXT* forMarshaling)
-{
+void marshal_VkDebugMarkerObjectTagInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugMarkerObjectTagInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDebugReportObjectTypeEXT*)&forMarshaling->objectType, sizeof(VkDebugReportObjectTypeEXT));
+ vkStream->write((VkDebugReportObjectTypeEXT*)&forMarshaling->objectType,
+ sizeof(VkDebugReportObjectTypeEXT));
vkStream->write((uint64_t*)&forMarshaling->object, sizeof(uint64_t));
vkStream->write((uint64_t*)&forMarshaling->tagName, sizeof(uint64_t));
uint64_t cgen_var_0 = (uint64_t)forMarshaling->tagSize;
vkStream->putBe64(cgen_var_0);
- vkStream->write((const void*)forMarshaling->pTag, forMarshaling->tagSize * sizeof(const uint8_t));
+ vkStream->write((const void*)forMarshaling->pTag,
+ forMarshaling->tagSize * sizeof(const uint8_t));
}
-void unmarshal_VkDebugMarkerObjectTagInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDebugMarkerObjectTagInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkDebugMarkerObjectTagInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDebugMarkerObjectTagInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDebugReportObjectTypeEXT*)&forUnmarshaling->objectType, sizeof(VkDebugReportObjectTypeEXT));
+ vkStream->read((VkDebugReportObjectTypeEXT*)&forUnmarshaling->objectType,
+ sizeof(VkDebugReportObjectTypeEXT));
vkStream->read((uint64_t*)&forUnmarshaling->object, sizeof(uint64_t));
vkStream->read((uint64_t*)&forUnmarshaling->tagName, sizeof(uint64_t));
forUnmarshaling->tagSize = (size_t)vkStream->getBe64();
vkStream->read((void*)forUnmarshaling->pTag, forUnmarshaling->tagSize * sizeof(const uint8_t));
}
-void marshal_VkDebugMarkerMarkerInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugMarkerMarkerInfoEXT* forMarshaling)
-{
+void marshal_VkDebugMarkerMarkerInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugMarkerMarkerInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -15542,15 +14057,11 @@
vkStream->write((float*)forMarshaling->color, 4 * sizeof(float));
}
-void unmarshal_VkDebugMarkerMarkerInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDebugMarkerMarkerInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkDebugMarkerMarkerInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDebugMarkerMarkerInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -15563,14 +14074,11 @@
#endif
#ifdef VK_NV_dedicated_allocation
void marshal_VkDedicatedAllocationImageCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDedicatedAllocationImageCreateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDedicatedAllocationImageCreateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -15578,14 +14086,11 @@
}
void unmarshal_VkDedicatedAllocationImageCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDedicatedAllocationImageCreateInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDedicatedAllocationImageCreateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -15593,14 +14098,11 @@
}
void marshal_VkDedicatedAllocationBufferCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDedicatedAllocationBufferCreateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDedicatedAllocationBufferCreateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -15608,14 +14110,11 @@
}
void unmarshal_VkDedicatedAllocationBufferCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDedicatedAllocationBufferCreateInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDedicatedAllocationBufferCreateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -15623,14 +14122,11 @@
}
void marshal_VkDedicatedAllocationMemoryAllocateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDedicatedAllocationMemoryAllocateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDedicatedAllocationMemoryAllocateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -15643,36 +14139,32 @@
}
void unmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDedicatedAllocationMemoryAllocateInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDedicatedAllocationMemoryAllocateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0, (VkImage*)&forUnmarshaling->image, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+ (VkImage*)&forUnmarshaling->image, 1);
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_1, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_1,
+ (VkBuffer*)&forUnmarshaling->buffer, 1);
}
#endif
#ifdef VK_EXT_transform_feedback
void marshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTransformFeedbackFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTransformFeedbackFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -15681,14 +14173,11 @@
}
void unmarshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceTransformFeedbackFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceTransformFeedbackFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -15697,129 +14186,121 @@
}
void marshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTransformFeedbackPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTransformFeedbackPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->maxTransformFeedbackStreams, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxTransformFeedbackBuffers, sizeof(uint32_t));
- vkStream->write((VkDeviceSize*)&forMarshaling->maxTransformFeedbackBufferSize, sizeof(VkDeviceSize));
- vkStream->write((uint32_t*)&forMarshaling->maxTransformFeedbackStreamDataSize, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxTransformFeedbackBufferDataSize, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxTransformFeedbackBufferDataStride, sizeof(uint32_t));
+ vkStream->write((VkDeviceSize*)&forMarshaling->maxTransformFeedbackBufferSize,
+ sizeof(VkDeviceSize));
+ vkStream->write((uint32_t*)&forMarshaling->maxTransformFeedbackStreamDataSize,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxTransformFeedbackBufferDataSize,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxTransformFeedbackBufferDataStride,
+ sizeof(uint32_t));
vkStream->write((VkBool32*)&forMarshaling->transformFeedbackQueries, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->transformFeedbackStreamsLinesTriangles, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->transformFeedbackRasterizationStreamSelect, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->transformFeedbackStreamsLinesTriangles,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->transformFeedbackRasterizationStreamSelect,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->transformFeedbackDraw, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceTransformFeedbackPropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceTransformFeedbackPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->maxTransformFeedbackStreams, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxTransformFeedbackBuffers, sizeof(uint32_t));
- vkStream->read((VkDeviceSize*)&forUnmarshaling->maxTransformFeedbackBufferSize, sizeof(VkDeviceSize));
- vkStream->read((uint32_t*)&forUnmarshaling->maxTransformFeedbackStreamDataSize, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxTransformFeedbackBufferDataSize, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxTransformFeedbackBufferDataStride, sizeof(uint32_t));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->maxTransformFeedbackBufferSize,
+ sizeof(VkDeviceSize));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxTransformFeedbackStreamDataSize,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxTransformFeedbackBufferDataSize,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxTransformFeedbackBufferDataStride,
+ sizeof(uint32_t));
vkStream->read((VkBool32*)&forUnmarshaling->transformFeedbackQueries, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->transformFeedbackStreamsLinesTriangles, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->transformFeedbackRasterizationStreamSelect, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->transformFeedbackStreamsLinesTriangles,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->transformFeedbackRasterizationStreamSelect,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->transformFeedbackDraw, sizeof(VkBool32));
}
void marshal_VkPipelineRasterizationStateStreamCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationStateStreamCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationStateStreamCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineRasterizationStateStreamCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkPipelineRasterizationStateStreamCreateFlagsEXT));
+ vkStream->write((VkPipelineRasterizationStateStreamCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkPipelineRasterizationStateStreamCreateFlagsEXT));
vkStream->write((uint32_t*)&forMarshaling->rasterizationStream, sizeof(uint32_t));
}
void unmarshal_VkPipelineRasterizationStateStreamCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineRasterizationStateStreamCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineRasterizationStateStreamCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineRasterizationStateStreamCreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkPipelineRasterizationStateStreamCreateFlagsEXT));
+ vkStream->read((VkPipelineRasterizationStateStreamCreateFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkPipelineRasterizationStateStreamCreateFlagsEXT));
vkStream->read((uint32_t*)&forUnmarshaling->rasterizationStream, sizeof(uint32_t));
}
#endif
#ifdef VK_NVX_binary_import
-void marshal_VkCuModuleCreateInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCuModuleCreateInfoNVX* forMarshaling)
-{
+void marshal_VkCuModuleCreateInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCuModuleCreateInfoNVX* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0 = (uint64_t)forMarshaling->dataSize;
vkStream->putBe64(cgen_var_0);
- vkStream->write((const void*)forMarshaling->pData, forMarshaling->dataSize * sizeof(const uint8_t));
+ vkStream->write((const void*)forMarshaling->pData,
+ forMarshaling->dataSize * sizeof(const uint8_t));
}
-void unmarshal_VkCuModuleCreateInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCuModuleCreateInfoNVX* forUnmarshaling)
-{
+void unmarshal_VkCuModuleCreateInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCuModuleCreateInfoNVX* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
forUnmarshaling->dataSize = (size_t)vkStream->getBe64();
- vkStream->read((void*)forUnmarshaling->pData, forUnmarshaling->dataSize * sizeof(const uint8_t));
+ vkStream->read((void*)forUnmarshaling->pData,
+ forUnmarshaling->dataSize * sizeof(const uint8_t));
}
-void marshal_VkCuFunctionCreateInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCuFunctionCreateInfoNVX* forMarshaling)
-{
+void marshal_VkCuFunctionCreateInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCuFunctionCreateInfoNVX* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -15828,15 +14309,11 @@
vkStream->putString(forMarshaling->pName);
}
-void unmarshal_VkCuFunctionCreateInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCuFunctionCreateInfoNVX* forUnmarshaling)
-{
+void unmarshal_VkCuFunctionCreateInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCuFunctionCreateInfoNVX* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -15844,15 +14321,11 @@
vkStream->loadStringInPlace((char**)&forUnmarshaling->pName);
}
-void marshal_VkCuLaunchInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCuLaunchInfoNVX* forMarshaling)
-{
+void marshal_VkCuLaunchInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCuLaunchInfoNVX* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -15871,15 +14344,11 @@
vkStream->putBe64(cgen_var_2);
}
-void unmarshal_VkCuLaunchInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCuLaunchInfoNVX* forUnmarshaling)
-{
+void unmarshal_VkCuLaunchInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCuLaunchInfoNVX* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -15897,20 +14366,17 @@
#endif
#ifdef VK_NVX_image_view_handle
-void marshal_VkImageViewHandleInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageViewHandleInfoNVX* forMarshaling)
-{
+void marshal_VkImageViewHandleInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageViewHandleInfoNVX* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((VkDescriptorType*)&forMarshaling->descriptorType, sizeof(VkDescriptorType));
uint64_t cgen_var_1;
@@ -15918,36 +14384,30 @@
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
}
-void unmarshal_VkImageViewHandleInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageViewHandleInfoNVX* forUnmarshaling)
-{
+void unmarshal_VkImageViewHandleInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageViewHandleInfoNVX* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_0, (VkImageView*)&forUnmarshaling->imageView, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkImageView(
+ &cgen_var_0, (VkImageView*)&forUnmarshaling->imageView, 1);
vkStream->read((VkDescriptorType*)&forUnmarshaling->descriptorType, sizeof(VkDescriptorType));
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_1, (VkSampler*)&forUnmarshaling->sampler, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_1,
+ (VkSampler*)&forUnmarshaling->sampler, 1);
}
-void marshal_VkImageViewAddressPropertiesNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageViewAddressPropertiesNVX* forMarshaling)
-{
+void marshal_VkImageViewAddressPropertiesNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageViewAddressPropertiesNVX* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -15955,15 +14415,12 @@
vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
}
-void unmarshal_VkImageViewAddressPropertiesNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageViewAddressPropertiesNVX* forUnmarshaling)
-{
+void unmarshal_VkImageViewAddressPropertiesNVX(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkImageViewAddressPropertiesNVX* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -15982,20 +14439,20 @@
#endif
#ifdef VK_EXT_video_encode_h264
void marshal_VkVideoEncodeH264CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264CapabilitiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264CapabilitiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkVideoEncodeH264CapabilityFlagsEXT*)&forMarshaling->flags, sizeof(VkVideoEncodeH264CapabilityFlagsEXT));
- vkStream->write((VkVideoEncodeH264InputModeFlagsEXT*)&forMarshaling->inputModeFlags, sizeof(VkVideoEncodeH264InputModeFlagsEXT));
- vkStream->write((VkVideoEncodeH264OutputModeFlagsEXT*)&forMarshaling->outputModeFlags, sizeof(VkVideoEncodeH264OutputModeFlagsEXT));
+ vkStream->write((VkVideoEncodeH264CapabilityFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkVideoEncodeH264CapabilityFlagsEXT));
+ vkStream->write((VkVideoEncodeH264InputModeFlagsEXT*)&forMarshaling->inputModeFlags,
+ sizeof(VkVideoEncodeH264InputModeFlagsEXT));
+ vkStream->write((VkVideoEncodeH264OutputModeFlagsEXT*)&forMarshaling->outputModeFlags,
+ sizeof(VkVideoEncodeH264OutputModeFlagsEXT));
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minPictureSizeInMbs));
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxPictureSizeInMbs));
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->inputImageDataAlignment));
@@ -16003,77 +14460,75 @@
vkStream->write((uint8_t*)&forMarshaling->maxNumL0ReferenceForB, sizeof(uint8_t));
vkStream->write((uint8_t*)&forMarshaling->maxNumL1Reference, sizeof(uint8_t));
vkStream->write((uint8_t*)&forMarshaling->qualityLevelCount, sizeof(uint8_t));
- marshal_VkExtensionProperties(vkStream, rootType, (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion));
+ marshal_VkExtensionProperties(vkStream, rootType,
+ (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion));
}
-void unmarshal_VkVideoEncodeH264CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH264CapabilitiesEXT* forUnmarshaling)
-{
+void unmarshal_VkVideoEncodeH264CapabilitiesEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoEncodeH264CapabilitiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkVideoEncodeH264CapabilityFlagsEXT*)&forUnmarshaling->flags, sizeof(VkVideoEncodeH264CapabilityFlagsEXT));
- vkStream->read((VkVideoEncodeH264InputModeFlagsEXT*)&forUnmarshaling->inputModeFlags, sizeof(VkVideoEncodeH264InputModeFlagsEXT));
- vkStream->read((VkVideoEncodeH264OutputModeFlagsEXT*)&forUnmarshaling->outputModeFlags, sizeof(VkVideoEncodeH264OutputModeFlagsEXT));
+ vkStream->read((VkVideoEncodeH264CapabilityFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkVideoEncodeH264CapabilityFlagsEXT));
+ vkStream->read((VkVideoEncodeH264InputModeFlagsEXT*)&forUnmarshaling->inputModeFlags,
+ sizeof(VkVideoEncodeH264InputModeFlagsEXT));
+ vkStream->read((VkVideoEncodeH264OutputModeFlagsEXT*)&forUnmarshaling->outputModeFlags,
+ sizeof(VkVideoEncodeH264OutputModeFlagsEXT));
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->minPictureSizeInMbs));
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxPictureSizeInMbs));
- unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->inputImageDataAlignment));
+ unmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forUnmarshaling->inputImageDataAlignment));
vkStream->read((uint8_t*)&forUnmarshaling->maxNumL0ReferenceForP, sizeof(uint8_t));
vkStream->read((uint8_t*)&forUnmarshaling->maxNumL0ReferenceForB, sizeof(uint8_t));
vkStream->read((uint8_t*)&forUnmarshaling->maxNumL1Reference, sizeof(uint8_t));
vkStream->read((uint8_t*)&forUnmarshaling->qualityLevelCount, sizeof(uint8_t));
- unmarshal_VkExtensionProperties(vkStream, rootType, (VkExtensionProperties*)(&forUnmarshaling->stdExtensionVersion));
+ unmarshal_VkExtensionProperties(
+ vkStream, rootType, (VkExtensionProperties*)(&forUnmarshaling->stdExtensionVersion));
}
void marshal_VkVideoEncodeH264SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264SessionCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264SessionCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkVideoEncodeH264CreateFlagsEXT*)&forMarshaling->flags, sizeof(VkVideoEncodeH264CreateFlagsEXT));
+ vkStream->write((VkVideoEncodeH264CreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkVideoEncodeH264CreateFlagsEXT));
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxPictureSizeInMbs));
- marshal_VkExtensionProperties(vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion));
+ marshal_VkExtensionProperties(
+ vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion));
}
void unmarshal_VkVideoEncodeH264SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH264SessionCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEncodeH264SessionCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkVideoEncodeH264CreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkVideoEncodeH264CreateFlagsEXT));
+ vkStream->read((VkVideoEncodeH264CreateFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkVideoEncodeH264CreateFlagsEXT));
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxPictureSizeInMbs));
- unmarshal_VkExtensionProperties(vkStream, rootType, (VkExtensionProperties*)(forUnmarshaling->pStdExtensionVersion));
+ unmarshal_VkExtensionProperties(
+ vkStream, rootType, (VkExtensionProperties*)(forUnmarshaling->pStdExtensionVersion));
}
void marshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264SessionParametersAddInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264SessionParametersAddInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -16081,29 +14536,27 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pSpsStd;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pSpsStd)
- {
- vkStream->write((const StdVideoH264SequenceParameterSet*)forMarshaling->pSpsStd, forMarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
+ if (forMarshaling->pSpsStd) {
+ vkStream->write(
+ (const StdVideoH264SequenceParameterSet*)forMarshaling->pSpsStd,
+ forMarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
}
vkStream->write((uint32_t*)&forMarshaling->ppsStdCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pPpsStd;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pPpsStd)
- {
- vkStream->write((const StdVideoH264PictureParameterSet*)forMarshaling->pPpsStd, forMarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
+ if (forMarshaling->pPpsStd) {
+ vkStream->write((const StdVideoH264PictureParameterSet*)forMarshaling->pPpsStd,
+ forMarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
}
}
void unmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH264SessionParametersAddInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEncodeH264SessionParametersAddInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -16111,37 +14564,36 @@
// WARNING PTR CHECK
const StdVideoH264SequenceParameterSet* check_pSpsStd;
check_pSpsStd = (const StdVideoH264SequenceParameterSet*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pSpsStd)
- {
- if (!(check_pSpsStd))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pSpsStd inconsistent between guest and host\n");
+ if (forUnmarshaling->pSpsStd) {
+ if (!(check_pSpsStd)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pSpsStd inconsistent between guest and host\n");
}
- vkStream->read((StdVideoH264SequenceParameterSet*)forUnmarshaling->pSpsStd, forUnmarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
+ vkStream->read(
+ (StdVideoH264SequenceParameterSet*)forUnmarshaling->pSpsStd,
+ forUnmarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
}
vkStream->read((uint32_t*)&forUnmarshaling->ppsStdCount, sizeof(uint32_t));
// WARNING PTR CHECK
const StdVideoH264PictureParameterSet* check_pPpsStd;
check_pPpsStd = (const StdVideoH264PictureParameterSet*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pPpsStd)
- {
- if (!(check_pPpsStd))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pPpsStd inconsistent between guest and host\n");
+ if (forUnmarshaling->pPpsStd) {
+ if (!(check_pPpsStd)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pPpsStd inconsistent between guest and host\n");
}
- vkStream->read((StdVideoH264PictureParameterSet*)forUnmarshaling->pPpsStd, forUnmarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
+ vkStream->read(
+ (StdVideoH264PictureParameterSet*)forUnmarshaling->pPpsStd,
+ forUnmarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
}
}
void marshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264SessionParametersCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264SessionParametersCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -16150,21 +14602,20 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pParametersAddInfo;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pParametersAddInfo)
- {
- marshal_VkVideoEncodeH264SessionParametersAddInfoEXT(vkStream, rootType, (const VkVideoEncodeH264SessionParametersAddInfoEXT*)(forMarshaling->pParametersAddInfo));
+ if (forMarshaling->pParametersAddInfo) {
+ marshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH264SessionParametersAddInfoEXT*)(forMarshaling
+ ->pParametersAddInfo));
}
}
void unmarshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH264SessionParametersCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEncodeH264SessionParametersCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -16172,77 +14623,72 @@
vkStream->read((uint32_t*)&forUnmarshaling->maxPpsStdCount, sizeof(uint32_t));
// WARNING PTR CHECK
const VkVideoEncodeH264SessionParametersAddInfoEXT* check_pParametersAddInfo;
- check_pParametersAddInfo = (const VkVideoEncodeH264SessionParametersAddInfoEXT*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pParametersAddInfo)
- {
- if (!(check_pParametersAddInfo))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pParametersAddInfo inconsistent between guest and host\n");
+ check_pParametersAddInfo =
+ (const VkVideoEncodeH264SessionParametersAddInfoEXT*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pParametersAddInfo) {
+ if (!(check_pParametersAddInfo)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pParametersAddInfo inconsistent between guest and host\n");
}
- unmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(vkStream, rootType, (VkVideoEncodeH264SessionParametersAddInfoEXT*)(forUnmarshaling->pParametersAddInfo));
+ unmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ (VkVideoEncodeH264SessionParametersAddInfoEXT*)(forUnmarshaling->pParametersAddInfo));
}
}
-void marshal_VkVideoEncodeH264DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264DpbSlotInfoEXT* forMarshaling)
-{
+void marshal_VkVideoEncodeH264DpbSlotInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264DpbSlotInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((int8_t*)&forMarshaling->slotIndex, sizeof(int8_t));
- vkStream->write((const StdVideoEncodeH264PictureInfo*)forMarshaling->pStdPictureInfo, sizeof(const StdVideoEncodeH264PictureInfo));
+ vkStream->write((const StdVideoEncodeH264PictureInfo*)forMarshaling->pStdPictureInfo,
+ sizeof(const StdVideoEncodeH264PictureInfo));
}
-void unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH264DpbSlotInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoEncodeH264DpbSlotInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((int8_t*)&forUnmarshaling->slotIndex, sizeof(int8_t));
- vkStream->read((StdVideoEncodeH264PictureInfo*)forUnmarshaling->pStdPictureInfo, sizeof(const StdVideoEncodeH264PictureInfo));
+ vkStream->read((StdVideoEncodeH264PictureInfo*)forUnmarshaling->pStdPictureInfo,
+ sizeof(const StdVideoEncodeH264PictureInfo));
}
-void marshal_VkVideoEncodeH264NaluSliceEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264NaluSliceEXT* forMarshaling)
-{
+void marshal_VkVideoEncodeH264NaluSliceEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264NaluSliceEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((const StdVideoEncodeH264SliceHeader*)forMarshaling->pSliceHeaderStd, sizeof(const StdVideoEncodeH264SliceHeader));
+ vkStream->write((const StdVideoEncodeH264SliceHeader*)forMarshaling->pSliceHeaderStd,
+ sizeof(const StdVideoEncodeH264SliceHeader));
vkStream->write((uint32_t*)&forMarshaling->mbCount, sizeof(uint32_t));
vkStream->write((uint8_t*)&forMarshaling->refFinalList0EntryCount, sizeof(uint8_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->refFinalList0EntryCount; ++i)
- {
- marshal_VkVideoEncodeH264DpbSlotInfoEXT(vkStream, rootType, (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pRefFinalList0Entries + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->refFinalList0EntryCount; ++i) {
+ marshal_VkVideoEncodeH264DpbSlotInfoEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pRefFinalList0Entries + i));
}
}
vkStream->write((uint8_t*)&forMarshaling->refFinalList1EntryCount, sizeof(uint8_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->refFinalList1EntryCount; ++i)
- {
- marshal_VkVideoEncodeH264DpbSlotInfoEXT(vkStream, rootType, (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pRefFinalList1Entries + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->refFinalList1EntryCount; ++i) {
+ marshal_VkVideoEncodeH264DpbSlotInfoEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pRefFinalList1Entries + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->precedingNaluBytes, sizeof(uint32_t));
@@ -16250,34 +14696,31 @@
vkStream->write((uint8_t*)&forMarshaling->maxQp, sizeof(uint8_t));
}
-void unmarshal_VkVideoEncodeH264NaluSliceEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH264NaluSliceEXT* forUnmarshaling)
-{
+void unmarshal_VkVideoEncodeH264NaluSliceEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEncodeH264NaluSliceEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((StdVideoEncodeH264SliceHeader*)forUnmarshaling->pSliceHeaderStd, sizeof(const StdVideoEncodeH264SliceHeader));
+ vkStream->read((StdVideoEncodeH264SliceHeader*)forUnmarshaling->pSliceHeaderStd,
+ sizeof(const StdVideoEncodeH264SliceHeader));
vkStream->read((uint32_t*)&forUnmarshaling->mbCount, sizeof(uint32_t));
vkStream->read((uint8_t*)&forUnmarshaling->refFinalList0EntryCount, sizeof(uint8_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->refFinalList0EntryCount; ++i)
- {
- unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(vkStream, rootType, (VkVideoEncodeH264DpbSlotInfoEXT*)(forUnmarshaling->pRefFinalList0Entries + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->refFinalList0EntryCount; ++i) {
+ unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
+ vkStream, rootType,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(forUnmarshaling->pRefFinalList0Entries + i));
}
}
vkStream->read((uint8_t*)&forUnmarshaling->refFinalList1EntryCount, sizeof(uint8_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->refFinalList1EntryCount; ++i)
- {
- unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(vkStream, rootType, (VkVideoEncodeH264DpbSlotInfoEXT*)(forUnmarshaling->pRefFinalList1Entries + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->refFinalList1EntryCount; ++i) {
+ unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
+ vkStream, rootType,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(forUnmarshaling->pRefFinalList1Entries + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->precedingNaluBytes, sizeof(uint32_t));
@@ -16286,242 +14729,236 @@
}
void marshal_VkVideoEncodeH264VclFrameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264VclFrameInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264VclFrameInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint8_t*)&forMarshaling->refDefaultFinalList0EntryCount, sizeof(uint8_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->refDefaultFinalList0EntryCount; ++i)
- {
- marshal_VkVideoEncodeH264DpbSlotInfoEXT(vkStream, rootType, (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pRefDefaultFinalList0Entries + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->refDefaultFinalList0EntryCount; ++i) {
+ marshal_VkVideoEncodeH264DpbSlotInfoEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling
+ ->pRefDefaultFinalList0Entries +
+ i));
}
}
vkStream->write((uint8_t*)&forMarshaling->refDefaultFinalList1EntryCount, sizeof(uint8_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->refDefaultFinalList1EntryCount; ++i)
- {
- marshal_VkVideoEncodeH264DpbSlotInfoEXT(vkStream, rootType, (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pRefDefaultFinalList1Entries + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->refDefaultFinalList1EntryCount; ++i) {
+ marshal_VkVideoEncodeH264DpbSlotInfoEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling
+ ->pRefDefaultFinalList1Entries +
+ i));
}
}
vkStream->write((uint32_t*)&forMarshaling->naluSliceEntryCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->naluSliceEntryCount; ++i)
- {
- marshal_VkVideoEncodeH264NaluSliceEXT(vkStream, rootType, (const VkVideoEncodeH264NaluSliceEXT*)(forMarshaling->pNaluSliceEntries + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->naluSliceEntryCount; ++i) {
+ marshal_VkVideoEncodeH264NaluSliceEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH264NaluSliceEXT*)(forMarshaling->pNaluSliceEntries + i));
}
}
- marshal_VkVideoEncodeH264DpbSlotInfoEXT(vkStream, rootType, (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pCurrentPictureInfo));
+ marshal_VkVideoEncodeH264DpbSlotInfoEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pCurrentPictureInfo));
}
-void unmarshal_VkVideoEncodeH264VclFrameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH264VclFrameInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkVideoEncodeH264VclFrameInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoEncodeH264VclFrameInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint8_t*)&forUnmarshaling->refDefaultFinalList0EntryCount, sizeof(uint8_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->refDefaultFinalList0EntryCount; ++i)
- {
- unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(vkStream, rootType, (VkVideoEncodeH264DpbSlotInfoEXT*)(forUnmarshaling->pRefDefaultFinalList0Entries + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->refDefaultFinalList0EntryCount; ++i) {
+ unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
+ vkStream, rootType,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(forUnmarshaling->pRefDefaultFinalList0Entries +
+ i));
}
}
vkStream->read((uint8_t*)&forUnmarshaling->refDefaultFinalList1EntryCount, sizeof(uint8_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->refDefaultFinalList1EntryCount; ++i)
- {
- unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(vkStream, rootType, (VkVideoEncodeH264DpbSlotInfoEXT*)(forUnmarshaling->pRefDefaultFinalList1Entries + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->refDefaultFinalList1EntryCount; ++i) {
+ unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
+ vkStream, rootType,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(forUnmarshaling->pRefDefaultFinalList1Entries +
+ i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->naluSliceEntryCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->naluSliceEntryCount; ++i)
- {
- unmarshal_VkVideoEncodeH264NaluSliceEXT(vkStream, rootType, (VkVideoEncodeH264NaluSliceEXT*)(forUnmarshaling->pNaluSliceEntries + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->naluSliceEntryCount; ++i) {
+ unmarshal_VkVideoEncodeH264NaluSliceEXT(
+ vkStream, rootType,
+ (VkVideoEncodeH264NaluSliceEXT*)(forUnmarshaling->pNaluSliceEntries + i));
}
}
- unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(vkStream, rootType, (VkVideoEncodeH264DpbSlotInfoEXT*)(forUnmarshaling->pCurrentPictureInfo));
+ unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
+ vkStream, rootType,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(forUnmarshaling->pCurrentPictureInfo));
}
void marshal_VkVideoEncodeH264EmitPictureParametersEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264EmitPictureParametersEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264EmitPictureParametersEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint8_t*)&forMarshaling->spsId, sizeof(uint8_t));
vkStream->write((VkBool32*)&forMarshaling->emitSpsEnable, sizeof(VkBool32));
vkStream->write((uint32_t*)&forMarshaling->ppsIdEntryCount, sizeof(uint32_t));
- vkStream->write((const uint8_t*)forMarshaling->ppsIdEntries, forMarshaling->ppsIdEntryCount * sizeof(const uint8_t));
+ vkStream->write((const uint8_t*)forMarshaling->ppsIdEntries,
+ forMarshaling->ppsIdEntryCount * sizeof(const uint8_t));
}
void unmarshal_VkVideoEncodeH264EmitPictureParametersEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH264EmitPictureParametersEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEncodeH264EmitPictureParametersEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint8_t*)&forUnmarshaling->spsId, sizeof(uint8_t));
vkStream->read((VkBool32*)&forUnmarshaling->emitSpsEnable, sizeof(VkBool32));
vkStream->read((uint32_t*)&forUnmarshaling->ppsIdEntryCount, sizeof(uint32_t));
- vkStream->read((uint8_t*)forUnmarshaling->ppsIdEntries, forUnmarshaling->ppsIdEntryCount * sizeof(const uint8_t));
+ vkStream->read((uint8_t*)forUnmarshaling->ppsIdEntries,
+ forUnmarshaling->ppsIdEntryCount * sizeof(const uint8_t));
}
-void marshal_VkVideoEncodeH264ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264ProfileEXT* forMarshaling)
-{
+void marshal_VkVideoEncodeH264ProfileEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264ProfileEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((StdVideoH264ProfileIdc*)&forMarshaling->stdProfileIdc, sizeof(StdVideoH264ProfileIdc));
+ vkStream->write((StdVideoH264ProfileIdc*)&forMarshaling->stdProfileIdc,
+ sizeof(StdVideoH264ProfileIdc));
}
-void unmarshal_VkVideoEncodeH264ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH264ProfileEXT* forUnmarshaling)
-{
+void unmarshal_VkVideoEncodeH264ProfileEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEncodeH264ProfileEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((StdVideoH264ProfileIdc*)&forUnmarshaling->stdProfileIdc, sizeof(StdVideoH264ProfileIdc));
+ vkStream->read((StdVideoH264ProfileIdc*)&forUnmarshaling->stdProfileIdc,
+ sizeof(StdVideoH264ProfileIdc));
}
#endif
#ifdef VK_EXT_video_encode_h265
void marshal_VkVideoEncodeH265CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265CapabilitiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265CapabilitiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkVideoEncodeH265CapabilityFlagsEXT*)&forMarshaling->flags, sizeof(VkVideoEncodeH265CapabilityFlagsEXT));
- vkStream->write((VkVideoEncodeH265InputModeFlagsEXT*)&forMarshaling->inputModeFlags, sizeof(VkVideoEncodeH265InputModeFlagsEXT));
- vkStream->write((VkVideoEncodeH265OutputModeFlagsEXT*)&forMarshaling->outputModeFlags, sizeof(VkVideoEncodeH265OutputModeFlagsEXT));
- vkStream->write((VkVideoEncodeH265CtbSizeFlagsEXT*)&forMarshaling->ctbSizes, sizeof(VkVideoEncodeH265CtbSizeFlagsEXT));
+ vkStream->write((VkVideoEncodeH265CapabilityFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkVideoEncodeH265CapabilityFlagsEXT));
+ vkStream->write((VkVideoEncodeH265InputModeFlagsEXT*)&forMarshaling->inputModeFlags,
+ sizeof(VkVideoEncodeH265InputModeFlagsEXT));
+ vkStream->write((VkVideoEncodeH265OutputModeFlagsEXT*)&forMarshaling->outputModeFlags,
+ sizeof(VkVideoEncodeH265OutputModeFlagsEXT));
+ vkStream->write((VkVideoEncodeH265CtbSizeFlagsEXT*)&forMarshaling->ctbSizes,
+ sizeof(VkVideoEncodeH265CtbSizeFlagsEXT));
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->inputImageDataAlignment));
vkStream->write((uint8_t*)&forMarshaling->maxNumL0ReferenceForP, sizeof(uint8_t));
vkStream->write((uint8_t*)&forMarshaling->maxNumL0ReferenceForB, sizeof(uint8_t));
vkStream->write((uint8_t*)&forMarshaling->maxNumL1Reference, sizeof(uint8_t));
vkStream->write((uint8_t*)&forMarshaling->maxNumSubLayers, sizeof(uint8_t));
vkStream->write((uint8_t*)&forMarshaling->qualityLevelCount, sizeof(uint8_t));
- marshal_VkExtensionProperties(vkStream, rootType, (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion));
+ marshal_VkExtensionProperties(vkStream, rootType,
+ (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion));
}
-void unmarshal_VkVideoEncodeH265CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH265CapabilitiesEXT* forUnmarshaling)
-{
+void unmarshal_VkVideoEncodeH265CapabilitiesEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoEncodeH265CapabilitiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkVideoEncodeH265CapabilityFlagsEXT*)&forUnmarshaling->flags, sizeof(VkVideoEncodeH265CapabilityFlagsEXT));
- vkStream->read((VkVideoEncodeH265InputModeFlagsEXT*)&forUnmarshaling->inputModeFlags, sizeof(VkVideoEncodeH265InputModeFlagsEXT));
- vkStream->read((VkVideoEncodeH265OutputModeFlagsEXT*)&forUnmarshaling->outputModeFlags, sizeof(VkVideoEncodeH265OutputModeFlagsEXT));
- vkStream->read((VkVideoEncodeH265CtbSizeFlagsEXT*)&forUnmarshaling->ctbSizes, sizeof(VkVideoEncodeH265CtbSizeFlagsEXT));
- unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->inputImageDataAlignment));
+ vkStream->read((VkVideoEncodeH265CapabilityFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkVideoEncodeH265CapabilityFlagsEXT));
+ vkStream->read((VkVideoEncodeH265InputModeFlagsEXT*)&forUnmarshaling->inputModeFlags,
+ sizeof(VkVideoEncodeH265InputModeFlagsEXT));
+ vkStream->read((VkVideoEncodeH265OutputModeFlagsEXT*)&forUnmarshaling->outputModeFlags,
+ sizeof(VkVideoEncodeH265OutputModeFlagsEXT));
+ vkStream->read((VkVideoEncodeH265CtbSizeFlagsEXT*)&forUnmarshaling->ctbSizes,
+ sizeof(VkVideoEncodeH265CtbSizeFlagsEXT));
+ unmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forUnmarshaling->inputImageDataAlignment));
vkStream->read((uint8_t*)&forUnmarshaling->maxNumL0ReferenceForP, sizeof(uint8_t));
vkStream->read((uint8_t*)&forUnmarshaling->maxNumL0ReferenceForB, sizeof(uint8_t));
vkStream->read((uint8_t*)&forUnmarshaling->maxNumL1Reference, sizeof(uint8_t));
vkStream->read((uint8_t*)&forUnmarshaling->maxNumSubLayers, sizeof(uint8_t));
vkStream->read((uint8_t*)&forUnmarshaling->qualityLevelCount, sizeof(uint8_t));
- unmarshal_VkExtensionProperties(vkStream, rootType, (VkExtensionProperties*)(&forUnmarshaling->stdExtensionVersion));
+ unmarshal_VkExtensionProperties(
+ vkStream, rootType, (VkExtensionProperties*)(&forUnmarshaling->stdExtensionVersion));
}
void marshal_VkVideoEncodeH265SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265SessionCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265SessionCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkVideoEncodeH265CreateFlagsEXT*)&forMarshaling->flags, sizeof(VkVideoEncodeH265CreateFlagsEXT));
- marshal_VkExtensionProperties(vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion));
+ vkStream->write((VkVideoEncodeH265CreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkVideoEncodeH265CreateFlagsEXT));
+ marshal_VkExtensionProperties(
+ vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion));
}
void unmarshal_VkVideoEncodeH265SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH265SessionCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEncodeH265SessionCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkVideoEncodeH265CreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkVideoEncodeH265CreateFlagsEXT));
- unmarshal_VkExtensionProperties(vkStream, rootType, (VkExtensionProperties*)(forUnmarshaling->pStdExtensionVersion));
+ vkStream->read((VkVideoEncodeH265CreateFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkVideoEncodeH265CreateFlagsEXT));
+ unmarshal_VkExtensionProperties(
+ vkStream, rootType, (VkExtensionProperties*)(forUnmarshaling->pStdExtensionVersion));
}
void marshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265SessionParametersAddInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265SessionParametersAddInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -16529,37 +14966,35 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pVpsStd;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pVpsStd)
- {
- vkStream->write((const StdVideoH265VideoParameterSet*)forMarshaling->pVpsStd, forMarshaling->vpsStdCount * sizeof(const StdVideoH265VideoParameterSet));
+ if (forMarshaling->pVpsStd) {
+ vkStream->write((const StdVideoH265VideoParameterSet*)forMarshaling->pVpsStd,
+ forMarshaling->vpsStdCount * sizeof(const StdVideoH265VideoParameterSet));
}
vkStream->write((uint32_t*)&forMarshaling->spsStdCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pSpsStd;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pSpsStd)
- {
- vkStream->write((const StdVideoH265SequenceParameterSet*)forMarshaling->pSpsStd, forMarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
+ if (forMarshaling->pSpsStd) {
+ vkStream->write(
+ (const StdVideoH265SequenceParameterSet*)forMarshaling->pSpsStd,
+ forMarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
}
vkStream->write((uint32_t*)&forMarshaling->ppsStdCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pPpsStd;
vkStream->putBe64(cgen_var_2);
- if (forMarshaling->pPpsStd)
- {
- vkStream->write((const StdVideoH265PictureParameterSet*)forMarshaling->pPpsStd, forMarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
+ if (forMarshaling->pPpsStd) {
+ vkStream->write((const StdVideoH265PictureParameterSet*)forMarshaling->pPpsStd,
+ forMarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
}
}
void unmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH265SessionParametersAddInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEncodeH265SessionParametersAddInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -16567,49 +15002,48 @@
// WARNING PTR CHECK
const StdVideoH265VideoParameterSet* check_pVpsStd;
check_pVpsStd = (const StdVideoH265VideoParameterSet*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pVpsStd)
- {
- if (!(check_pVpsStd))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pVpsStd inconsistent between guest and host\n");
+ if (forUnmarshaling->pVpsStd) {
+ if (!(check_pVpsStd)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pVpsStd inconsistent between guest and host\n");
}
- vkStream->read((StdVideoH265VideoParameterSet*)forUnmarshaling->pVpsStd, forUnmarshaling->vpsStdCount * sizeof(const StdVideoH265VideoParameterSet));
+ vkStream->read((StdVideoH265VideoParameterSet*)forUnmarshaling->pVpsStd,
+ forUnmarshaling->vpsStdCount * sizeof(const StdVideoH265VideoParameterSet));
}
vkStream->read((uint32_t*)&forUnmarshaling->spsStdCount, sizeof(uint32_t));
// WARNING PTR CHECK
const StdVideoH265SequenceParameterSet* check_pSpsStd;
check_pSpsStd = (const StdVideoH265SequenceParameterSet*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pSpsStd)
- {
- if (!(check_pSpsStd))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pSpsStd inconsistent between guest and host\n");
+ if (forUnmarshaling->pSpsStd) {
+ if (!(check_pSpsStd)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pSpsStd inconsistent between guest and host\n");
}
- vkStream->read((StdVideoH265SequenceParameterSet*)forUnmarshaling->pSpsStd, forUnmarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
+ vkStream->read(
+ (StdVideoH265SequenceParameterSet*)forUnmarshaling->pSpsStd,
+ forUnmarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
}
vkStream->read((uint32_t*)&forUnmarshaling->ppsStdCount, sizeof(uint32_t));
// WARNING PTR CHECK
const StdVideoH265PictureParameterSet* check_pPpsStd;
check_pPpsStd = (const StdVideoH265PictureParameterSet*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pPpsStd)
- {
- if (!(check_pPpsStd))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pPpsStd inconsistent between guest and host\n");
+ if (forUnmarshaling->pPpsStd) {
+ if (!(check_pPpsStd)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pPpsStd inconsistent between guest and host\n");
}
- vkStream->read((StdVideoH265PictureParameterSet*)forUnmarshaling->pPpsStd, forUnmarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
+ vkStream->read(
+ (StdVideoH265PictureParameterSet*)forUnmarshaling->pPpsStd,
+ forUnmarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
}
}
void marshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265SessionParametersCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265SessionParametersCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -16619,21 +15053,20 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pParametersAddInfo;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pParametersAddInfo)
- {
- marshal_VkVideoEncodeH265SessionParametersAddInfoEXT(vkStream, rootType, (const VkVideoEncodeH265SessionParametersAddInfoEXT*)(forMarshaling->pParametersAddInfo));
+ if (forMarshaling->pParametersAddInfo) {
+ marshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH265SessionParametersAddInfoEXT*)(forMarshaling
+ ->pParametersAddInfo));
}
}
void unmarshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH265SessionParametersCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEncodeH265SessionParametersCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -16642,120 +15075,114 @@
vkStream->read((uint32_t*)&forUnmarshaling->maxPpsStdCount, sizeof(uint32_t));
// WARNING PTR CHECK
const VkVideoEncodeH265SessionParametersAddInfoEXT* check_pParametersAddInfo;
- check_pParametersAddInfo = (const VkVideoEncodeH265SessionParametersAddInfoEXT*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pParametersAddInfo)
- {
- if (!(check_pParametersAddInfo))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pParametersAddInfo inconsistent between guest and host\n");
+ check_pParametersAddInfo =
+ (const VkVideoEncodeH265SessionParametersAddInfoEXT*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pParametersAddInfo) {
+ if (!(check_pParametersAddInfo)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pParametersAddInfo inconsistent between guest and host\n");
}
- unmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(vkStream, rootType, (VkVideoEncodeH265SessionParametersAddInfoEXT*)(forUnmarshaling->pParametersAddInfo));
+ unmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ (VkVideoEncodeH265SessionParametersAddInfoEXT*)(forUnmarshaling->pParametersAddInfo));
}
}
-void marshal_VkVideoEncodeH265DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265DpbSlotInfoEXT* forMarshaling)
-{
+void marshal_VkVideoEncodeH265DpbSlotInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265DpbSlotInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((int8_t*)&forMarshaling->slotIndex, sizeof(int8_t));
- vkStream->write((const StdVideoEncodeH265ReferenceInfo*)forMarshaling->pStdReferenceInfo, sizeof(const StdVideoEncodeH265ReferenceInfo));
+ vkStream->write((const StdVideoEncodeH265ReferenceInfo*)forMarshaling->pStdReferenceInfo,
+ sizeof(const StdVideoEncodeH265ReferenceInfo));
}
-void unmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH265DpbSlotInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkVideoEncodeH265DpbSlotInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoEncodeH265DpbSlotInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((int8_t*)&forUnmarshaling->slotIndex, sizeof(int8_t));
- vkStream->read((StdVideoEncodeH265ReferenceInfo*)forUnmarshaling->pStdReferenceInfo, sizeof(const StdVideoEncodeH265ReferenceInfo));
+ vkStream->read((StdVideoEncodeH265ReferenceInfo*)forUnmarshaling->pStdReferenceInfo,
+ sizeof(const StdVideoEncodeH265ReferenceInfo));
}
void marshal_VkVideoEncodeH265ReferenceListsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265ReferenceListsEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265ReferenceListsEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint8_t*)&forMarshaling->referenceList0EntryCount, sizeof(uint8_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceList0EntryCount; ++i)
- {
- marshal_VkVideoEncodeH265DpbSlotInfoEXT(vkStream, rootType, (const VkVideoEncodeH265DpbSlotInfoEXT*)(forMarshaling->pReferenceList0Entries + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceList0EntryCount; ++i) {
+ marshal_VkVideoEncodeH265DpbSlotInfoEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH265DpbSlotInfoEXT*)(forMarshaling->pReferenceList0Entries +
+ i));
}
}
vkStream->write((uint8_t*)&forMarshaling->referenceList1EntryCount, sizeof(uint8_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceList1EntryCount; ++i)
- {
- marshal_VkVideoEncodeH265DpbSlotInfoEXT(vkStream, rootType, (const VkVideoEncodeH265DpbSlotInfoEXT*)(forMarshaling->pReferenceList1Entries + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceList1EntryCount; ++i) {
+ marshal_VkVideoEncodeH265DpbSlotInfoEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH265DpbSlotInfoEXT*)(forMarshaling->pReferenceList1Entries +
+ i));
}
}
- vkStream->write((const StdVideoEncodeH265ReferenceModifications*)forMarshaling->pReferenceModifications, sizeof(const StdVideoEncodeH265ReferenceModifications));
+ vkStream->write(
+ (const StdVideoEncodeH265ReferenceModifications*)forMarshaling->pReferenceModifications,
+ sizeof(const StdVideoEncodeH265ReferenceModifications));
}
void unmarshal_VkVideoEncodeH265ReferenceListsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH265ReferenceListsEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEncodeH265ReferenceListsEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint8_t*)&forUnmarshaling->referenceList0EntryCount, sizeof(uint8_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceList0EntryCount; ++i)
- {
- unmarshal_VkVideoEncodeH265DpbSlotInfoEXT(vkStream, rootType, (VkVideoEncodeH265DpbSlotInfoEXT*)(forUnmarshaling->pReferenceList0Entries + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceList0EntryCount; ++i) {
+ unmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
+ vkStream, rootType,
+ (VkVideoEncodeH265DpbSlotInfoEXT*)(forUnmarshaling->pReferenceList0Entries + i));
}
}
vkStream->read((uint8_t*)&forUnmarshaling->referenceList1EntryCount, sizeof(uint8_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceList1EntryCount; ++i)
- {
- unmarshal_VkVideoEncodeH265DpbSlotInfoEXT(vkStream, rootType, (VkVideoEncodeH265DpbSlotInfoEXT*)(forUnmarshaling->pReferenceList1Entries + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceList1EntryCount; ++i) {
+ unmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
+ vkStream, rootType,
+ (VkVideoEncodeH265DpbSlotInfoEXT*)(forUnmarshaling->pReferenceList1Entries + i));
}
}
- vkStream->read((StdVideoEncodeH265ReferenceModifications*)forUnmarshaling->pReferenceModifications, sizeof(const StdVideoEncodeH265ReferenceModifications));
+ vkStream->read(
+ (StdVideoEncodeH265ReferenceModifications*)forUnmarshaling->pReferenceModifications,
+ sizeof(const StdVideoEncodeH265ReferenceModifications));
}
-void marshal_VkVideoEncodeH265NaluSliceEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265NaluSliceEXT* forMarshaling)
-{
+void marshal_VkVideoEncodeH265NaluSliceEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265NaluSliceEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -16763,113 +15190,112 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pReferenceFinalLists;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pReferenceFinalLists)
- {
- marshal_VkVideoEncodeH265ReferenceListsEXT(vkStream, rootType, (const VkVideoEncodeH265ReferenceListsEXT*)(forMarshaling->pReferenceFinalLists));
+ if (forMarshaling->pReferenceFinalLists) {
+ marshal_VkVideoEncodeH265ReferenceListsEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH265ReferenceListsEXT*)(forMarshaling->pReferenceFinalLists));
}
- vkStream->write((const StdVideoEncodeH265SliceHeader*)forMarshaling->pSliceHeaderStd, sizeof(const StdVideoEncodeH265SliceHeader));
+ vkStream->write((const StdVideoEncodeH265SliceHeader*)forMarshaling->pSliceHeaderStd,
+ sizeof(const StdVideoEncodeH265SliceHeader));
}
-void unmarshal_VkVideoEncodeH265NaluSliceEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH265NaluSliceEXT* forUnmarshaling)
-{
+void unmarshal_VkVideoEncodeH265NaluSliceEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEncodeH265NaluSliceEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->ctbCount, sizeof(uint32_t));
// WARNING PTR CHECK
const VkVideoEncodeH265ReferenceListsEXT* check_pReferenceFinalLists;
- check_pReferenceFinalLists = (const VkVideoEncodeH265ReferenceListsEXT*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pReferenceFinalLists)
- {
- if (!(check_pReferenceFinalLists))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pReferenceFinalLists inconsistent between guest and host\n");
+ check_pReferenceFinalLists =
+ (const VkVideoEncodeH265ReferenceListsEXT*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pReferenceFinalLists) {
+ if (!(check_pReferenceFinalLists)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pReferenceFinalLists inconsistent between guest and "
+ "host\n");
}
- unmarshal_VkVideoEncodeH265ReferenceListsEXT(vkStream, rootType, (VkVideoEncodeH265ReferenceListsEXT*)(forUnmarshaling->pReferenceFinalLists));
+ unmarshal_VkVideoEncodeH265ReferenceListsEXT(
+ vkStream, rootType,
+ (VkVideoEncodeH265ReferenceListsEXT*)(forUnmarshaling->pReferenceFinalLists));
}
- vkStream->read((StdVideoEncodeH265SliceHeader*)forUnmarshaling->pSliceHeaderStd, sizeof(const StdVideoEncodeH265SliceHeader));
+ vkStream->read((StdVideoEncodeH265SliceHeader*)forUnmarshaling->pSliceHeaderStd,
+ sizeof(const StdVideoEncodeH265SliceHeader));
}
void marshal_VkVideoEncodeH265VclFrameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265VclFrameInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265VclFrameInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pReferenceFinalLists;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pReferenceFinalLists)
- {
- marshal_VkVideoEncodeH265ReferenceListsEXT(vkStream, rootType, (const VkVideoEncodeH265ReferenceListsEXT*)(forMarshaling->pReferenceFinalLists));
+ if (forMarshaling->pReferenceFinalLists) {
+ marshal_VkVideoEncodeH265ReferenceListsEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH265ReferenceListsEXT*)(forMarshaling->pReferenceFinalLists));
}
vkStream->write((uint32_t*)&forMarshaling->naluSliceEntryCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->naluSliceEntryCount; ++i)
- {
- marshal_VkVideoEncodeH265NaluSliceEXT(vkStream, rootType, (const VkVideoEncodeH265NaluSliceEXT*)(forMarshaling->pNaluSliceEntries + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->naluSliceEntryCount; ++i) {
+ marshal_VkVideoEncodeH265NaluSliceEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH265NaluSliceEXT*)(forMarshaling->pNaluSliceEntries + i));
}
}
- vkStream->write((const StdVideoEncodeH265PictureInfo*)forMarshaling->pCurrentPictureInfo, sizeof(const StdVideoEncodeH265PictureInfo));
+ vkStream->write((const StdVideoEncodeH265PictureInfo*)forMarshaling->pCurrentPictureInfo,
+ sizeof(const StdVideoEncodeH265PictureInfo));
}
-void unmarshal_VkVideoEncodeH265VclFrameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH265VclFrameInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkVideoEncodeH265VclFrameInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoEncodeH265VclFrameInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
// WARNING PTR CHECK
const VkVideoEncodeH265ReferenceListsEXT* check_pReferenceFinalLists;
- check_pReferenceFinalLists = (const VkVideoEncodeH265ReferenceListsEXT*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pReferenceFinalLists)
- {
- if (!(check_pReferenceFinalLists))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pReferenceFinalLists inconsistent between guest and host\n");
+ check_pReferenceFinalLists =
+ (const VkVideoEncodeH265ReferenceListsEXT*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pReferenceFinalLists) {
+ if (!(check_pReferenceFinalLists)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pReferenceFinalLists inconsistent between guest and "
+ "host\n");
}
- unmarshal_VkVideoEncodeH265ReferenceListsEXT(vkStream, rootType, (VkVideoEncodeH265ReferenceListsEXT*)(forUnmarshaling->pReferenceFinalLists));
+ unmarshal_VkVideoEncodeH265ReferenceListsEXT(
+ vkStream, rootType,
+ (VkVideoEncodeH265ReferenceListsEXT*)(forUnmarshaling->pReferenceFinalLists));
}
vkStream->read((uint32_t*)&forUnmarshaling->naluSliceEntryCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->naluSliceEntryCount; ++i)
- {
- unmarshal_VkVideoEncodeH265NaluSliceEXT(vkStream, rootType, (VkVideoEncodeH265NaluSliceEXT*)(forUnmarshaling->pNaluSliceEntries + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->naluSliceEntryCount; ++i) {
+ unmarshal_VkVideoEncodeH265NaluSliceEXT(
+ vkStream, rootType,
+ (VkVideoEncodeH265NaluSliceEXT*)(forUnmarshaling->pNaluSliceEntries + i));
}
}
- vkStream->read((StdVideoEncodeH265PictureInfo*)forUnmarshaling->pCurrentPictureInfo, sizeof(const StdVideoEncodeH265PictureInfo));
+ vkStream->read((StdVideoEncodeH265PictureInfo*)forUnmarshaling->pCurrentPictureInfo,
+ sizeof(const StdVideoEncodeH265PictureInfo));
}
void marshal_VkVideoEncodeH265EmitPictureParametersEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265EmitPictureParametersEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265EmitPictureParametersEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -16878,18 +15304,16 @@
vkStream->write((VkBool32*)&forMarshaling->emitVpsEnable, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->emitSpsEnable, sizeof(VkBool32));
vkStream->write((uint32_t*)&forMarshaling->ppsIdEntryCount, sizeof(uint32_t));
- vkStream->write((const uint8_t*)forMarshaling->ppsIdEntries, forMarshaling->ppsIdEntryCount * sizeof(const uint8_t));
+ vkStream->write((const uint8_t*)forMarshaling->ppsIdEntries,
+ forMarshaling->ppsIdEntryCount * sizeof(const uint8_t));
}
void unmarshal_VkVideoEncodeH265EmitPictureParametersEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH265EmitPictureParametersEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEncodeH265EmitPictureParametersEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -16898,148 +15322,131 @@
vkStream->read((VkBool32*)&forUnmarshaling->emitVpsEnable, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->emitSpsEnable, sizeof(VkBool32));
vkStream->read((uint32_t*)&forUnmarshaling->ppsIdEntryCount, sizeof(uint32_t));
- vkStream->read((uint8_t*)forUnmarshaling->ppsIdEntries, forUnmarshaling->ppsIdEntryCount * sizeof(const uint8_t));
+ vkStream->read((uint8_t*)forUnmarshaling->ppsIdEntries,
+ forUnmarshaling->ppsIdEntryCount * sizeof(const uint8_t));
}
-void marshal_VkVideoEncodeH265ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265ProfileEXT* forMarshaling)
-{
+void marshal_VkVideoEncodeH265ProfileEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265ProfileEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((StdVideoH265ProfileIdc*)&forMarshaling->stdProfileIdc, sizeof(StdVideoH265ProfileIdc));
+ vkStream->write((StdVideoH265ProfileIdc*)&forMarshaling->stdProfileIdc,
+ sizeof(StdVideoH265ProfileIdc));
}
-void unmarshal_VkVideoEncodeH265ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH265ProfileEXT* forUnmarshaling)
-{
+void unmarshal_VkVideoEncodeH265ProfileEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEncodeH265ProfileEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((StdVideoH265ProfileIdc*)&forUnmarshaling->stdProfileIdc, sizeof(StdVideoH265ProfileIdc));
+ vkStream->read((StdVideoH265ProfileIdc*)&forUnmarshaling->stdProfileIdc,
+ sizeof(StdVideoH265ProfileIdc));
}
#endif
#ifdef VK_EXT_video_decode_h264
-void marshal_VkVideoDecodeH264ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264ProfileEXT* forMarshaling)
-{
+void marshal_VkVideoDecodeH264ProfileEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264ProfileEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((StdVideoH264ProfileIdc*)&forMarshaling->stdProfileIdc, sizeof(StdVideoH264ProfileIdc));
- vkStream->write((VkVideoDecodeH264PictureLayoutFlagsEXT*)&forMarshaling->pictureLayout, sizeof(VkVideoDecodeH264PictureLayoutFlagsEXT));
+ vkStream->write((StdVideoH264ProfileIdc*)&forMarshaling->stdProfileIdc,
+ sizeof(StdVideoH264ProfileIdc));
+ vkStream->write((VkVideoDecodeH264PictureLayoutFlagsEXT*)&forMarshaling->pictureLayout,
+ sizeof(VkVideoDecodeH264PictureLayoutFlagsEXT));
}
-void unmarshal_VkVideoDecodeH264ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH264ProfileEXT* forUnmarshaling)
-{
+void unmarshal_VkVideoDecodeH264ProfileEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoDecodeH264ProfileEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((StdVideoH264ProfileIdc*)&forUnmarshaling->stdProfileIdc, sizeof(StdVideoH264ProfileIdc));
- vkStream->read((VkVideoDecodeH264PictureLayoutFlagsEXT*)&forUnmarshaling->pictureLayout, sizeof(VkVideoDecodeH264PictureLayoutFlagsEXT));
+ vkStream->read((StdVideoH264ProfileIdc*)&forUnmarshaling->stdProfileIdc,
+ sizeof(StdVideoH264ProfileIdc));
+ vkStream->read((VkVideoDecodeH264PictureLayoutFlagsEXT*)&forUnmarshaling->pictureLayout,
+ sizeof(VkVideoDecodeH264PictureLayoutFlagsEXT));
}
void marshal_VkVideoDecodeH264CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264CapabilitiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264CapabilitiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->maxLevel, sizeof(uint32_t));
marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->fieldOffsetGranularity));
- marshal_VkExtensionProperties(vkStream, rootType, (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion));
+ marshal_VkExtensionProperties(vkStream, rootType,
+ (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion));
}
-void unmarshal_VkVideoDecodeH264CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH264CapabilitiesEXT* forUnmarshaling)
-{
+void unmarshal_VkVideoDecodeH264CapabilitiesEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoDecodeH264CapabilitiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->maxLevel, sizeof(uint32_t));
- unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->fieldOffsetGranularity));
- unmarshal_VkExtensionProperties(vkStream, rootType, (VkExtensionProperties*)(&forUnmarshaling->stdExtensionVersion));
+ unmarshal_VkOffset2D(vkStream, rootType,
+ (VkOffset2D*)(&forUnmarshaling->fieldOffsetGranularity));
+ unmarshal_VkExtensionProperties(
+ vkStream, rootType, (VkExtensionProperties*)(&forUnmarshaling->stdExtensionVersion));
}
void marshal_VkVideoDecodeH264SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264SessionCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264SessionCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkVideoDecodeH264CreateFlagsEXT*)&forMarshaling->flags, sizeof(VkVideoDecodeH264CreateFlagsEXT));
- marshal_VkExtensionProperties(vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion));
+ vkStream->write((VkVideoDecodeH264CreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkVideoDecodeH264CreateFlagsEXT));
+ marshal_VkExtensionProperties(
+ vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion));
}
void unmarshal_VkVideoDecodeH264SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH264SessionCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoDecodeH264SessionCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkVideoDecodeH264CreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkVideoDecodeH264CreateFlagsEXT));
- unmarshal_VkExtensionProperties(vkStream, rootType, (VkExtensionProperties*)(forUnmarshaling->pStdExtensionVersion));
+ vkStream->read((VkVideoDecodeH264CreateFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkVideoDecodeH264CreateFlagsEXT));
+ unmarshal_VkExtensionProperties(
+ vkStream, rootType, (VkExtensionProperties*)(forUnmarshaling->pStdExtensionVersion));
}
void marshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264SessionParametersAddInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264SessionParametersAddInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -17047,29 +15454,27 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pSpsStd;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pSpsStd)
- {
- vkStream->write((const StdVideoH264SequenceParameterSet*)forMarshaling->pSpsStd, forMarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
+ if (forMarshaling->pSpsStd) {
+ vkStream->write(
+ (const StdVideoH264SequenceParameterSet*)forMarshaling->pSpsStd,
+ forMarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
}
vkStream->write((uint32_t*)&forMarshaling->ppsStdCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pPpsStd;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pPpsStd)
- {
- vkStream->write((const StdVideoH264PictureParameterSet*)forMarshaling->pPpsStd, forMarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
+ if (forMarshaling->pPpsStd) {
+ vkStream->write((const StdVideoH264PictureParameterSet*)forMarshaling->pPpsStd,
+ forMarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
}
}
void unmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH264SessionParametersAddInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoDecodeH264SessionParametersAddInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -17077,37 +15482,36 @@
// WARNING PTR CHECK
const StdVideoH264SequenceParameterSet* check_pSpsStd;
check_pSpsStd = (const StdVideoH264SequenceParameterSet*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pSpsStd)
- {
- if (!(check_pSpsStd))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pSpsStd inconsistent between guest and host\n");
+ if (forUnmarshaling->pSpsStd) {
+ if (!(check_pSpsStd)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pSpsStd inconsistent between guest and host\n");
}
- vkStream->read((StdVideoH264SequenceParameterSet*)forUnmarshaling->pSpsStd, forUnmarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
+ vkStream->read(
+ (StdVideoH264SequenceParameterSet*)forUnmarshaling->pSpsStd,
+ forUnmarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
}
vkStream->read((uint32_t*)&forUnmarshaling->ppsStdCount, sizeof(uint32_t));
// WARNING PTR CHECK
const StdVideoH264PictureParameterSet* check_pPpsStd;
check_pPpsStd = (const StdVideoH264PictureParameterSet*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pPpsStd)
- {
- if (!(check_pPpsStd))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pPpsStd inconsistent between guest and host\n");
+ if (forUnmarshaling->pPpsStd) {
+ if (!(check_pPpsStd)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pPpsStd inconsistent between guest and host\n");
}
- vkStream->read((StdVideoH264PictureParameterSet*)forUnmarshaling->pPpsStd, forUnmarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
+ vkStream->read(
+ (StdVideoH264PictureParameterSet*)forUnmarshaling->pPpsStd,
+ forUnmarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
}
}
void marshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264SessionParametersCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264SessionParametersCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -17116,21 +15520,20 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pParametersAddInfo;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pParametersAddInfo)
- {
- marshal_VkVideoDecodeH264SessionParametersAddInfoEXT(vkStream, rootType, (const VkVideoDecodeH264SessionParametersAddInfoEXT*)(forMarshaling->pParametersAddInfo));
+ if (forMarshaling->pParametersAddInfo) {
+ marshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ (const VkVideoDecodeH264SessionParametersAddInfoEXT*)(forMarshaling
+ ->pParametersAddInfo));
}
}
void unmarshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH264SessionParametersCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoDecodeH264SessionParametersCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -17138,122 +15541,108 @@
vkStream->read((uint32_t*)&forUnmarshaling->maxPpsStdCount, sizeof(uint32_t));
// WARNING PTR CHECK
const VkVideoDecodeH264SessionParametersAddInfoEXT* check_pParametersAddInfo;
- check_pParametersAddInfo = (const VkVideoDecodeH264SessionParametersAddInfoEXT*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pParametersAddInfo)
- {
- if (!(check_pParametersAddInfo))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pParametersAddInfo inconsistent between guest and host\n");
+ check_pParametersAddInfo =
+ (const VkVideoDecodeH264SessionParametersAddInfoEXT*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pParametersAddInfo) {
+ if (!(check_pParametersAddInfo)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pParametersAddInfo inconsistent between guest and host\n");
}
- unmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(vkStream, rootType, (VkVideoDecodeH264SessionParametersAddInfoEXT*)(forUnmarshaling->pParametersAddInfo));
+ unmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ (VkVideoDecodeH264SessionParametersAddInfoEXT*)(forUnmarshaling->pParametersAddInfo));
}
}
-void marshal_VkVideoDecodeH264PictureInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264PictureInfoEXT* forMarshaling)
-{
+void marshal_VkVideoDecodeH264PictureInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264PictureInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((const StdVideoDecodeH264PictureInfo*)forMarshaling->pStdPictureInfo, sizeof(const StdVideoDecodeH264PictureInfo));
+ vkStream->write((const StdVideoDecodeH264PictureInfo*)forMarshaling->pStdPictureInfo,
+ sizeof(const StdVideoDecodeH264PictureInfo));
vkStream->write((uint32_t*)&forMarshaling->slicesCount, sizeof(uint32_t));
- vkStream->write((const uint32_t*)forMarshaling->pSlicesDataOffsets, forMarshaling->slicesCount * sizeof(const uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pSlicesDataOffsets,
+ forMarshaling->slicesCount * sizeof(const uint32_t));
}
-void unmarshal_VkVideoDecodeH264PictureInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH264PictureInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkVideoDecodeH264PictureInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoDecodeH264PictureInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((StdVideoDecodeH264PictureInfo*)forUnmarshaling->pStdPictureInfo, sizeof(const StdVideoDecodeH264PictureInfo));
+ vkStream->read((StdVideoDecodeH264PictureInfo*)forUnmarshaling->pStdPictureInfo,
+ sizeof(const StdVideoDecodeH264PictureInfo));
vkStream->read((uint32_t*)&forUnmarshaling->slicesCount, sizeof(uint32_t));
- vkStream->read((uint32_t*)forUnmarshaling->pSlicesDataOffsets, forUnmarshaling->slicesCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pSlicesDataOffsets,
+ forUnmarshaling->slicesCount * sizeof(const uint32_t));
}
-void marshal_VkVideoDecodeH264MvcEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264MvcEXT* forMarshaling)
-{
+void marshal_VkVideoDecodeH264MvcEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264MvcEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((const StdVideoDecodeH264Mvc*)forMarshaling->pStdMvc, sizeof(const StdVideoDecodeH264Mvc));
+ vkStream->write((const StdVideoDecodeH264Mvc*)forMarshaling->pStdMvc,
+ sizeof(const StdVideoDecodeH264Mvc));
}
-void unmarshal_VkVideoDecodeH264MvcEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH264MvcEXT* forUnmarshaling)
-{
+void unmarshal_VkVideoDecodeH264MvcEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoDecodeH264MvcEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((StdVideoDecodeH264Mvc*)forUnmarshaling->pStdMvc, sizeof(const StdVideoDecodeH264Mvc));
+ vkStream->read((StdVideoDecodeH264Mvc*)forUnmarshaling->pStdMvc,
+ sizeof(const StdVideoDecodeH264Mvc));
}
-void marshal_VkVideoDecodeH264DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264DpbSlotInfoEXT* forMarshaling)
-{
+void marshal_VkVideoDecodeH264DpbSlotInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264DpbSlotInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((const StdVideoDecodeH264ReferenceInfo*)forMarshaling->pStdReferenceInfo, sizeof(const StdVideoDecodeH264ReferenceInfo));
+ vkStream->write((const StdVideoDecodeH264ReferenceInfo*)forMarshaling->pStdReferenceInfo,
+ sizeof(const StdVideoDecodeH264ReferenceInfo));
}
-void unmarshal_VkVideoDecodeH264DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH264DpbSlotInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkVideoDecodeH264DpbSlotInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoDecodeH264DpbSlotInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((StdVideoDecodeH264ReferenceInfo*)forUnmarshaling->pStdReferenceInfo, sizeof(const StdVideoDecodeH264ReferenceInfo));
+ vkStream->read((StdVideoDecodeH264ReferenceInfo*)forUnmarshaling->pStdReferenceInfo,
+ sizeof(const StdVideoDecodeH264ReferenceInfo));
}
#endif
#ifdef VK_AMD_texture_gather_bias_lod
void marshal_VkTextureLODGatherFormatPropertiesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkTextureLODGatherFormatPropertiesAMD* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkTextureLODGatherFormatPropertiesAMD* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -17261,14 +15650,11 @@
}
void unmarshal_VkTextureLODGatherFormatPropertiesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkTextureLODGatherFormatPropertiesAMD* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkTextureLODGatherFormatPropertiesAMD* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -17277,11 +15663,8 @@
#endif
#ifdef VK_AMD_shader_info
-void marshal_VkShaderResourceUsageAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkShaderResourceUsageAMD* forMarshaling)
-{
+void marshal_VkShaderResourceUsageAMD(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkShaderResourceUsageAMD* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->numUsedVgprs, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->numUsedSgprs, sizeof(uint32_t));
@@ -17292,11 +15675,8 @@
vkStream->putBe64(cgen_var_1);
}
-void unmarshal_VkShaderResourceUsageAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkShaderResourceUsageAMD* forUnmarshaling)
-{
+void unmarshal_VkShaderResourceUsageAMD(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkShaderResourceUsageAMD* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->numUsedVgprs, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->numUsedSgprs, sizeof(uint32_t));
@@ -17305,14 +15685,13 @@
forUnmarshaling->scratchMemUsageInBytes = (size_t)vkStream->getBe64();
}
-void marshal_VkShaderStatisticsInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkShaderStatisticsInfoAMD* forMarshaling)
-{
+void marshal_VkShaderStatisticsInfoAMD(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkShaderStatisticsInfoAMD* forMarshaling) {
(void)rootType;
- vkStream->write((VkShaderStageFlags*)&forMarshaling->shaderStageMask, sizeof(VkShaderStageFlags));
- marshal_VkShaderResourceUsageAMD(vkStream, rootType, (VkShaderResourceUsageAMD*)(&forMarshaling->resourceUsage));
+ vkStream->write((VkShaderStageFlags*)&forMarshaling->shaderStageMask,
+ sizeof(VkShaderStageFlags));
+ marshal_VkShaderResourceUsageAMD(vkStream, rootType,
+ (VkShaderResourceUsageAMD*)(&forMarshaling->resourceUsage));
vkStream->write((uint32_t*)&forMarshaling->numPhysicalVgprs, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->numPhysicalSgprs, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->numAvailableVgprs, sizeof(uint32_t));
@@ -17320,14 +15699,13 @@
vkStream->write((uint32_t*)forMarshaling->computeWorkGroupSize, 3 * sizeof(uint32_t));
}
-void unmarshal_VkShaderStatisticsInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkShaderStatisticsInfoAMD* forUnmarshaling)
-{
+void unmarshal_VkShaderStatisticsInfoAMD(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkShaderStatisticsInfoAMD* forUnmarshaling) {
(void)rootType;
- vkStream->read((VkShaderStageFlags*)&forUnmarshaling->shaderStageMask, sizeof(VkShaderStageFlags));
- unmarshal_VkShaderResourceUsageAMD(vkStream, rootType, (VkShaderResourceUsageAMD*)(&forUnmarshaling->resourceUsage));
+ vkStream->read((VkShaderStageFlags*)&forUnmarshaling->shaderStageMask,
+ sizeof(VkShaderStageFlags));
+ unmarshal_VkShaderResourceUsageAMD(
+ vkStream, rootType, (VkShaderResourceUsageAMD*)(&forUnmarshaling->resourceUsage));
vkStream->read((uint32_t*)&forUnmarshaling->numPhysicalVgprs, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->numPhysicalSgprs, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->numAvailableVgprs, sizeof(uint32_t));
@@ -17340,48 +15718,43 @@
#endif
#ifdef VK_GGP_stream_descriptor_surface
void marshal_VkStreamDescriptorSurfaceCreateInfoGGP(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkStreamDescriptorSurfaceCreateInfoGGP* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkStreamDescriptorSurfaceCreateInfoGGP* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkStreamDescriptorSurfaceCreateFlagsGGP*)&forMarshaling->flags, sizeof(VkStreamDescriptorSurfaceCreateFlagsGGP));
- vkStream->write((GgpStreamDescriptor*)&forMarshaling->streamDescriptor, sizeof(GgpStreamDescriptor));
+ vkStream->write((VkStreamDescriptorSurfaceCreateFlagsGGP*)&forMarshaling->flags,
+ sizeof(VkStreamDescriptorSurfaceCreateFlagsGGP));
+ vkStream->write((GgpStreamDescriptor*)&forMarshaling->streamDescriptor,
+ sizeof(GgpStreamDescriptor));
}
void unmarshal_VkStreamDescriptorSurfaceCreateInfoGGP(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkStreamDescriptorSurfaceCreateInfoGGP* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkStreamDescriptorSurfaceCreateInfoGGP* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkStreamDescriptorSurfaceCreateFlagsGGP*)&forUnmarshaling->flags, sizeof(VkStreamDescriptorSurfaceCreateFlagsGGP));
- vkStream->read((GgpStreamDescriptor*)&forUnmarshaling->streamDescriptor, sizeof(GgpStreamDescriptor));
+ vkStream->read((VkStreamDescriptorSurfaceCreateFlagsGGP*)&forUnmarshaling->flags,
+ sizeof(VkStreamDescriptorSurfaceCreateFlagsGGP));
+ vkStream->read((GgpStreamDescriptor*)&forUnmarshaling->streamDescriptor,
+ sizeof(GgpStreamDescriptor));
}
#endif
#ifdef VK_NV_corner_sampled_image
void marshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCornerSampledImageFeaturesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCornerSampledImageFeaturesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -17389,14 +15762,11 @@
}
void unmarshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceCornerSampledImageFeaturesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceCornerSampledImageFeaturesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -17408,169 +15778,153 @@
#endif
#ifdef VK_NV_external_memory_capabilities
void marshal_VkExternalImageFormatPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalImageFormatPropertiesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalImageFormatPropertiesNV* forMarshaling) {
(void)rootType;
- marshal_VkImageFormatProperties(vkStream, rootType, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties));
- vkStream->write((VkExternalMemoryFeatureFlagsNV*)&forMarshaling->externalMemoryFeatures, sizeof(VkExternalMemoryFeatureFlagsNV));
- vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->exportFromImportedHandleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
- vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->compatibleHandleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ marshal_VkImageFormatProperties(
+ vkStream, rootType, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties));
+ vkStream->write((VkExternalMemoryFeatureFlagsNV*)&forMarshaling->externalMemoryFeatures,
+ sizeof(VkExternalMemoryFeatureFlagsNV));
+ vkStream->write(
+ (VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->exportFromImportedHandleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->compatibleHandleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlagsNV));
}
void unmarshal_VkExternalImageFormatPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExternalImageFormatPropertiesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExternalImageFormatPropertiesNV* forUnmarshaling) {
(void)rootType;
- unmarshal_VkImageFormatProperties(vkStream, rootType, (VkImageFormatProperties*)(&forUnmarshaling->imageFormatProperties));
- vkStream->read((VkExternalMemoryFeatureFlagsNV*)&forUnmarshaling->externalMemoryFeatures, sizeof(VkExternalMemoryFeatureFlagsNV));
- vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->exportFromImportedHandleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
- vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->compatibleHandleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ unmarshal_VkImageFormatProperties(
+ vkStream, rootType, (VkImageFormatProperties*)(&forUnmarshaling->imageFormatProperties));
+ vkStream->read((VkExternalMemoryFeatureFlagsNV*)&forUnmarshaling->externalMemoryFeatures,
+ sizeof(VkExternalMemoryFeatureFlagsNV));
+ vkStream->read(
+ (VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->exportFromImportedHandleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->compatibleHandleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlagsNV));
}
#endif
#ifdef VK_NV_external_memory
void marshal_VkExternalMemoryImageCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalMemoryImageCreateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalMemoryImageCreateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlagsNV));
}
void unmarshal_VkExternalMemoryImageCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExternalMemoryImageCreateInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExternalMemoryImageCreateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->handleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlagsNV));
}
-void marshal_VkExportMemoryAllocateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportMemoryAllocateInfoNV* forMarshaling)
-{
+void marshal_VkExportMemoryAllocateInfoNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportMemoryAllocateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlagsNV));
}
-void unmarshal_VkExportMemoryAllocateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExportMemoryAllocateInfoNV* forUnmarshaling)
-{
+void unmarshal_VkExportMemoryAllocateInfoNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExportMemoryAllocateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->handleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlagsNV));
}
#endif
#ifdef VK_NV_external_memory_win32
-void marshal_VkImportMemoryWin32HandleInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportMemoryWin32HandleInfoNV* forMarshaling)
-{
+void marshal_VkImportMemoryWin32HandleInfoNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportMemoryWin32HandleInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ vkStream->write((VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagsNV));
vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
}
-void unmarshal_VkImportMemoryWin32HandleInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportMemoryWin32HandleInfoNV* forUnmarshaling)
-{
+void unmarshal_VkImportMemoryWin32HandleInfoNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkImportMemoryWin32HandleInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ vkStream->read((VkExternalMemoryHandleTypeFlagsNV*)&forUnmarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagsNV));
vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
}
-void marshal_VkExportMemoryWin32HandleInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportMemoryWin32HandleInfoNV* forMarshaling)
-{
+void marshal_VkExportMemoryWin32HandleInfoNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportMemoryWin32HandleInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pAttributes)
- {
- vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ if (forMarshaling->pAttributes) {
+ vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes,
+ sizeof(const SECURITY_ATTRIBUTES));
}
vkStream->write((DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
}
-void unmarshal_VkExportMemoryWin32HandleInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExportMemoryWin32HandleInfoNV* forUnmarshaling)
-{
+void unmarshal_VkExportMemoryWin32HandleInfoNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkExportMemoryWin32HandleInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
// WARNING PTR CHECK
const SECURITY_ATTRIBUTES* check_pAttributes;
check_pAttributes = (const SECURITY_ATTRIBUTES*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pAttributes)
- {
- if (!(check_pAttributes))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pAttributes inconsistent between guest and host\n");
+ if (forUnmarshaling->pAttributes) {
+ if (!(check_pAttributes)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pAttributes inconsistent between guest and host\n");
}
- vkStream->read((SECURITY_ATTRIBUTES*)forUnmarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ vkStream->read((SECURITY_ATTRIBUTES*)forUnmarshaling->pAttributes,
+ sizeof(const SECURITY_ATTRIBUTES));
}
vkStream->read((DWORD*)&forUnmarshaling->dwAccess, sizeof(DWORD));
}
@@ -17578,149 +15932,138 @@
#endif
#ifdef VK_NV_win32_keyed_mutex
void marshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWin32KeyedMutexAcquireReleaseInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWin32KeyedMutexAcquireReleaseInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->acquireCount, sizeof(uint32_t));
- if (forMarshaling->acquireCount)
- {
+ if (forMarshaling->acquireCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forMarshaling->acquireCount * 8);
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pAcquireSyncs, cgen_var_0, forMarshaling->acquireCount);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(
+ forMarshaling->pAcquireSyncs, cgen_var_0, forMarshaling->acquireCount);
vkStream->write((uint64_t*)cgen_var_0, forMarshaling->acquireCount * 8);
}
- vkStream->write((const uint64_t*)forMarshaling->pAcquireKeys, forMarshaling->acquireCount * sizeof(const uint64_t));
- vkStream->write((const uint32_t*)forMarshaling->pAcquireTimeoutMilliseconds, forMarshaling->acquireCount * sizeof(const uint32_t));
+ vkStream->write((const uint64_t*)forMarshaling->pAcquireKeys,
+ forMarshaling->acquireCount * sizeof(const uint64_t));
+ vkStream->write((const uint32_t*)forMarshaling->pAcquireTimeoutMilliseconds,
+ forMarshaling->acquireCount * sizeof(const uint32_t));
vkStream->write((uint32_t*)&forMarshaling->releaseCount, sizeof(uint32_t));
- if (forMarshaling->releaseCount)
- {
+ if (forMarshaling->releaseCount) {
uint64_t* cgen_var_1;
vkStream->alloc((void**)&cgen_var_1, forMarshaling->releaseCount * 8);
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pReleaseSyncs, cgen_var_1, forMarshaling->releaseCount);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(
+ forMarshaling->pReleaseSyncs, cgen_var_1, forMarshaling->releaseCount);
vkStream->write((uint64_t*)cgen_var_1, forMarshaling->releaseCount * 8);
}
- vkStream->write((const uint64_t*)forMarshaling->pReleaseKeys, forMarshaling->releaseCount * sizeof(const uint64_t));
+ vkStream->write((const uint64_t*)forMarshaling->pReleaseKeys,
+ forMarshaling->releaseCount * sizeof(const uint64_t));
}
void unmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkWin32KeyedMutexAcquireReleaseInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkWin32KeyedMutexAcquireReleaseInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->acquireCount, sizeof(uint32_t));
- if (forUnmarshaling->acquireCount)
- {
+ if (forUnmarshaling->acquireCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->acquireCount * 8);
vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->acquireCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_0, (VkDeviceMemory*)forUnmarshaling->pAcquireSyncs, forUnmarshaling->acquireCount);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+ cgen_var_0, (VkDeviceMemory*)forUnmarshaling->pAcquireSyncs,
+ forUnmarshaling->acquireCount);
}
- vkStream->read((uint64_t*)forUnmarshaling->pAcquireKeys, forUnmarshaling->acquireCount * sizeof(const uint64_t));
- vkStream->read((uint32_t*)forUnmarshaling->pAcquireTimeoutMilliseconds, forUnmarshaling->acquireCount * sizeof(const uint32_t));
+ vkStream->read((uint64_t*)forUnmarshaling->pAcquireKeys,
+ forUnmarshaling->acquireCount * sizeof(const uint64_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pAcquireTimeoutMilliseconds,
+ forUnmarshaling->acquireCount * sizeof(const uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->releaseCount, sizeof(uint32_t));
- if (forUnmarshaling->releaseCount)
- {
+ if (forUnmarshaling->releaseCount) {
uint64_t* cgen_var_1;
vkStream->alloc((void**)&cgen_var_1, forUnmarshaling->releaseCount * 8);
vkStream->read((uint64_t*)cgen_var_1, forUnmarshaling->releaseCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_1, (VkDeviceMemory*)forUnmarshaling->pReleaseSyncs, forUnmarshaling->releaseCount);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+ cgen_var_1, (VkDeviceMemory*)forUnmarshaling->pReleaseSyncs,
+ forUnmarshaling->releaseCount);
}
- vkStream->read((uint64_t*)forUnmarshaling->pReleaseKeys, forUnmarshaling->releaseCount * sizeof(const uint64_t));
+ vkStream->read((uint64_t*)forUnmarshaling->pReleaseKeys,
+ forUnmarshaling->releaseCount * sizeof(const uint64_t));
}
#endif
#ifdef VK_EXT_validation_flags
-void marshal_VkValidationFlagsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkValidationFlagsEXT* forMarshaling)
-{
+void marshal_VkValidationFlagsEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkValidationFlagsEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->disabledValidationCheckCount, sizeof(uint32_t));
- vkStream->write((const VkValidationCheckEXT*)forMarshaling->pDisabledValidationChecks, forMarshaling->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
+ vkStream->write(
+ (const VkValidationCheckEXT*)forMarshaling->pDisabledValidationChecks,
+ forMarshaling->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
}
-void unmarshal_VkValidationFlagsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkValidationFlagsEXT* forUnmarshaling)
-{
+void unmarshal_VkValidationFlagsEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkValidationFlagsEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->disabledValidationCheckCount, sizeof(uint32_t));
- vkStream->read((VkValidationCheckEXT*)forUnmarshaling->pDisabledValidationChecks, forUnmarshaling->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
+ vkStream->read(
+ (VkValidationCheckEXT*)forUnmarshaling->pDisabledValidationChecks,
+ forUnmarshaling->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
}
#endif
#ifdef VK_NN_vi_surface
-void marshal_VkViSurfaceCreateInfoNN(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkViSurfaceCreateInfoNN* forMarshaling)
-{
+void marshal_VkViSurfaceCreateInfoNN(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkViSurfaceCreateInfoNN* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkViSurfaceCreateFlagsNN*)&forMarshaling->flags, sizeof(VkViSurfaceCreateFlagsNN));
+ vkStream->write((VkViSurfaceCreateFlagsNN*)&forMarshaling->flags,
+ sizeof(VkViSurfaceCreateFlagsNN));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->window;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->window)
- {
+ if (forMarshaling->window) {
vkStream->write((void*)forMarshaling->window, sizeof(uint8_t));
}
}
-void unmarshal_VkViSurfaceCreateInfoNN(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkViSurfaceCreateInfoNN* forUnmarshaling)
-{
+void unmarshal_VkViSurfaceCreateInfoNN(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkViSurfaceCreateInfoNN* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkViSurfaceCreateFlagsNN*)&forUnmarshaling->flags, sizeof(VkViSurfaceCreateFlagsNN));
+ vkStream->read((VkViSurfaceCreateFlagsNN*)&forUnmarshaling->flags,
+ sizeof(VkViSurfaceCreateFlagsNN));
// WARNING PTR CHECK
void* check_window;
check_window = (void*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->window)
- {
- if (!(check_window))
- {
+ if (forUnmarshaling->window) {
+ if (!(check_window)) {
fprintf(stderr, "fatal: forUnmarshaling->window inconsistent between guest and host\n");
}
vkStream->read((void*)forUnmarshaling->window, sizeof(uint8_t));
@@ -17734,14 +16077,11 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
void marshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -17749,14 +16089,11 @@
}
void unmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -17765,30 +16102,22 @@
#endif
#ifdef VK_EXT_astc_decode_mode
-void marshal_VkImageViewASTCDecodeModeEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageViewASTCDecodeModeEXT* forMarshaling)
-{
+void marshal_VkImageViewASTCDecodeModeEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageViewASTCDecodeModeEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkFormat*)&forMarshaling->decodeMode, sizeof(VkFormat));
}
-void unmarshal_VkImageViewASTCDecodeModeEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageViewASTCDecodeModeEXT* forUnmarshaling)
-{
+void unmarshal_VkImageViewASTCDecodeModeEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageViewASTCDecodeModeEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -17796,14 +16125,11 @@
}
void marshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceASTCDecodeFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceASTCDecodeFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -17811,14 +16137,11 @@
}
void unmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceASTCDecodeFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceASTCDecodeFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -17828,14 +16151,11 @@
#endif
#ifdef VK_EXT_conditional_rendering
void marshal_VkConditionalRenderingBeginInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkConditionalRenderingBeginInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkConditionalRenderingBeginInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -17843,37 +16163,34 @@
vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
- vkStream->write((VkConditionalRenderingFlagsEXT*)&forMarshaling->flags, sizeof(VkConditionalRenderingFlagsEXT));
+ vkStream->write((VkConditionalRenderingFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkConditionalRenderingFlagsEXT));
}
void unmarshal_VkConditionalRenderingBeginInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkConditionalRenderingBeginInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkConditionalRenderingBeginInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+ (VkBuffer*)&forUnmarshaling->buffer, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
- vkStream->read((VkConditionalRenderingFlagsEXT*)&forUnmarshaling->flags, sizeof(VkConditionalRenderingFlagsEXT));
+ vkStream->read((VkConditionalRenderingFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkConditionalRenderingFlagsEXT));
}
void marshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceConditionalRenderingFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceConditionalRenderingFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -17882,14 +16199,11 @@
}
void unmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceConditionalRenderingFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceConditionalRenderingFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -17898,14 +16212,11 @@
}
void marshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferInheritanceConditionalRenderingInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferInheritanceConditionalRenderingInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -17913,14 +16224,11 @@
}
void unmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCommandBufferInheritanceConditionalRenderingInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCommandBufferInheritanceConditionalRenderingInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -17929,35 +16237,26 @@
#endif
#ifdef VK_NV_clip_space_w_scaling
-void marshal_VkViewportWScalingNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkViewportWScalingNV* forMarshaling)
-{
+void marshal_VkViewportWScalingNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkViewportWScalingNV* forMarshaling) {
(void)rootType;
vkStream->write((float*)&forMarshaling->xcoeff, sizeof(float));
vkStream->write((float*)&forMarshaling->ycoeff, sizeof(float));
}
-void unmarshal_VkViewportWScalingNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkViewportWScalingNV* forUnmarshaling)
-{
+void unmarshal_VkViewportWScalingNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkViewportWScalingNV* forUnmarshaling) {
(void)rootType;
vkStream->read((float*)&forUnmarshaling->xcoeff, sizeof(float));
vkStream->read((float*)&forUnmarshaling->ycoeff, sizeof(float));
}
void marshal_VkPipelineViewportWScalingStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineViewportWScalingStateCreateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineViewportWScalingStateCreateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -17966,27 +16265,23 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pViewportWScalings;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pViewportWScalings)
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
- {
- marshal_VkViewportWScalingNV(vkStream, rootType, (const VkViewportWScalingNV*)(forMarshaling->pViewportWScalings + i));
+ if (forMarshaling->pViewportWScalings) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i) {
+ marshal_VkViewportWScalingNV(
+ vkStream, rootType,
+ (const VkViewportWScalingNV*)(forMarshaling->pViewportWScalings + i));
}
}
}
}
void unmarshal_VkPipelineViewportWScalingStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineViewportWScalingStateCreateInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineViewportWScalingStateCreateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -17995,17 +16290,17 @@
// WARNING PTR CHECK
const VkViewportWScalingNV* check_pViewportWScalings;
check_pViewportWScalings = (const VkViewportWScalingNV*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pViewportWScalings)
- {
- if (!(check_pViewportWScalings))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pViewportWScalings inconsistent between guest and host\n");
+ if (forUnmarshaling->pViewportWScalings) {
+ if (!(check_pViewportWScalings)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pViewportWScalings inconsistent between guest and host\n");
}
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i)
- {
- unmarshal_VkViewportWScalingNV(vkStream, rootType, (VkViewportWScalingNV*)(forUnmarshaling->pViewportWScalings + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i) {
+ unmarshal_VkViewportWScalingNV(
+ vkStream, rootType,
+ (VkViewportWScalingNV*)(forUnmarshaling->pViewportWScalings + i));
}
}
}
@@ -18017,15 +16312,11 @@
#ifdef VK_EXT_acquire_xlib_display
#endif
#ifdef VK_EXT_display_surface_counter
-void marshal_VkSurfaceCapabilities2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceCapabilities2EXT* forMarshaling)
-{
+void marshal_VkSurfaceCapabilities2EXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceCapabilities2EXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -18035,22 +16326,23 @@
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minImageExtent));
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxImageExtent));
vkStream->write((uint32_t*)&forMarshaling->maxImageArrayLayers, sizeof(uint32_t));
- vkStream->write((VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
- vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->currentTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
- vkStream->write((VkCompositeAlphaFlagsKHR*)&forMarshaling->supportedCompositeAlpha, sizeof(VkCompositeAlphaFlagsKHR));
- vkStream->write((VkImageUsageFlags*)&forMarshaling->supportedUsageFlags, sizeof(VkImageUsageFlags));
- vkStream->write((VkSurfaceCounterFlagsEXT*)&forMarshaling->supportedSurfaceCounters, sizeof(VkSurfaceCounterFlagsEXT));
+ vkStream->write((VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms,
+ sizeof(VkSurfaceTransformFlagsKHR));
+ vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->currentTransform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->write((VkCompositeAlphaFlagsKHR*)&forMarshaling->supportedCompositeAlpha,
+ sizeof(VkCompositeAlphaFlagsKHR));
+ vkStream->write((VkImageUsageFlags*)&forMarshaling->supportedUsageFlags,
+ sizeof(VkImageUsageFlags));
+ vkStream->write((VkSurfaceCounterFlagsEXT*)&forMarshaling->supportedSurfaceCounters,
+ sizeof(VkSurfaceCounterFlagsEXT));
}
-void unmarshal_VkSurfaceCapabilities2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSurfaceCapabilities2EXT* forUnmarshaling)
-{
+void unmarshal_VkSurfaceCapabilities2EXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSurfaceCapabilities2EXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -18060,160 +16352,133 @@
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->minImageExtent));
unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxImageExtent));
vkStream->read((uint32_t*)&forUnmarshaling->maxImageArrayLayers, sizeof(uint32_t));
- vkStream->read((VkSurfaceTransformFlagsKHR*)&forUnmarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
- vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->currentTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
- vkStream->read((VkCompositeAlphaFlagsKHR*)&forUnmarshaling->supportedCompositeAlpha, sizeof(VkCompositeAlphaFlagsKHR));
- vkStream->read((VkImageUsageFlags*)&forUnmarshaling->supportedUsageFlags, sizeof(VkImageUsageFlags));
- vkStream->read((VkSurfaceCounterFlagsEXT*)&forUnmarshaling->supportedSurfaceCounters, sizeof(VkSurfaceCounterFlagsEXT));
+ vkStream->read((VkSurfaceTransformFlagsKHR*)&forUnmarshaling->supportedTransforms,
+ sizeof(VkSurfaceTransformFlagsKHR));
+ vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->currentTransform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->read((VkCompositeAlphaFlagsKHR*)&forUnmarshaling->supportedCompositeAlpha,
+ sizeof(VkCompositeAlphaFlagsKHR));
+ vkStream->read((VkImageUsageFlags*)&forUnmarshaling->supportedUsageFlags,
+ sizeof(VkImageUsageFlags));
+ vkStream->read((VkSurfaceCounterFlagsEXT*)&forUnmarshaling->supportedSurfaceCounters,
+ sizeof(VkSurfaceCounterFlagsEXT));
}
#endif
#ifdef VK_EXT_display_control
-void marshal_VkDisplayPowerInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPowerInfoEXT* forMarshaling)
-{
+void marshal_VkDisplayPowerInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPowerInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDisplayPowerStateEXT*)&forMarshaling->powerState, sizeof(VkDisplayPowerStateEXT));
+ vkStream->write((VkDisplayPowerStateEXT*)&forMarshaling->powerState,
+ sizeof(VkDisplayPowerStateEXT));
}
-void unmarshal_VkDisplayPowerInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayPowerInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkDisplayPowerInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayPowerInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDisplayPowerStateEXT*)&forUnmarshaling->powerState, sizeof(VkDisplayPowerStateEXT));
+ vkStream->read((VkDisplayPowerStateEXT*)&forUnmarshaling->powerState,
+ sizeof(VkDisplayPowerStateEXT));
}
-void marshal_VkDeviceEventInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceEventInfoEXT* forMarshaling)
-{
+void marshal_VkDeviceEventInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceEventInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDeviceEventTypeEXT*)&forMarshaling->deviceEvent, sizeof(VkDeviceEventTypeEXT));
+ vkStream->write((VkDeviceEventTypeEXT*)&forMarshaling->deviceEvent,
+ sizeof(VkDeviceEventTypeEXT));
}
-void unmarshal_VkDeviceEventInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceEventInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkDeviceEventInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceEventInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDeviceEventTypeEXT*)&forUnmarshaling->deviceEvent, sizeof(VkDeviceEventTypeEXT));
+ vkStream->read((VkDeviceEventTypeEXT*)&forUnmarshaling->deviceEvent,
+ sizeof(VkDeviceEventTypeEXT));
}
-void marshal_VkDisplayEventInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayEventInfoEXT* forMarshaling)
-{
+void marshal_VkDisplayEventInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayEventInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDisplayEventTypeEXT*)&forMarshaling->displayEvent, sizeof(VkDisplayEventTypeEXT));
+ vkStream->write((VkDisplayEventTypeEXT*)&forMarshaling->displayEvent,
+ sizeof(VkDisplayEventTypeEXT));
}
-void unmarshal_VkDisplayEventInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayEventInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkDisplayEventInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayEventInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDisplayEventTypeEXT*)&forUnmarshaling->displayEvent, sizeof(VkDisplayEventTypeEXT));
+ vkStream->read((VkDisplayEventTypeEXT*)&forUnmarshaling->displayEvent,
+ sizeof(VkDisplayEventTypeEXT));
}
-void marshal_VkSwapchainCounterCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSwapchainCounterCreateInfoEXT* forMarshaling)
-{
+void marshal_VkSwapchainCounterCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSwapchainCounterCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkSurfaceCounterFlagsEXT*)&forMarshaling->surfaceCounters, sizeof(VkSurfaceCounterFlagsEXT));
+ vkStream->write((VkSurfaceCounterFlagsEXT*)&forMarshaling->surfaceCounters,
+ sizeof(VkSurfaceCounterFlagsEXT));
}
-void unmarshal_VkSwapchainCounterCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSwapchainCounterCreateInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkSwapchainCounterCreateInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkSwapchainCounterCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkSurfaceCounterFlagsEXT*)&forUnmarshaling->surfaceCounters, sizeof(VkSurfaceCounterFlagsEXT));
+ vkStream->read((VkSurfaceCounterFlagsEXT*)&forUnmarshaling->surfaceCounters,
+ sizeof(VkSurfaceCounterFlagsEXT));
}
#endif
#ifdef VK_GOOGLE_display_timing
-void marshal_VkRefreshCycleDurationGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRefreshCycleDurationGOOGLE* forMarshaling)
-{
+void marshal_VkRefreshCycleDurationGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRefreshCycleDurationGOOGLE* forMarshaling) {
(void)rootType;
vkStream->write((uint64_t*)&forMarshaling->refreshDuration, sizeof(uint64_t));
}
-void unmarshal_VkRefreshCycleDurationGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRefreshCycleDurationGOOGLE* forUnmarshaling)
-{
+void unmarshal_VkRefreshCycleDurationGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRefreshCycleDurationGOOGLE* forUnmarshaling) {
(void)rootType;
vkStream->read((uint64_t*)&forUnmarshaling->refreshDuration, sizeof(uint64_t));
}
-void marshal_VkPastPresentationTimingGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPastPresentationTimingGOOGLE* forMarshaling)
-{
+void marshal_VkPastPresentationTimingGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPastPresentationTimingGOOGLE* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->presentID, sizeof(uint32_t));
vkStream->write((uint64_t*)&forMarshaling->desiredPresentTime, sizeof(uint64_t));
@@ -18222,11 +16487,8 @@
vkStream->write((uint64_t*)&forMarshaling->presentMargin, sizeof(uint64_t));
}
-void unmarshal_VkPastPresentationTimingGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPastPresentationTimingGOOGLE* forUnmarshaling)
-{
+void unmarshal_VkPastPresentationTimingGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPastPresentationTimingGOOGLE* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->presentID, sizeof(uint32_t));
vkStream->read((uint64_t*)&forUnmarshaling->desiredPresentTime, sizeof(uint64_t));
@@ -18235,35 +16497,25 @@
vkStream->read((uint64_t*)&forUnmarshaling->presentMargin, sizeof(uint64_t));
}
-void marshal_VkPresentTimeGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentTimeGOOGLE* forMarshaling)
-{
+void marshal_VkPresentTimeGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentTimeGOOGLE* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->presentID, sizeof(uint32_t));
vkStream->write((uint64_t*)&forMarshaling->desiredPresentTime, sizeof(uint64_t));
}
-void unmarshal_VkPresentTimeGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPresentTimeGOOGLE* forUnmarshaling)
-{
+void unmarshal_VkPresentTimeGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPresentTimeGOOGLE* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->presentID, sizeof(uint32_t));
vkStream->read((uint64_t*)&forUnmarshaling->desiredPresentTime, sizeof(uint64_t));
}
-void marshal_VkPresentTimesInfoGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentTimesInfoGOOGLE* forMarshaling)
-{
+void marshal_VkPresentTimesInfoGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentTimesInfoGOOGLE* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -18271,27 +16523,21 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pTimes;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pTimes)
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i)
- {
- marshal_VkPresentTimeGOOGLE(vkStream, rootType, (const VkPresentTimeGOOGLE*)(forMarshaling->pTimes + i));
+ if (forMarshaling->pTimes) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i) {
+ marshal_VkPresentTimeGOOGLE(
+ vkStream, rootType, (const VkPresentTimeGOOGLE*)(forMarshaling->pTimes + i));
}
}
}
}
-void unmarshal_VkPresentTimesInfoGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPresentTimesInfoGOOGLE* forUnmarshaling)
-{
+void unmarshal_VkPresentTimesInfoGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPresentTimesInfoGOOGLE* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -18299,17 +16545,14 @@
// WARNING PTR CHECK
const VkPresentTimeGOOGLE* check_pTimes;
check_pTimes = (const VkPresentTimeGOOGLE*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pTimes)
- {
- if (!(check_pTimes))
- {
+ if (forUnmarshaling->pTimes) {
+ if (!(check_pTimes)) {
fprintf(stderr, "fatal: forUnmarshaling->pTimes inconsistent between guest and host\n");
}
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->swapchainCount; ++i)
- {
- unmarshal_VkPresentTimeGOOGLE(vkStream, rootType, (VkPresentTimeGOOGLE*)(forUnmarshaling->pTimes + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->swapchainCount; ++i) {
+ unmarshal_VkPresentTimeGOOGLE(vkStream, rootType,
+ (VkPresentTimeGOOGLE*)(forUnmarshaling->pTimes + i));
}
}
}
@@ -18324,14 +16567,11 @@
#endif
#ifdef VK_NVX_multiview_per_view_attributes
void marshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -18339,14 +16579,11 @@
}
void unmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -18355,87 +16592,84 @@
#endif
#ifdef VK_NV_viewport_swizzle
-void marshal_VkViewportSwizzleNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkViewportSwizzleNV* forMarshaling)
-{
+void marshal_VkViewportSwizzleNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkViewportSwizzleNV* forMarshaling) {
(void)rootType;
- vkStream->write((VkViewportCoordinateSwizzleNV*)&forMarshaling->x, sizeof(VkViewportCoordinateSwizzleNV));
- vkStream->write((VkViewportCoordinateSwizzleNV*)&forMarshaling->y, sizeof(VkViewportCoordinateSwizzleNV));
- vkStream->write((VkViewportCoordinateSwizzleNV*)&forMarshaling->z, sizeof(VkViewportCoordinateSwizzleNV));
- vkStream->write((VkViewportCoordinateSwizzleNV*)&forMarshaling->w, sizeof(VkViewportCoordinateSwizzleNV));
+ vkStream->write((VkViewportCoordinateSwizzleNV*)&forMarshaling->x,
+ sizeof(VkViewportCoordinateSwizzleNV));
+ vkStream->write((VkViewportCoordinateSwizzleNV*)&forMarshaling->y,
+ sizeof(VkViewportCoordinateSwizzleNV));
+ vkStream->write((VkViewportCoordinateSwizzleNV*)&forMarshaling->z,
+ sizeof(VkViewportCoordinateSwizzleNV));
+ vkStream->write((VkViewportCoordinateSwizzleNV*)&forMarshaling->w,
+ sizeof(VkViewportCoordinateSwizzleNV));
}
-void unmarshal_VkViewportSwizzleNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkViewportSwizzleNV* forUnmarshaling)
-{
+void unmarshal_VkViewportSwizzleNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkViewportSwizzleNV* forUnmarshaling) {
(void)rootType;
- vkStream->read((VkViewportCoordinateSwizzleNV*)&forUnmarshaling->x, sizeof(VkViewportCoordinateSwizzleNV));
- vkStream->read((VkViewportCoordinateSwizzleNV*)&forUnmarshaling->y, sizeof(VkViewportCoordinateSwizzleNV));
- vkStream->read((VkViewportCoordinateSwizzleNV*)&forUnmarshaling->z, sizeof(VkViewportCoordinateSwizzleNV));
- vkStream->read((VkViewportCoordinateSwizzleNV*)&forUnmarshaling->w, sizeof(VkViewportCoordinateSwizzleNV));
+ vkStream->read((VkViewportCoordinateSwizzleNV*)&forUnmarshaling->x,
+ sizeof(VkViewportCoordinateSwizzleNV));
+ vkStream->read((VkViewportCoordinateSwizzleNV*)&forUnmarshaling->y,
+ sizeof(VkViewportCoordinateSwizzleNV));
+ vkStream->read((VkViewportCoordinateSwizzleNV*)&forUnmarshaling->z,
+ sizeof(VkViewportCoordinateSwizzleNV));
+ vkStream->read((VkViewportCoordinateSwizzleNV*)&forUnmarshaling->w,
+ sizeof(VkViewportCoordinateSwizzleNV));
}
void marshal_VkPipelineViewportSwizzleStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineViewportSwizzleStateCreateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineViewportSwizzleStateCreateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineViewportSwizzleStateCreateFlagsNV*)&forMarshaling->flags, sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV));
+ vkStream->write((VkPipelineViewportSwizzleStateCreateFlagsNV*)&forMarshaling->flags,
+ sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV));
vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pViewportSwizzles;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pViewportSwizzles)
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
- {
- marshal_VkViewportSwizzleNV(vkStream, rootType, (const VkViewportSwizzleNV*)(forMarshaling->pViewportSwizzles + i));
+ if (forMarshaling->pViewportSwizzles) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i) {
+ marshal_VkViewportSwizzleNV(
+ vkStream, rootType,
+ (const VkViewportSwizzleNV*)(forMarshaling->pViewportSwizzles + i));
}
}
}
}
void unmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineViewportSwizzleStateCreateInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineViewportSwizzleStateCreateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineViewportSwizzleStateCreateFlagsNV*)&forUnmarshaling->flags, sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV));
+ vkStream->read((VkPipelineViewportSwizzleStateCreateFlagsNV*)&forUnmarshaling->flags,
+ sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV));
vkStream->read((uint32_t*)&forUnmarshaling->viewportCount, sizeof(uint32_t));
// WARNING PTR CHECK
const VkViewportSwizzleNV* check_pViewportSwizzles;
check_pViewportSwizzles = (const VkViewportSwizzleNV*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pViewportSwizzles)
- {
- if (!(check_pViewportSwizzles))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pViewportSwizzles inconsistent between guest and host\n");
+ if (forUnmarshaling->pViewportSwizzles) {
+ if (!(check_pViewportSwizzles)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pViewportSwizzles inconsistent between guest and host\n");
}
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i)
- {
- unmarshal_VkViewportSwizzleNV(vkStream, rootType, (VkViewportSwizzleNV*)(forUnmarshaling->pViewportSwizzles + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i) {
+ unmarshal_VkViewportSwizzleNV(
+ vkStream, rootType,
+ (VkViewportSwizzleNV*)(forUnmarshaling->pViewportSwizzles + i));
}
}
}
@@ -18444,14 +16678,11 @@
#endif
#ifdef VK_EXT_discard_rectangles
void marshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDiscardRectanglePropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDiscardRectanglePropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -18459,14 +16690,11 @@
}
void unmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceDiscardRectanglePropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceDiscardRectanglePropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -18474,64 +16702,59 @@
}
void marshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineDiscardRectangleStateCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineDiscardRectangleStateCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineDiscardRectangleStateCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkPipelineDiscardRectangleStateCreateFlagsEXT));
- vkStream->write((VkDiscardRectangleModeEXT*)&forMarshaling->discardRectangleMode, sizeof(VkDiscardRectangleModeEXT));
+ vkStream->write((VkPipelineDiscardRectangleStateCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkPipelineDiscardRectangleStateCreateFlagsEXT));
+ vkStream->write((VkDiscardRectangleModeEXT*)&forMarshaling->discardRectangleMode,
+ sizeof(VkDiscardRectangleModeEXT));
vkStream->write((uint32_t*)&forMarshaling->discardRectangleCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pDiscardRectangles;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pDiscardRectangles)
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->discardRectangleCount; ++i)
- {
- marshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pDiscardRectangles + i));
+ if (forMarshaling->pDiscardRectangles) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->discardRectangleCount; ++i) {
+ marshal_VkRect2D(vkStream, rootType,
+ (const VkRect2D*)(forMarshaling->pDiscardRectangles + i));
}
}
}
}
void unmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineDiscardRectangleStateCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineDiscardRectangleStateCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineDiscardRectangleStateCreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkPipelineDiscardRectangleStateCreateFlagsEXT));
- vkStream->read((VkDiscardRectangleModeEXT*)&forUnmarshaling->discardRectangleMode, sizeof(VkDiscardRectangleModeEXT));
+ vkStream->read((VkPipelineDiscardRectangleStateCreateFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkPipelineDiscardRectangleStateCreateFlagsEXT));
+ vkStream->read((VkDiscardRectangleModeEXT*)&forUnmarshaling->discardRectangleMode,
+ sizeof(VkDiscardRectangleModeEXT));
vkStream->read((uint32_t*)&forUnmarshaling->discardRectangleCount, sizeof(uint32_t));
// WARNING PTR CHECK
const VkRect2D* check_pDiscardRectangles;
check_pDiscardRectangles = (const VkRect2D*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pDiscardRectangles)
- {
- if (!(check_pDiscardRectangles))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pDiscardRectangles inconsistent between guest and host\n");
+ if (forUnmarshaling->pDiscardRectangles) {
+ if (!(check_pDiscardRectangles)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pDiscardRectangles inconsistent between guest and host\n");
}
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->discardRectangleCount; ++i)
- {
- unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(forUnmarshaling->pDiscardRectangles + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->discardRectangleCount; ++i) {
+ unmarshal_VkRect2D(vkStream, rootType,
+ (VkRect2D*)(forUnmarshaling->pDiscardRectangles + i));
}
}
}
@@ -18540,96 +16763,95 @@
#endif
#ifdef VK_EXT_conservative_rasterization
void marshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((float*)&forMarshaling->primitiveOverestimationSize, sizeof(float));
vkStream->write((float*)&forMarshaling->maxExtraPrimitiveOverestimationSize, sizeof(float));
- vkStream->write((float*)&forMarshaling->extraPrimitiveOverestimationSizeGranularity, sizeof(float));
+ vkStream->write((float*)&forMarshaling->extraPrimitiveOverestimationSizeGranularity,
+ sizeof(float));
vkStream->write((VkBool32*)&forMarshaling->primitiveUnderestimation, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->conservativePointAndLineRasterization, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->conservativePointAndLineRasterization,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->degenerateTrianglesRasterized, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->degenerateLinesRasterized, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->fullyCoveredFragmentShaderInputVariable, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->conservativeRasterizationPostDepthCoverage, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->fullyCoveredFragmentShaderInputVariable,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->conservativeRasterizationPostDepthCoverage,
+ sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((float*)&forUnmarshaling->primitiveOverestimationSize, sizeof(float));
vkStream->read((float*)&forUnmarshaling->maxExtraPrimitiveOverestimationSize, sizeof(float));
- vkStream->read((float*)&forUnmarshaling->extraPrimitiveOverestimationSizeGranularity, sizeof(float));
+ vkStream->read((float*)&forUnmarshaling->extraPrimitiveOverestimationSizeGranularity,
+ sizeof(float));
vkStream->read((VkBool32*)&forUnmarshaling->primitiveUnderestimation, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->conservativePointAndLineRasterization, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->conservativePointAndLineRasterization,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->degenerateTrianglesRasterized, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->degenerateLinesRasterized, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->fullyCoveredFragmentShaderInputVariable, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->conservativeRasterizationPostDepthCoverage, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->fullyCoveredFragmentShaderInputVariable,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->conservativeRasterizationPostDepthCoverage,
+ sizeof(VkBool32));
}
void marshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationConservativeStateCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationConservativeStateCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineRasterizationConservativeStateCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkPipelineRasterizationConservativeStateCreateFlagsEXT));
- vkStream->write((VkConservativeRasterizationModeEXT*)&forMarshaling->conservativeRasterizationMode, sizeof(VkConservativeRasterizationModeEXT));
+ vkStream->write((VkPipelineRasterizationConservativeStateCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkPipelineRasterizationConservativeStateCreateFlagsEXT));
+ vkStream->write(
+ (VkConservativeRasterizationModeEXT*)&forMarshaling->conservativeRasterizationMode,
+ sizeof(VkConservativeRasterizationModeEXT));
vkStream->write((float*)&forMarshaling->extraPrimitiveOverestimationSize, sizeof(float));
}
void unmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineRasterizationConservativeStateCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineRasterizationConservativeStateCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineRasterizationConservativeStateCreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkPipelineRasterizationConservativeStateCreateFlagsEXT));
- vkStream->read((VkConservativeRasterizationModeEXT*)&forUnmarshaling->conservativeRasterizationMode, sizeof(VkConservativeRasterizationModeEXT));
+ vkStream->read((VkPipelineRasterizationConservativeStateCreateFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkPipelineRasterizationConservativeStateCreateFlagsEXT));
+ vkStream->read(
+ (VkConservativeRasterizationModeEXT*)&forUnmarshaling->conservativeRasterizationMode,
+ sizeof(VkConservativeRasterizationModeEXT));
vkStream->read((float*)&forUnmarshaling->extraPrimitiveOverestimationSize, sizeof(float));
}
#endif
#ifdef VK_EXT_depth_clip_enable
void marshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -18637,14 +16859,11 @@
}
void unmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceDepthClipEnableFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceDepthClipEnableFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -18652,34 +16871,30 @@
}
void marshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineRasterizationDepthClipStateCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT));
+ vkStream->write((VkPipelineRasterizationDepthClipStateCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT));
vkStream->write((VkBool32*)&forMarshaling->depthClipEnable, sizeof(VkBool32));
}
void unmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineRasterizationDepthClipStateCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineRasterizationDepthClipStateCreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT));
+ vkStream->read((VkPipelineRasterizationDepthClipStateCreateFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT));
vkStream->read((VkBool32*)&forUnmarshaling->depthClipEnable, sizeof(VkBool32));
}
@@ -18687,35 +16902,25 @@
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
-void marshal_VkXYColorEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkXYColorEXT* forMarshaling)
-{
+void marshal_VkXYColorEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkXYColorEXT* forMarshaling) {
(void)rootType;
vkStream->write((float*)&forMarshaling->x, sizeof(float));
vkStream->write((float*)&forMarshaling->y, sizeof(float));
}
-void unmarshal_VkXYColorEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkXYColorEXT* forUnmarshaling)
-{
+void unmarshal_VkXYColorEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkXYColorEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((float*)&forUnmarshaling->x, sizeof(float));
vkStream->read((float*)&forUnmarshaling->y, sizeof(float));
}
-void marshal_VkHdrMetadataEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkHdrMetadataEXT* forMarshaling)
-{
+void marshal_VkHdrMetadataEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkHdrMetadataEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -18729,21 +16934,20 @@
vkStream->write((float*)&forMarshaling->maxFrameAverageLightLevel, sizeof(float));
}
-void unmarshal_VkHdrMetadataEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkHdrMetadataEXT* forUnmarshaling)
-{
+void unmarshal_VkHdrMetadataEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkHdrMetadataEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkXYColorEXT(vkStream, rootType, (VkXYColorEXT*)(&forUnmarshaling->displayPrimaryRed));
- unmarshal_VkXYColorEXT(vkStream, rootType, (VkXYColorEXT*)(&forUnmarshaling->displayPrimaryGreen));
- unmarshal_VkXYColorEXT(vkStream, rootType, (VkXYColorEXT*)(&forUnmarshaling->displayPrimaryBlue));
+ unmarshal_VkXYColorEXT(vkStream, rootType,
+ (VkXYColorEXT*)(&forUnmarshaling->displayPrimaryRed));
+ unmarshal_VkXYColorEXT(vkStream, rootType,
+ (VkXYColorEXT*)(&forUnmarshaling->displayPrimaryGreen));
+ unmarshal_VkXYColorEXT(vkStream, rootType,
+ (VkXYColorEXT*)(&forUnmarshaling->displayPrimaryBlue));
unmarshal_VkXYColorEXT(vkStream, rootType, (VkXYColorEXT*)(&forUnmarshaling->whitePoint));
vkStream->read((float*)&forUnmarshaling->maxLuminance, sizeof(float));
vkStream->read((float*)&forUnmarshaling->minLuminance, sizeof(float));
@@ -18753,48 +16957,39 @@
#endif
#ifdef VK_MVK_ios_surface
-void marshal_VkIOSSurfaceCreateInfoMVK(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkIOSSurfaceCreateInfoMVK* forMarshaling)
-{
+void marshal_VkIOSSurfaceCreateInfoMVK(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkIOSSurfaceCreateInfoMVK* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkIOSSurfaceCreateFlagsMVK*)&forMarshaling->flags, sizeof(VkIOSSurfaceCreateFlagsMVK));
+ vkStream->write((VkIOSSurfaceCreateFlagsMVK*)&forMarshaling->flags,
+ sizeof(VkIOSSurfaceCreateFlagsMVK));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pView;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pView)
- {
+ if (forMarshaling->pView) {
vkStream->write((const void*)forMarshaling->pView, sizeof(const uint8_t));
}
}
-void unmarshal_VkIOSSurfaceCreateInfoMVK(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkIOSSurfaceCreateInfoMVK* forUnmarshaling)
-{
+void unmarshal_VkIOSSurfaceCreateInfoMVK(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkIOSSurfaceCreateInfoMVK* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkIOSSurfaceCreateFlagsMVK*)&forUnmarshaling->flags, sizeof(VkIOSSurfaceCreateFlagsMVK));
+ vkStream->read((VkIOSSurfaceCreateFlagsMVK*)&forUnmarshaling->flags,
+ sizeof(VkIOSSurfaceCreateFlagsMVK));
// WARNING PTR CHECK
const void* check_pView;
check_pView = (const void*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pView)
- {
- if (!(check_pView))
- {
+ if (forUnmarshaling->pView) {
+ if (!(check_pView)) {
fprintf(stderr, "fatal: forUnmarshaling->pView inconsistent between guest and host\n");
}
vkStream->read((void*)forUnmarshaling->pView, sizeof(const uint8_t));
@@ -18803,48 +16998,39 @@
#endif
#ifdef VK_MVK_macos_surface
-void marshal_VkMacOSSurfaceCreateInfoMVK(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMacOSSurfaceCreateInfoMVK* forMarshaling)
-{
+void marshal_VkMacOSSurfaceCreateInfoMVK(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMacOSSurfaceCreateInfoMVK* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkMacOSSurfaceCreateFlagsMVK*)&forMarshaling->flags, sizeof(VkMacOSSurfaceCreateFlagsMVK));
+ vkStream->write((VkMacOSSurfaceCreateFlagsMVK*)&forMarshaling->flags,
+ sizeof(VkMacOSSurfaceCreateFlagsMVK));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pView;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pView)
- {
+ if (forMarshaling->pView) {
vkStream->write((const void*)forMarshaling->pView, sizeof(const uint8_t));
}
}
-void unmarshal_VkMacOSSurfaceCreateInfoMVK(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMacOSSurfaceCreateInfoMVK* forUnmarshaling)
-{
+void unmarshal_VkMacOSSurfaceCreateInfoMVK(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMacOSSurfaceCreateInfoMVK* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkMacOSSurfaceCreateFlagsMVK*)&forUnmarshaling->flags, sizeof(VkMacOSSurfaceCreateFlagsMVK));
+ vkStream->read((VkMacOSSurfaceCreateFlagsMVK*)&forUnmarshaling->flags,
+ sizeof(VkMacOSSurfaceCreateFlagsMVK));
// WARNING PTR CHECK
const void* check_pView;
check_pView = (const void*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pView)
- {
- if (!(check_pView))
- {
+ if (forUnmarshaling->pView) {
+ if (!(check_pView)) {
fprintf(stderr, "fatal: forUnmarshaling->pView inconsistent between guest and host\n");
}
vkStream->read((void*)forUnmarshaling->pView, sizeof(const uint8_t));
@@ -18859,15 +17045,11 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
-void marshal_VkDebugUtilsLabelEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugUtilsLabelEXT* forMarshaling)
-{
+void marshal_VkDebugUtilsLabelEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugUtilsLabelEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -18875,15 +17057,11 @@
vkStream->write((float*)forMarshaling->color, 4 * sizeof(float));
}
-void unmarshal_VkDebugUtilsLabelEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDebugUtilsLabelEXT* forUnmarshaling)
-{
+void unmarshal_VkDebugUtilsLabelEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDebugUtilsLabelEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -18891,95 +17069,74 @@
vkStream->read((float*)forUnmarshaling->color, 4 * sizeof(float));
}
-void marshal_VkDebugUtilsObjectNameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugUtilsObjectNameInfoEXT* forMarshaling)
-{
+void marshal_VkDebugUtilsObjectNameInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugUtilsObjectNameInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkObjectType*)&forMarshaling->objectType, sizeof(VkObjectType));
vkStream->write((uint64_t*)&forMarshaling->objectHandle, sizeof(uint64_t));
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
- {
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pObjectName;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pObjectName)
- {
+ if (forMarshaling->pObjectName) {
vkStream->putString(forMarshaling->pObjectName);
}
- }
- else
- {
+ } else {
vkStream->putString(forMarshaling->pObjectName);
}
}
-void unmarshal_VkDebugUtilsObjectNameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDebugUtilsObjectNameInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkDebugUtilsObjectNameInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDebugUtilsObjectNameInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkObjectType*)&forUnmarshaling->objectType, sizeof(VkObjectType));
vkStream->read((uint64_t*)&forUnmarshaling->objectHandle, sizeof(uint64_t));
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
- {
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
// WARNING PTR CHECK
const char* check_pObjectName;
check_pObjectName = (const char*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pObjectName)
- {
- if (!(check_pObjectName))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pObjectName inconsistent between guest and host\n");
+ if (forUnmarshaling->pObjectName) {
+ if (!(check_pObjectName)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pObjectName inconsistent between guest and host\n");
}
vkStream->loadStringInPlace((char**)&forUnmarshaling->pObjectName);
}
- }
- else
- {
+ } else {
vkStream->loadStringInPlace((char**)&forUnmarshaling->pObjectName);
}
}
void marshal_VkDebugUtilsMessengerCallbackDataEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugUtilsMessengerCallbackDataEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugUtilsMessengerCallbackDataEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDebugUtilsMessengerCallbackDataFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT));
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
- {
+ vkStream->write((VkDebugUtilsMessengerCallbackDataFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT));
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pMessageIdName;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pMessageIdName)
- {
+ if (forMarshaling->pMessageIdName) {
vkStream->putString(forMarshaling->pMessageIdName);
}
- }
- else
- {
+ } else {
vkStream->putString(forMarshaling->pMessageIdName);
}
vkStream->write((int32_t*)&forMarshaling->messageIdNumber, sizeof(int32_t));
@@ -18988,13 +17145,11 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pQueueLabels;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pQueueLabels)
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueLabelCount; ++i)
- {
- marshal_VkDebugUtilsLabelEXT(vkStream, rootType, (VkDebugUtilsLabelEXT*)(forMarshaling->pQueueLabels + i));
+ if (forMarshaling->pQueueLabels) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueLabelCount; ++i) {
+ marshal_VkDebugUtilsLabelEXT(
+ vkStream, rootType, (VkDebugUtilsLabelEXT*)(forMarshaling->pQueueLabels + i));
}
}
}
@@ -19002,13 +17157,11 @@
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pCmdBufLabels;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pCmdBufLabels)
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->cmdBufLabelCount; ++i)
- {
- marshal_VkDebugUtilsLabelEXT(vkStream, rootType, (VkDebugUtilsLabelEXT*)(forMarshaling->pCmdBufLabels + i));
+ if (forMarshaling->pCmdBufLabels) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->cmdBufLabelCount; ++i) {
+ marshal_VkDebugUtilsLabelEXT(
+ vkStream, rootType, (VkDebugUtilsLabelEXT*)(forMarshaling->pCmdBufLabels + i));
}
}
}
@@ -19016,47 +17169,41 @@
// WARNING PTR CHECK
uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pObjects;
vkStream->putBe64(cgen_var_2);
- if (forMarshaling->pObjects)
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->objectCount; ++i)
- {
- marshal_VkDebugUtilsObjectNameInfoEXT(vkStream, rootType, (VkDebugUtilsObjectNameInfoEXT*)(forMarshaling->pObjects + i));
+ if (forMarshaling->pObjects) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->objectCount; ++i) {
+ marshal_VkDebugUtilsObjectNameInfoEXT(
+ vkStream, rootType,
+ (VkDebugUtilsObjectNameInfoEXT*)(forMarshaling->pObjects + i));
}
}
}
}
void unmarshal_VkDebugUtilsMessengerCallbackDataEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDebugUtilsMessengerCallbackDataEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDebugUtilsMessengerCallbackDataEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDebugUtilsMessengerCallbackDataFlagsEXT*)&forUnmarshaling->flags, sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT));
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
- {
+ vkStream->read((VkDebugUtilsMessengerCallbackDataFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT));
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
// WARNING PTR CHECK
const char* check_pMessageIdName;
check_pMessageIdName = (const char*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pMessageIdName)
- {
- if (!(check_pMessageIdName))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pMessageIdName inconsistent between guest and host\n");
+ if (forUnmarshaling->pMessageIdName) {
+ if (!(check_pMessageIdName)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pMessageIdName inconsistent between guest and host\n");
}
vkStream->loadStringInPlace((char**)&forUnmarshaling->pMessageIdName);
}
- }
- else
- {
+ } else {
vkStream->loadStringInPlace((char**)&forUnmarshaling->pMessageIdName);
}
vkStream->read((int32_t*)&forUnmarshaling->messageIdNumber, sizeof(int32_t));
@@ -19065,17 +17212,15 @@
// WARNING PTR CHECK
VkDebugUtilsLabelEXT* check_pQueueLabels;
check_pQueueLabels = (VkDebugUtilsLabelEXT*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pQueueLabels)
- {
- if (!(check_pQueueLabels))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pQueueLabels inconsistent between guest and host\n");
+ if (forUnmarshaling->pQueueLabels) {
+ if (!(check_pQueueLabels)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pQueueLabels inconsistent between guest and host\n");
}
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->queueLabelCount; ++i)
- {
- unmarshal_VkDebugUtilsLabelEXT(vkStream, rootType, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pQueueLabels + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->queueLabelCount; ++i) {
+ unmarshal_VkDebugUtilsLabelEXT(
+ vkStream, rootType, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pQueueLabels + i));
}
}
}
@@ -19083,17 +17228,16 @@
// WARNING PTR CHECK
VkDebugUtilsLabelEXT* check_pCmdBufLabels;
check_pCmdBufLabels = (VkDebugUtilsLabelEXT*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pCmdBufLabels)
- {
- if (!(check_pCmdBufLabels))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pCmdBufLabels inconsistent between guest and host\n");
+ if (forUnmarshaling->pCmdBufLabels) {
+ if (!(check_pCmdBufLabels)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pCmdBufLabels inconsistent between guest and host\n");
}
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->cmdBufLabelCount; ++i)
- {
- unmarshal_VkDebugUtilsLabelEXT(vkStream, rootType, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pCmdBufLabels + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->cmdBufLabelCount; ++i) {
+ unmarshal_VkDebugUtilsLabelEXT(
+ vkStream, rootType,
+ (VkDebugUtilsLabelEXT*)(forUnmarshaling->pCmdBufLabels + i));
}
}
}
@@ -19101,86 +17245,79 @@
// WARNING PTR CHECK
VkDebugUtilsObjectNameInfoEXT* check_pObjects;
check_pObjects = (VkDebugUtilsObjectNameInfoEXT*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pObjects)
- {
- if (!(check_pObjects))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pObjects inconsistent between guest and host\n");
+ if (forUnmarshaling->pObjects) {
+ if (!(check_pObjects)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pObjects inconsistent between guest and host\n");
}
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->objectCount; ++i)
- {
- unmarshal_VkDebugUtilsObjectNameInfoEXT(vkStream, rootType, (VkDebugUtilsObjectNameInfoEXT*)(forUnmarshaling->pObjects + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->objectCount; ++i) {
+ unmarshal_VkDebugUtilsObjectNameInfoEXT(
+ vkStream, rootType,
+ (VkDebugUtilsObjectNameInfoEXT*)(forUnmarshaling->pObjects + i));
}
}
}
}
void marshal_VkDebugUtilsMessengerCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugUtilsMessengerCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugUtilsMessengerCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDebugUtilsMessengerCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugUtilsMessengerCreateFlagsEXT));
- vkStream->write((VkDebugUtilsMessageSeverityFlagsEXT*)&forMarshaling->messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagsEXT));
- vkStream->write((VkDebugUtilsMessageTypeFlagsEXT*)&forMarshaling->messageType, sizeof(VkDebugUtilsMessageTypeFlagsEXT));
+ vkStream->write((VkDebugUtilsMessengerCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkDebugUtilsMessengerCreateFlagsEXT));
+ vkStream->write((VkDebugUtilsMessageSeverityFlagsEXT*)&forMarshaling->messageSeverity,
+ sizeof(VkDebugUtilsMessageSeverityFlagsEXT));
+ vkStream->write((VkDebugUtilsMessageTypeFlagsEXT*)&forMarshaling->messageType,
+ sizeof(VkDebugUtilsMessageTypeFlagsEXT));
uint64_t cgen_var_0 = (uint64_t)forMarshaling->pfnUserCallback;
vkStream->putBe64(cgen_var_0);
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pUserData)
- {
+ if (forMarshaling->pUserData) {
vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
}
}
void unmarshal_VkDebugUtilsMessengerCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDebugUtilsMessengerCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDebugUtilsMessengerCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDebugUtilsMessengerCreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkDebugUtilsMessengerCreateFlagsEXT));
- vkStream->read((VkDebugUtilsMessageSeverityFlagsEXT*)&forUnmarshaling->messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagsEXT));
- vkStream->read((VkDebugUtilsMessageTypeFlagsEXT*)&forUnmarshaling->messageType, sizeof(VkDebugUtilsMessageTypeFlagsEXT));
+ vkStream->read((VkDebugUtilsMessengerCreateFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkDebugUtilsMessengerCreateFlagsEXT));
+ vkStream->read((VkDebugUtilsMessageSeverityFlagsEXT*)&forUnmarshaling->messageSeverity,
+ sizeof(VkDebugUtilsMessageSeverityFlagsEXT));
+ vkStream->read((VkDebugUtilsMessageTypeFlagsEXT*)&forUnmarshaling->messageType,
+ sizeof(VkDebugUtilsMessageTypeFlagsEXT));
forUnmarshaling->pfnUserCallback = (PFN_vkDebugUtilsMessengerCallbackEXT)vkStream->getBe64();
// WARNING PTR CHECK
void* check_pUserData;
check_pUserData = (void*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pUserData)
- {
- if (!(check_pUserData))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pUserData inconsistent between guest and host\n");
+ if (forUnmarshaling->pUserData) {
+ if (!(check_pUserData)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pUserData inconsistent between guest and host\n");
}
vkStream->read((void*)forUnmarshaling->pUserData, sizeof(uint8_t));
}
}
-void marshal_VkDebugUtilsObjectTagInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugUtilsObjectTagInfoEXT* forMarshaling)
-{
+void marshal_VkDebugUtilsObjectTagInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugUtilsObjectTagInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -19189,18 +17326,15 @@
vkStream->write((uint64_t*)&forMarshaling->tagName, sizeof(uint64_t));
uint64_t cgen_var_0 = (uint64_t)forMarshaling->tagSize;
vkStream->putBe64(cgen_var_0);
- vkStream->write((const void*)forMarshaling->pTag, forMarshaling->tagSize * sizeof(const uint8_t));
+ vkStream->write((const void*)forMarshaling->pTag,
+ forMarshaling->tagSize * sizeof(const uint8_t));
}
-void unmarshal_VkDebugUtilsObjectTagInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDebugUtilsObjectTagInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkDebugUtilsObjectTagInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDebugUtilsObjectTagInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -19214,14 +17348,11 @@
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
void marshal_VkAndroidHardwareBufferUsageANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAndroidHardwareBufferUsageANDROID* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAndroidHardwareBufferUsageANDROID* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -19229,14 +17360,11 @@
}
void unmarshal_VkAndroidHardwareBufferUsageANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAndroidHardwareBufferUsageANDROID* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAndroidHardwareBufferUsageANDROID* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -19244,14 +17372,11 @@
}
void marshal_VkAndroidHardwareBufferPropertiesANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAndroidHardwareBufferPropertiesANDROID* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAndroidHardwareBufferPropertiesANDROID* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -19260,14 +17385,11 @@
}
void unmarshal_VkAndroidHardwareBufferPropertiesANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAndroidHardwareBufferPropertiesANDROID* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAndroidHardwareBufferPropertiesANDROID* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -19276,58 +17398,63 @@
}
void marshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAndroidHardwareBufferFormatPropertiesANDROID* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAndroidHardwareBufferFormatPropertiesANDROID* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
vkStream->write((uint64_t*)&forMarshaling->externalFormat, sizeof(uint64_t));
- vkStream->write((VkFormatFeatureFlags*)&forMarshaling->formatFeatures, sizeof(VkFormatFeatureFlags));
- marshal_VkComponentMapping(vkStream, rootType, (VkComponentMapping*)(&forMarshaling->samplerYcbcrConversionComponents));
- vkStream->write((VkSamplerYcbcrModelConversion*)&forMarshaling->suggestedYcbcrModel, sizeof(VkSamplerYcbcrModelConversion));
- vkStream->write((VkSamplerYcbcrRange*)&forMarshaling->suggestedYcbcrRange, sizeof(VkSamplerYcbcrRange));
- vkStream->write((VkChromaLocation*)&forMarshaling->suggestedXChromaOffset, sizeof(VkChromaLocation));
- vkStream->write((VkChromaLocation*)&forMarshaling->suggestedYChromaOffset, sizeof(VkChromaLocation));
+ vkStream->write((VkFormatFeatureFlags*)&forMarshaling->formatFeatures,
+ sizeof(VkFormatFeatureFlags));
+ marshal_VkComponentMapping(
+ vkStream, rootType,
+ (VkComponentMapping*)(&forMarshaling->samplerYcbcrConversionComponents));
+ vkStream->write((VkSamplerYcbcrModelConversion*)&forMarshaling->suggestedYcbcrModel,
+ sizeof(VkSamplerYcbcrModelConversion));
+ vkStream->write((VkSamplerYcbcrRange*)&forMarshaling->suggestedYcbcrRange,
+ sizeof(VkSamplerYcbcrRange));
+ vkStream->write((VkChromaLocation*)&forMarshaling->suggestedXChromaOffset,
+ sizeof(VkChromaLocation));
+ vkStream->write((VkChromaLocation*)&forMarshaling->suggestedYChromaOffset,
+ sizeof(VkChromaLocation));
}
void unmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAndroidHardwareBufferFormatPropertiesANDROID* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAndroidHardwareBufferFormatPropertiesANDROID* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
vkStream->read((uint64_t*)&forUnmarshaling->externalFormat, sizeof(uint64_t));
- vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->formatFeatures, sizeof(VkFormatFeatureFlags));
- unmarshal_VkComponentMapping(vkStream, rootType, (VkComponentMapping*)(&forUnmarshaling->samplerYcbcrConversionComponents));
- vkStream->read((VkSamplerYcbcrModelConversion*)&forUnmarshaling->suggestedYcbcrModel, sizeof(VkSamplerYcbcrModelConversion));
- vkStream->read((VkSamplerYcbcrRange*)&forUnmarshaling->suggestedYcbcrRange, sizeof(VkSamplerYcbcrRange));
- vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedXChromaOffset, sizeof(VkChromaLocation));
- vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedYChromaOffset, sizeof(VkChromaLocation));
+ vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->formatFeatures,
+ sizeof(VkFormatFeatureFlags));
+ unmarshal_VkComponentMapping(
+ vkStream, rootType,
+ (VkComponentMapping*)(&forUnmarshaling->samplerYcbcrConversionComponents));
+ vkStream->read((VkSamplerYcbcrModelConversion*)&forUnmarshaling->suggestedYcbcrModel,
+ sizeof(VkSamplerYcbcrModelConversion));
+ vkStream->read((VkSamplerYcbcrRange*)&forUnmarshaling->suggestedYcbcrRange,
+ sizeof(VkSamplerYcbcrRange));
+ vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedXChromaOffset,
+ sizeof(VkChromaLocation));
+ vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedYChromaOffset,
+ sizeof(VkChromaLocation));
}
void marshal_VkImportAndroidHardwareBufferInfoANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportAndroidHardwareBufferInfoANDROID* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportAndroidHardwareBufferInfoANDROID* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -19335,14 +17462,11 @@
}
void unmarshal_VkImportAndroidHardwareBufferInfoANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportAndroidHardwareBufferInfoANDROID* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImportAndroidHardwareBufferInfoANDROID* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -19350,63 +17474,51 @@
}
void marshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryGetAndroidHardwareBufferInfoANDROID* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryGetAndroidHardwareBufferInfoANDROID* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}
void unmarshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryGetAndroidHardwareBufferInfoANDROID* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryGetAndroidHardwareBufferInfoANDROID* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+ &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
}
-void marshal_VkExternalFormatANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalFormatANDROID* forMarshaling)
-{
+void marshal_VkExternalFormatANDROID(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalFormatANDROID* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint64_t*)&forMarshaling->externalFormat, sizeof(uint64_t));
}
-void unmarshal_VkExternalFormatANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExternalFormatANDROID* forUnmarshaling)
-{
+void unmarshal_VkExternalFormatANDROID(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExternalFormatANDROID* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -19414,47 +17526,55 @@
}
void marshal_VkAndroidHardwareBufferFormatProperties2ANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAndroidHardwareBufferFormatProperties2ANDROID* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAndroidHardwareBufferFormatProperties2ANDROID* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
vkStream->write((uint64_t*)&forMarshaling->externalFormat, sizeof(uint64_t));
- vkStream->write((VkFormatFeatureFlags2KHR*)&forMarshaling->formatFeatures, sizeof(VkFormatFeatureFlags2KHR));
- marshal_VkComponentMapping(vkStream, rootType, (VkComponentMapping*)(&forMarshaling->samplerYcbcrConversionComponents));
- vkStream->write((VkSamplerYcbcrModelConversion*)&forMarshaling->suggestedYcbcrModel, sizeof(VkSamplerYcbcrModelConversion));
- vkStream->write((VkSamplerYcbcrRange*)&forMarshaling->suggestedYcbcrRange, sizeof(VkSamplerYcbcrRange));
- vkStream->write((VkChromaLocation*)&forMarshaling->suggestedXChromaOffset, sizeof(VkChromaLocation));
- vkStream->write((VkChromaLocation*)&forMarshaling->suggestedYChromaOffset, sizeof(VkChromaLocation));
+ vkStream->write((VkFormatFeatureFlags2KHR*)&forMarshaling->formatFeatures,
+ sizeof(VkFormatFeatureFlags2KHR));
+ marshal_VkComponentMapping(
+ vkStream, rootType,
+ (VkComponentMapping*)(&forMarshaling->samplerYcbcrConversionComponents));
+ vkStream->write((VkSamplerYcbcrModelConversion*)&forMarshaling->suggestedYcbcrModel,
+ sizeof(VkSamplerYcbcrModelConversion));
+ vkStream->write((VkSamplerYcbcrRange*)&forMarshaling->suggestedYcbcrRange,
+ sizeof(VkSamplerYcbcrRange));
+ vkStream->write((VkChromaLocation*)&forMarshaling->suggestedXChromaOffset,
+ sizeof(VkChromaLocation));
+ vkStream->write((VkChromaLocation*)&forMarshaling->suggestedYChromaOffset,
+ sizeof(VkChromaLocation));
}
void unmarshal_VkAndroidHardwareBufferFormatProperties2ANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAndroidHardwareBufferFormatProperties2ANDROID* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAndroidHardwareBufferFormatProperties2ANDROID* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
vkStream->read((uint64_t*)&forUnmarshaling->externalFormat, sizeof(uint64_t));
- vkStream->read((VkFormatFeatureFlags2KHR*)&forUnmarshaling->formatFeatures, sizeof(VkFormatFeatureFlags2KHR));
- unmarshal_VkComponentMapping(vkStream, rootType, (VkComponentMapping*)(&forUnmarshaling->samplerYcbcrConversionComponents));
- vkStream->read((VkSamplerYcbcrModelConversion*)&forUnmarshaling->suggestedYcbcrModel, sizeof(VkSamplerYcbcrModelConversion));
- vkStream->read((VkSamplerYcbcrRange*)&forUnmarshaling->suggestedYcbcrRange, sizeof(VkSamplerYcbcrRange));
- vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedXChromaOffset, sizeof(VkChromaLocation));
- vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedYChromaOffset, sizeof(VkChromaLocation));
+ vkStream->read((VkFormatFeatureFlags2KHR*)&forUnmarshaling->formatFeatures,
+ sizeof(VkFormatFeatureFlags2KHR));
+ unmarshal_VkComponentMapping(
+ vkStream, rootType,
+ (VkComponentMapping*)(&forUnmarshaling->samplerYcbcrConversionComponents));
+ vkStream->read((VkSamplerYcbcrModelConversion*)&forUnmarshaling->suggestedYcbcrModel,
+ sizeof(VkSamplerYcbcrModelConversion));
+ vkStream->read((VkSamplerYcbcrRange*)&forUnmarshaling->suggestedYcbcrRange,
+ sizeof(VkSamplerYcbcrRange));
+ vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedXChromaOffset,
+ sizeof(VkChromaLocation));
+ vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedYChromaOffset,
+ sizeof(VkChromaLocation));
}
#endif
@@ -19468,116 +17588,109 @@
#endif
#ifdef VK_EXT_inline_uniform_block
void marshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->inlineUniformBlock, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->descriptorBindingInlineUniformBlockUpdateAfterBind, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->descriptorBindingInlineUniformBlockUpdateAfterBind,
+ sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->inlineUniformBlock, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingInlineUniformBlockUpdateAfterBind, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingInlineUniformBlockUpdateAfterBind,
+ sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->maxInlineUniformBlockSize, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorInlineUniformBlocks, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetInlineUniformBlocks, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInlineUniformBlocks, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorInlineUniformBlocks,
+ sizeof(uint32_t));
+ vkStream->write(
+ (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetInlineUniformBlocks,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInlineUniformBlocks,
+ sizeof(uint32_t));
}
void unmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->maxInlineUniformBlockSize, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorInlineUniformBlocks, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetInlineUniformBlocks, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindInlineUniformBlocks, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorInlineUniformBlocks,
+ sizeof(uint32_t));
+ vkStream->read(
+ (uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetInlineUniformBlocks,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindInlineUniformBlocks,
+ sizeof(uint32_t));
}
void marshal_VkWriteDescriptorSetInlineUniformBlockEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWriteDescriptorSetInlineUniformBlockEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWriteDescriptorSetInlineUniformBlockEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->dataSize, sizeof(uint32_t));
- vkStream->write((const void*)forMarshaling->pData, forMarshaling->dataSize * sizeof(const uint8_t));
+ vkStream->write((const void*)forMarshaling->pData,
+ forMarshaling->dataSize * sizeof(const uint8_t));
}
void unmarshal_VkWriteDescriptorSetInlineUniformBlockEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkWriteDescriptorSetInlineUniformBlockEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkWriteDescriptorSetInlineUniformBlockEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->dataSize, sizeof(uint32_t));
- vkStream->read((void*)forUnmarshaling->pData, forUnmarshaling->dataSize * sizeof(const uint8_t));
+ vkStream->read((void*)forUnmarshaling->pData,
+ forUnmarshaling->dataSize * sizeof(const uint8_t));
}
void marshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -19585,14 +17698,11 @@
}
void unmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -19603,285 +17713,253 @@
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
-void marshal_VkSampleLocationEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSampleLocationEXT* forMarshaling)
-{
+void marshal_VkSampleLocationEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSampleLocationEXT* forMarshaling) {
(void)rootType;
vkStream->write((float*)&forMarshaling->x, sizeof(float));
vkStream->write((float*)&forMarshaling->y, sizeof(float));
}
-void unmarshal_VkSampleLocationEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSampleLocationEXT* forUnmarshaling)
-{
+void unmarshal_VkSampleLocationEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSampleLocationEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((float*)&forUnmarshaling->x, sizeof(float));
vkStream->read((float*)&forUnmarshaling->y, sizeof(float));
}
-void marshal_VkSampleLocationsInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSampleLocationsInfoEXT* forMarshaling)
-{
+void marshal_VkSampleLocationsInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSampleLocationsInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkSampleCountFlagBits*)&forMarshaling->sampleLocationsPerPixel, sizeof(VkSampleCountFlagBits));
+ vkStream->write((VkSampleCountFlagBits*)&forMarshaling->sampleLocationsPerPixel,
+ sizeof(VkSampleCountFlagBits));
marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->sampleLocationGridSize));
vkStream->write((uint32_t*)&forMarshaling->sampleLocationsCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->sampleLocationsCount; ++i)
- {
- marshal_VkSampleLocationEXT(vkStream, rootType, (const VkSampleLocationEXT*)(forMarshaling->pSampleLocations + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->sampleLocationsCount; ++i) {
+ marshal_VkSampleLocationEXT(
+ vkStream, rootType,
+ (const VkSampleLocationEXT*)(forMarshaling->pSampleLocations + i));
}
}
}
-void unmarshal_VkSampleLocationsInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSampleLocationsInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkSampleLocationsInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSampleLocationsInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->sampleLocationsPerPixel, sizeof(VkSampleCountFlagBits));
- unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->sampleLocationGridSize));
+ vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->sampleLocationsPerPixel,
+ sizeof(VkSampleCountFlagBits));
+ unmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forUnmarshaling->sampleLocationGridSize));
vkStream->read((uint32_t*)&forUnmarshaling->sampleLocationsCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->sampleLocationsCount; ++i)
- {
- unmarshal_VkSampleLocationEXT(vkStream, rootType, (VkSampleLocationEXT*)(forUnmarshaling->pSampleLocations + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->sampleLocationsCount; ++i) {
+ unmarshal_VkSampleLocationEXT(
+ vkStream, rootType, (VkSampleLocationEXT*)(forUnmarshaling->pSampleLocations + i));
}
}
}
-void marshal_VkAttachmentSampleLocationsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentSampleLocationsEXT* forMarshaling)
-{
+void marshal_VkAttachmentSampleLocationsEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentSampleLocationsEXT* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->attachmentIndex, sizeof(uint32_t));
- marshal_VkSampleLocationsInfoEXT(vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
+ marshal_VkSampleLocationsInfoEXT(
+ vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
}
-void unmarshal_VkAttachmentSampleLocationsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAttachmentSampleLocationsEXT* forUnmarshaling)
-{
+void unmarshal_VkAttachmentSampleLocationsEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAttachmentSampleLocationsEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->attachmentIndex, sizeof(uint32_t));
- unmarshal_VkSampleLocationsInfoEXT(vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
+ unmarshal_VkSampleLocationsInfoEXT(
+ vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
}
-void marshal_VkSubpassSampleLocationsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassSampleLocationsEXT* forMarshaling)
-{
+void marshal_VkSubpassSampleLocationsEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassSampleLocationsEXT* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->subpassIndex, sizeof(uint32_t));
- marshal_VkSampleLocationsInfoEXT(vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
+ marshal_VkSampleLocationsInfoEXT(
+ vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
}
-void unmarshal_VkSubpassSampleLocationsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubpassSampleLocationsEXT* forUnmarshaling)
-{
+void unmarshal_VkSubpassSampleLocationsEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubpassSampleLocationsEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->subpassIndex, sizeof(uint32_t));
- unmarshal_VkSampleLocationsInfoEXT(vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
+ unmarshal_VkSampleLocationsInfoEXT(
+ vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
}
void marshal_VkRenderPassSampleLocationsBeginInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassSampleLocationsBeginInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassSampleLocationsBeginInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((uint32_t*)&forMarshaling->attachmentInitialSampleLocationsCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentInitialSampleLocationsCount; ++i)
- {
- marshal_VkAttachmentSampleLocationsEXT(vkStream, rootType, (const VkAttachmentSampleLocationsEXT*)(forMarshaling->pAttachmentInitialSampleLocations + i));
+ vkStream->write((uint32_t*)&forMarshaling->attachmentInitialSampleLocationsCount,
+ sizeof(uint32_t));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentInitialSampleLocationsCount;
+ ++i) {
+ marshal_VkAttachmentSampleLocationsEXT(
+ vkStream, rootType,
+ (const VkAttachmentSampleLocationsEXT*)(forMarshaling
+ ->pAttachmentInitialSampleLocations +
+ i));
}
}
vkStream->write((uint32_t*)&forMarshaling->postSubpassSampleLocationsCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->postSubpassSampleLocationsCount; ++i)
- {
- marshal_VkSubpassSampleLocationsEXT(vkStream, rootType, (const VkSubpassSampleLocationsEXT*)(forMarshaling->pPostSubpassSampleLocations + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->postSubpassSampleLocationsCount; ++i) {
+ marshal_VkSubpassSampleLocationsEXT(
+ vkStream, rootType,
+ (const VkSubpassSampleLocationsEXT*)(forMarshaling->pPostSubpassSampleLocations +
+ i));
}
}
}
void unmarshal_VkRenderPassSampleLocationsBeginInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRenderPassSampleLocationsBeginInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderPassSampleLocationsBeginInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((uint32_t*)&forUnmarshaling->attachmentInitialSampleLocationsCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentInitialSampleLocationsCount; ++i)
- {
- unmarshal_VkAttachmentSampleLocationsEXT(vkStream, rootType, (VkAttachmentSampleLocationsEXT*)(forUnmarshaling->pAttachmentInitialSampleLocations + i));
+ vkStream->read((uint32_t*)&forUnmarshaling->attachmentInitialSampleLocationsCount,
+ sizeof(uint32_t));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->attachmentInitialSampleLocationsCount;
+ ++i) {
+ unmarshal_VkAttachmentSampleLocationsEXT(
+ vkStream, rootType,
+ (VkAttachmentSampleLocationsEXT*)(forUnmarshaling
+ ->pAttachmentInitialSampleLocations +
+ i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->postSubpassSampleLocationsCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->postSubpassSampleLocationsCount; ++i)
- {
- unmarshal_VkSubpassSampleLocationsEXT(vkStream, rootType, (VkSubpassSampleLocationsEXT*)(forUnmarshaling->pPostSubpassSampleLocations + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->postSubpassSampleLocationsCount; ++i) {
+ unmarshal_VkSubpassSampleLocationsEXT(
+ vkStream, rootType,
+ (VkSubpassSampleLocationsEXT*)(forUnmarshaling->pPostSubpassSampleLocations + i));
}
}
}
void marshal_VkPipelineSampleLocationsStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineSampleLocationsStateCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineSampleLocationsStateCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->sampleLocationsEnable, sizeof(VkBool32));
- marshal_VkSampleLocationsInfoEXT(vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
+ marshal_VkSampleLocationsInfoEXT(
+ vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo));
}
void unmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineSampleLocationsStateCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineSampleLocationsStateCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->sampleLocationsEnable, sizeof(VkBool32));
- unmarshal_VkSampleLocationsInfoEXT(vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
+ unmarshal_VkSampleLocationsInfoEXT(
+ vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forUnmarshaling->sampleLocationsInfo));
}
void marshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSampleLocationsPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSampleLocationsPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkSampleCountFlags*)&forMarshaling->sampleLocationSampleCounts, sizeof(VkSampleCountFlags));
- marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxSampleLocationGridSize));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->sampleLocationSampleCounts,
+ sizeof(VkSampleCountFlags));
+ marshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->maxSampleLocationGridSize));
vkStream->write((float*)forMarshaling->sampleLocationCoordinateRange, 2 * sizeof(float));
vkStream->write((uint32_t*)&forMarshaling->sampleLocationSubPixelBits, sizeof(uint32_t));
vkStream->write((VkBool32*)&forMarshaling->variableSampleLocations, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceSampleLocationsPropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceSampleLocationsPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampleLocationSampleCounts, sizeof(VkSampleCountFlags));
- unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxSampleLocationGridSize));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->sampleLocationSampleCounts,
+ sizeof(VkSampleCountFlags));
+ unmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forUnmarshaling->maxSampleLocationGridSize));
vkStream->read((float*)forUnmarshaling->sampleLocationCoordinateRange, 2 * sizeof(float));
vkStream->read((uint32_t*)&forUnmarshaling->sampleLocationSubPixelBits, sizeof(uint32_t));
vkStream->read((VkBool32*)&forUnmarshaling->variableSampleLocations, sizeof(VkBool32));
}
-void marshal_VkMultisamplePropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMultisamplePropertiesEXT* forMarshaling)
-{
+void marshal_VkMultisamplePropertiesEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMultisamplePropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxSampleLocationGridSize));
+ marshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->maxSampleLocationGridSize));
}
-void unmarshal_VkMultisamplePropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMultisamplePropertiesEXT* forUnmarshaling)
-{
+void unmarshal_VkMultisamplePropertiesEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMultisamplePropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxSampleLocationGridSize));
+ unmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forUnmarshaling->maxSampleLocationGridSize));
}
#endif
#ifdef VK_EXT_blend_operation_advanced
void marshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -19889,14 +17967,11 @@
}
void unmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -19904,54 +17979,49 @@
}
void marshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->advancedBlendMaxColorAttachments, sizeof(uint32_t));
vkStream->write((VkBool32*)&forMarshaling->advancedBlendIndependentBlend, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->advancedBlendNonPremultipliedSrcColor, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->advancedBlendNonPremultipliedDstColor, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->advancedBlendNonPremultipliedSrcColor,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->advancedBlendNonPremultipliedDstColor,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->advancedBlendCorrelatedOverlap, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->advancedBlendAllOperations, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->advancedBlendMaxColorAttachments, sizeof(uint32_t));
vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendIndependentBlend, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendNonPremultipliedSrcColor, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendNonPremultipliedDstColor, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendNonPremultipliedSrcColor,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendNonPremultipliedDstColor,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendCorrelatedOverlap, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->advancedBlendAllOperations, sizeof(VkBool32));
}
void marshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineColorBlendAdvancedStateCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineColorBlendAdvancedStateCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -19961,14 +18031,11 @@
}
void unmarshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineColorBlendAdvancedStateCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineColorBlendAdvancedStateCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -19980,35 +18047,31 @@
#endif
#ifdef VK_NV_fragment_coverage_to_color
void marshal_VkPipelineCoverageToColorStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCoverageToColorStateCreateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCoverageToColorStateCreateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineCoverageToColorStateCreateFlagsNV*)&forMarshaling->flags, sizeof(VkPipelineCoverageToColorStateCreateFlagsNV));
+ vkStream->write((VkPipelineCoverageToColorStateCreateFlagsNV*)&forMarshaling->flags,
+ sizeof(VkPipelineCoverageToColorStateCreateFlagsNV));
vkStream->write((VkBool32*)&forMarshaling->coverageToColorEnable, sizeof(VkBool32));
vkStream->write((uint32_t*)&forMarshaling->coverageToColorLocation, sizeof(uint32_t));
}
void unmarshal_VkPipelineCoverageToColorStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineCoverageToColorStateCreateInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineCoverageToColorStateCreateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineCoverageToColorStateCreateFlagsNV*)&forUnmarshaling->flags, sizeof(VkPipelineCoverageToColorStateCreateFlagsNV));
+ vkStream->read((VkPipelineCoverageToColorStateCreateFlagsNV*)&forUnmarshaling->flags,
+ sizeof(VkPipelineCoverageToColorStateCreateFlagsNV));
vkStream->read((VkBool32*)&forUnmarshaling->coverageToColorEnable, sizeof(VkBool32));
vkStream->read((uint32_t*)&forUnmarshaling->coverageToColorLocation, sizeof(uint32_t));
}
@@ -20016,56 +18079,55 @@
#endif
#ifdef VK_NV_framebuffer_mixed_samples
void marshal_VkPipelineCoverageModulationStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCoverageModulationStateCreateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCoverageModulationStateCreateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineCoverageModulationStateCreateFlagsNV*)&forMarshaling->flags, sizeof(VkPipelineCoverageModulationStateCreateFlagsNV));
- vkStream->write((VkCoverageModulationModeNV*)&forMarshaling->coverageModulationMode, sizeof(VkCoverageModulationModeNV));
+ vkStream->write((VkPipelineCoverageModulationStateCreateFlagsNV*)&forMarshaling->flags,
+ sizeof(VkPipelineCoverageModulationStateCreateFlagsNV));
+ vkStream->write((VkCoverageModulationModeNV*)&forMarshaling->coverageModulationMode,
+ sizeof(VkCoverageModulationModeNV));
vkStream->write((VkBool32*)&forMarshaling->coverageModulationTableEnable, sizeof(VkBool32));
vkStream->write((uint32_t*)&forMarshaling->coverageModulationTableCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pCoverageModulationTable;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pCoverageModulationTable)
- {
- vkStream->write((const float*)forMarshaling->pCoverageModulationTable, forMarshaling->coverageModulationTableCount * sizeof(const float));
+ if (forMarshaling->pCoverageModulationTable) {
+ vkStream->write((const float*)forMarshaling->pCoverageModulationTable,
+ forMarshaling->coverageModulationTableCount * sizeof(const float));
}
}
void unmarshal_VkPipelineCoverageModulationStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineCoverageModulationStateCreateInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineCoverageModulationStateCreateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineCoverageModulationStateCreateFlagsNV*)&forUnmarshaling->flags, sizeof(VkPipelineCoverageModulationStateCreateFlagsNV));
- vkStream->read((VkCoverageModulationModeNV*)&forUnmarshaling->coverageModulationMode, sizeof(VkCoverageModulationModeNV));
+ vkStream->read((VkPipelineCoverageModulationStateCreateFlagsNV*)&forUnmarshaling->flags,
+ sizeof(VkPipelineCoverageModulationStateCreateFlagsNV));
+ vkStream->read((VkCoverageModulationModeNV*)&forUnmarshaling->coverageModulationMode,
+ sizeof(VkCoverageModulationModeNV));
vkStream->read((VkBool32*)&forUnmarshaling->coverageModulationTableEnable, sizeof(VkBool32));
vkStream->read((uint32_t*)&forUnmarshaling->coverageModulationTableCount, sizeof(uint32_t));
// WARNING PTR CHECK
const float* check_pCoverageModulationTable;
check_pCoverageModulationTable = (const float*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pCoverageModulationTable)
- {
- if (!(check_pCoverageModulationTable))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pCoverageModulationTable inconsistent between guest and host\n");
+ if (forUnmarshaling->pCoverageModulationTable) {
+ if (!(check_pCoverageModulationTable)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pCoverageModulationTable inconsistent between guest "
+ "and host\n");
}
- vkStream->read((float*)forUnmarshaling->pCoverageModulationTable, forUnmarshaling->coverageModulationTableCount * sizeof(const float));
+ vkStream->read((float*)forUnmarshaling->pCoverageModulationTable,
+ forUnmarshaling->coverageModulationTableCount * sizeof(const float));
}
}
@@ -20074,14 +18136,11 @@
#endif
#ifdef VK_NV_shader_sm_builtins
void marshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -20090,14 +18149,11 @@
}
void unmarshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -20106,14 +18162,11 @@
}
void marshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -20121,14 +18174,11 @@
}
void unmarshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -20140,36 +18190,31 @@
#endif
#ifdef VK_EXT_image_drm_format_modifier
void marshal_VkDrmFormatModifierPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrmFormatModifierPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((uint64_t*)&forMarshaling->drmFormatModifier, sizeof(uint64_t));
vkStream->write((uint32_t*)&forMarshaling->drmFormatModifierPlaneCount, sizeof(uint32_t));
- vkStream->write((VkFormatFeatureFlags*)&forMarshaling->drmFormatModifierTilingFeatures, sizeof(VkFormatFeatureFlags));
+ vkStream->write((VkFormatFeatureFlags*)&forMarshaling->drmFormatModifierTilingFeatures,
+ sizeof(VkFormatFeatureFlags));
}
-void unmarshal_VkDrmFormatModifierPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDrmFormatModifierPropertiesEXT* forUnmarshaling)
-{
+void unmarshal_VkDrmFormatModifierPropertiesEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkDrmFormatModifierPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((uint64_t*)&forUnmarshaling->drmFormatModifier, sizeof(uint64_t));
vkStream->read((uint32_t*)&forUnmarshaling->drmFormatModifierPlaneCount, sizeof(uint32_t));
- vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->drmFormatModifierTilingFeatures, sizeof(VkFormatFeatureFlags));
+ vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->drmFormatModifierTilingFeatures,
+ sizeof(VkFormatFeatureFlags));
}
void marshal_VkDrmFormatModifierPropertiesListEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesListEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrmFormatModifierPropertiesListEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -20177,59 +18222,57 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pDrmFormatModifierProperties;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pDrmFormatModifierProperties)
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->drmFormatModifierCount; ++i)
- {
- marshal_VkDrmFormatModifierPropertiesEXT(vkStream, rootType, (VkDrmFormatModifierPropertiesEXT*)(forMarshaling->pDrmFormatModifierProperties + i));
+ if (forMarshaling->pDrmFormatModifierProperties) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->drmFormatModifierCount; ++i) {
+ marshal_VkDrmFormatModifierPropertiesEXT(
+ vkStream, rootType,
+ (VkDrmFormatModifierPropertiesEXT*)(forMarshaling
+ ->pDrmFormatModifierProperties +
+ i));
}
}
}
}
void unmarshal_VkDrmFormatModifierPropertiesListEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDrmFormatModifierPropertiesListEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDrmFormatModifierPropertiesListEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->drmFormatModifierCount, sizeof(uint32_t));
// WARNING PTR CHECK
VkDrmFormatModifierPropertiesEXT* check_pDrmFormatModifierProperties;
- check_pDrmFormatModifierProperties = (VkDrmFormatModifierPropertiesEXT*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pDrmFormatModifierProperties)
- {
- if (!(check_pDrmFormatModifierProperties))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pDrmFormatModifierProperties inconsistent between guest and host\n");
+ check_pDrmFormatModifierProperties =
+ (VkDrmFormatModifierPropertiesEXT*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pDrmFormatModifierProperties) {
+ if (!(check_pDrmFormatModifierProperties)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pDrmFormatModifierProperties inconsistent between "
+ "guest and host\n");
}
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->drmFormatModifierCount; ++i)
- {
- unmarshal_VkDrmFormatModifierPropertiesEXT(vkStream, rootType, (VkDrmFormatModifierPropertiesEXT*)(forUnmarshaling->pDrmFormatModifierProperties + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->drmFormatModifierCount; ++i) {
+ unmarshal_VkDrmFormatModifierPropertiesEXT(
+ vkStream, rootType,
+ (VkDrmFormatModifierPropertiesEXT*)(forUnmarshaling
+ ->pDrmFormatModifierProperties +
+ i));
}
}
}
}
void marshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -20239,21 +18282,18 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pQueueFamilyIndices)
- {
- vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices, forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ if (forMarshaling->pQueueFamilyIndices) {
+ vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices,
+ forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
}
}
void unmarshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceImageDrmFormatModifierInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceImageDrmFormatModifierInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -20263,103 +18303,89 @@
// WARNING PTR CHECK
const uint32_t* check_pQueueFamilyIndices;
check_pQueueFamilyIndices = (const uint32_t*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pQueueFamilyIndices)
- {
- if (!(check_pQueueFamilyIndices))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pQueueFamilyIndices inconsistent between guest and host\n");
+ if (forUnmarshaling->pQueueFamilyIndices) {
+ if (!(check_pQueueFamilyIndices)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pQueueFamilyIndices inconsistent between guest and "
+ "host\n");
}
- vkStream->read((uint32_t*)forUnmarshaling->pQueueFamilyIndices, forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pQueueFamilyIndices,
+ forUnmarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
}
}
void marshal_VkImageDrmFormatModifierListCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageDrmFormatModifierListCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageDrmFormatModifierListCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->drmFormatModifierCount, sizeof(uint32_t));
- vkStream->write((const uint64_t*)forMarshaling->pDrmFormatModifiers, forMarshaling->drmFormatModifierCount * sizeof(const uint64_t));
+ vkStream->write((const uint64_t*)forMarshaling->pDrmFormatModifiers,
+ forMarshaling->drmFormatModifierCount * sizeof(const uint64_t));
}
void unmarshal_VkImageDrmFormatModifierListCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageDrmFormatModifierListCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageDrmFormatModifierListCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->drmFormatModifierCount, sizeof(uint32_t));
- vkStream->read((uint64_t*)forUnmarshaling->pDrmFormatModifiers, forUnmarshaling->drmFormatModifierCount * sizeof(const uint64_t));
+ vkStream->read((uint64_t*)forUnmarshaling->pDrmFormatModifiers,
+ forUnmarshaling->drmFormatModifierCount * sizeof(const uint64_t));
}
void marshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageDrmFormatModifierExplicitCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageDrmFormatModifierExplicitCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint64_t*)&forMarshaling->drmFormatModifier, sizeof(uint64_t));
vkStream->write((uint32_t*)&forMarshaling->drmFormatModifierPlaneCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->drmFormatModifierPlaneCount; ++i)
- {
- marshal_VkSubresourceLayout(vkStream, rootType, (const VkSubresourceLayout*)(forMarshaling->pPlaneLayouts + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->drmFormatModifierPlaneCount; ++i) {
+ marshal_VkSubresourceLayout(
+ vkStream, rootType, (const VkSubresourceLayout*)(forMarshaling->pPlaneLayouts + i));
}
}
}
void unmarshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageDrmFormatModifierExplicitCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageDrmFormatModifierExplicitCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint64_t*)&forUnmarshaling->drmFormatModifier, sizeof(uint64_t));
vkStream->read((uint32_t*)&forUnmarshaling->drmFormatModifierPlaneCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->drmFormatModifierPlaneCount; ++i)
- {
- unmarshal_VkSubresourceLayout(vkStream, rootType, (VkSubresourceLayout*)(forUnmarshaling->pPlaneLayouts + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->drmFormatModifierPlaneCount; ++i) {
+ unmarshal_VkSubresourceLayout(
+ vkStream, rootType, (VkSubresourceLayout*)(forUnmarshaling->pPlaneLayouts + i));
}
}
}
void marshal_VkImageDrmFormatModifierPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageDrmFormatModifierPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageDrmFormatModifierPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -20367,14 +18393,11 @@
}
void unmarshal_VkImageDrmFormatModifierPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageDrmFormatModifierPropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageDrmFormatModifierPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -20382,36 +18405,31 @@
}
void marshal_VkDrmFormatModifierProperties2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrmFormatModifierProperties2EXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrmFormatModifierProperties2EXT* forMarshaling) {
(void)rootType;
vkStream->write((uint64_t*)&forMarshaling->drmFormatModifier, sizeof(uint64_t));
vkStream->write((uint32_t*)&forMarshaling->drmFormatModifierPlaneCount, sizeof(uint32_t));
- vkStream->write((VkFormatFeatureFlags2KHR*)&forMarshaling->drmFormatModifierTilingFeatures, sizeof(VkFormatFeatureFlags2KHR));
+ vkStream->write((VkFormatFeatureFlags2KHR*)&forMarshaling->drmFormatModifierTilingFeatures,
+ sizeof(VkFormatFeatureFlags2KHR));
}
void unmarshal_VkDrmFormatModifierProperties2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDrmFormatModifierProperties2EXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDrmFormatModifierProperties2EXT* forUnmarshaling) {
(void)rootType;
vkStream->read((uint64_t*)&forUnmarshaling->drmFormatModifier, sizeof(uint64_t));
vkStream->read((uint32_t*)&forUnmarshaling->drmFormatModifierPlaneCount, sizeof(uint32_t));
- vkStream->read((VkFormatFeatureFlags2KHR*)&forUnmarshaling->drmFormatModifierTilingFeatures, sizeof(VkFormatFeatureFlags2KHR));
+ vkStream->read((VkFormatFeatureFlags2KHR*)&forUnmarshaling->drmFormatModifierTilingFeatures,
+ sizeof(VkFormatFeatureFlags2KHR));
}
void marshal_VkDrmFormatModifierPropertiesList2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesList2EXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrmFormatModifierPropertiesList2EXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -20419,45 +18437,46 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pDrmFormatModifierProperties;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pDrmFormatModifierProperties)
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->drmFormatModifierCount; ++i)
- {
- marshal_VkDrmFormatModifierProperties2EXT(vkStream, rootType, (VkDrmFormatModifierProperties2EXT*)(forMarshaling->pDrmFormatModifierProperties + i));
+ if (forMarshaling->pDrmFormatModifierProperties) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->drmFormatModifierCount; ++i) {
+ marshal_VkDrmFormatModifierProperties2EXT(
+ vkStream, rootType,
+ (VkDrmFormatModifierProperties2EXT*)(forMarshaling
+ ->pDrmFormatModifierProperties +
+ i));
}
}
}
}
void unmarshal_VkDrmFormatModifierPropertiesList2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDrmFormatModifierPropertiesList2EXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDrmFormatModifierPropertiesList2EXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->drmFormatModifierCount, sizeof(uint32_t));
// WARNING PTR CHECK
VkDrmFormatModifierProperties2EXT* check_pDrmFormatModifierProperties;
- check_pDrmFormatModifierProperties = (VkDrmFormatModifierProperties2EXT*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pDrmFormatModifierProperties)
- {
- if (!(check_pDrmFormatModifierProperties))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pDrmFormatModifierProperties inconsistent between guest and host\n");
+ check_pDrmFormatModifierProperties =
+ (VkDrmFormatModifierProperties2EXT*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pDrmFormatModifierProperties) {
+ if (!(check_pDrmFormatModifierProperties)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pDrmFormatModifierProperties inconsistent between "
+ "guest and host\n");
}
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->drmFormatModifierCount; ++i)
- {
- unmarshal_VkDrmFormatModifierProperties2EXT(vkStream, rootType, (VkDrmFormatModifierProperties2EXT*)(forUnmarshaling->pDrmFormatModifierProperties + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->drmFormatModifierCount; ++i) {
+ unmarshal_VkDrmFormatModifierProperties2EXT(
+ vkStream, rootType,
+ (VkDrmFormatModifierProperties2EXT*)(forUnmarshaling
+ ->pDrmFormatModifierProperties +
+ i));
}
}
}
@@ -20465,73 +18484,65 @@
#endif
#ifdef VK_EXT_validation_cache
-void marshal_VkValidationCacheCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkValidationCacheCreateInfoEXT* forMarshaling)
-{
+void marshal_VkValidationCacheCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkValidationCacheCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkValidationCacheCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkValidationCacheCreateFlagsEXT));
+ vkStream->write((VkValidationCacheCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkValidationCacheCreateFlagsEXT));
uint64_t cgen_var_0 = (uint64_t)forMarshaling->initialDataSize;
vkStream->putBe64(cgen_var_0);
- vkStream->write((const void*)forMarshaling->pInitialData, forMarshaling->initialDataSize * sizeof(const uint8_t));
+ vkStream->write((const void*)forMarshaling->pInitialData,
+ forMarshaling->initialDataSize * sizeof(const uint8_t));
}
-void unmarshal_VkValidationCacheCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkValidationCacheCreateInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkValidationCacheCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkValidationCacheCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkValidationCacheCreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkValidationCacheCreateFlagsEXT));
+ vkStream->read((VkValidationCacheCreateFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkValidationCacheCreateFlagsEXT));
forUnmarshaling->initialDataSize = (size_t)vkStream->getBe64();
- vkStream->read((void*)forUnmarshaling->pInitialData, forUnmarshaling->initialDataSize * sizeof(const uint8_t));
+ vkStream->read((void*)forUnmarshaling->pInitialData,
+ forUnmarshaling->initialDataSize * sizeof(const uint8_t));
}
void marshal_VkShaderModuleValidationCacheCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkShaderModuleValidationCacheCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkShaderModuleValidationCacheCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&forMarshaling->validationCache, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&forMarshaling->validationCache,
+ &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}
void unmarshal_VkShaderModuleValidationCacheCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkShaderModuleValidationCacheCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkShaderModuleValidationCacheCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(&cgen_var_0, (VkValidationCacheEXT*)&forUnmarshaling->validationCache, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(
+ &cgen_var_0, (VkValidationCacheEXT*)&forUnmarshaling->validationCache, 1);
}
#endif
@@ -20540,35 +18551,30 @@
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_NV_shading_rate_image
-void marshal_VkShadingRatePaletteNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkShadingRatePaletteNV* forMarshaling)
-{
+void marshal_VkShadingRatePaletteNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkShadingRatePaletteNV* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->shadingRatePaletteEntryCount, sizeof(uint32_t));
- vkStream->write((const VkShadingRatePaletteEntryNV*)forMarshaling->pShadingRatePaletteEntries, forMarshaling->shadingRatePaletteEntryCount * sizeof(const VkShadingRatePaletteEntryNV));
+ vkStream->write(
+ (const VkShadingRatePaletteEntryNV*)forMarshaling->pShadingRatePaletteEntries,
+ forMarshaling->shadingRatePaletteEntryCount * sizeof(const VkShadingRatePaletteEntryNV));
}
-void unmarshal_VkShadingRatePaletteNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkShadingRatePaletteNV* forUnmarshaling)
-{
+void unmarshal_VkShadingRatePaletteNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkShadingRatePaletteNV* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->shadingRatePaletteEntryCount, sizeof(uint32_t));
- vkStream->read((VkShadingRatePaletteEntryNV*)forUnmarshaling->pShadingRatePaletteEntries, forUnmarshaling->shadingRatePaletteEntryCount * sizeof(const VkShadingRatePaletteEntryNV));
+ vkStream->read(
+ (VkShadingRatePaletteEntryNV*)forUnmarshaling->pShadingRatePaletteEntries,
+ forUnmarshaling->shadingRatePaletteEntryCount * sizeof(const VkShadingRatePaletteEntryNV));
}
void marshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineViewportShadingRateImageStateCreateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineViewportShadingRateImageStateCreateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -20577,27 +18583,23 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pShadingRatePalettes;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pShadingRatePalettes)
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
- {
- marshal_VkShadingRatePaletteNV(vkStream, rootType, (const VkShadingRatePaletteNV*)(forMarshaling->pShadingRatePalettes + i));
+ if (forMarshaling->pShadingRatePalettes) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i) {
+ marshal_VkShadingRatePaletteNV(
+ vkStream, rootType,
+ (const VkShadingRatePaletteNV*)(forMarshaling->pShadingRatePalettes + i));
}
}
}
}
void unmarshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineViewportShadingRateImageStateCreateInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineViewportShadingRateImageStateCreateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -20606,31 +18608,28 @@
// WARNING PTR CHECK
const VkShadingRatePaletteNV* check_pShadingRatePalettes;
check_pShadingRatePalettes = (const VkShadingRatePaletteNV*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pShadingRatePalettes)
- {
- if (!(check_pShadingRatePalettes))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pShadingRatePalettes inconsistent between guest and host\n");
+ if (forUnmarshaling->pShadingRatePalettes) {
+ if (!(check_pShadingRatePalettes)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pShadingRatePalettes inconsistent between guest and "
+ "host\n");
}
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i)
- {
- unmarshal_VkShadingRatePaletteNV(vkStream, rootType, (VkShadingRatePaletteNV*)(forUnmarshaling->pShadingRatePalettes + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i) {
+ unmarshal_VkShadingRatePaletteNV(
+ vkStream, rootType,
+ (VkShadingRatePaletteNV*)(forUnmarshaling->pShadingRatePalettes + i));
}
}
}
}
void marshal_VkPhysicalDeviceShadingRateImageFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShadingRateImageFeaturesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShadingRateImageFeaturesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -20639,14 +18638,11 @@
}
void unmarshal_VkPhysicalDeviceShadingRateImageFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShadingRateImageFeaturesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShadingRateImageFeaturesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -20655,14 +18651,11 @@
}
void marshal_VkPhysicalDeviceShadingRateImagePropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShadingRateImagePropertiesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShadingRateImagePropertiesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -20672,14 +18665,11 @@
}
void unmarshal_VkPhysicalDeviceShadingRateImagePropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShadingRateImagePropertiesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShadingRateImagePropertiesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -20688,106 +18678,92 @@
vkStream->read((uint32_t*)&forUnmarshaling->shadingRateMaxCoarseSamples, sizeof(uint32_t));
}
-void marshal_VkCoarseSampleLocationNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCoarseSampleLocationNV* forMarshaling)
-{
+void marshal_VkCoarseSampleLocationNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCoarseSampleLocationNV* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->pixelX, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->pixelY, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->sample, sizeof(uint32_t));
}
-void unmarshal_VkCoarseSampleLocationNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCoarseSampleLocationNV* forUnmarshaling)
-{
+void unmarshal_VkCoarseSampleLocationNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCoarseSampleLocationNV* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->pixelX, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->pixelY, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->sample, sizeof(uint32_t));
}
-void marshal_VkCoarseSampleOrderCustomNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCoarseSampleOrderCustomNV* forMarshaling)
-{
+void marshal_VkCoarseSampleOrderCustomNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCoarseSampleOrderCustomNV* forMarshaling) {
(void)rootType;
- vkStream->write((VkShadingRatePaletteEntryNV*)&forMarshaling->shadingRate, sizeof(VkShadingRatePaletteEntryNV));
+ vkStream->write((VkShadingRatePaletteEntryNV*)&forMarshaling->shadingRate,
+ sizeof(VkShadingRatePaletteEntryNV));
vkStream->write((uint32_t*)&forMarshaling->sampleCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->sampleLocationCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->sampleLocationCount; ++i)
- {
- marshal_VkCoarseSampleLocationNV(vkStream, rootType, (const VkCoarseSampleLocationNV*)(forMarshaling->pSampleLocations + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->sampleLocationCount; ++i) {
+ marshal_VkCoarseSampleLocationNV(
+ vkStream, rootType,
+ (const VkCoarseSampleLocationNV*)(forMarshaling->pSampleLocations + i));
}
}
}
-void unmarshal_VkCoarseSampleOrderCustomNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCoarseSampleOrderCustomNV* forUnmarshaling)
-{
+void unmarshal_VkCoarseSampleOrderCustomNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCoarseSampleOrderCustomNV* forUnmarshaling) {
(void)rootType;
- vkStream->read((VkShadingRatePaletteEntryNV*)&forUnmarshaling->shadingRate, sizeof(VkShadingRatePaletteEntryNV));
+ vkStream->read((VkShadingRatePaletteEntryNV*)&forUnmarshaling->shadingRate,
+ sizeof(VkShadingRatePaletteEntryNV));
vkStream->read((uint32_t*)&forUnmarshaling->sampleCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->sampleLocationCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->sampleLocationCount; ++i)
- {
- unmarshal_VkCoarseSampleLocationNV(vkStream, rootType, (VkCoarseSampleLocationNV*)(forUnmarshaling->pSampleLocations + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->sampleLocationCount; ++i) {
+ unmarshal_VkCoarseSampleLocationNV(
+ vkStream, rootType,
+ (VkCoarseSampleLocationNV*)(forUnmarshaling->pSampleLocations + i));
}
}
}
void marshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkCoarseSampleOrderTypeNV*)&forMarshaling->sampleOrderType, sizeof(VkCoarseSampleOrderTypeNV));
+ vkStream->write((VkCoarseSampleOrderTypeNV*)&forMarshaling->sampleOrderType,
+ sizeof(VkCoarseSampleOrderTypeNV));
vkStream->write((uint32_t*)&forMarshaling->customSampleOrderCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->customSampleOrderCount; ++i)
- {
- marshal_VkCoarseSampleOrderCustomNV(vkStream, rootType, (const VkCoarseSampleOrderCustomNV*)(forMarshaling->pCustomSampleOrders + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->customSampleOrderCount; ++i) {
+ marshal_VkCoarseSampleOrderCustomNV(
+ vkStream, rootType,
+ (const VkCoarseSampleOrderCustomNV*)(forMarshaling->pCustomSampleOrders + i));
}
}
}
void unmarshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkCoarseSampleOrderTypeNV*)&forUnmarshaling->sampleOrderType, sizeof(VkCoarseSampleOrderTypeNV));
+ vkStream->read((VkCoarseSampleOrderTypeNV*)&forUnmarshaling->sampleOrderType,
+ sizeof(VkCoarseSampleOrderTypeNV));
vkStream->read((uint32_t*)&forUnmarshaling->customSampleOrderCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->customSampleOrderCount; ++i)
- {
- unmarshal_VkCoarseSampleOrderCustomNV(vkStream, rootType, (VkCoarseSampleOrderCustomNV*)(forUnmarshaling->pCustomSampleOrders + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->customSampleOrderCount; ++i) {
+ unmarshal_VkCoarseSampleOrderCustomNV(
+ vkStream, rootType,
+ (VkCoarseSampleOrderCustomNV*)(forUnmarshaling->pCustomSampleOrders + i));
}
}
}
@@ -20795,18 +18771,16 @@
#endif
#ifdef VK_NV_ray_tracing
void marshal_VkRayTracingShaderGroupCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRayTracingShaderGroupCreateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRayTracingShaderGroupCreateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkRayTracingShaderGroupTypeKHR*)&forMarshaling->type, sizeof(VkRayTracingShaderGroupTypeKHR));
+ vkStream->write((VkRayTracingShaderGroupTypeKHR*)&forMarshaling->type,
+ sizeof(VkRayTracingShaderGroupTypeKHR));
vkStream->write((uint32_t*)&forMarshaling->generalShader, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->closestHitShader, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->anyHitShader, sizeof(uint32_t));
@@ -20814,18 +18788,16 @@
}
void unmarshal_VkRayTracingShaderGroupCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRayTracingShaderGroupCreateInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRayTracingShaderGroupCreateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkRayTracingShaderGroupTypeKHR*)&forUnmarshaling->type, sizeof(VkRayTracingShaderGroupTypeKHR));
+ vkStream->read((VkRayTracingShaderGroupTypeKHR*)&forUnmarshaling->type,
+ sizeof(VkRayTracingShaderGroupTypeKHR));
vkStream->read((uint32_t*)&forUnmarshaling->generalShader, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->closestHitShader, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->anyHitShader, sizeof(uint32_t));
@@ -20833,92 +18805,86 @@
}
void marshal_VkRayTracingPipelineCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRayTracingPipelineCreateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRayTracingPipelineCreateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkPipelineCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags));
vkStream->write((uint32_t*)&forMarshaling->stageCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i)
- {
- marshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i) {
+ marshal_VkPipelineShaderStageCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->groupCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->groupCount; ++i)
- {
- marshal_VkRayTracingShaderGroupCreateInfoNV(vkStream, rootType, (const VkRayTracingShaderGroupCreateInfoNV*)(forMarshaling->pGroups + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->groupCount; ++i) {
+ marshal_VkRayTracingShaderGroupCreateInfoNV(
+ vkStream, rootType,
+ (const VkRayTracingShaderGroupCreateInfoNV*)(forMarshaling->pGroups + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->maxRecursionDepth, sizeof(uint32_t));
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
uint64_t cgen_var_1;
- vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle, &cgen_var_1, 1);
+ vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle,
+ &cgen_var_1, 1);
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
vkStream->write((int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
}
-void unmarshal_VkRayTracingPipelineCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRayTracingPipelineCreateInfoNV* forUnmarshaling)
-{
+void unmarshal_VkRayTracingPipelineCreateInfoNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkRayTracingPipelineCreateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkPipelineCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCreateFlags));
vkStream->read((uint32_t*)&forUnmarshaling->stageCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->stageCount; ++i)
- {
- unmarshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->stageCount; ++i) {
+ unmarshal_VkPipelineShaderStageCreateInfo(
+ vkStream, rootType,
+ (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->groupCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->groupCount; ++i)
- {
- unmarshal_VkRayTracingShaderGroupCreateInfoNV(vkStream, rootType, (VkRayTracingShaderGroupCreateInfoNV*)(forUnmarshaling->pGroups + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->groupCount; ++i) {
+ unmarshal_VkRayTracingShaderGroupCreateInfoNV(
+ vkStream, rootType,
+ (VkRayTracingShaderGroupCreateInfoNV*)(forUnmarshaling->pGroups + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->maxRecursionDepth, sizeof(uint32_t));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_0, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(
+ &cgen_var_0, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_1, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkPipeline(
+ &cgen_var_1, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
vkStream->read((int32_t*)&forUnmarshaling->basePipelineIndex, sizeof(int32_t));
}
-void marshal_VkGeometryTrianglesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeometryTrianglesNV* forMarshaling)
-{
+void marshal_VkGeometryTrianglesNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeometryTrianglesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -20936,51 +18902,47 @@
vkStream->write((uint32_t*)&forMarshaling->indexCount, sizeof(uint32_t));
vkStream->write((VkIndexType*)&forMarshaling->indexType, sizeof(VkIndexType));
uint64_t cgen_var_2;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->transformData, &cgen_var_2, 1);
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->transformData, &cgen_var_2,
+ 1);
vkStream->write((uint64_t*)&cgen_var_2, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->transformOffset, sizeof(VkDeviceSize));
}
-void unmarshal_VkGeometryTrianglesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkGeometryTrianglesNV* forUnmarshaling)
-{
+void unmarshal_VkGeometryTrianglesNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkGeometryTrianglesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0, (VkBuffer*)&forUnmarshaling->vertexData, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+ (VkBuffer*)&forUnmarshaling->vertexData, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->vertexOffset, sizeof(VkDeviceSize));
vkStream->read((uint32_t*)&forUnmarshaling->vertexCount, sizeof(uint32_t));
vkStream->read((VkDeviceSize*)&forUnmarshaling->vertexStride, sizeof(VkDeviceSize));
vkStream->read((VkFormat*)&forUnmarshaling->vertexFormat, sizeof(VkFormat));
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_1, (VkBuffer*)&forUnmarshaling->indexData, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_1,
+ (VkBuffer*)&forUnmarshaling->indexData, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->indexOffset, sizeof(VkDeviceSize));
vkStream->read((uint32_t*)&forUnmarshaling->indexCount, sizeof(uint32_t));
vkStream->read((VkIndexType*)&forUnmarshaling->indexType, sizeof(VkIndexType));
uint64_t cgen_var_2;
vkStream->read((uint64_t*)&cgen_var_2, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_2, (VkBuffer*)&forUnmarshaling->transformData, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(
+ &cgen_var_2, (VkBuffer*)&forUnmarshaling->transformData, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->transformOffset, sizeof(VkDeviceSize));
}
-void marshal_VkGeometryAABBNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeometryAABBNV* forMarshaling)
-{
+void marshal_VkGeometryAABBNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeometryAABBNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -20992,55 +18954,44 @@
vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
}
-void unmarshal_VkGeometryAABBNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkGeometryAABBNV* forUnmarshaling)
-{
+void unmarshal_VkGeometryAABBNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkGeometryAABBNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0, (VkBuffer*)&forUnmarshaling->aabbData, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+ (VkBuffer*)&forUnmarshaling->aabbData, 1);
vkStream->read((uint32_t*)&forUnmarshaling->numAABBs, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->stride, sizeof(uint32_t));
vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
}
-void marshal_VkGeometryDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeometryDataNV* forMarshaling)
-{
+void marshal_VkGeometryDataNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeometryDataNV* forMarshaling) {
(void)rootType;
- marshal_VkGeometryTrianglesNV(vkStream, rootType, (VkGeometryTrianglesNV*)(&forMarshaling->triangles));
+ marshal_VkGeometryTrianglesNV(vkStream, rootType,
+ (VkGeometryTrianglesNV*)(&forMarshaling->triangles));
marshal_VkGeometryAABBNV(vkStream, rootType, (VkGeometryAABBNV*)(&forMarshaling->aabbs));
}
-void unmarshal_VkGeometryDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkGeometryDataNV* forUnmarshaling)
-{
+void unmarshal_VkGeometryDataNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkGeometryDataNV* forUnmarshaling) {
(void)rootType;
- unmarshal_VkGeometryTrianglesNV(vkStream, rootType, (VkGeometryTrianglesNV*)(&forUnmarshaling->triangles));
+ unmarshal_VkGeometryTrianglesNV(vkStream, rootType,
+ (VkGeometryTrianglesNV*)(&forUnmarshaling->triangles));
unmarshal_VkGeometryAABBNV(vkStream, rootType, (VkGeometryAABBNV*)(&forUnmarshaling->aabbs));
}
-void marshal_VkGeometryNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeometryNV* forMarshaling)
-{
+void marshal_VkGeometryNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeometryNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -21049,15 +19000,11 @@
vkStream->write((VkGeometryFlagsKHR*)&forMarshaling->flags, sizeof(VkGeometryFlagsKHR));
}
-void unmarshal_VkGeometryNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkGeometryNV* forUnmarshaling)
-{
+void unmarshal_VkGeometryNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkGeometryNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -21066,143 +19013,130 @@
vkStream->read((VkGeometryFlagsKHR*)&forUnmarshaling->flags, sizeof(VkGeometryFlagsKHR));
}
-void marshal_VkAccelerationStructureInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureInfoNV* forMarshaling)
-{
+void marshal_VkAccelerationStructureInfoNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkAccelerationStructureTypeNV*)&forMarshaling->type, sizeof(VkAccelerationStructureTypeNV));
- vkStream->write((VkBuildAccelerationStructureFlagsNV*)&forMarshaling->flags, sizeof(VkBuildAccelerationStructureFlagsNV));
+ vkStream->write((VkAccelerationStructureTypeNV*)&forMarshaling->type,
+ sizeof(VkAccelerationStructureTypeNV));
+ vkStream->write((VkBuildAccelerationStructureFlagsNV*)&forMarshaling->flags,
+ sizeof(VkBuildAccelerationStructureFlagsNV));
vkStream->write((uint32_t*)&forMarshaling->instanceCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->geometryCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->geometryCount; ++i)
- {
- marshal_VkGeometryNV(vkStream, rootType, (const VkGeometryNV*)(forMarshaling->pGeometries + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->geometryCount; ++i) {
+ marshal_VkGeometryNV(vkStream, rootType,
+ (const VkGeometryNV*)(forMarshaling->pGeometries + i));
}
}
}
-void unmarshal_VkAccelerationStructureInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureInfoNV* forUnmarshaling)
-{
+void unmarshal_VkAccelerationStructureInfoNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkAccelerationStructureTypeNV*)&forUnmarshaling->type, sizeof(VkAccelerationStructureTypeNV));
- vkStream->read((VkBuildAccelerationStructureFlagsNV*)&forUnmarshaling->flags, sizeof(VkBuildAccelerationStructureFlagsNV));
+ vkStream->read((VkAccelerationStructureTypeNV*)&forUnmarshaling->type,
+ sizeof(VkAccelerationStructureTypeNV));
+ vkStream->read((VkBuildAccelerationStructureFlagsNV*)&forUnmarshaling->flags,
+ sizeof(VkBuildAccelerationStructureFlagsNV));
vkStream->read((uint32_t*)&forUnmarshaling->instanceCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->geometryCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->geometryCount; ++i)
- {
- unmarshal_VkGeometryNV(vkStream, rootType, (VkGeometryNV*)(forUnmarshaling->pGeometries + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->geometryCount; ++i) {
+ unmarshal_VkGeometryNV(vkStream, rootType,
+ (VkGeometryNV*)(forUnmarshaling->pGeometries + i));
}
}
}
void marshal_VkAccelerationStructureCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureCreateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureCreateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkDeviceSize*)&forMarshaling->compactedSize, sizeof(VkDeviceSize));
- marshal_VkAccelerationStructureInfoNV(vkStream, rootType, (VkAccelerationStructureInfoNV*)(&forMarshaling->info));
+ marshal_VkAccelerationStructureInfoNV(vkStream, rootType,
+ (VkAccelerationStructureInfoNV*)(&forMarshaling->info));
}
void unmarshal_VkAccelerationStructureCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureCreateInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureCreateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkDeviceSize*)&forUnmarshaling->compactedSize, sizeof(VkDeviceSize));
- unmarshal_VkAccelerationStructureInfoNV(vkStream, rootType, (VkAccelerationStructureInfoNV*)(&forUnmarshaling->info));
+ unmarshal_VkAccelerationStructureInfoNV(
+ vkStream, rootType, (VkAccelerationStructureInfoNV*)(&forUnmarshaling->info));
}
void marshal_VkBindAccelerationStructureMemoryInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindAccelerationStructureMemoryInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindAccelerationStructureMemoryInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkAccelerationStructureNV_u64(&forMarshaling->accelerationStructure, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkAccelerationStructureNV_u64(
+ &forMarshaling->accelerationStructure, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
uint64_t cgen_var_1;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_1, 1);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_1,
+ 1);
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
vkStream->write((uint32_t*)&forMarshaling->deviceIndexCount, sizeof(uint32_t));
- vkStream->write((const uint32_t*)forMarshaling->pDeviceIndices, forMarshaling->deviceIndexCount * sizeof(const uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pDeviceIndices,
+ forMarshaling->deviceIndexCount * sizeof(const uint32_t));
}
void unmarshal_VkBindAccelerationStructureMemoryInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBindAccelerationStructureMemoryInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBindAccelerationStructureMemoryInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureNV(&cgen_var_0, (VkAccelerationStructureNV*)&forUnmarshaling->accelerationStructure, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureNV(
+ &cgen_var_0, (VkAccelerationStructureNV*)&forUnmarshaling->accelerationStructure, 1);
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_1, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+ &cgen_var_1, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
vkStream->read((uint32_t*)&forUnmarshaling->deviceIndexCount, sizeof(uint32_t));
- vkStream->read((uint32_t*)forUnmarshaling->pDeviceIndices, forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pDeviceIndices,
+ forUnmarshaling->deviceIndexCount * sizeof(const uint32_t));
}
void marshal_VkWriteDescriptorSetAccelerationStructureNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWriteDescriptorSetAccelerationStructureNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWriteDescriptorSetAccelerationStructureNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -21210,95 +19144,90 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAccelerationStructures;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pAccelerationStructures)
- {
- if (forMarshaling->accelerationStructureCount)
- {
+ if (forMarshaling->pAccelerationStructures) {
+ if (forMarshaling->accelerationStructureCount) {
uint64_t* cgen_var_0_0;
vkStream->alloc((void**)&cgen_var_0_0, forMarshaling->accelerationStructureCount * 8);
- vkStream->handleMapping()->mapHandles_VkAccelerationStructureNV_u64(forMarshaling->pAccelerationStructures, cgen_var_0_0, forMarshaling->accelerationStructureCount);
+ vkStream->handleMapping()->mapHandles_VkAccelerationStructureNV_u64(
+ forMarshaling->pAccelerationStructures, cgen_var_0_0,
+ forMarshaling->accelerationStructureCount);
vkStream->write((uint64_t*)cgen_var_0_0, forMarshaling->accelerationStructureCount * 8);
}
}
}
void unmarshal_VkWriteDescriptorSetAccelerationStructureNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkWriteDescriptorSetAccelerationStructureNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkWriteDescriptorSetAccelerationStructureNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->accelerationStructureCount, sizeof(uint32_t));
// WARNING PTR CHECK
const VkAccelerationStructureNV* check_pAccelerationStructures;
- check_pAccelerationStructures = (const VkAccelerationStructureNV*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pAccelerationStructures)
- {
- if (!(check_pAccelerationStructures))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pAccelerationStructures inconsistent between guest and host\n");
+ check_pAccelerationStructures =
+ (const VkAccelerationStructureNV*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pAccelerationStructures) {
+ if (!(check_pAccelerationStructures)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pAccelerationStructures inconsistent between guest "
+ "and host\n");
}
- if (forUnmarshaling->accelerationStructureCount)
- {
+ if (forUnmarshaling->accelerationStructureCount) {
uint64_t* cgen_var_0_0;
vkStream->alloc((void**)&cgen_var_0_0, forUnmarshaling->accelerationStructureCount * 8);
- vkStream->read((uint64_t*)cgen_var_0_0, forUnmarshaling->accelerationStructureCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureNV(cgen_var_0_0, (VkAccelerationStructureNV*)forUnmarshaling->pAccelerationStructures, forUnmarshaling->accelerationStructureCount);
+ vkStream->read((uint64_t*)cgen_var_0_0,
+ forUnmarshaling->accelerationStructureCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureNV(
+ cgen_var_0_0, (VkAccelerationStructureNV*)forUnmarshaling->pAccelerationStructures,
+ forUnmarshaling->accelerationStructureCount);
}
}
}
void marshal_VkAccelerationStructureMemoryRequirementsInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureMemoryRequirementsInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureMemoryRequirementsInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkAccelerationStructureMemoryRequirementsTypeNV*)&forMarshaling->type, sizeof(VkAccelerationStructureMemoryRequirementsTypeNV));
+ vkStream->write((VkAccelerationStructureMemoryRequirementsTypeNV*)&forMarshaling->type,
+ sizeof(VkAccelerationStructureMemoryRequirementsTypeNV));
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkAccelerationStructureNV_u64(&forMarshaling->accelerationStructure, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkAccelerationStructureNV_u64(
+ &forMarshaling->accelerationStructure, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}
void unmarshal_VkAccelerationStructureMemoryRequirementsInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureMemoryRequirementsInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureMemoryRequirementsInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkAccelerationStructureMemoryRequirementsTypeNV*)&forUnmarshaling->type, sizeof(VkAccelerationStructureMemoryRequirementsTypeNV));
+ vkStream->read((VkAccelerationStructureMemoryRequirementsTypeNV*)&forUnmarshaling->type,
+ sizeof(VkAccelerationStructureMemoryRequirementsTypeNV));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureNV(&cgen_var_0, (VkAccelerationStructureNV*)&forUnmarshaling->accelerationStructure, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureNV(
+ &cgen_var_0, (VkAccelerationStructureNV*)&forUnmarshaling->accelerationStructure, 1);
}
void marshal_VkPhysicalDeviceRayTracingPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingPropertiesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPropertiesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -21309,18 +19238,16 @@
vkStream->write((uint64_t*)&forMarshaling->maxGeometryCount, sizeof(uint64_t));
vkStream->write((uint64_t*)&forMarshaling->maxInstanceCount, sizeof(uint64_t));
vkStream->write((uint64_t*)&forMarshaling->maxTriangleCount, sizeof(uint64_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetAccelerationStructures, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetAccelerationStructures,
+ sizeof(uint32_t));
}
void unmarshal_VkPhysicalDeviceRayTracingPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceRayTracingPropertiesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceRayTracingPropertiesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -21331,32 +19258,24 @@
vkStream->read((uint64_t*)&forUnmarshaling->maxGeometryCount, sizeof(uint64_t));
vkStream->read((uint64_t*)&forUnmarshaling->maxInstanceCount, sizeof(uint64_t));
vkStream->read((uint64_t*)&forUnmarshaling->maxTriangleCount, sizeof(uint64_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetAccelerationStructures, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetAccelerationStructures,
+ sizeof(uint32_t));
}
-void marshal_VkTransformMatrixKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkTransformMatrixKHR* forMarshaling)
-{
+void marshal_VkTransformMatrixKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkTransformMatrixKHR* forMarshaling) {
(void)rootType;
- vkStream->write((float*)forMarshaling->matrix, ((3)*(4)) * sizeof(float));
+ vkStream->write((float*)forMarshaling->matrix, ((3) * (4)) * sizeof(float));
}
-void unmarshal_VkTransformMatrixKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkTransformMatrixKHR* forUnmarshaling)
-{
+void unmarshal_VkTransformMatrixKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkTransformMatrixKHR* forUnmarshaling) {
(void)rootType;
- vkStream->read((float*)forUnmarshaling->matrix, ((3)*(4)) * sizeof(float));
+ vkStream->read((float*)forUnmarshaling->matrix, ((3) * (4)) * sizeof(float));
}
-void marshal_VkAabbPositionsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAabbPositionsKHR* forMarshaling)
-{
+void marshal_VkAabbPositionsKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAabbPositionsKHR* forMarshaling) {
(void)rootType;
vkStream->write((float*)&forMarshaling->minX, sizeof(float));
vkStream->write((float*)&forMarshaling->minY, sizeof(float));
@@ -21366,11 +19285,8 @@
vkStream->write((float*)&forMarshaling->maxZ, sizeof(float));
}
-void unmarshal_VkAabbPositionsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAabbPositionsKHR* forUnmarshaling)
-{
+void unmarshal_VkAabbPositionsKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAabbPositionsKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((float*)&forUnmarshaling->minX, sizeof(float));
vkStream->read((float*)&forUnmarshaling->minY, sizeof(float));
@@ -21381,60 +19297,57 @@
}
void marshal_VkAccelerationStructureInstanceKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureInstanceKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureInstanceKHR* forMarshaling) {
(void)rootType;
-
+
typedef struct VkAccelerationStructureInstanceKHRWithoutBitFields {
- VkTransformMatrixKHR transform;
- uint32_t dwords[2];
- uint64_t accelerationStructureReference;
+ VkTransformMatrixKHR transform;
+ uint32_t dwords[2];
+ uint64_t accelerationStructureReference;
} VkAccelerationStructureInstanceKHRWithoutBitFields;
-
- const VkAccelerationStructureInstanceKHRWithoutBitFields* forMarshaling_new = (const VkAccelerationStructureInstanceKHRWithoutBitFields*)(forMarshaling);
- marshal_VkTransformMatrixKHR(vkStream, rootType, (VkTransformMatrixKHR*)(&forMarshaling_new->transform));
+
+ const VkAccelerationStructureInstanceKHRWithoutBitFields* forMarshaling_new =
+ (const VkAccelerationStructureInstanceKHRWithoutBitFields*)(forMarshaling);
+ marshal_VkTransformMatrixKHR(vkStream, rootType,
+ (VkTransformMatrixKHR*)(&forMarshaling_new->transform));
for (uint32_t i = 0; i < 2; i++) {
vkStream->write((uint32_t*)&(forMarshaling_new->dwords[i]), sizeof(uint32_t));
}
- vkStream->write((uint64_t*)&forMarshaling_new->accelerationStructureReference, sizeof(uint64_t));
-
+ vkStream->write((uint64_t*)&forMarshaling_new->accelerationStructureReference,
+ sizeof(uint64_t));
}
void unmarshal_VkAccelerationStructureInstanceKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureInstanceKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureInstanceKHR* forUnmarshaling) {
(void)rootType;
-
+
typedef struct VkAccelerationStructureInstanceKHRWithoutBitFields {
- VkTransformMatrixKHR transform;
- uint32_t dwords[2];
- uint64_t accelerationStructureReference;
+ VkTransformMatrixKHR transform;
+ uint32_t dwords[2];
+ uint64_t accelerationStructureReference;
} VkAccelerationStructureInstanceKHRWithoutBitFields;
-
- VkAccelerationStructureInstanceKHRWithoutBitFields* forUnmarshaling_new = (VkAccelerationStructureInstanceKHRWithoutBitFields*)(forUnmarshaling);
- unmarshal_VkTransformMatrixKHR(vkStream, rootType, (VkTransformMatrixKHR*)(&forUnmarshaling_new->transform));
+
+ VkAccelerationStructureInstanceKHRWithoutBitFields* forUnmarshaling_new =
+ (VkAccelerationStructureInstanceKHRWithoutBitFields*)(forUnmarshaling);
+ unmarshal_VkTransformMatrixKHR(vkStream, rootType,
+ (VkTransformMatrixKHR*)(&forUnmarshaling_new->transform));
for (uint32_t i = 0; i < 2; i++) {
vkStream->read((uint32_t*)&(forUnmarshaling_new->dwords[i]), sizeof(uint32_t));
}
- vkStream->read((uint64_t*)&forUnmarshaling_new->accelerationStructureReference, sizeof(uint64_t));
-
+ vkStream->read((uint64_t*)&forUnmarshaling_new->accelerationStructureReference,
+ sizeof(uint64_t));
}
#endif
#ifdef VK_NV_representative_fragment_test
void marshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -21442,14 +19355,11 @@
}
void unmarshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -21457,14 +19367,11 @@
}
void marshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -21472,14 +19379,11 @@
}
void unmarshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineRepresentativeFragmentTestStateCreateInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineRepresentativeFragmentTestStateCreateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -21489,14 +19393,11 @@
#endif
#ifdef VK_EXT_filter_cubic
void marshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceImageViewImageFormatInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceImageViewImageFormatInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -21504,14 +19405,11 @@
}
void unmarshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceImageViewImageFormatInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceImageViewImageFormatInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -21519,14 +19417,11 @@
}
void marshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFilterCubicImageViewImageFormatPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFilterCubicImageViewImageFormatPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -21535,14 +19430,11 @@
}
void unmarshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkFilterCubicImageViewImageFormatPropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkFilterCubicImageViewImageFormatPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -21555,109 +19447,93 @@
#endif
#ifdef VK_EXT_global_priority
void marshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceQueueGlobalPriorityCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceQueueGlobalPriorityCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkQueueGlobalPriorityEXT*)&forMarshaling->globalPriority, sizeof(VkQueueGlobalPriorityEXT));
+ vkStream->write((VkQueueGlobalPriorityEXT*)&forMarshaling->globalPriority,
+ sizeof(VkQueueGlobalPriorityEXT));
}
void unmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceQueueGlobalPriorityCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceQueueGlobalPriorityCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkQueueGlobalPriorityEXT*)&forUnmarshaling->globalPriority, sizeof(VkQueueGlobalPriorityEXT));
+ vkStream->read((VkQueueGlobalPriorityEXT*)&forUnmarshaling->globalPriority,
+ sizeof(VkQueueGlobalPriorityEXT));
}
#endif
#ifdef VK_EXT_external_memory_host
void marshal_VkImportMemoryHostPointerInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportMemoryHostPointerInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportMemoryHostPointerInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pHostPointer;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pHostPointer)
- {
+ if (forMarshaling->pHostPointer) {
vkStream->write((void*)forMarshaling->pHostPointer, sizeof(uint8_t));
}
}
-void unmarshal_VkImportMemoryHostPointerInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportMemoryHostPointerInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkImportMemoryHostPointerInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkImportMemoryHostPointerInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
// WARNING PTR CHECK
void* check_pHostPointer;
check_pHostPointer = (void*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pHostPointer)
- {
- if (!(check_pHostPointer))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pHostPointer inconsistent between guest and host\n");
+ if (forUnmarshaling->pHostPointer) {
+ if (!(check_pHostPointer)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pHostPointer inconsistent between guest and host\n");
}
vkStream->read((void*)forUnmarshaling->pHostPointer, sizeof(uint8_t));
}
}
void marshal_VkMemoryHostPointerPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryHostPointerPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryHostPointerPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
}
-void unmarshal_VkMemoryHostPointerPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryHostPointerPropertiesEXT* forUnmarshaling)
-{
+void unmarshal_VkMemoryHostPointerPropertiesEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkMemoryHostPointerPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -21665,33 +19541,29 @@
}
void marshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDeviceSize*)&forMarshaling->minImportedHostPointerAlignment, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->minImportedHostPointerAlignment,
+ sizeof(VkDeviceSize));
}
void unmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDeviceSize*)&forUnmarshaling->minImportedHostPointerAlignment, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->minImportedHostPointerAlignment,
+ sizeof(VkDeviceSize));
}
#endif
@@ -21699,61 +19571,49 @@
#endif
#ifdef VK_AMD_pipeline_compiler_control
void marshal_VkPipelineCompilerControlCreateInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCompilerControlCreateInfoAMD* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCompilerControlCreateInfoAMD* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineCompilerControlFlagsAMD*)&forMarshaling->compilerControlFlags, sizeof(VkPipelineCompilerControlFlagsAMD));
+ vkStream->write((VkPipelineCompilerControlFlagsAMD*)&forMarshaling->compilerControlFlags,
+ sizeof(VkPipelineCompilerControlFlagsAMD));
}
void unmarshal_VkPipelineCompilerControlCreateInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineCompilerControlCreateInfoAMD* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineCompilerControlCreateInfoAMD* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineCompilerControlFlagsAMD*)&forUnmarshaling->compilerControlFlags, sizeof(VkPipelineCompilerControlFlagsAMD));
+ vkStream->read((VkPipelineCompilerControlFlagsAMD*)&forUnmarshaling->compilerControlFlags,
+ sizeof(VkPipelineCompilerControlFlagsAMD));
}
#endif
#ifdef VK_EXT_calibrated_timestamps
-void marshal_VkCalibratedTimestampInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCalibratedTimestampInfoEXT* forMarshaling)
-{
+void marshal_VkCalibratedTimestampInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCalibratedTimestampInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkTimeDomainEXT*)&forMarshaling->timeDomain, sizeof(VkTimeDomainEXT));
}
-void unmarshal_VkCalibratedTimestampInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCalibratedTimestampInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkCalibratedTimestampInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCalibratedTimestampInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -21763,14 +19623,11 @@
#endif
#ifdef VK_AMD_shader_core_properties
void marshal_VkPhysicalDeviceShaderCorePropertiesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderCorePropertiesAMD* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderCorePropertiesAMD* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -21791,14 +19648,11 @@
}
void unmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShaderCorePropertiesAMD* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderCorePropertiesAMD* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -21820,109 +19674,94 @@
#endif
#ifdef VK_EXT_video_decode_h265
-void marshal_VkVideoDecodeH265ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265ProfileEXT* forMarshaling)
-{
+void marshal_VkVideoDecodeH265ProfileEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265ProfileEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((StdVideoH265ProfileIdc*)&forMarshaling->stdProfileIdc, sizeof(StdVideoH265ProfileIdc));
+ vkStream->write((StdVideoH265ProfileIdc*)&forMarshaling->stdProfileIdc,
+ sizeof(StdVideoH265ProfileIdc));
}
-void unmarshal_VkVideoDecodeH265ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH265ProfileEXT* forUnmarshaling)
-{
+void unmarshal_VkVideoDecodeH265ProfileEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoDecodeH265ProfileEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((StdVideoH265ProfileIdc*)&forUnmarshaling->stdProfileIdc, sizeof(StdVideoH265ProfileIdc));
+ vkStream->read((StdVideoH265ProfileIdc*)&forUnmarshaling->stdProfileIdc,
+ sizeof(StdVideoH265ProfileIdc));
}
void marshal_VkVideoDecodeH265CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265CapabilitiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265CapabilitiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->maxLevel, sizeof(uint32_t));
- marshal_VkExtensionProperties(vkStream, rootType, (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion));
+ marshal_VkExtensionProperties(vkStream, rootType,
+ (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion));
}
-void unmarshal_VkVideoDecodeH265CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH265CapabilitiesEXT* forUnmarshaling)
-{
+void unmarshal_VkVideoDecodeH265CapabilitiesEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoDecodeH265CapabilitiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->maxLevel, sizeof(uint32_t));
- unmarshal_VkExtensionProperties(vkStream, rootType, (VkExtensionProperties*)(&forUnmarshaling->stdExtensionVersion));
+ unmarshal_VkExtensionProperties(
+ vkStream, rootType, (VkExtensionProperties*)(&forUnmarshaling->stdExtensionVersion));
}
void marshal_VkVideoDecodeH265SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265SessionCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265SessionCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkVideoDecodeH265CreateFlagsEXT*)&forMarshaling->flags, sizeof(VkVideoDecodeH265CreateFlagsEXT));
- marshal_VkExtensionProperties(vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion));
+ vkStream->write((VkVideoDecodeH265CreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkVideoDecodeH265CreateFlagsEXT));
+ marshal_VkExtensionProperties(
+ vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion));
}
void unmarshal_VkVideoDecodeH265SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH265SessionCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoDecodeH265SessionCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkVideoDecodeH265CreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkVideoDecodeH265CreateFlagsEXT));
- unmarshal_VkExtensionProperties(vkStream, rootType, (VkExtensionProperties*)(forUnmarshaling->pStdExtensionVersion));
+ vkStream->read((VkVideoDecodeH265CreateFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkVideoDecodeH265CreateFlagsEXT));
+ unmarshal_VkExtensionProperties(
+ vkStream, rootType, (VkExtensionProperties*)(forUnmarshaling->pStdExtensionVersion));
}
void marshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265SessionParametersAddInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265SessionParametersAddInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -21930,29 +19769,27 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pSpsStd;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pSpsStd)
- {
- vkStream->write((const StdVideoH265SequenceParameterSet*)forMarshaling->pSpsStd, forMarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
+ if (forMarshaling->pSpsStd) {
+ vkStream->write(
+ (const StdVideoH265SequenceParameterSet*)forMarshaling->pSpsStd,
+ forMarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
}
vkStream->write((uint32_t*)&forMarshaling->ppsStdCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pPpsStd;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pPpsStd)
- {
- vkStream->write((const StdVideoH265PictureParameterSet*)forMarshaling->pPpsStd, forMarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
+ if (forMarshaling->pPpsStd) {
+ vkStream->write((const StdVideoH265PictureParameterSet*)forMarshaling->pPpsStd,
+ forMarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
}
}
void unmarshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH265SessionParametersAddInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoDecodeH265SessionParametersAddInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -21960,37 +19797,36 @@
// WARNING PTR CHECK
const StdVideoH265SequenceParameterSet* check_pSpsStd;
check_pSpsStd = (const StdVideoH265SequenceParameterSet*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pSpsStd)
- {
- if (!(check_pSpsStd))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pSpsStd inconsistent between guest and host\n");
+ if (forUnmarshaling->pSpsStd) {
+ if (!(check_pSpsStd)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pSpsStd inconsistent between guest and host\n");
}
- vkStream->read((StdVideoH265SequenceParameterSet*)forUnmarshaling->pSpsStd, forUnmarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
+ vkStream->read(
+ (StdVideoH265SequenceParameterSet*)forUnmarshaling->pSpsStd,
+ forUnmarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
}
vkStream->read((uint32_t*)&forUnmarshaling->ppsStdCount, sizeof(uint32_t));
// WARNING PTR CHECK
const StdVideoH265PictureParameterSet* check_pPpsStd;
check_pPpsStd = (const StdVideoH265PictureParameterSet*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pPpsStd)
- {
- if (!(check_pPpsStd))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pPpsStd inconsistent between guest and host\n");
+ if (forUnmarshaling->pPpsStd) {
+ if (!(check_pPpsStd)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pPpsStd inconsistent between guest and host\n");
}
- vkStream->read((StdVideoH265PictureParameterSet*)forUnmarshaling->pPpsStd, forUnmarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
+ vkStream->read(
+ (StdVideoH265PictureParameterSet*)forUnmarshaling->pPpsStd,
+ forUnmarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
}
}
void marshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265SessionParametersCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265SessionParametersCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -21999,21 +19835,20 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pParametersAddInfo;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pParametersAddInfo)
- {
- marshal_VkVideoDecodeH265SessionParametersAddInfoEXT(vkStream, rootType, (const VkVideoDecodeH265SessionParametersAddInfoEXT*)(forMarshaling->pParametersAddInfo));
+ if (forMarshaling->pParametersAddInfo) {
+ marshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ (const VkVideoDecodeH265SessionParametersAddInfoEXT*)(forMarshaling
+ ->pParametersAddInfo));
}
}
void unmarshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH265SessionParametersCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoDecodeH265SessionParametersCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -22021,124 +19856,112 @@
vkStream->read((uint32_t*)&forUnmarshaling->maxPpsStdCount, sizeof(uint32_t));
// WARNING PTR CHECK
const VkVideoDecodeH265SessionParametersAddInfoEXT* check_pParametersAddInfo;
- check_pParametersAddInfo = (const VkVideoDecodeH265SessionParametersAddInfoEXT*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pParametersAddInfo)
- {
- if (!(check_pParametersAddInfo))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pParametersAddInfo inconsistent between guest and host\n");
+ check_pParametersAddInfo =
+ (const VkVideoDecodeH265SessionParametersAddInfoEXT*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pParametersAddInfo) {
+ if (!(check_pParametersAddInfo)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pParametersAddInfo inconsistent between guest and host\n");
}
- unmarshal_VkVideoDecodeH265SessionParametersAddInfoEXT(vkStream, rootType, (VkVideoDecodeH265SessionParametersAddInfoEXT*)(forUnmarshaling->pParametersAddInfo));
+ unmarshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ (VkVideoDecodeH265SessionParametersAddInfoEXT*)(forUnmarshaling->pParametersAddInfo));
}
}
-void marshal_VkVideoDecodeH265PictureInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265PictureInfoEXT* forMarshaling)
-{
+void marshal_VkVideoDecodeH265PictureInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265PictureInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((StdVideoDecodeH265PictureInfo*)forMarshaling->pStdPictureInfo, sizeof(StdVideoDecodeH265PictureInfo));
+ vkStream->write((StdVideoDecodeH265PictureInfo*)forMarshaling->pStdPictureInfo,
+ sizeof(StdVideoDecodeH265PictureInfo));
vkStream->write((uint32_t*)&forMarshaling->slicesCount, sizeof(uint32_t));
- vkStream->write((const uint32_t*)forMarshaling->pSlicesDataOffsets, forMarshaling->slicesCount * sizeof(const uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pSlicesDataOffsets,
+ forMarshaling->slicesCount * sizeof(const uint32_t));
}
-void unmarshal_VkVideoDecodeH265PictureInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH265PictureInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkVideoDecodeH265PictureInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoDecodeH265PictureInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((StdVideoDecodeH265PictureInfo*)forUnmarshaling->pStdPictureInfo, sizeof(StdVideoDecodeH265PictureInfo));
+ vkStream->read((StdVideoDecodeH265PictureInfo*)forUnmarshaling->pStdPictureInfo,
+ sizeof(StdVideoDecodeH265PictureInfo));
vkStream->read((uint32_t*)&forUnmarshaling->slicesCount, sizeof(uint32_t));
- vkStream->read((uint32_t*)forUnmarshaling->pSlicesDataOffsets, forUnmarshaling->slicesCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pSlicesDataOffsets,
+ forUnmarshaling->slicesCount * sizeof(const uint32_t));
}
-void marshal_VkVideoDecodeH265DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265DpbSlotInfoEXT* forMarshaling)
-{
+void marshal_VkVideoDecodeH265DpbSlotInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265DpbSlotInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((const StdVideoDecodeH265ReferenceInfo*)forMarshaling->pStdReferenceInfo, sizeof(const StdVideoDecodeH265ReferenceInfo));
+ vkStream->write((const StdVideoDecodeH265ReferenceInfo*)forMarshaling->pStdReferenceInfo,
+ sizeof(const StdVideoDecodeH265ReferenceInfo));
}
-void unmarshal_VkVideoDecodeH265DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH265DpbSlotInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkVideoDecodeH265DpbSlotInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoDecodeH265DpbSlotInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((StdVideoDecodeH265ReferenceInfo*)forUnmarshaling->pStdReferenceInfo, sizeof(const StdVideoDecodeH265ReferenceInfo));
+ vkStream->read((StdVideoDecodeH265ReferenceInfo*)forUnmarshaling->pStdReferenceInfo,
+ sizeof(const StdVideoDecodeH265ReferenceInfo));
}
#endif
#ifdef VK_AMD_memory_overallocation_behavior
void marshal_VkDeviceMemoryOverallocationCreateInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceMemoryOverallocationCreateInfoAMD* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceMemoryOverallocationCreateInfoAMD* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkMemoryOverallocationBehaviorAMD*)&forMarshaling->overallocationBehavior, sizeof(VkMemoryOverallocationBehaviorAMD));
+ vkStream->write((VkMemoryOverallocationBehaviorAMD*)&forMarshaling->overallocationBehavior,
+ sizeof(VkMemoryOverallocationBehaviorAMD));
}
void unmarshal_VkDeviceMemoryOverallocationCreateInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceMemoryOverallocationCreateInfoAMD* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceMemoryOverallocationCreateInfoAMD* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkMemoryOverallocationBehaviorAMD*)&forUnmarshaling->overallocationBehavior, sizeof(VkMemoryOverallocationBehaviorAMD));
+ vkStream->read((VkMemoryOverallocationBehaviorAMD*)&forUnmarshaling->overallocationBehavior,
+ sizeof(VkMemoryOverallocationBehaviorAMD));
}
#endif
#ifdef VK_EXT_vertex_attribute_divisor
void marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -22146,14 +19969,11 @@
}
void unmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -22161,127 +19981,111 @@
}
void marshal_VkVertexInputBindingDivisorDescriptionEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVertexInputBindingDivisorDescriptionEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVertexInputBindingDivisorDescriptionEXT* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->divisor, sizeof(uint32_t));
}
void unmarshal_VkVertexInputBindingDivisorDescriptionEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVertexInputBindingDivisorDescriptionEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVertexInputBindingDivisorDescriptionEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->binding, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->divisor, sizeof(uint32_t));
}
void marshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineVertexInputDivisorStateCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineVertexInputDivisorStateCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->vertexBindingDivisorCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexBindingDivisorCount; ++i)
- {
- marshal_VkVertexInputBindingDivisorDescriptionEXT(vkStream, rootType, (const VkVertexInputBindingDivisorDescriptionEXT*)(forMarshaling->pVertexBindingDivisors + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexBindingDivisorCount; ++i) {
+ marshal_VkVertexInputBindingDivisorDescriptionEXT(
+ vkStream, rootType,
+ (const VkVertexInputBindingDivisorDescriptionEXT*)(forMarshaling
+ ->pVertexBindingDivisors +
+ i));
}
}
}
void unmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineVertexInputDivisorStateCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineVertexInputDivisorStateCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->vertexBindingDivisorCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->vertexBindingDivisorCount; ++i)
- {
- unmarshal_VkVertexInputBindingDivisorDescriptionEXT(vkStream, rootType, (VkVertexInputBindingDivisorDescriptionEXT*)(forUnmarshaling->pVertexBindingDivisors + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->vertexBindingDivisorCount; ++i) {
+ unmarshal_VkVertexInputBindingDivisorDescriptionEXT(
+ vkStream, rootType,
+ (VkVertexInputBindingDivisorDescriptionEXT*)(forUnmarshaling
+ ->pVertexBindingDivisors +
+ i));
}
}
}
void marshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkBool32*)&forMarshaling->vertexAttributeInstanceRateDivisor, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->vertexAttributeInstanceRateZeroDivisor, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->vertexAttributeInstanceRateDivisor,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->vertexAttributeInstanceRateZeroDivisor,
+ sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkBool32*)&forUnmarshaling->vertexAttributeInstanceRateDivisor, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->vertexAttributeInstanceRateZeroDivisor, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->vertexAttributeInstanceRateDivisor,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->vertexAttributeInstanceRateZeroDivisor,
+ sizeof(VkBool32));
}
#endif
#ifdef VK_GGP_frame_token
-void marshal_VkPresentFrameTokenGGP(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentFrameTokenGGP* forMarshaling)
-{
+void marshal_VkPresentFrameTokenGGP(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentFrameTokenGGP* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((GgpFrameToken*)&forMarshaling->frameToken, sizeof(GgpFrameToken));
}
-void unmarshal_VkPresentFrameTokenGGP(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPresentFrameTokenGGP* forUnmarshaling)
-{
+void unmarshal_VkPresentFrameTokenGGP(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPresentFrameTokenGGP* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -22290,68 +20094,67 @@
#endif
#ifdef VK_EXT_pipeline_creation_feedback
-void marshal_VkPipelineCreationFeedbackEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCreationFeedbackEXT* forMarshaling)
-{
+void marshal_VkPipelineCreationFeedbackEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCreationFeedbackEXT* forMarshaling) {
(void)rootType;
- vkStream->write((VkPipelineCreationFeedbackFlagsEXT*)&forMarshaling->flags, sizeof(VkPipelineCreationFeedbackFlagsEXT));
+ vkStream->write((VkPipelineCreationFeedbackFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkPipelineCreationFeedbackFlagsEXT));
vkStream->write((uint64_t*)&forMarshaling->duration, sizeof(uint64_t));
}
-void unmarshal_VkPipelineCreationFeedbackEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineCreationFeedbackEXT* forUnmarshaling)
-{
+void unmarshal_VkPipelineCreationFeedbackEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineCreationFeedbackEXT* forUnmarshaling) {
(void)rootType;
- vkStream->read((VkPipelineCreationFeedbackFlagsEXT*)&forUnmarshaling->flags, sizeof(VkPipelineCreationFeedbackFlagsEXT));
+ vkStream->read((VkPipelineCreationFeedbackFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkPipelineCreationFeedbackFlagsEXT));
vkStream->read((uint64_t*)&forUnmarshaling->duration, sizeof(uint64_t));
}
void marshal_VkPipelineCreationFeedbackCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCreationFeedbackCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCreationFeedbackCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkPipelineCreationFeedbackEXT(vkStream, rootType, (VkPipelineCreationFeedbackEXT*)(forMarshaling->pPipelineCreationFeedback));
- vkStream->write((uint32_t*)&forMarshaling->pipelineStageCreationFeedbackCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->pipelineStageCreationFeedbackCount; ++i)
- {
- marshal_VkPipelineCreationFeedbackEXT(vkStream, rootType, (VkPipelineCreationFeedbackEXT*)(forMarshaling->pPipelineStageCreationFeedbacks + i));
+ marshal_VkPipelineCreationFeedbackEXT(
+ vkStream, rootType,
+ (VkPipelineCreationFeedbackEXT*)(forMarshaling->pPipelineCreationFeedback));
+ vkStream->write((uint32_t*)&forMarshaling->pipelineStageCreationFeedbackCount,
+ sizeof(uint32_t));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->pipelineStageCreationFeedbackCount; ++i) {
+ marshal_VkPipelineCreationFeedbackEXT(
+ vkStream, rootType,
+ (VkPipelineCreationFeedbackEXT*)(forMarshaling->pPipelineStageCreationFeedbacks +
+ i));
}
}
}
void unmarshal_VkPipelineCreationFeedbackCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineCreationFeedbackCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineCreationFeedbackCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkPipelineCreationFeedbackEXT(vkStream, rootType, (VkPipelineCreationFeedbackEXT*)(forUnmarshaling->pPipelineCreationFeedback));
- vkStream->read((uint32_t*)&forUnmarshaling->pipelineStageCreationFeedbackCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->pipelineStageCreationFeedbackCount; ++i)
- {
- unmarshal_VkPipelineCreationFeedbackEXT(vkStream, rootType, (VkPipelineCreationFeedbackEXT*)(forUnmarshaling->pPipelineStageCreationFeedbacks + i));
+ unmarshal_VkPipelineCreationFeedbackEXT(
+ vkStream, rootType,
+ (VkPipelineCreationFeedbackEXT*)(forUnmarshaling->pPipelineCreationFeedback));
+ vkStream->read((uint32_t*)&forUnmarshaling->pipelineStageCreationFeedbackCount,
+ sizeof(uint32_t));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->pipelineStageCreationFeedbackCount;
+ ++i) {
+ unmarshal_VkPipelineCreationFeedbackEXT(
+ vkStream, rootType,
+ (VkPipelineCreationFeedbackEXT*)(forUnmarshaling->pPipelineStageCreationFeedbacks +
+ i));
}
}
}
@@ -22361,14 +20164,11 @@
#endif
#ifdef VK_NV_compute_shader_derivatives
void marshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -22377,14 +20177,11 @@
}
void unmarshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -22395,14 +20192,11 @@
#endif
#ifdef VK_NV_mesh_shader
void marshal_VkPhysicalDeviceMeshShaderFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMeshShaderFeaturesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMeshShaderFeaturesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -22411,14 +20205,11 @@
}
void unmarshal_VkPhysicalDeviceMeshShaderFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceMeshShaderFeaturesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMeshShaderFeaturesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -22427,14 +20218,11 @@
}
void marshal_VkPhysicalDeviceMeshShaderPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMeshShaderPropertiesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMeshShaderPropertiesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -22454,14 +20242,11 @@
}
void unmarshal_VkPhysicalDeviceMeshShaderPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceMeshShaderPropertiesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMeshShaderPropertiesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -22477,24 +20262,21 @@
vkStream->read((uint32_t*)&forUnmarshaling->maxMeshOutputPrimitives, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxMeshMultiviewViewCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->meshOutputPerVertexGranularity, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->meshOutputPerPrimitiveGranularity, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->meshOutputPerPrimitiveGranularity,
+ sizeof(uint32_t));
}
void marshal_VkDrawMeshTasksIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrawMeshTasksIndirectCommandNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrawMeshTasksIndirectCommandNV* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->taskCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->firstTask, sizeof(uint32_t));
}
-void unmarshal_VkDrawMeshTasksIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDrawMeshTasksIndirectCommandNV* forUnmarshaling)
-{
+void unmarshal_VkDrawMeshTasksIndirectCommandNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkDrawMeshTasksIndirectCommandNV* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->taskCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->firstTask, sizeof(uint32_t));
@@ -22503,14 +20285,11 @@
#endif
#ifdef VK_NV_fragment_shader_barycentric
void marshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -22518,14 +20297,11 @@
}
void unmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -22535,14 +20311,11 @@
#endif
#ifdef VK_NV_shader_image_footprint
void marshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderImageFootprintFeaturesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderImageFootprintFeaturesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -22550,14 +20323,11 @@
}
void unmarshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShaderImageFootprintFeaturesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderImageFootprintFeaturesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -22567,14 +20337,11 @@
#endif
#ifdef VK_NV_scissor_exclusive
void marshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineViewportExclusiveScissorStateCreateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineViewportExclusiveScissorStateCreateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -22582,27 +20349,22 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pExclusiveScissors;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pExclusiveScissors)
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->exclusiveScissorCount; ++i)
- {
- marshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pExclusiveScissors + i));
+ if (forMarshaling->pExclusiveScissors) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->exclusiveScissorCount; ++i) {
+ marshal_VkRect2D(vkStream, rootType,
+ (const VkRect2D*)(forMarshaling->pExclusiveScissors + i));
}
}
}
}
void unmarshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineViewportExclusiveScissorStateCreateInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineViewportExclusiveScissorStateCreateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -22610,31 +20372,27 @@
// WARNING PTR CHECK
const VkRect2D* check_pExclusiveScissors;
check_pExclusiveScissors = (const VkRect2D*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pExclusiveScissors)
- {
- if (!(check_pExclusiveScissors))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pExclusiveScissors inconsistent between guest and host\n");
+ if (forUnmarshaling->pExclusiveScissors) {
+ if (!(check_pExclusiveScissors)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pExclusiveScissors inconsistent between guest and host\n");
}
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->exclusiveScissorCount; ++i)
- {
- unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(forUnmarshaling->pExclusiveScissors + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->exclusiveScissorCount; ++i) {
+ unmarshal_VkRect2D(vkStream, rootType,
+ (VkRect2D*)(forUnmarshaling->pExclusiveScissors + i));
}
}
}
}
void marshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExclusiveScissorFeaturesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExclusiveScissorFeaturesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -22642,14 +20400,11 @@
}
void unmarshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceExclusiveScissorFeaturesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceExclusiveScissorFeaturesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -22659,78 +20414,67 @@
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
void marshal_VkQueueFamilyCheckpointPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueueFamilyCheckpointPropertiesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyCheckpointPropertiesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineStageFlags*)&forMarshaling->checkpointExecutionStageMask, sizeof(VkPipelineStageFlags));
+ vkStream->write((VkPipelineStageFlags*)&forMarshaling->checkpointExecutionStageMask,
+ sizeof(VkPipelineStageFlags));
}
void unmarshal_VkQueueFamilyCheckpointPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkQueueFamilyCheckpointPropertiesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkQueueFamilyCheckpointPropertiesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->checkpointExecutionStageMask, sizeof(VkPipelineStageFlags));
+ vkStream->read((VkPipelineStageFlags*)&forUnmarshaling->checkpointExecutionStageMask,
+ sizeof(VkPipelineStageFlags));
}
-void marshal_VkCheckpointDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCheckpointDataNV* forMarshaling)
-{
+void marshal_VkCheckpointDataNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCheckpointDataNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineStageFlagBits*)&forMarshaling->stage, sizeof(VkPipelineStageFlagBits));
+ vkStream->write((VkPipelineStageFlagBits*)&forMarshaling->stage,
+ sizeof(VkPipelineStageFlagBits));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pCheckpointMarker;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pCheckpointMarker)
- {
+ if (forMarshaling->pCheckpointMarker) {
vkStream->write((void*)forMarshaling->pCheckpointMarker, sizeof(uint8_t));
}
}
-void unmarshal_VkCheckpointDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCheckpointDataNV* forUnmarshaling)
-{
+void unmarshal_VkCheckpointDataNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCheckpointDataNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineStageFlagBits*)&forUnmarshaling->stage, sizeof(VkPipelineStageFlagBits));
+ vkStream->read((VkPipelineStageFlagBits*)&forUnmarshaling->stage,
+ sizeof(VkPipelineStageFlagBits));
// WARNING PTR CHECK
void* check_pCheckpointMarker;
check_pCheckpointMarker = (void*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pCheckpointMarker)
- {
- if (!(check_pCheckpointMarker))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pCheckpointMarker inconsistent between guest and host\n");
+ if (forUnmarshaling->pCheckpointMarker) {
+ if (!(check_pCheckpointMarker)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pCheckpointMarker inconsistent between guest and host\n");
}
vkStream->read((void*)forUnmarshaling->pCheckpointMarker, sizeof(uint8_t));
}
@@ -22739,14 +20483,11 @@
#endif
#ifdef VK_INTEL_shader_integer_functions2
void marshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -22754,14 +20495,11 @@
}
void unmarshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -22770,144 +20508,116 @@
#endif
#ifdef VK_INTEL_performance_query
-void marshal_VkPerformanceValueDataINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceValueDataINTEL* forMarshaling)
-{
+void marshal_VkPerformanceValueDataINTEL(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceValueDataINTEL* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->value32, sizeof(uint32_t));
}
-void unmarshal_VkPerformanceValueDataINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPerformanceValueDataINTEL* forUnmarshaling)
-{
+void unmarshal_VkPerformanceValueDataINTEL(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPerformanceValueDataINTEL* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->value32, sizeof(uint32_t));
}
-void marshal_VkPerformanceValueINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceValueINTEL* forMarshaling)
-{
+void marshal_VkPerformanceValueINTEL(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceValueINTEL* forMarshaling) {
(void)rootType;
- vkStream->write((VkPerformanceValueTypeINTEL*)&forMarshaling->type, sizeof(VkPerformanceValueTypeINTEL));
- marshal_VkPerformanceValueDataINTEL(vkStream, rootType, (VkPerformanceValueDataINTEL*)(&forMarshaling->data));
+ vkStream->write((VkPerformanceValueTypeINTEL*)&forMarshaling->type,
+ sizeof(VkPerformanceValueTypeINTEL));
+ marshal_VkPerformanceValueDataINTEL(vkStream, rootType,
+ (VkPerformanceValueDataINTEL*)(&forMarshaling->data));
}
-void unmarshal_VkPerformanceValueINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPerformanceValueINTEL* forUnmarshaling)
-{
+void unmarshal_VkPerformanceValueINTEL(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPerformanceValueINTEL* forUnmarshaling) {
(void)rootType;
- vkStream->read((VkPerformanceValueTypeINTEL*)&forUnmarshaling->type, sizeof(VkPerformanceValueTypeINTEL));
- unmarshal_VkPerformanceValueDataINTEL(vkStream, rootType, (VkPerformanceValueDataINTEL*)(&forUnmarshaling->data));
+ vkStream->read((VkPerformanceValueTypeINTEL*)&forUnmarshaling->type,
+ sizeof(VkPerformanceValueTypeINTEL));
+ unmarshal_VkPerformanceValueDataINTEL(vkStream, rootType,
+ (VkPerformanceValueDataINTEL*)(&forUnmarshaling->data));
}
void marshal_VkInitializePerformanceApiInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkInitializePerformanceApiInfoINTEL* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkInitializePerformanceApiInfoINTEL* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pUserData)
- {
+ if (forMarshaling->pUserData) {
vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
}
}
void unmarshal_VkInitializePerformanceApiInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkInitializePerformanceApiInfoINTEL* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkInitializePerformanceApiInfoINTEL* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
// WARNING PTR CHECK
void* check_pUserData;
check_pUserData = (void*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pUserData)
- {
- if (!(check_pUserData))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pUserData inconsistent between guest and host\n");
+ if (forUnmarshaling->pUserData) {
+ if (!(check_pUserData)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pUserData inconsistent between guest and host\n");
}
vkStream->read((void*)forUnmarshaling->pUserData, sizeof(uint8_t));
}
}
void marshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueryPoolPerformanceQueryCreateInfoINTEL* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueryPoolPerformanceQueryCreateInfoINTEL* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkQueryPoolSamplingModeINTEL*)&forMarshaling->performanceCountersSampling, sizeof(VkQueryPoolSamplingModeINTEL));
+ vkStream->write((VkQueryPoolSamplingModeINTEL*)&forMarshaling->performanceCountersSampling,
+ sizeof(VkQueryPoolSamplingModeINTEL));
}
void unmarshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkQueryPoolPerformanceQueryCreateInfoINTEL* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkQueryPoolPerformanceQueryCreateInfoINTEL* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkQueryPoolSamplingModeINTEL*)&forUnmarshaling->performanceCountersSampling, sizeof(VkQueryPoolSamplingModeINTEL));
+ vkStream->read((VkQueryPoolSamplingModeINTEL*)&forUnmarshaling->performanceCountersSampling,
+ sizeof(VkQueryPoolSamplingModeINTEL));
}
-void marshal_VkPerformanceMarkerInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceMarkerInfoINTEL* forMarshaling)
-{
+void marshal_VkPerformanceMarkerInfoINTEL(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceMarkerInfoINTEL* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint64_t*)&forMarshaling->marker, sizeof(uint64_t));
}
-void unmarshal_VkPerformanceMarkerInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPerformanceMarkerInfoINTEL* forUnmarshaling)
-{
+void unmarshal_VkPerformanceMarkerInfoINTEL(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPerformanceMarkerInfoINTEL* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -22915,14 +20625,11 @@
}
void marshal_VkPerformanceStreamMarkerInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceStreamMarkerInfoINTEL* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceStreamMarkerInfoINTEL* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -22930,95 +20637,79 @@
}
void unmarshal_VkPerformanceStreamMarkerInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPerformanceStreamMarkerInfoINTEL* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPerformanceStreamMarkerInfoINTEL* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->marker, sizeof(uint32_t));
}
-void marshal_VkPerformanceOverrideInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceOverrideInfoINTEL* forMarshaling)
-{
+void marshal_VkPerformanceOverrideInfoINTEL(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceOverrideInfoINTEL* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPerformanceOverrideTypeINTEL*)&forMarshaling->type, sizeof(VkPerformanceOverrideTypeINTEL));
+ vkStream->write((VkPerformanceOverrideTypeINTEL*)&forMarshaling->type,
+ sizeof(VkPerformanceOverrideTypeINTEL));
vkStream->write((VkBool32*)&forMarshaling->enable, sizeof(VkBool32));
vkStream->write((uint64_t*)&forMarshaling->parameter, sizeof(uint64_t));
}
-void unmarshal_VkPerformanceOverrideInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPerformanceOverrideInfoINTEL* forUnmarshaling)
-{
+void unmarshal_VkPerformanceOverrideInfoINTEL(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPerformanceOverrideInfoINTEL* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPerformanceOverrideTypeINTEL*)&forUnmarshaling->type, sizeof(VkPerformanceOverrideTypeINTEL));
+ vkStream->read((VkPerformanceOverrideTypeINTEL*)&forUnmarshaling->type,
+ sizeof(VkPerformanceOverrideTypeINTEL));
vkStream->read((VkBool32*)&forUnmarshaling->enable, sizeof(VkBool32));
vkStream->read((uint64_t*)&forUnmarshaling->parameter, sizeof(uint64_t));
}
void marshal_VkPerformanceConfigurationAcquireInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceConfigurationAcquireInfoINTEL* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceConfigurationAcquireInfoINTEL* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPerformanceConfigurationTypeINTEL*)&forMarshaling->type, sizeof(VkPerformanceConfigurationTypeINTEL));
+ vkStream->write((VkPerformanceConfigurationTypeINTEL*)&forMarshaling->type,
+ sizeof(VkPerformanceConfigurationTypeINTEL));
}
void unmarshal_VkPerformanceConfigurationAcquireInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPerformanceConfigurationAcquireInfoINTEL* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPerformanceConfigurationAcquireInfoINTEL* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPerformanceConfigurationTypeINTEL*)&forUnmarshaling->type, sizeof(VkPerformanceConfigurationTypeINTEL));
+ vkStream->read((VkPerformanceConfigurationTypeINTEL*)&forUnmarshaling->type,
+ sizeof(VkPerformanceConfigurationTypeINTEL));
}
#endif
#ifdef VK_EXT_pci_bus_info
void marshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePCIBusInfoPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePCIBusInfoPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -23029,14 +20720,11 @@
}
void unmarshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDevicePCIBusInfoPropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePCIBusInfoPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -23049,14 +20737,11 @@
#endif
#ifdef VK_AMD_display_native_hdr
void marshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayNativeHdrSurfaceCapabilitiesAMD* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayNativeHdrSurfaceCapabilitiesAMD* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -23064,14 +20749,11 @@
}
void unmarshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayNativeHdrSurfaceCapabilitiesAMD* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayNativeHdrSurfaceCapabilitiesAMD* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -23079,14 +20761,11 @@
}
void marshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSwapchainDisplayNativeHdrCreateInfoAMD* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSwapchainDisplayNativeHdrCreateInfoAMD* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -23094,14 +20773,11 @@
}
void unmarshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSwapchainDisplayNativeHdrCreateInfoAMD* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSwapchainDisplayNativeHdrCreateInfoAMD* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -23111,164 +20787,143 @@
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
void marshal_VkImagePipeSurfaceCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImagePipeSurfaceCreateInfoFUCHSIA* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImagePipeSurfaceCreateInfoFUCHSIA* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkImagePipeSurfaceCreateFlagsFUCHSIA*)&forMarshaling->flags, sizeof(VkImagePipeSurfaceCreateFlagsFUCHSIA));
+ vkStream->write((VkImagePipeSurfaceCreateFlagsFUCHSIA*)&forMarshaling->flags,
+ sizeof(VkImagePipeSurfaceCreateFlagsFUCHSIA));
vkStream->write((zx_handle_t*)&forMarshaling->imagePipeHandle, sizeof(zx_handle_t));
}
void unmarshal_VkImagePipeSurfaceCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImagePipeSurfaceCreateInfoFUCHSIA* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImagePipeSurfaceCreateInfoFUCHSIA* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkImagePipeSurfaceCreateFlagsFUCHSIA*)&forUnmarshaling->flags, sizeof(VkImagePipeSurfaceCreateFlagsFUCHSIA));
+ vkStream->read((VkImagePipeSurfaceCreateFlagsFUCHSIA*)&forUnmarshaling->flags,
+ sizeof(VkImagePipeSurfaceCreateFlagsFUCHSIA));
vkStream->read((zx_handle_t*)&forUnmarshaling->imagePipeHandle, sizeof(zx_handle_t));
}
#endif
#ifdef VK_EXT_metal_surface
-void marshal_VkMetalSurfaceCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMetalSurfaceCreateInfoEXT* forMarshaling)
-{
+void marshal_VkMetalSurfaceCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMetalSurfaceCreateInfoEXT* forMarshaling) {
(void)rootType;
-
+
// This struct should never be marshaled / unmarshaled.
__builtin_trap();
-
}
-void unmarshal_VkMetalSurfaceCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMetalSurfaceCreateInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkMetalSurfaceCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMetalSurfaceCreateInfoEXT* forUnmarshaling) {
(void)rootType;
-
+
// This struct should never be marshaled / unmarshaled.
__builtin_trap();
-
}
#endif
#ifdef VK_EXT_fragment_density_map
void marshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->fragmentDensityMap, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->fragmentDensityMapDynamic, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->fragmentDensityMapNonSubsampledImages, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->fragmentDensityMapNonSubsampledImages,
+ sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceFragmentDensityMapFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceFragmentDensityMapFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
forUnmarshaling->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->fragmentDensityMap, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->fragmentDensityMapDynamic, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->fragmentDensityMapNonSubsampledImages, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->fragmentDensityMapNonSubsampledImages,
+ sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minFragmentDensityTexelSize));
- marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxFragmentDensityTexelSize));
+ marshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->minFragmentDensityTexelSize));
+ marshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->maxFragmentDensityTexelSize));
vkStream->write((VkBool32*)&forMarshaling->fragmentDensityInvocations, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceFragmentDensityMapPropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceFragmentDensityMapPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
forUnmarshaling->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->minFragmentDensityTexelSize));
- unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxFragmentDensityTexelSize));
+ unmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forUnmarshaling->minFragmentDensityTexelSize));
+ unmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forUnmarshaling->maxFragmentDensityTexelSize));
vkStream->read((VkBool32*)&forUnmarshaling->fragmentDensityInvocations, sizeof(VkBool32));
}
void marshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassFragmentDensityMapCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassFragmentDensityMapCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkAttachmentReference(vkStream, rootType, (VkAttachmentReference*)(&forMarshaling->fragmentDensityMapAttachment));
+ marshal_VkAttachmentReference(
+ vkStream, rootType, (VkAttachmentReference*)(&forMarshaling->fragmentDensityMapAttachment));
}
void unmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRenderPassFragmentDensityMapCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderPassFragmentDensityMapCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
forUnmarshaling->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkAttachmentReference(vkStream, rootType, (VkAttachmentReference*)(&forUnmarshaling->fragmentDensityMapAttachment));
+ unmarshal_VkAttachmentReference(
+ vkStream, rootType,
+ (VkAttachmentReference*)(&forUnmarshaling->fragmentDensityMapAttachment));
}
#endif
@@ -23280,14 +20935,11 @@
#endif
#ifdef VK_EXT_subgroup_size_control
void marshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -23296,14 +20948,11 @@
}
void unmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -23312,50 +20961,43 @@
}
void marshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->minSubgroupSize, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxSubgroupSize, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxComputeWorkgroupSubgroups, sizeof(uint32_t));
- vkStream->write((VkShaderStageFlags*)&forMarshaling->requiredSubgroupSizeStages, sizeof(VkShaderStageFlags));
+ vkStream->write((VkShaderStageFlags*)&forMarshaling->requiredSubgroupSizeStages,
+ sizeof(VkShaderStageFlags));
}
void unmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->minSubgroupSize, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxSubgroupSize, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxComputeWorkgroupSubgroups, sizeof(uint32_t));
- vkStream->read((VkShaderStageFlags*)&forUnmarshaling->requiredSubgroupSizeStages, sizeof(VkShaderStageFlags));
+ vkStream->read((VkShaderStageFlags*)&forUnmarshaling->requiredSubgroupSizeStages,
+ sizeof(VkShaderStageFlags));
}
void marshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -23363,14 +21005,11 @@
}
void unmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -23380,48 +21019,41 @@
#endif
#ifdef VK_AMD_shader_core_properties2
void marshal_VkPhysicalDeviceShaderCoreProperties2AMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderCoreProperties2AMD* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderCoreProperties2AMD* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkShaderCorePropertiesFlagsAMD*)&forMarshaling->shaderCoreFeatures, sizeof(VkShaderCorePropertiesFlagsAMD));
+ vkStream->write((VkShaderCorePropertiesFlagsAMD*)&forMarshaling->shaderCoreFeatures,
+ sizeof(VkShaderCorePropertiesFlagsAMD));
vkStream->write((uint32_t*)&forMarshaling->activeComputeUnitCount, sizeof(uint32_t));
}
void unmarshal_VkPhysicalDeviceShaderCoreProperties2AMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShaderCoreProperties2AMD* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderCoreProperties2AMD* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkShaderCorePropertiesFlagsAMD*)&forUnmarshaling->shaderCoreFeatures, sizeof(VkShaderCorePropertiesFlagsAMD));
+ vkStream->read((VkShaderCorePropertiesFlagsAMD*)&forUnmarshaling->shaderCoreFeatures,
+ sizeof(VkShaderCorePropertiesFlagsAMD));
vkStream->read((uint32_t*)&forUnmarshaling->activeComputeUnitCount, sizeof(uint32_t));
}
#endif
#ifdef VK_AMD_device_coherent_memory
void marshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCoherentMemoryFeaturesAMD* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCoherentMemoryFeaturesAMD* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -23429,14 +21061,11 @@
}
void unmarshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceCoherentMemoryFeaturesAMD* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceCoherentMemoryFeaturesAMD* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -23446,14 +21075,11 @@
#endif
#ifdef VK_EXT_shader_image_atomic_int64
void marshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -23462,14 +21088,11 @@
}
void unmarshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -23480,48 +21103,43 @@
#endif
#ifdef VK_EXT_memory_budget
void marshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryBudgetPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryBudgetPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDeviceSize*)forMarshaling->heapBudget, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
- vkStream->write((VkDeviceSize*)forMarshaling->heapUsage, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)forMarshaling->heapBudget,
+ VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)forMarshaling->heapUsage,
+ VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
}
void unmarshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceMemoryBudgetPropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMemoryBudgetPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDeviceSize*)forUnmarshaling->heapBudget, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
- vkStream->read((VkDeviceSize*)forUnmarshaling->heapUsage, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)forUnmarshaling->heapBudget,
+ VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)forUnmarshaling->heapUsage,
+ VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
}
#endif
#ifdef VK_EXT_memory_priority
void marshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryPriorityFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryPriorityFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -23529,44 +21147,34 @@
}
void unmarshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceMemoryPriorityFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMemoryPriorityFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->memoryPriority, sizeof(VkBool32));
}
-void marshal_VkMemoryPriorityAllocateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryPriorityAllocateInfoEXT* forMarshaling)
-{
+void marshal_VkMemoryPriorityAllocateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryPriorityAllocateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((float*)&forMarshaling->priority, sizeof(float));
}
-void unmarshal_VkMemoryPriorityAllocateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryPriorityAllocateInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkMemoryPriorityAllocateInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkMemoryPriorityAllocateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -23576,14 +21184,11 @@
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
void marshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -23591,14 +21196,11 @@
}
void unmarshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -23608,14 +21210,11 @@
#endif
#ifdef VK_EXT_buffer_device_address
void marshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -23625,14 +21224,11 @@
}
void unmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -23642,14 +21238,11 @@
}
void marshal_VkBufferDeviceAddressCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferDeviceAddressCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferDeviceAddressCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -23657,14 +21250,11 @@
}
void unmarshal_VkBufferDeviceAddressCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferDeviceAddressCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferDeviceAddressCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -23674,39 +21264,35 @@
#endif
#ifdef VK_EXT_tooling_info
void marshal_VkPhysicalDeviceToolPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceToolPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceToolPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((char*)forMarshaling->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
vkStream->write((char*)forMarshaling->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
- vkStream->write((VkToolPurposeFlagsEXT*)&forMarshaling->purposes, sizeof(VkToolPurposeFlagsEXT));
+ vkStream->write((VkToolPurposeFlagsEXT*)&forMarshaling->purposes,
+ sizeof(VkToolPurposeFlagsEXT));
vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
vkStream->write((char*)forMarshaling->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
}
void unmarshal_VkPhysicalDeviceToolPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceToolPropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceToolPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((char*)forUnmarshaling->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
vkStream->read((char*)forUnmarshaling->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
- vkStream->read((VkToolPurposeFlagsEXT*)&forUnmarshaling->purposes, sizeof(VkToolPurposeFlagsEXT));
+ vkStream->read((VkToolPurposeFlagsEXT*)&forUnmarshaling->purposes,
+ sizeof(VkToolPurposeFlagsEXT));
vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
vkStream->read((char*)forUnmarshaling->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
}
@@ -23715,53 +21301,50 @@
#ifdef VK_EXT_separate_stencil_usage
#endif
#ifdef VK_EXT_validation_features
-void marshal_VkValidationFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkValidationFeaturesEXT* forMarshaling)
-{
+void marshal_VkValidationFeaturesEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkValidationFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->enabledValidationFeatureCount, sizeof(uint32_t));
- vkStream->write((const VkValidationFeatureEnableEXT*)forMarshaling->pEnabledValidationFeatures, forMarshaling->enabledValidationFeatureCount * sizeof(const VkValidationFeatureEnableEXT));
+ vkStream->write(
+ (const VkValidationFeatureEnableEXT*)forMarshaling->pEnabledValidationFeatures,
+ forMarshaling->enabledValidationFeatureCount * sizeof(const VkValidationFeatureEnableEXT));
vkStream->write((uint32_t*)&forMarshaling->disabledValidationFeatureCount, sizeof(uint32_t));
- vkStream->write((const VkValidationFeatureDisableEXT*)forMarshaling->pDisabledValidationFeatures, forMarshaling->disabledValidationFeatureCount * sizeof(const VkValidationFeatureDisableEXT));
+ vkStream->write(
+ (const VkValidationFeatureDisableEXT*)forMarshaling->pDisabledValidationFeatures,
+ forMarshaling->disabledValidationFeatureCount *
+ sizeof(const VkValidationFeatureDisableEXT));
}
-void unmarshal_VkValidationFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkValidationFeaturesEXT* forUnmarshaling)
-{
+void unmarshal_VkValidationFeaturesEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkValidationFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->enabledValidationFeatureCount, sizeof(uint32_t));
- vkStream->read((VkValidationFeatureEnableEXT*)forUnmarshaling->pEnabledValidationFeatures, forUnmarshaling->enabledValidationFeatureCount * sizeof(const VkValidationFeatureEnableEXT));
+ vkStream->read((VkValidationFeatureEnableEXT*)forUnmarshaling->pEnabledValidationFeatures,
+ forUnmarshaling->enabledValidationFeatureCount *
+ sizeof(const VkValidationFeatureEnableEXT));
vkStream->read((uint32_t*)&forUnmarshaling->disabledValidationFeatureCount, sizeof(uint32_t));
- vkStream->read((VkValidationFeatureDisableEXT*)forUnmarshaling->pDisabledValidationFeatures, forUnmarshaling->disabledValidationFeatureCount * sizeof(const VkValidationFeatureDisableEXT));
+ vkStream->read((VkValidationFeatureDisableEXT*)forUnmarshaling->pDisabledValidationFeatures,
+ forUnmarshaling->disabledValidationFeatureCount *
+ sizeof(const VkValidationFeatureDisableEXT));
}
#endif
#ifdef VK_NV_cooperative_matrix
-void marshal_VkCooperativeMatrixPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCooperativeMatrixPropertiesNV* forMarshaling)
-{
+void marshal_VkCooperativeMatrixPropertiesNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCooperativeMatrixPropertiesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -23775,15 +21358,12 @@
vkStream->write((VkScopeNV*)&forMarshaling->scope, sizeof(VkScopeNV));
}
-void unmarshal_VkCooperativeMatrixPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCooperativeMatrixPropertiesNV* forUnmarshaling)
-{
+void unmarshal_VkCooperativeMatrixPropertiesNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkCooperativeMatrixPropertiesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -23798,78 +21378,67 @@
}
void marshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCooperativeMatrixFeaturesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCooperativeMatrixFeaturesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->cooperativeMatrix, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->cooperativeMatrixRobustBufferAccess, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->cooperativeMatrixRobustBufferAccess,
+ sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceCooperativeMatrixFeaturesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceCooperativeMatrixFeaturesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->cooperativeMatrix, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->cooperativeMatrixRobustBufferAccess, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->cooperativeMatrixRobustBufferAccess,
+ sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCooperativeMatrixPropertiesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCooperativeMatrixPropertiesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkShaderStageFlags*)&forMarshaling->cooperativeMatrixSupportedStages, sizeof(VkShaderStageFlags));
+ vkStream->write((VkShaderStageFlags*)&forMarshaling->cooperativeMatrixSupportedStages,
+ sizeof(VkShaderStageFlags));
}
void unmarshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceCooperativeMatrixPropertiesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceCooperativeMatrixPropertiesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkShaderStageFlags*)&forUnmarshaling->cooperativeMatrixSupportedStages, sizeof(VkShaderStageFlags));
+ vkStream->read((VkShaderStageFlags*)&forUnmarshaling->cooperativeMatrixSupportedStages,
+ sizeof(VkShaderStageFlags));
}
#endif
#ifdef VK_NV_coverage_reduction_mode
void marshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCoverageReductionModeFeaturesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCoverageReductionModeFeaturesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -23877,14 +21446,11 @@
}
void unmarshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceCoverageReductionModeFeaturesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceCoverageReductionModeFeaturesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -23892,120 +21458,111 @@
}
void marshal_VkPipelineCoverageReductionStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCoverageReductionStateCreateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCoverageReductionStateCreateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineCoverageReductionStateCreateFlagsNV*)&forMarshaling->flags, sizeof(VkPipelineCoverageReductionStateCreateFlagsNV));
- vkStream->write((VkCoverageReductionModeNV*)&forMarshaling->coverageReductionMode, sizeof(VkCoverageReductionModeNV));
+ vkStream->write((VkPipelineCoverageReductionStateCreateFlagsNV*)&forMarshaling->flags,
+ sizeof(VkPipelineCoverageReductionStateCreateFlagsNV));
+ vkStream->write((VkCoverageReductionModeNV*)&forMarshaling->coverageReductionMode,
+ sizeof(VkCoverageReductionModeNV));
}
void unmarshal_VkPipelineCoverageReductionStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineCoverageReductionStateCreateInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineCoverageReductionStateCreateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineCoverageReductionStateCreateFlagsNV*)&forUnmarshaling->flags, sizeof(VkPipelineCoverageReductionStateCreateFlagsNV));
- vkStream->read((VkCoverageReductionModeNV*)&forUnmarshaling->coverageReductionMode, sizeof(VkCoverageReductionModeNV));
+ vkStream->read((VkPipelineCoverageReductionStateCreateFlagsNV*)&forUnmarshaling->flags,
+ sizeof(VkPipelineCoverageReductionStateCreateFlagsNV));
+ vkStream->read((VkCoverageReductionModeNV*)&forUnmarshaling->coverageReductionMode,
+ sizeof(VkCoverageReductionModeNV));
}
void marshal_VkFramebufferMixedSamplesCombinationNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFramebufferMixedSamplesCombinationNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFramebufferMixedSamplesCombinationNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkCoverageReductionModeNV*)&forMarshaling->coverageReductionMode, sizeof(VkCoverageReductionModeNV));
- vkStream->write((VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples, sizeof(VkSampleCountFlagBits));
- vkStream->write((VkSampleCountFlags*)&forMarshaling->depthStencilSamples, sizeof(VkSampleCountFlags));
+ vkStream->write((VkCoverageReductionModeNV*)&forMarshaling->coverageReductionMode,
+ sizeof(VkCoverageReductionModeNV));
+ vkStream->write((VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples,
+ sizeof(VkSampleCountFlagBits));
+ vkStream->write((VkSampleCountFlags*)&forMarshaling->depthStencilSamples,
+ sizeof(VkSampleCountFlags));
vkStream->write((VkSampleCountFlags*)&forMarshaling->colorSamples, sizeof(VkSampleCountFlags));
}
void unmarshal_VkFramebufferMixedSamplesCombinationNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkFramebufferMixedSamplesCombinationNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkFramebufferMixedSamplesCombinationNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkCoverageReductionModeNV*)&forUnmarshaling->coverageReductionMode, sizeof(VkCoverageReductionModeNV));
- vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->rasterizationSamples, sizeof(VkSampleCountFlagBits));
- vkStream->read((VkSampleCountFlags*)&forUnmarshaling->depthStencilSamples, sizeof(VkSampleCountFlags));
+ vkStream->read((VkCoverageReductionModeNV*)&forUnmarshaling->coverageReductionMode,
+ sizeof(VkCoverageReductionModeNV));
+ vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->rasterizationSamples,
+ sizeof(VkSampleCountFlagBits));
+ vkStream->read((VkSampleCountFlags*)&forUnmarshaling->depthStencilSamples,
+ sizeof(VkSampleCountFlags));
vkStream->read((VkSampleCountFlags*)&forUnmarshaling->colorSamples, sizeof(VkSampleCountFlags));
}
#endif
#ifdef VK_EXT_fragment_shader_interlock
void marshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->fragmentShaderSampleInterlock, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->fragmentShaderPixelInterlock, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->fragmentShaderShadingRateInterlock, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->fragmentShaderShadingRateInterlock,
+ sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->fragmentShaderSampleInterlock, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->fragmentShaderPixelInterlock, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->fragmentShaderShadingRateInterlock, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->fragmentShaderShadingRateInterlock,
+ sizeof(VkBool32));
}
#endif
#ifdef VK_EXT_ycbcr_image_arrays
void marshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -24013,14 +21570,11 @@
}
void unmarshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -24030,140 +21584,122 @@
#endif
#ifdef VK_EXT_provoking_vertex
void marshal_VkPhysicalDeviceProvokingVertexFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceProvokingVertexFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceProvokingVertexFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->provokingVertexLast, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->transformFeedbackPreservesProvokingVertex, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->transformFeedbackPreservesProvokingVertex,
+ sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceProvokingVertexFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceProvokingVertexFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceProvokingVertexFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->provokingVertexLast, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->transformFeedbackPreservesProvokingVertex, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->transformFeedbackPreservesProvokingVertex,
+ sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceProvokingVertexPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceProvokingVertexPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceProvokingVertexPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->provokingVertexModePerPipeline, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->transformFeedbackPreservesTriangleFanProvokingVertex, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->transformFeedbackPreservesTriangleFanProvokingVertex,
+ sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceProvokingVertexPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceProvokingVertexPropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceProvokingVertexPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->provokingVertexModePerPipeline, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->transformFeedbackPreservesTriangleFanProvokingVertex, sizeof(VkBool32));
+ vkStream->read(
+ (VkBool32*)&forUnmarshaling->transformFeedbackPreservesTriangleFanProvokingVertex,
+ sizeof(VkBool32));
}
void marshal_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkProvokingVertexModeEXT*)&forMarshaling->provokingVertexMode, sizeof(VkProvokingVertexModeEXT));
+ vkStream->write((VkProvokingVertexModeEXT*)&forMarshaling->provokingVertexMode,
+ sizeof(VkProvokingVertexModeEXT));
}
void unmarshal_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkProvokingVertexModeEXT*)&forUnmarshaling->provokingVertexMode, sizeof(VkProvokingVertexModeEXT));
+ vkStream->read((VkProvokingVertexModeEXT*)&forUnmarshaling->provokingVertexMode,
+ sizeof(VkProvokingVertexModeEXT));
}
#endif
#ifdef VK_EXT_full_screen_exclusive
void marshal_VkSurfaceFullScreenExclusiveInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceFullScreenExclusiveInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceFullScreenExclusiveInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkFullScreenExclusiveEXT*)&forMarshaling->fullScreenExclusive, sizeof(VkFullScreenExclusiveEXT));
+ vkStream->write((VkFullScreenExclusiveEXT*)&forMarshaling->fullScreenExclusive,
+ sizeof(VkFullScreenExclusiveEXT));
}
void unmarshal_VkSurfaceFullScreenExclusiveInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSurfaceFullScreenExclusiveInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSurfaceFullScreenExclusiveInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkFullScreenExclusiveEXT*)&forUnmarshaling->fullScreenExclusive, sizeof(VkFullScreenExclusiveEXT));
+ vkStream->read((VkFullScreenExclusiveEXT*)&forUnmarshaling->fullScreenExclusive,
+ sizeof(VkFullScreenExclusiveEXT));
}
void marshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceCapabilitiesFullScreenExclusiveEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceCapabilitiesFullScreenExclusiveEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -24171,14 +21707,11 @@
}
void unmarshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSurfaceCapabilitiesFullScreenExclusiveEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSurfaceCapabilitiesFullScreenExclusiveEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -24186,14 +21719,11 @@
}
void marshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceFullScreenExclusiveWin32InfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceFullScreenExclusiveWin32InfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -24201,14 +21731,11 @@
}
void unmarshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSurfaceFullScreenExclusiveWin32InfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSurfaceFullScreenExclusiveWin32InfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -24217,47 +21744,38 @@
#endif
#ifdef VK_EXT_headless_surface
-void marshal_VkHeadlessSurfaceCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkHeadlessSurfaceCreateInfoEXT* forMarshaling)
-{
+void marshal_VkHeadlessSurfaceCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkHeadlessSurfaceCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkHeadlessSurfaceCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkHeadlessSurfaceCreateFlagsEXT));
+ vkStream->write((VkHeadlessSurfaceCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkHeadlessSurfaceCreateFlagsEXT));
}
-void unmarshal_VkHeadlessSurfaceCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkHeadlessSurfaceCreateInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkHeadlessSurfaceCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkHeadlessSurfaceCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkHeadlessSurfaceCreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkHeadlessSurfaceCreateFlagsEXT));
+ vkStream->read((VkHeadlessSurfaceCreateFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkHeadlessSurfaceCreateFlagsEXT));
}
#endif
#ifdef VK_EXT_line_rasterization
void marshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -24270,14 +21788,11 @@
}
void unmarshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceLineRasterizationFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceLineRasterizationFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -24290,14 +21805,11 @@
}
void marshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -24305,14 +21817,11 @@
}
void unmarshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceLineRasterizationPropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceLineRasterizationPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -24320,36 +21829,32 @@
}
void marshal_VkPipelineRasterizationLineStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationLineStateCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationLineStateCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkLineRasterizationModeEXT*)&forMarshaling->lineRasterizationMode, sizeof(VkLineRasterizationModeEXT));
+ vkStream->write((VkLineRasterizationModeEXT*)&forMarshaling->lineRasterizationMode,
+ sizeof(VkLineRasterizationModeEXT));
vkStream->write((VkBool32*)&forMarshaling->stippledLineEnable, sizeof(VkBool32));
vkStream->write((uint32_t*)&forMarshaling->lineStippleFactor, sizeof(uint32_t));
vkStream->write((uint16_t*)&forMarshaling->lineStipplePattern, sizeof(uint16_t));
}
void unmarshal_VkPipelineRasterizationLineStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineRasterizationLineStateCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineRasterizationLineStateCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkLineRasterizationModeEXT*)&forUnmarshaling->lineRasterizationMode, sizeof(VkLineRasterizationModeEXT));
+ vkStream->read((VkLineRasterizationModeEXT*)&forUnmarshaling->lineRasterizationMode,
+ sizeof(VkLineRasterizationModeEXT));
vkStream->read((VkBool32*)&forUnmarshaling->stippledLineEnable, sizeof(VkBool32));
vkStream->read((uint32_t*)&forUnmarshaling->lineStippleFactor, sizeof(uint32_t));
vkStream->read((uint16_t*)&forUnmarshaling->lineStipplePattern, sizeof(uint16_t));
@@ -24358,14 +21863,11 @@
#endif
#ifdef VK_EXT_shader_atomic_float
void marshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -24384,14 +21886,11 @@
}
void unmarshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -24414,14 +21913,11 @@
#endif
#ifdef VK_EXT_index_type_uint8
void marshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -24429,14 +21925,11 @@
}
void unmarshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceIndexTypeUint8FeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceIndexTypeUint8FeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -24446,14 +21939,11 @@
#endif
#ifdef VK_EXT_extended_dynamic_state
void marshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -24461,14 +21951,11 @@
}
void unmarshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -24478,14 +21965,11 @@
#endif
#ifdef VK_EXT_shader_atomic_float2
void marshal_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -24504,14 +21988,11 @@
}
void unmarshal_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -24532,14 +22013,11 @@
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
void marshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -24547,14 +22025,11 @@
}
void unmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -24564,14 +22039,11 @@
#endif
#ifdef VK_NV_device_generated_commands
void marshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -24581,20 +22053,20 @@
vkStream->write((uint32_t*)&forMarshaling->maxIndirectCommandsStreamCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxIndirectCommandsTokenOffset, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxIndirectCommandsStreamStride, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->minSequencesCountBufferOffsetAlignment, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->minSequencesIndexBufferOffsetAlignment, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->minIndirectCommandsBufferOffsetAlignment, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->minSequencesCountBufferOffsetAlignment,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->minSequencesIndexBufferOffsetAlignment,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->minIndirectCommandsBufferOffsetAlignment,
+ sizeof(uint32_t));
}
void unmarshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -24604,20 +22076,20 @@
vkStream->read((uint32_t*)&forUnmarshaling->maxIndirectCommandsStreamCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxIndirectCommandsTokenOffset, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxIndirectCommandsStreamStride, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->minSequencesCountBufferOffsetAlignment, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->minSequencesIndexBufferOffsetAlignment, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->minIndirectCommandsBufferOffsetAlignment, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->minSequencesCountBufferOffsetAlignment,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->minSequencesIndexBufferOffsetAlignment,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->minIndirectCommandsBufferOffsetAlignment,
+ sizeof(uint32_t));
}
void marshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -24625,14 +22097,11 @@
}
void unmarshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -24640,168 +22109,158 @@
}
void marshal_VkGraphicsShaderGroupCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGraphicsShaderGroupCreateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGraphicsShaderGroupCreateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->stageCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i)
- {
- marshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i) {
+ marshal_VkPipelineShaderStageCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
}
}
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pVertexInputState;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pVertexInputState)
- {
- marshal_VkPipelineVertexInputStateCreateInfo(vkStream, rootType, (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState));
+ if (forMarshaling->pVertexInputState) {
+ marshal_VkPipelineVertexInputStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState));
}
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pTessellationState;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pTessellationState)
- {
- marshal_VkPipelineTessellationStateCreateInfo(vkStream, rootType, (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState));
+ if (forMarshaling->pTessellationState) {
+ marshal_VkPipelineTessellationStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState));
}
}
void unmarshal_VkGraphicsShaderGroupCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkGraphicsShaderGroupCreateInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkGraphicsShaderGroupCreateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->stageCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->stageCount; ++i)
- {
- unmarshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->stageCount; ++i) {
+ unmarshal_VkPipelineShaderStageCreateInfo(
+ vkStream, rootType,
+ (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
}
}
// WARNING PTR CHECK
const VkPipelineVertexInputStateCreateInfo* check_pVertexInputState;
- check_pVertexInputState = (const VkPipelineVertexInputStateCreateInfo*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pVertexInputState)
- {
- if (!(check_pVertexInputState))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pVertexInputState inconsistent between guest and host\n");
+ check_pVertexInputState =
+ (const VkPipelineVertexInputStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pVertexInputState) {
+ if (!(check_pVertexInputState)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pVertexInputState inconsistent between guest and host\n");
}
- unmarshal_VkPipelineVertexInputStateCreateInfo(vkStream, rootType, (VkPipelineVertexInputStateCreateInfo*)(forUnmarshaling->pVertexInputState));
+ unmarshal_VkPipelineVertexInputStateCreateInfo(
+ vkStream, rootType,
+ (VkPipelineVertexInputStateCreateInfo*)(forUnmarshaling->pVertexInputState));
}
// WARNING PTR CHECK
const VkPipelineTessellationStateCreateInfo* check_pTessellationState;
- check_pTessellationState = (const VkPipelineTessellationStateCreateInfo*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pTessellationState)
- {
- if (!(check_pTessellationState))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pTessellationState inconsistent between guest and host\n");
+ check_pTessellationState =
+ (const VkPipelineTessellationStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pTessellationState) {
+ if (!(check_pTessellationState)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pTessellationState inconsistent between guest and host\n");
}
- unmarshal_VkPipelineTessellationStateCreateInfo(vkStream, rootType, (VkPipelineTessellationStateCreateInfo*)(forUnmarshaling->pTessellationState));
+ unmarshal_VkPipelineTessellationStateCreateInfo(
+ vkStream, rootType,
+ (VkPipelineTessellationStateCreateInfo*)(forUnmarshaling->pTessellationState));
}
}
void marshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGraphicsPipelineShaderGroupsCreateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGraphicsPipelineShaderGroupsCreateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->groupCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->groupCount; ++i)
- {
- marshal_VkGraphicsShaderGroupCreateInfoNV(vkStream, rootType, (const VkGraphicsShaderGroupCreateInfoNV*)(forMarshaling->pGroups + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->groupCount; ++i) {
+ marshal_VkGraphicsShaderGroupCreateInfoNV(
+ vkStream, rootType,
+ (const VkGraphicsShaderGroupCreateInfoNV*)(forMarshaling->pGroups + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->pipelineCount, sizeof(uint32_t));
- if (forMarshaling->pipelineCount)
- {
+ if (forMarshaling->pipelineCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forMarshaling->pipelineCount * 8);
- vkStream->handleMapping()->mapHandles_VkPipeline_u64(forMarshaling->pPipelines, cgen_var_0, forMarshaling->pipelineCount);
+ vkStream->handleMapping()->mapHandles_VkPipeline_u64(forMarshaling->pPipelines, cgen_var_0,
+ forMarshaling->pipelineCount);
vkStream->write((uint64_t*)cgen_var_0, forMarshaling->pipelineCount * 8);
}
}
void unmarshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkGraphicsPipelineShaderGroupsCreateInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkGraphicsPipelineShaderGroupsCreateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->groupCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->groupCount; ++i)
- {
- unmarshal_VkGraphicsShaderGroupCreateInfoNV(vkStream, rootType, (VkGraphicsShaderGroupCreateInfoNV*)(forUnmarshaling->pGroups + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->groupCount; ++i) {
+ unmarshal_VkGraphicsShaderGroupCreateInfoNV(
+ vkStream, rootType,
+ (VkGraphicsShaderGroupCreateInfoNV*)(forUnmarshaling->pGroups + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->pipelineCount, sizeof(uint32_t));
- if (forUnmarshaling->pipelineCount)
- {
+ if (forUnmarshaling->pipelineCount) {
uint64_t* cgen_var_0;
vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->pipelineCount * 8);
vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->pipelineCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_0, (VkPipeline*)forUnmarshaling->pPipelines, forUnmarshaling->pipelineCount);
+ vkStream->handleMapping()->mapHandles_u64_VkPipeline(
+ cgen_var_0, (VkPipeline*)forUnmarshaling->pPipelines, forUnmarshaling->pipelineCount);
}
}
void marshal_VkBindShaderGroupIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindShaderGroupIndirectCommandNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindShaderGroupIndirectCommandNV* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->groupIndex, sizeof(uint32_t));
}
void unmarshal_VkBindShaderGroupIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBindShaderGroupIndirectCommandNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBindShaderGroupIndirectCommandNV* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->groupIndex, sizeof(uint32_t));
}
void marshal_VkBindIndexBufferIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindIndexBufferIndirectCommandNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindIndexBufferIndirectCommandNV* forMarshaling) {
(void)rootType;
vkStream->write((VkDeviceAddress*)&forMarshaling->bufferAddress, sizeof(VkDeviceAddress));
vkStream->write((uint32_t*)&forMarshaling->size, sizeof(uint32_t));
@@ -24809,10 +22268,8 @@
}
void unmarshal_VkBindIndexBufferIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBindIndexBufferIndirectCommandNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBindIndexBufferIndirectCommandNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkDeviceAddress*)&forUnmarshaling->bufferAddress, sizeof(VkDeviceAddress));
vkStream->read((uint32_t*)&forUnmarshaling->size, sizeof(uint32_t));
@@ -24820,10 +22277,8 @@
}
void marshal_VkBindVertexBufferIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindVertexBufferIndirectCommandNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindVertexBufferIndirectCommandNV* forMarshaling) {
(void)rootType;
vkStream->write((VkDeviceAddress*)&forMarshaling->bufferAddress, sizeof(VkDeviceAddress));
vkStream->write((uint32_t*)&forMarshaling->size, sizeof(uint32_t));
@@ -24831,10 +22286,8 @@
}
void unmarshal_VkBindVertexBufferIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBindVertexBufferIndirectCommandNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBindVertexBufferIndirectCommandNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkDeviceAddress*)&forUnmarshaling->bufferAddress, sizeof(VkDeviceAddress));
vkStream->read((uint32_t*)&forUnmarshaling->size, sizeof(uint32_t));
@@ -24842,28 +22295,21 @@
}
void marshal_VkSetStateFlagsIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSetStateFlagsIndirectCommandNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSetStateFlagsIndirectCommandNV* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->data, sizeof(uint32_t));
}
-void unmarshal_VkSetStateFlagsIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSetStateFlagsIndirectCommandNV* forUnmarshaling)
-{
+void unmarshal_VkSetStateFlagsIndirectCommandNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkSetStateFlagsIndirectCommandNV* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->data, sizeof(uint32_t));
}
-void marshal_VkIndirectCommandsStreamNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkIndirectCommandsStreamNV* forMarshaling)
-{
+void marshal_VkIndirectCommandsStreamNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkIndirectCommandsStreamNV* forMarshaling) {
(void)rootType;
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
@@ -24871,269 +22317,270 @@
vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
}
-void unmarshal_VkIndirectCommandsStreamNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkIndirectCommandsStreamNV* forUnmarshaling)
-{
+void unmarshal_VkIndirectCommandsStreamNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkIndirectCommandsStreamNV* forUnmarshaling) {
(void)rootType;
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+ (VkBuffer*)&forUnmarshaling->buffer, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
}
-void marshal_VkIndirectCommandsLayoutTokenNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkIndirectCommandsLayoutTokenNV* forMarshaling)
-{
+void marshal_VkIndirectCommandsLayoutTokenNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkIndirectCommandsLayoutTokenNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkIndirectCommandsTokenTypeNV*)&forMarshaling->tokenType, sizeof(VkIndirectCommandsTokenTypeNV));
+ vkStream->write((VkIndirectCommandsTokenTypeNV*)&forMarshaling->tokenType,
+ sizeof(VkIndirectCommandsTokenTypeNV));
vkStream->write((uint32_t*)&forMarshaling->stream, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->offset, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->vertexBindingUnit, sizeof(uint32_t));
vkStream->write((VkBool32*)&forMarshaling->vertexDynamicStride, sizeof(VkBool32));
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pushconstantPipelineLayout, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(
+ &forMarshaling->pushconstantPipelineLayout, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->write((VkShaderStageFlags*)&forMarshaling->pushconstantShaderStageFlags, sizeof(VkShaderStageFlags));
+ vkStream->write((VkShaderStageFlags*)&forMarshaling->pushconstantShaderStageFlags,
+ sizeof(VkShaderStageFlags));
vkStream->write((uint32_t*)&forMarshaling->pushconstantOffset, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->pushconstantSize, sizeof(uint32_t));
- vkStream->write((VkIndirectStateFlagsNV*)&forMarshaling->indirectStateFlags, sizeof(VkIndirectStateFlagsNV));
+ vkStream->write((VkIndirectStateFlagsNV*)&forMarshaling->indirectStateFlags,
+ sizeof(VkIndirectStateFlagsNV));
vkStream->write((uint32_t*)&forMarshaling->indexTypeCount, sizeof(uint32_t));
- vkStream->write((const VkIndexType*)forMarshaling->pIndexTypes, forMarshaling->indexTypeCount * sizeof(const VkIndexType));
- vkStream->write((const uint32_t*)forMarshaling->pIndexTypeValues, forMarshaling->indexTypeCount * sizeof(const uint32_t));
+ vkStream->write((const VkIndexType*)forMarshaling->pIndexTypes,
+ forMarshaling->indexTypeCount * sizeof(const VkIndexType));
+ vkStream->write((const uint32_t*)forMarshaling->pIndexTypeValues,
+ forMarshaling->indexTypeCount * sizeof(const uint32_t));
}
-void unmarshal_VkIndirectCommandsLayoutTokenNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkIndirectCommandsLayoutTokenNV* forUnmarshaling)
-{
+void unmarshal_VkIndirectCommandsLayoutTokenNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkIndirectCommandsLayoutTokenNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkIndirectCommandsTokenTypeNV*)&forUnmarshaling->tokenType, sizeof(VkIndirectCommandsTokenTypeNV));
+ vkStream->read((VkIndirectCommandsTokenTypeNV*)&forUnmarshaling->tokenType,
+ sizeof(VkIndirectCommandsTokenTypeNV));
vkStream->read((uint32_t*)&forUnmarshaling->stream, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->offset, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->vertexBindingUnit, sizeof(uint32_t));
vkStream->read((VkBool32*)&forUnmarshaling->vertexDynamicStride, sizeof(VkBool32));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_0, (VkPipelineLayout*)&forUnmarshaling->pushconstantPipelineLayout, 1);
- vkStream->read((VkShaderStageFlags*)&forUnmarshaling->pushconstantShaderStageFlags, sizeof(VkShaderStageFlags));
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(
+ &cgen_var_0, (VkPipelineLayout*)&forUnmarshaling->pushconstantPipelineLayout, 1);
+ vkStream->read((VkShaderStageFlags*)&forUnmarshaling->pushconstantShaderStageFlags,
+ sizeof(VkShaderStageFlags));
vkStream->read((uint32_t*)&forUnmarshaling->pushconstantOffset, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->pushconstantSize, sizeof(uint32_t));
- vkStream->read((VkIndirectStateFlagsNV*)&forUnmarshaling->indirectStateFlags, sizeof(VkIndirectStateFlagsNV));
+ vkStream->read((VkIndirectStateFlagsNV*)&forUnmarshaling->indirectStateFlags,
+ sizeof(VkIndirectStateFlagsNV));
vkStream->read((uint32_t*)&forUnmarshaling->indexTypeCount, sizeof(uint32_t));
- vkStream->read((VkIndexType*)forUnmarshaling->pIndexTypes, forUnmarshaling->indexTypeCount * sizeof(const VkIndexType));
- vkStream->read((uint32_t*)forUnmarshaling->pIndexTypeValues, forUnmarshaling->indexTypeCount * sizeof(const uint32_t));
+ vkStream->read((VkIndexType*)forUnmarshaling->pIndexTypes,
+ forUnmarshaling->indexTypeCount * sizeof(const VkIndexType));
+ vkStream->read((uint32_t*)forUnmarshaling->pIndexTypeValues,
+ forUnmarshaling->indexTypeCount * sizeof(const uint32_t));
}
void marshal_VkIndirectCommandsLayoutCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkIndirectCommandsLayoutCreateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkIndirectCommandsLayoutCreateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkIndirectCommandsLayoutUsageFlagsNV*)&forMarshaling->flags, sizeof(VkIndirectCommandsLayoutUsageFlagsNV));
- vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ vkStream->write((VkIndirectCommandsLayoutUsageFlagsNV*)&forMarshaling->flags,
+ sizeof(VkIndirectCommandsLayoutUsageFlagsNV));
+ vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
vkStream->write((uint32_t*)&forMarshaling->tokenCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->tokenCount; ++i)
- {
- marshal_VkIndirectCommandsLayoutTokenNV(vkStream, rootType, (const VkIndirectCommandsLayoutTokenNV*)(forMarshaling->pTokens + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->tokenCount; ++i) {
+ marshal_VkIndirectCommandsLayoutTokenNV(
+ vkStream, rootType,
+ (const VkIndirectCommandsLayoutTokenNV*)(forMarshaling->pTokens + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->streamCount, sizeof(uint32_t));
- vkStream->write((const uint32_t*)forMarshaling->pStreamStrides, forMarshaling->streamCount * sizeof(const uint32_t));
+ vkStream->write((const uint32_t*)forMarshaling->pStreamStrides,
+ forMarshaling->streamCount * sizeof(const uint32_t));
}
void unmarshal_VkIndirectCommandsLayoutCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkIndirectCommandsLayoutCreateInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkIndirectCommandsLayoutCreateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkIndirectCommandsLayoutUsageFlagsNV*)&forUnmarshaling->flags, sizeof(VkIndirectCommandsLayoutUsageFlagsNV));
- vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ vkStream->read((VkIndirectCommandsLayoutUsageFlagsNV*)&forUnmarshaling->flags,
+ sizeof(VkIndirectCommandsLayoutUsageFlagsNV));
+ vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
vkStream->read((uint32_t*)&forUnmarshaling->tokenCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->tokenCount; ++i)
- {
- unmarshal_VkIndirectCommandsLayoutTokenNV(vkStream, rootType, (VkIndirectCommandsLayoutTokenNV*)(forUnmarshaling->pTokens + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->tokenCount; ++i) {
+ unmarshal_VkIndirectCommandsLayoutTokenNV(
+ vkStream, rootType,
+ (VkIndirectCommandsLayoutTokenNV*)(forUnmarshaling->pTokens + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->streamCount, sizeof(uint32_t));
- vkStream->read((uint32_t*)forUnmarshaling->pStreamStrides, forUnmarshaling->streamCount * sizeof(const uint32_t));
+ vkStream->read((uint32_t*)forUnmarshaling->pStreamStrides,
+ forUnmarshaling->streamCount * sizeof(const uint32_t));
}
-void marshal_VkGeneratedCommandsInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeneratedCommandsInfoNV* forMarshaling)
-{
+void marshal_VkGeneratedCommandsInfoNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeneratedCommandsInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->pipeline, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
uint64_t cgen_var_1;
- vkStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNV_u64(&forMarshaling->indirectCommandsLayout, &cgen_var_1, 1);
+ vkStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNV_u64(
+ &forMarshaling->indirectCommandsLayout, &cgen_var_1, 1);
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->streamCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->streamCount; ++i)
- {
- marshal_VkIndirectCommandsStreamNV(vkStream, rootType, (const VkIndirectCommandsStreamNV*)(forMarshaling->pStreams + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->streamCount; ++i) {
+ marshal_VkIndirectCommandsStreamNV(
+ vkStream, rootType,
+ (const VkIndirectCommandsStreamNV*)(forMarshaling->pStreams + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->sequencesCount, sizeof(uint32_t));
uint64_t cgen_var_2;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->preprocessBuffer, &cgen_var_2, 1);
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->preprocessBuffer,
+ &cgen_var_2, 1);
vkStream->write((uint64_t*)&cgen_var_2, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->preprocessOffset, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->preprocessSize, sizeof(VkDeviceSize));
uint64_t cgen_var_3;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->sequencesCountBuffer, &cgen_var_3, 1);
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->sequencesCountBuffer,
+ &cgen_var_3, 1);
vkStream->write((uint64_t*)&cgen_var_3, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->sequencesCountOffset, sizeof(VkDeviceSize));
uint64_t cgen_var_4;
- vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->sequencesIndexBuffer, &cgen_var_4, 1);
+ vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->sequencesIndexBuffer,
+ &cgen_var_4, 1);
vkStream->write((uint64_t*)&cgen_var_4, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->sequencesIndexOffset, sizeof(VkDeviceSize));
}
-void unmarshal_VkGeneratedCommandsInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkGeneratedCommandsInfoNV* forUnmarshaling)
-{
+void unmarshal_VkGeneratedCommandsInfoNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkGeneratedCommandsInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_0, (VkPipeline*)&forUnmarshaling->pipeline, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkPipeline(
+ &cgen_var_0, (VkPipeline*)&forUnmarshaling->pipeline, 1);
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNV(&cgen_var_1, (VkIndirectCommandsLayoutNV*)&forUnmarshaling->indirectCommandsLayout, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNV(
+ &cgen_var_1, (VkIndirectCommandsLayoutNV*)&forUnmarshaling->indirectCommandsLayout, 1);
vkStream->read((uint32_t*)&forUnmarshaling->streamCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->streamCount; ++i)
- {
- unmarshal_VkIndirectCommandsStreamNV(vkStream, rootType, (VkIndirectCommandsStreamNV*)(forUnmarshaling->pStreams + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->streamCount; ++i) {
+ unmarshal_VkIndirectCommandsStreamNV(
+ vkStream, rootType, (VkIndirectCommandsStreamNV*)(forUnmarshaling->pStreams + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->sequencesCount, sizeof(uint32_t));
uint64_t cgen_var_2;
vkStream->read((uint64_t*)&cgen_var_2, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_2, (VkBuffer*)&forUnmarshaling->preprocessBuffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(
+ &cgen_var_2, (VkBuffer*)&forUnmarshaling->preprocessBuffer, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->preprocessOffset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->preprocessSize, sizeof(VkDeviceSize));
uint64_t cgen_var_3;
vkStream->read((uint64_t*)&cgen_var_3, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_3, (VkBuffer*)&forUnmarshaling->sequencesCountBuffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(
+ &cgen_var_3, (VkBuffer*)&forUnmarshaling->sequencesCountBuffer, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->sequencesCountOffset, sizeof(VkDeviceSize));
uint64_t cgen_var_4;
vkStream->read((uint64_t*)&cgen_var_4, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_4, (VkBuffer*)&forUnmarshaling->sequencesIndexBuffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(
+ &cgen_var_4, (VkBuffer*)&forUnmarshaling->sequencesIndexBuffer, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->sequencesIndexOffset, sizeof(VkDeviceSize));
}
void marshal_VkGeneratedCommandsMemoryRequirementsInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeneratedCommandsMemoryRequirementsInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeneratedCommandsMemoryRequirementsInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->pipeline, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
uint64_t cgen_var_1;
- vkStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNV_u64(&forMarshaling->indirectCommandsLayout, &cgen_var_1, 1);
+ vkStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNV_u64(
+ &forMarshaling->indirectCommandsLayout, &cgen_var_1, 1);
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->maxSequencesCount, sizeof(uint32_t));
}
void unmarshal_VkGeneratedCommandsMemoryRequirementsInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkGeneratedCommandsMemoryRequirementsInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkGeneratedCommandsMemoryRequirementsInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_0, (VkPipeline*)&forUnmarshaling->pipeline, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkPipeline(
+ &cgen_var_0, (VkPipeline*)&forUnmarshaling->pipeline, 1);
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNV(&cgen_var_1, (VkIndirectCommandsLayoutNV*)&forUnmarshaling->indirectCommandsLayout, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNV(
+ &cgen_var_1, (VkIndirectCommandsLayoutNV*)&forUnmarshaling->indirectCommandsLayout, 1);
vkStream->read((uint32_t*)&forUnmarshaling->maxSequencesCount, sizeof(uint32_t));
}
#endif
#ifdef VK_NV_inherited_viewport_scissor
void marshal_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -25141,14 +22588,11 @@
}
void unmarshal_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceInheritedViewportScissorFeaturesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceInheritedViewportScissorFeaturesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -25156,14 +22600,11 @@
}
void marshal_VkCommandBufferInheritanceViewportScissorInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferInheritanceViewportScissorInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferInheritanceViewportScissorInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -25172,21 +22613,17 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pViewportDepths;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pViewportDepths)
- {
+ if (forMarshaling->pViewportDepths) {
marshal_VkViewport(vkStream, rootType, (const VkViewport*)(forMarshaling->pViewportDepths));
}
}
void unmarshal_VkCommandBufferInheritanceViewportScissorInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCommandBufferInheritanceViewportScissorInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCommandBufferInheritanceViewportScissorInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -25195,11 +22632,11 @@
// WARNING PTR CHECK
const VkViewport* check_pViewportDepths;
check_pViewportDepths = (const VkViewport*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pViewportDepths)
- {
- if (!(check_pViewportDepths))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pViewportDepths inconsistent between guest and host\n");
+ if (forUnmarshaling->pViewportDepths) {
+ if (!(check_pViewportDepths)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pViewportDepths inconsistent between guest and host\n");
}
unmarshal_VkViewport(vkStream, rootType, (VkViewport*)(forUnmarshaling->pViewportDepths));
}
@@ -25208,14 +22645,11 @@
#endif
#ifdef VK_EXT_texel_buffer_alignment
void marshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -25223,14 +22657,11 @@
}
void unmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -25238,116 +22669,107 @@
}
void marshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDeviceSize*)&forMarshaling->storageTexelBufferOffsetAlignmentBytes, sizeof(VkDeviceSize));
- vkStream->write((VkBool32*)&forMarshaling->storageTexelBufferOffsetSingleTexelAlignment, sizeof(VkBool32));
- vkStream->write((VkDeviceSize*)&forMarshaling->uniformTexelBufferOffsetAlignmentBytes, sizeof(VkDeviceSize));
- vkStream->write((VkBool32*)&forMarshaling->uniformTexelBufferOffsetSingleTexelAlignment, sizeof(VkBool32));
+ vkStream->write((VkDeviceSize*)&forMarshaling->storageTexelBufferOffsetAlignmentBytes,
+ sizeof(VkDeviceSize));
+ vkStream->write((VkBool32*)&forMarshaling->storageTexelBufferOffsetSingleTexelAlignment,
+ sizeof(VkBool32));
+ vkStream->write((VkDeviceSize*)&forMarshaling->uniformTexelBufferOffsetAlignmentBytes,
+ sizeof(VkDeviceSize));
+ vkStream->write((VkBool32*)&forMarshaling->uniformTexelBufferOffsetSingleTexelAlignment,
+ sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDeviceSize*)&forUnmarshaling->storageTexelBufferOffsetAlignmentBytes, sizeof(VkDeviceSize));
- vkStream->read((VkBool32*)&forUnmarshaling->storageTexelBufferOffsetSingleTexelAlignment, sizeof(VkBool32));
- vkStream->read((VkDeviceSize*)&forUnmarshaling->uniformTexelBufferOffsetAlignmentBytes, sizeof(VkDeviceSize));
- vkStream->read((VkBool32*)&forUnmarshaling->uniformTexelBufferOffsetSingleTexelAlignment, sizeof(VkBool32));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->storageTexelBufferOffsetAlignmentBytes,
+ sizeof(VkDeviceSize));
+ vkStream->read((VkBool32*)&forUnmarshaling->storageTexelBufferOffsetSingleTexelAlignment,
+ sizeof(VkBool32));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->uniformTexelBufferOffsetAlignmentBytes,
+ sizeof(VkDeviceSize));
+ vkStream->read((VkBool32*)&forUnmarshaling->uniformTexelBufferOffsetSingleTexelAlignment,
+ sizeof(VkBool32));
}
#endif
#ifdef VK_QCOM_render_pass_transform
void marshal_VkRenderPassTransformBeginInfoQCOM(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassTransformBeginInfoQCOM* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassTransformBeginInfoQCOM* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
}
void unmarshal_VkRenderPassTransformBeginInfoQCOM(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRenderPassTransformBeginInfoQCOM* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderPassTransformBeginInfoQCOM* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->transform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
}
void marshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
marshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->renderArea));
}
void unmarshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCommandBufferInheritanceRenderPassTransformInfoQCOM* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCommandBufferInheritanceRenderPassTransformInfoQCOM* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->transform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forUnmarshaling->renderArea));
}
#endif
#ifdef VK_EXT_device_memory_report
void marshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -25355,14 +22777,11 @@
}
void unmarshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -25370,19 +22789,18 @@
}
void marshal_VkDeviceMemoryReportCallbackDataEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceMemoryReportCallbackDataEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceMemoryReportCallbackDataEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDeviceMemoryReportFlagsEXT*)&forMarshaling->flags, sizeof(VkDeviceMemoryReportFlagsEXT));
- vkStream->write((VkDeviceMemoryReportEventTypeEXT*)&forMarshaling->type, sizeof(VkDeviceMemoryReportEventTypeEXT));
+ vkStream->write((VkDeviceMemoryReportFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkDeviceMemoryReportFlagsEXT));
+ vkStream->write((VkDeviceMemoryReportEventTypeEXT*)&forMarshaling->type,
+ sizeof(VkDeviceMemoryReportEventTypeEXT));
vkStream->write((uint64_t*)&forMarshaling->memoryObjectId, sizeof(uint64_t));
vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
vkStream->write((VkObjectType*)&forMarshaling->objectType, sizeof(VkObjectType));
@@ -25391,19 +22809,18 @@
}
void unmarshal_VkDeviceMemoryReportCallbackDataEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceMemoryReportCallbackDataEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceMemoryReportCallbackDataEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDeviceMemoryReportFlagsEXT*)&forUnmarshaling->flags, sizeof(VkDeviceMemoryReportFlagsEXT));
- vkStream->read((VkDeviceMemoryReportEventTypeEXT*)&forUnmarshaling->type, sizeof(VkDeviceMemoryReportEventTypeEXT));
+ vkStream->read((VkDeviceMemoryReportFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkDeviceMemoryReportFlagsEXT));
+ vkStream->read((VkDeviceMemoryReportEventTypeEXT*)&forUnmarshaling->type,
+ sizeof(VkDeviceMemoryReportEventTypeEXT));
vkStream->read((uint64_t*)&forUnmarshaling->memoryObjectId, sizeof(uint64_t));
vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
vkStream->read((VkObjectType*)&forUnmarshaling->objectType, sizeof(VkObjectType));
@@ -25412,36 +22829,32 @@
}
void marshal_VkDeviceDeviceMemoryReportCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceDeviceMemoryReportCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceDeviceMemoryReportCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDeviceMemoryReportFlagsEXT*)&forMarshaling->flags, sizeof(VkDeviceMemoryReportFlagsEXT));
+ vkStream->write((VkDeviceMemoryReportFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkDeviceMemoryReportFlagsEXT));
uint64_t cgen_var_0 = (uint64_t)forMarshaling->pfnUserCallback;
vkStream->putBe64(cgen_var_0);
vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
}
void unmarshal_VkDeviceDeviceMemoryReportCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceDeviceMemoryReportCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceDeviceMemoryReportCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDeviceMemoryReportFlagsEXT*)&forUnmarshaling->flags, sizeof(VkDeviceMemoryReportFlagsEXT));
+ vkStream->read((VkDeviceMemoryReportFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkDeviceMemoryReportFlagsEXT));
forUnmarshaling->pfnUserCallback = (PFN_vkDeviceMemoryReportCallbackEXT)vkStream->getBe64();
vkStream->read((void*)forUnmarshaling->pUserData, sizeof(uint8_t));
}
@@ -25451,14 +22864,11 @@
#endif
#ifdef VK_EXT_robustness2
void marshal_VkPhysicalDeviceRobustness2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRobustness2FeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRobustness2FeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -25468,14 +22878,11 @@
}
void unmarshal_VkPhysicalDeviceRobustness2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceRobustness2FeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceRobustness2FeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -25485,80 +22892,71 @@
}
void marshal_VkPhysicalDeviceRobustness2PropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRobustness2PropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRobustness2PropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDeviceSize*)&forMarshaling->robustStorageBufferAccessSizeAlignment, sizeof(VkDeviceSize));
- vkStream->write((VkDeviceSize*)&forMarshaling->robustUniformBufferAccessSizeAlignment, sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->robustStorageBufferAccessSizeAlignment,
+ sizeof(VkDeviceSize));
+ vkStream->write((VkDeviceSize*)&forMarshaling->robustUniformBufferAccessSizeAlignment,
+ sizeof(VkDeviceSize));
}
void unmarshal_VkPhysicalDeviceRobustness2PropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceRobustness2PropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceRobustness2PropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDeviceSize*)&forUnmarshaling->robustStorageBufferAccessSizeAlignment, sizeof(VkDeviceSize));
- vkStream->read((VkDeviceSize*)&forUnmarshaling->robustUniformBufferAccessSizeAlignment, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->robustStorageBufferAccessSizeAlignment,
+ sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->robustUniformBufferAccessSizeAlignment,
+ sizeof(VkDeviceSize));
}
#endif
#ifdef VK_EXT_custom_border_color
void marshal_VkSamplerCustomBorderColorCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerCustomBorderColorCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerCustomBorderColorCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkClearColorValue(vkStream, rootType, (VkClearColorValue*)(&forMarshaling->customBorderColor));
+ marshal_VkClearColorValue(vkStream, rootType,
+ (VkClearColorValue*)(&forMarshaling->customBorderColor));
vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
}
void unmarshal_VkSamplerCustomBorderColorCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSamplerCustomBorderColorCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSamplerCustomBorderColorCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkClearColorValue(vkStream, rootType, (VkClearColorValue*)(&forUnmarshaling->customBorderColor));
+ unmarshal_VkClearColorValue(vkStream, rootType,
+ (VkClearColorValue*)(&forUnmarshaling->customBorderColor));
vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
}
void marshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCustomBorderColorPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCustomBorderColorPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -25566,14 +22964,11 @@
}
void unmarshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceCustomBorderColorPropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceCustomBorderColorPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -25581,14 +22976,11 @@
}
void marshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCustomBorderColorFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCustomBorderColorFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -25597,14 +22989,11 @@
}
void unmarshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceCustomBorderColorFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceCustomBorderColorFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -25617,14 +23006,11 @@
#endif
#ifdef VK_EXT_private_data
void marshal_VkPhysicalDevicePrivateDataFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePrivateDataFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePrivateDataFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -25632,14 +23018,11 @@
}
void unmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDevicePrivateDataFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePrivateDataFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -25647,76 +23030,61 @@
}
void marshal_VkDevicePrivateDataCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDevicePrivateDataCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDevicePrivateDataCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->privateDataSlotRequestCount, sizeof(uint32_t));
}
-void unmarshal_VkDevicePrivateDataCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDevicePrivateDataCreateInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkDevicePrivateDataCreateInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkDevicePrivateDataCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->privateDataSlotRequestCount, sizeof(uint32_t));
}
-void marshal_VkPrivateDataSlotCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPrivateDataSlotCreateInfoEXT* forMarshaling)
-{
+void marshal_VkPrivateDataSlotCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPrivateDataSlotCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkPrivateDataSlotCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkPrivateDataSlotCreateFlagsEXT));
+ vkStream->write((VkPrivateDataSlotCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkPrivateDataSlotCreateFlagsEXT));
}
-void unmarshal_VkPrivateDataSlotCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPrivateDataSlotCreateInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkPrivateDataSlotCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPrivateDataSlotCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkPrivateDataSlotCreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkPrivateDataSlotCreateFlagsEXT));
+ vkStream->read((VkPrivateDataSlotCreateFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkPrivateDataSlotCreateFlagsEXT));
}
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
void marshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -25724,14 +23092,11 @@
}
void unmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -25741,14 +23106,11 @@
#endif
#ifdef VK_NV_device_diagnostics_config
void marshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -25756,14 +23118,11 @@
}
void unmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -25771,33 +23130,29 @@
}
void marshal_VkDeviceDiagnosticsConfigCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceDiagnosticsConfigCreateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceDiagnosticsConfigCreateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDeviceDiagnosticsConfigFlagsNV*)&forMarshaling->flags, sizeof(VkDeviceDiagnosticsConfigFlagsNV));
+ vkStream->write((VkDeviceDiagnosticsConfigFlagsNV*)&forMarshaling->flags,
+ sizeof(VkDeviceDiagnosticsConfigFlagsNV));
}
void unmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceDiagnosticsConfigCreateInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceDiagnosticsConfigCreateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDeviceDiagnosticsConfigFlagsNV*)&forUnmarshaling->flags, sizeof(VkDeviceDiagnosticsConfigFlagsNV));
+ vkStream->read((VkDeviceDiagnosticsConfigFlagsNV*)&forUnmarshaling->flags,
+ sizeof(VkDeviceDiagnosticsConfigFlagsNV));
}
#endif
@@ -25805,14 +23160,11 @@
#endif
#ifdef VK_NV_fragment_shading_rate_enums
void marshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -25822,14 +23174,11 @@
}
void unmarshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -25839,204 +23188,185 @@
}
void marshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkSampleCountFlagBits*)&forMarshaling->maxFragmentShadingRateInvocationCount, sizeof(VkSampleCountFlagBits));
+ vkStream->write((VkSampleCountFlagBits*)&forMarshaling->maxFragmentShadingRateInvocationCount,
+ sizeof(VkSampleCountFlagBits));
}
void unmarshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->maxFragmentShadingRateInvocationCount, sizeof(VkSampleCountFlagBits));
+ vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->maxFragmentShadingRateInvocationCount,
+ sizeof(VkSampleCountFlagBits));
}
void marshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkFragmentShadingRateTypeNV*)&forMarshaling->shadingRateType, sizeof(VkFragmentShadingRateTypeNV));
- vkStream->write((VkFragmentShadingRateNV*)&forMarshaling->shadingRate, sizeof(VkFragmentShadingRateNV));
- vkStream->write((VkFragmentShadingRateCombinerOpKHR*)forMarshaling->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
+ vkStream->write((VkFragmentShadingRateTypeNV*)&forMarshaling->shadingRateType,
+ sizeof(VkFragmentShadingRateTypeNV));
+ vkStream->write((VkFragmentShadingRateNV*)&forMarshaling->shadingRate,
+ sizeof(VkFragmentShadingRateNV));
+ vkStream->write((VkFragmentShadingRateCombinerOpKHR*)forMarshaling->combinerOps,
+ 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
}
void unmarshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineFragmentShadingRateEnumStateCreateInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineFragmentShadingRateEnumStateCreateInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkFragmentShadingRateTypeNV*)&forUnmarshaling->shadingRateType, sizeof(VkFragmentShadingRateTypeNV));
- vkStream->read((VkFragmentShadingRateNV*)&forUnmarshaling->shadingRate, sizeof(VkFragmentShadingRateNV));
- vkStream->read((VkFragmentShadingRateCombinerOpKHR*)forUnmarshaling->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
+ vkStream->read((VkFragmentShadingRateTypeNV*)&forUnmarshaling->shadingRateType,
+ sizeof(VkFragmentShadingRateTypeNV));
+ vkStream->read((VkFragmentShadingRateNV*)&forUnmarshaling->shadingRate,
+ sizeof(VkFragmentShadingRateNV));
+ vkStream->read((VkFragmentShadingRateCombinerOpKHR*)forUnmarshaling->combinerOps,
+ 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
}
#endif
#ifdef VK_NV_ray_tracing_motion_blur
-void marshal_VkDeviceOrHostAddressConstKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceOrHostAddressConstKHR* forMarshaling)
-{
+void marshal_VkDeviceOrHostAddressConstKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceOrHostAddressConstKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
}
-void unmarshal_VkDeviceOrHostAddressConstKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceOrHostAddressConstKHR* forUnmarshaling)
-{
+void unmarshal_VkDeviceOrHostAddressConstKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceOrHostAddressConstKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkDeviceAddress*)&forUnmarshaling->deviceAddress, sizeof(VkDeviceAddress));
}
void marshal_VkAccelerationStructureGeometryMotionTrianglesDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryMotionTrianglesDataNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureGeometryMotionTrianglesDataNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->vertexData));
+ marshal_VkDeviceOrHostAddressConstKHR(
+ vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->vertexData));
}
void unmarshal_VkAccelerationStructureGeometryMotionTrianglesDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureGeometryMotionTrianglesDataNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureGeometryMotionTrianglesDataNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->vertexData));
+ unmarshal_VkDeviceOrHostAddressConstKHR(
+ vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->vertexData));
}
void marshal_VkAccelerationStructureMotionInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureMotionInfoNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureMotionInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->maxInstances, sizeof(uint32_t));
- vkStream->write((VkAccelerationStructureMotionInfoFlagsNV*)&forMarshaling->flags, sizeof(VkAccelerationStructureMotionInfoFlagsNV));
+ vkStream->write((VkAccelerationStructureMotionInfoFlagsNV*)&forMarshaling->flags,
+ sizeof(VkAccelerationStructureMotionInfoFlagsNV));
}
void unmarshal_VkAccelerationStructureMotionInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureMotionInfoNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureMotionInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->maxInstances, sizeof(uint32_t));
- vkStream->read((VkAccelerationStructureMotionInfoFlagsNV*)&forUnmarshaling->flags, sizeof(VkAccelerationStructureMotionInfoFlagsNV));
+ vkStream->read((VkAccelerationStructureMotionInfoFlagsNV*)&forUnmarshaling->flags,
+ sizeof(VkAccelerationStructureMotionInfoFlagsNV));
}
void marshal_VkAccelerationStructureMatrixMotionInstanceNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureMatrixMotionInstanceNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureMatrixMotionInstanceNV* forMarshaling) {
(void)rootType;
-
+
typedef struct VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields {
- VkTransformMatrixKHR transformT0;
- VkTransformMatrixKHR transformT1;
- uint32_t dwords[2];
- uint64_t accelerationStructureReference;
+ VkTransformMatrixKHR transformT0;
+ VkTransformMatrixKHR transformT1;
+ uint32_t dwords[2];
+ uint64_t accelerationStructureReference;
} VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields;
-
- const VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields* forMarshaling_new = (const VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields*)(forMarshaling);
- marshal_VkTransformMatrixKHR(vkStream, rootType, (VkTransformMatrixKHR*)(&forMarshaling_new->transformT0));
- marshal_VkTransformMatrixKHR(vkStream, rootType, (VkTransformMatrixKHR*)(&forMarshaling_new->transformT1));
+
+ const VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields* forMarshaling_new =
+ (const VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields*)(forMarshaling);
+ marshal_VkTransformMatrixKHR(vkStream, rootType,
+ (VkTransformMatrixKHR*)(&forMarshaling_new->transformT0));
+ marshal_VkTransformMatrixKHR(vkStream, rootType,
+ (VkTransformMatrixKHR*)(&forMarshaling_new->transformT1));
for (uint32_t i = 0; i < 2; i++) {
vkStream->write((uint32_t*)&(forMarshaling_new->dwords[i]), sizeof(uint32_t));
}
- vkStream->write((uint64_t*)&forMarshaling_new->accelerationStructureReference, sizeof(uint64_t));
-
+ vkStream->write((uint64_t*)&forMarshaling_new->accelerationStructureReference,
+ sizeof(uint64_t));
}
void unmarshal_VkAccelerationStructureMatrixMotionInstanceNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureMatrixMotionInstanceNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureMatrixMotionInstanceNV* forUnmarshaling) {
(void)rootType;
-
+
typedef struct VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields {
- VkTransformMatrixKHR transformT0;
- VkTransformMatrixKHR transformT1;
- uint32_t dwords[2];
- uint64_t accelerationStructureReference;
+ VkTransformMatrixKHR transformT0;
+ VkTransformMatrixKHR transformT1;
+ uint32_t dwords[2];
+ uint64_t accelerationStructureReference;
} VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields;
-
- VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields* forUnmarshaling_new = (VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields*)(forUnmarshaling);
- unmarshal_VkTransformMatrixKHR(vkStream, rootType, (VkTransformMatrixKHR*)(&forUnmarshaling_new->transformT0));
- unmarshal_VkTransformMatrixKHR(vkStream, rootType, (VkTransformMatrixKHR*)(&forUnmarshaling_new->transformT1));
+
+ VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields* forUnmarshaling_new =
+ (VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields*)(forUnmarshaling);
+ unmarshal_VkTransformMatrixKHR(vkStream, rootType,
+ (VkTransformMatrixKHR*)(&forUnmarshaling_new->transformT0));
+ unmarshal_VkTransformMatrixKHR(vkStream, rootType,
+ (VkTransformMatrixKHR*)(&forUnmarshaling_new->transformT1));
for (uint32_t i = 0; i < 2; i++) {
vkStream->read((uint32_t*)&(forUnmarshaling_new->dwords[i]), sizeof(uint32_t));
}
- vkStream->read((uint64_t*)&forUnmarshaling_new->accelerationStructureReference, sizeof(uint64_t));
-
+ vkStream->read((uint64_t*)&forUnmarshaling_new->accelerationStructureReference,
+ sizeof(uint64_t));
}
-void marshal_VkSRTDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSRTDataNV* forMarshaling)
-{
+void marshal_VkSRTDataNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSRTDataNV* forMarshaling) {
(void)rootType;
vkStream->write((float*)&forMarshaling->sx, sizeof(float));
vkStream->write((float*)&forMarshaling->a, sizeof(float));
@@ -26056,11 +23386,8 @@
vkStream->write((float*)&forMarshaling->tz, sizeof(float));
}
-void unmarshal_VkSRTDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSRTDataNV* forUnmarshaling)
-{
+void unmarshal_VkSRTDataNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSRTDataNV* forUnmarshaling) {
(void)rootType;
vkStream->read((float*)&forUnmarshaling->sx, sizeof(float));
vkStream->read((float*)&forUnmarshaling->a, sizeof(float));
@@ -26081,136 +23408,128 @@
}
void marshal_VkAccelerationStructureSRTMotionInstanceNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureSRTMotionInstanceNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureSRTMotionInstanceNV* forMarshaling) {
(void)rootType;
-
+
typedef struct VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields {
- VkSRTDataNV transformT0;
- VkSRTDataNV transformT1;
- uint32_t dwords[2];
- uint64_t accelerationStructureReference;
+ VkSRTDataNV transformT0;
+ VkSRTDataNV transformT1;
+ uint32_t dwords[2];
+ uint64_t accelerationStructureReference;
} VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields;
-
- const VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields* forMarshaling_new = (const VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields*)(forMarshaling);
+
+ const VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields* forMarshaling_new =
+ (const VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields*)(forMarshaling);
marshal_VkSRTDataNV(vkStream, rootType, (VkSRTDataNV*)(&forMarshaling_new->transformT0));
marshal_VkSRTDataNV(vkStream, rootType, (VkSRTDataNV*)(&forMarshaling_new->transformT1));
for (uint32_t i = 0; i < 2; i++) {
vkStream->write((uint32_t*)&(forMarshaling_new->dwords[i]), sizeof(uint32_t));
}
- vkStream->write((uint64_t*)&forMarshaling_new->accelerationStructureReference, sizeof(uint64_t));
-
+ vkStream->write((uint64_t*)&forMarshaling_new->accelerationStructureReference,
+ sizeof(uint64_t));
}
void unmarshal_VkAccelerationStructureSRTMotionInstanceNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureSRTMotionInstanceNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureSRTMotionInstanceNV* forUnmarshaling) {
(void)rootType;
-
+
typedef struct VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields {
- VkSRTDataNV transformT0;
- VkSRTDataNV transformT1;
- uint32_t dwords[2];
- uint64_t accelerationStructureReference;
+ VkSRTDataNV transformT0;
+ VkSRTDataNV transformT1;
+ uint32_t dwords[2];
+ uint64_t accelerationStructureReference;
} VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields;
-
- VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields* forUnmarshaling_new = (VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields*)(forUnmarshaling);
+
+ VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields* forUnmarshaling_new =
+ (VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields*)(forUnmarshaling);
unmarshal_VkSRTDataNV(vkStream, rootType, (VkSRTDataNV*)(&forUnmarshaling_new->transformT0));
unmarshal_VkSRTDataNV(vkStream, rootType, (VkSRTDataNV*)(&forUnmarshaling_new->transformT1));
for (uint32_t i = 0; i < 2; i++) {
vkStream->read((uint32_t*)&(forUnmarshaling_new->dwords[i]), sizeof(uint32_t));
}
- vkStream->read((uint64_t*)&forUnmarshaling_new->accelerationStructureReference, sizeof(uint64_t));
-
+ vkStream->read((uint64_t*)&forUnmarshaling_new->accelerationStructureReference,
+ sizeof(uint64_t));
}
void marshal_VkAccelerationStructureMotionInstanceDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureMotionInstanceDataNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureMotionInstanceDataNV* forMarshaling) {
(void)rootType;
- marshal_VkAccelerationStructureInstanceKHR(vkStream, rootType, (VkAccelerationStructureInstanceKHR*)(&forMarshaling->staticInstance));
+ marshal_VkAccelerationStructureInstanceKHR(
+ vkStream, rootType, (VkAccelerationStructureInstanceKHR*)(&forMarshaling->staticInstance));
}
void unmarshal_VkAccelerationStructureMotionInstanceDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureMotionInstanceDataNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureMotionInstanceDataNV* forUnmarshaling) {
(void)rootType;
- unmarshal_VkAccelerationStructureInstanceKHR(vkStream, rootType, (VkAccelerationStructureInstanceKHR*)(&forUnmarshaling->staticInstance));
+ unmarshal_VkAccelerationStructureInstanceKHR(
+ vkStream, rootType,
+ (VkAccelerationStructureInstanceKHR*)(&forUnmarshaling->staticInstance));
}
void marshal_VkAccelerationStructureMotionInstanceNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureMotionInstanceNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureMotionInstanceNV* forMarshaling) {
(void)rootType;
- vkStream->write((VkAccelerationStructureMotionInstanceTypeNV*)&forMarshaling->type, sizeof(VkAccelerationStructureMotionInstanceTypeNV));
- vkStream->write((VkAccelerationStructureMotionInstanceFlagsNV*)&forMarshaling->flags, sizeof(VkAccelerationStructureMotionInstanceFlagsNV));
- marshal_VkAccelerationStructureMotionInstanceDataNV(vkStream, rootType, (VkAccelerationStructureMotionInstanceDataNV*)(&forMarshaling->data));
+ vkStream->write((VkAccelerationStructureMotionInstanceTypeNV*)&forMarshaling->type,
+ sizeof(VkAccelerationStructureMotionInstanceTypeNV));
+ vkStream->write((VkAccelerationStructureMotionInstanceFlagsNV*)&forMarshaling->flags,
+ sizeof(VkAccelerationStructureMotionInstanceFlagsNV));
+ marshal_VkAccelerationStructureMotionInstanceDataNV(
+ vkStream, rootType, (VkAccelerationStructureMotionInstanceDataNV*)(&forMarshaling->data));
}
void unmarshal_VkAccelerationStructureMotionInstanceNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureMotionInstanceNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureMotionInstanceNV* forUnmarshaling) {
(void)rootType;
- vkStream->read((VkAccelerationStructureMotionInstanceTypeNV*)&forUnmarshaling->type, sizeof(VkAccelerationStructureMotionInstanceTypeNV));
- vkStream->read((VkAccelerationStructureMotionInstanceFlagsNV*)&forUnmarshaling->flags, sizeof(VkAccelerationStructureMotionInstanceFlagsNV));
- unmarshal_VkAccelerationStructureMotionInstanceDataNV(vkStream, rootType, (VkAccelerationStructureMotionInstanceDataNV*)(&forUnmarshaling->data));
+ vkStream->read((VkAccelerationStructureMotionInstanceTypeNV*)&forUnmarshaling->type,
+ sizeof(VkAccelerationStructureMotionInstanceTypeNV));
+ vkStream->read((VkAccelerationStructureMotionInstanceFlagsNV*)&forUnmarshaling->flags,
+ sizeof(VkAccelerationStructureMotionInstanceFlagsNV));
+ unmarshal_VkAccelerationStructureMotionInstanceDataNV(
+ vkStream, rootType, (VkAccelerationStructureMotionInstanceDataNV*)(&forUnmarshaling->data));
}
void marshal_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->rayTracingMotionBlur, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->rayTracingMotionBlurPipelineTraceRaysIndirect, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->rayTracingMotionBlurPipelineTraceRaysIndirect,
+ sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->rayTracingMotionBlur, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->rayTracingMotionBlurPipelineTraceRaysIndirect, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->rayTracingMotionBlurPipelineTraceRaysIndirect,
+ sizeof(VkBool32));
}
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
void marshal_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -26218,14 +23537,11 @@
}
void unmarshal_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -26235,14 +23551,11 @@
#endif
#ifdef VK_EXT_fragment_density_map2
void marshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -26250,14 +23563,11 @@
}
void unmarshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -26265,84 +23575,73 @@
}
void marshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->subsampledLoads, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->subsampledCoarseReconstructionEarlyAccess, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->subsampledCoarseReconstructionEarlyAccess,
+ sizeof(VkBool32));
vkStream->write((uint32_t*)&forMarshaling->maxSubsampledArrayLayers, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetSubsampledSamplers, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetSubsampledSamplers,
+ sizeof(uint32_t));
}
void unmarshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->subsampledLoads, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->subsampledCoarseReconstructionEarlyAccess, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->subsampledCoarseReconstructionEarlyAccess,
+ sizeof(VkBool32));
vkStream->read((uint32_t*)&forUnmarshaling->maxSubsampledArrayLayers, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetSubsampledSamplers, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetSubsampledSamplers,
+ sizeof(uint32_t));
}
#endif
#ifdef VK_QCOM_rotated_copy_commands
-void marshal_VkCopyCommandTransformInfoQCOM(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyCommandTransformInfoQCOM* forMarshaling)
-{
+void marshal_VkCopyCommandTransformInfoQCOM(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyCommandTransformInfoQCOM* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
}
-void unmarshal_VkCopyCommandTransformInfoQCOM(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCopyCommandTransformInfoQCOM* forUnmarshaling)
-{
+void unmarshal_VkCopyCommandTransformInfoQCOM(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyCommandTransformInfoQCOM* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->transform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
}
#endif
#ifdef VK_EXT_image_robustness
void marshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceImageRobustnessFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceImageRobustnessFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -26350,14 +23649,11 @@
}
void unmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceImageRobustnessFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceImageRobustnessFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -26367,14 +23663,11 @@
#endif
#ifdef VK_EXT_4444_formats
void marshal_VkPhysicalDevice4444FormatsFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevice4444FormatsFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevice4444FormatsFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -26383,14 +23676,11 @@
}
void unmarshal_VkPhysicalDevice4444FormatsFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDevice4444FormatsFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevice4444FormatsFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -26401,14 +23691,11 @@
#endif
#ifdef VK_EXT_rgba10x6_formats
void marshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -26416,73 +23703,61 @@
}
void unmarshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkBool32*)&forUnmarshaling->formatRgba10x6WithoutYCbCrSampler, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->formatRgba10x6WithoutYCbCrSampler,
+ sizeof(VkBool32));
}
#endif
#ifdef VK_NV_acquire_winrt_display
#endif
#ifdef VK_EXT_directfb_surface
-void marshal_VkDirectFBSurfaceCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDirectFBSurfaceCreateInfoEXT* forMarshaling)
-{
+void marshal_VkDirectFBSurfaceCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDirectFBSurfaceCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkDirectFBSurfaceCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkDirectFBSurfaceCreateFlagsEXT));
+ vkStream->write((VkDirectFBSurfaceCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkDirectFBSurfaceCreateFlagsEXT));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->dfb;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->dfb)
- {
+ if (forMarshaling->dfb) {
vkStream->write((IDirectFB*)forMarshaling->dfb, sizeof(IDirectFB));
}
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->surface;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->surface)
- {
+ if (forMarshaling->surface) {
vkStream->write((IDirectFBSurface*)forMarshaling->surface, sizeof(IDirectFBSurface));
}
}
-void unmarshal_VkDirectFBSurfaceCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDirectFBSurfaceCreateInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkDirectFBSurfaceCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDirectFBSurfaceCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDirectFBSurfaceCreateFlagsEXT*)&forUnmarshaling->flags, sizeof(VkDirectFBSurfaceCreateFlagsEXT));
+ vkStream->read((VkDirectFBSurfaceCreateFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkDirectFBSurfaceCreateFlagsEXT));
// WARNING PTR CHECK
IDirectFB* check_dfb;
check_dfb = (IDirectFB*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->dfb)
- {
- if (!(check_dfb))
- {
+ if (forUnmarshaling->dfb) {
+ if (!(check_dfb)) {
fprintf(stderr, "fatal: forUnmarshaling->dfb inconsistent between guest and host\n");
}
vkStream->read((IDirectFB*)forUnmarshaling->dfb, sizeof(IDirectFB));
@@ -26490,11 +23765,10 @@
// WARNING PTR CHECK
IDirectFBSurface* check_surface;
check_surface = (IDirectFBSurface*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->surface)
- {
- if (!(check_surface))
- {
- fprintf(stderr, "fatal: forUnmarshaling->surface inconsistent between guest and host\n");
+ if (forUnmarshaling->surface) {
+ if (!(check_surface)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->surface inconsistent between guest and host\n");
}
vkStream->read((IDirectFBSurface*)forUnmarshaling->surface, sizeof(IDirectFBSurface));
}
@@ -26503,14 +23777,11 @@
#endif
#ifdef VK_VALVE_mutable_descriptor_type
void marshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -26518,14 +23789,11 @@
}
void unmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -26533,65 +23801,60 @@
}
void marshal_VkMutableDescriptorTypeListVALVE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMutableDescriptorTypeListVALVE* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMutableDescriptorTypeListVALVE* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->descriptorTypeCount, sizeof(uint32_t));
- vkStream->write((const VkDescriptorType*)forMarshaling->pDescriptorTypes, forMarshaling->descriptorTypeCount * sizeof(const VkDescriptorType));
+ vkStream->write((const VkDescriptorType*)forMarshaling->pDescriptorTypes,
+ forMarshaling->descriptorTypeCount * sizeof(const VkDescriptorType));
}
-void unmarshal_VkMutableDescriptorTypeListVALVE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMutableDescriptorTypeListVALVE* forUnmarshaling)
-{
+void unmarshal_VkMutableDescriptorTypeListVALVE(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkMutableDescriptorTypeListVALVE* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->descriptorTypeCount, sizeof(uint32_t));
- vkStream->read((VkDescriptorType*)forUnmarshaling->pDescriptorTypes, forUnmarshaling->descriptorTypeCount * sizeof(const VkDescriptorType));
+ vkStream->read((VkDescriptorType*)forUnmarshaling->pDescriptorTypes,
+ forUnmarshaling->descriptorTypeCount * sizeof(const VkDescriptorType));
}
void marshal_VkMutableDescriptorTypeCreateInfoVALVE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMutableDescriptorTypeCreateInfoVALVE* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMutableDescriptorTypeCreateInfoVALVE* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->mutableDescriptorTypeListCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->mutableDescriptorTypeListCount; ++i)
- {
- marshal_VkMutableDescriptorTypeListVALVE(vkStream, rootType, (const VkMutableDescriptorTypeListVALVE*)(forMarshaling->pMutableDescriptorTypeLists + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->mutableDescriptorTypeListCount; ++i) {
+ marshal_VkMutableDescriptorTypeListVALVE(
+ vkStream, rootType,
+ (const VkMutableDescriptorTypeListVALVE*)(forMarshaling
+ ->pMutableDescriptorTypeLists +
+ i));
}
}
}
void unmarshal_VkMutableDescriptorTypeCreateInfoVALVE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMutableDescriptorTypeCreateInfoVALVE* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMutableDescriptorTypeCreateInfoVALVE* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->mutableDescriptorTypeListCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->mutableDescriptorTypeListCount; ++i)
- {
- unmarshal_VkMutableDescriptorTypeListVALVE(vkStream, rootType, (VkMutableDescriptorTypeListVALVE*)(forUnmarshaling->pMutableDescriptorTypeLists + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->mutableDescriptorTypeListCount; ++i) {
+ unmarshal_VkMutableDescriptorTypeListVALVE(
+ vkStream, rootType,
+ (VkMutableDescriptorTypeListVALVE*)(forUnmarshaling->pMutableDescriptorTypeLists +
+ i));
}
}
}
@@ -26599,14 +23862,11 @@
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
void marshal_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -26614,14 +23874,11 @@
}
void unmarshal_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -26629,14 +23886,11 @@
}
void marshal_VkVertexInputBindingDescription2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVertexInputBindingDescription2EXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVertexInputBindingDescription2EXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -26647,14 +23901,11 @@
}
void unmarshal_VkVertexInputBindingDescription2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVertexInputBindingDescription2EXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVertexInputBindingDescription2EXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -26665,14 +23916,11 @@
}
void marshal_VkVertexInputAttributeDescription2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVertexInputAttributeDescription2EXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVertexInputAttributeDescription2EXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -26683,14 +23931,11 @@
}
void unmarshal_VkVertexInputAttributeDescription2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVertexInputAttributeDescription2EXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVertexInputAttributeDescription2EXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -26703,14 +23948,11 @@
#endif
#ifdef VK_EXT_physical_device_drm
void marshal_VkPhysicalDeviceDrmPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDrmPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDrmPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -26722,15 +23964,12 @@
vkStream->write((int64_t*)&forMarshaling->renderMinor, sizeof(int64_t));
}
-void unmarshal_VkPhysicalDeviceDrmPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceDrmPropertiesEXT* forUnmarshaling)
-{
+void unmarshal_VkPhysicalDeviceDrmPropertiesEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPhysicalDeviceDrmPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -26745,14 +23984,11 @@
#endif
#ifdef VK_EXT_primitive_topology_list_restart
void marshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -26761,64 +23997,55 @@
}
void unmarshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->primitiveTopologyListRestart, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->primitiveTopologyPatchListRestart, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->primitiveTopologyPatchListRestart,
+ sizeof(VkBool32));
}
#endif
#ifdef VK_FUCHSIA_external_memory
void marshal_VkImportMemoryZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportMemoryZirconHandleInfoFUCHSIA* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportMemoryZirconHandleInfoFUCHSIA* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
vkStream->write((zx_handle_t*)&forMarshaling->handle, sizeof(zx_handle_t));
}
void unmarshal_VkImportMemoryZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportMemoryZirconHandleInfoFUCHSIA* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImportMemoryZirconHandleInfoFUCHSIA* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
vkStream->read((zx_handle_t*)&forUnmarshaling->handle, sizeof(zx_handle_t));
}
void marshal_VkMemoryZirconHandlePropertiesFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryZirconHandlePropertiesFUCHSIA* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryZirconHandlePropertiesFUCHSIA* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -26826,14 +24053,11 @@
}
void unmarshal_VkMemoryZirconHandlePropertiesFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryZirconHandlePropertiesFUCHSIA* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryZirconHandlePropertiesFUCHSIA* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -26841,130 +24065,122 @@
}
void marshal_VkMemoryGetZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryGetZirconHandleInfoFUCHSIA* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
}
void unmarshal_VkMemoryGetZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryGetZirconHandleInfoFUCHSIA* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryGetZirconHandleInfoFUCHSIA* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
- vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+ &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
}
#endif
#ifdef VK_FUCHSIA_external_semaphore
void marshal_VkImportSemaphoreZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportSemaphoreZirconHandleInfoFUCHSIA* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((VkSemaphoreImportFlags*)&forMarshaling->flags, sizeof(VkSemaphoreImportFlags));
- vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
vkStream->write((zx_handle_t*)&forMarshaling->zirconHandle, sizeof(zx_handle_t));
}
void unmarshal_VkImportSemaphoreZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportSemaphoreZirconHandleInfoFUCHSIA* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImportSemaphoreZirconHandleInfoFUCHSIA* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
- vkStream->read((VkSemaphoreImportFlags*)&forUnmarshaling->flags, sizeof(VkSemaphoreImportFlags));
- vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
+ &cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ vkStream->read((VkSemaphoreImportFlags*)&forUnmarshaling->flags,
+ sizeof(VkSemaphoreImportFlags));
+ vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
vkStream->read((zx_handle_t*)&forUnmarshaling->zirconHandle, sizeof(zx_handle_t));
}
void marshal_VkSemaphoreGetZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreGetZirconHandleInfoFUCHSIA* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}
void unmarshal_VkSemaphoreGetZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSemaphoreGetZirconHandleInfoFUCHSIA* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSemaphoreGetZirconHandleInfoFUCHSIA* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
- vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
+ &cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+ vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
void marshal_VkBufferCollectionCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCollectionCreateInfoFUCHSIA* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCollectionCreateInfoFUCHSIA* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -26972,14 +24188,11 @@
}
void unmarshal_VkBufferCollectionCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferCollectionCreateInfoFUCHSIA* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferCollectionCreateInfoFUCHSIA* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -26987,14 +24200,11 @@
}
void marshal_VkImportMemoryBufferCollectionFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportMemoryBufferCollectionFUCHSIA* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportMemoryBufferCollectionFUCHSIA* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -27004,14 +24214,11 @@
}
void unmarshal_VkImportMemoryBufferCollectionFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportMemoryBufferCollectionFUCHSIA* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImportMemoryBufferCollectionFUCHSIA* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -27020,14 +24227,11 @@
}
void marshal_VkBufferCollectionImageCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCollectionImageCreateInfoFUCHSIA* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCollectionImageCreateInfoFUCHSIA* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -27037,14 +24241,11 @@
}
void unmarshal_VkBufferCollectionImageCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferCollectionImageCreateInfoFUCHSIA* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferCollectionImageCreateInfoFUCHSIA* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -27053,14 +24254,11 @@
}
void marshal_VkBufferCollectionConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCollectionConstraintsInfoFUCHSIA* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCollectionConstraintsInfoFUCHSIA* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -27072,14 +24270,11 @@
}
void unmarshal_VkBufferCollectionConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferCollectionConstraintsInfoFUCHSIA* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferCollectionConstraintsInfoFUCHSIA* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -27090,49 +24285,46 @@
vkStream->read((uint32_t*)&forUnmarshaling->minBufferCountForSharedSlack, sizeof(uint32_t));
}
-void marshal_VkBufferConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferConstraintsInfoFUCHSIA* forMarshaling)
-{
+void marshal_VkBufferConstraintsInfoFUCHSIA(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferConstraintsInfoFUCHSIA* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkBufferCreateInfo(vkStream, rootType, (VkBufferCreateInfo*)(&forMarshaling->createInfo));
- vkStream->write((VkFormatFeatureFlags*)&forMarshaling->requiredFormatFeatures, sizeof(VkFormatFeatureFlags));
- marshal_VkBufferCollectionConstraintsInfoFUCHSIA(vkStream, rootType, (VkBufferCollectionConstraintsInfoFUCHSIA*)(&forMarshaling->bufferCollectionConstraints));
+ marshal_VkBufferCreateInfo(vkStream, rootType,
+ (VkBufferCreateInfo*)(&forMarshaling->createInfo));
+ vkStream->write((VkFormatFeatureFlags*)&forMarshaling->requiredFormatFeatures,
+ sizeof(VkFormatFeatureFlags));
+ marshal_VkBufferCollectionConstraintsInfoFUCHSIA(
+ vkStream, rootType,
+ (VkBufferCollectionConstraintsInfoFUCHSIA*)(&forMarshaling->bufferCollectionConstraints));
}
-void unmarshal_VkBufferConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferConstraintsInfoFUCHSIA* forUnmarshaling)
-{
+void unmarshal_VkBufferConstraintsInfoFUCHSIA(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferConstraintsInfoFUCHSIA* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkBufferCreateInfo(vkStream, rootType, (VkBufferCreateInfo*)(&forUnmarshaling->createInfo));
- vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->requiredFormatFeatures, sizeof(VkFormatFeatureFlags));
- unmarshal_VkBufferCollectionConstraintsInfoFUCHSIA(vkStream, rootType, (VkBufferCollectionConstraintsInfoFUCHSIA*)(&forUnmarshaling->bufferCollectionConstraints));
+ unmarshal_VkBufferCreateInfo(vkStream, rootType,
+ (VkBufferCreateInfo*)(&forUnmarshaling->createInfo));
+ vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->requiredFormatFeatures,
+ sizeof(VkFormatFeatureFlags));
+ unmarshal_VkBufferCollectionConstraintsInfoFUCHSIA(
+ vkStream, rootType,
+ (VkBufferCollectionConstraintsInfoFUCHSIA*)(&forUnmarshaling->bufferCollectionConstraints));
}
void marshal_VkBufferCollectionBufferCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCollectionBufferCreateInfoFUCHSIA* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCollectionBufferCreateInfoFUCHSIA* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -27142,14 +24334,11 @@
}
void unmarshal_VkBufferCollectionBufferCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferCollectionBufferCreateInfoFUCHSIA* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferCollectionBufferCreateInfoFUCHSIA* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -27157,30 +24346,22 @@
vkStream->read((uint32_t*)&forUnmarshaling->index, sizeof(uint32_t));
}
-void marshal_VkSysmemColorSpaceFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSysmemColorSpaceFUCHSIA* forMarshaling)
-{
+void marshal_VkSysmemColorSpaceFUCHSIA(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSysmemColorSpaceFUCHSIA* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->colorSpace, sizeof(uint32_t));
}
-void unmarshal_VkSysmemColorSpaceFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSysmemColorSpaceFUCHSIA* forUnmarshaling)
-{
+void unmarshal_VkSysmemColorSpaceFUCHSIA(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSysmemColorSpaceFUCHSIA* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -27188,14 +24369,11 @@
}
void marshal_VkBufferCollectionPropertiesFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCollectionPropertiesFUCHSIA* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCollectionPropertiesFUCHSIA* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -27203,24 +24381,29 @@
vkStream->write((uint32_t*)&forMarshaling->bufferCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->createInfoIndex, sizeof(uint32_t));
vkStream->write((uint64_t*)&forMarshaling->sysmemPixelFormat, sizeof(uint64_t));
- vkStream->write((VkFormatFeatureFlags*)&forMarshaling->formatFeatures, sizeof(VkFormatFeatureFlags));
- marshal_VkSysmemColorSpaceFUCHSIA(vkStream, rootType, (VkSysmemColorSpaceFUCHSIA*)(&forMarshaling->sysmemColorSpaceIndex));
- marshal_VkComponentMapping(vkStream, rootType, (VkComponentMapping*)(&forMarshaling->samplerYcbcrConversionComponents));
- vkStream->write((VkSamplerYcbcrModelConversion*)&forMarshaling->suggestedYcbcrModel, sizeof(VkSamplerYcbcrModelConversion));
- vkStream->write((VkSamplerYcbcrRange*)&forMarshaling->suggestedYcbcrRange, sizeof(VkSamplerYcbcrRange));
- vkStream->write((VkChromaLocation*)&forMarshaling->suggestedXChromaOffset, sizeof(VkChromaLocation));
- vkStream->write((VkChromaLocation*)&forMarshaling->suggestedYChromaOffset, sizeof(VkChromaLocation));
+ vkStream->write((VkFormatFeatureFlags*)&forMarshaling->formatFeatures,
+ sizeof(VkFormatFeatureFlags));
+ marshal_VkSysmemColorSpaceFUCHSIA(
+ vkStream, rootType, (VkSysmemColorSpaceFUCHSIA*)(&forMarshaling->sysmemColorSpaceIndex));
+ marshal_VkComponentMapping(
+ vkStream, rootType,
+ (VkComponentMapping*)(&forMarshaling->samplerYcbcrConversionComponents));
+ vkStream->write((VkSamplerYcbcrModelConversion*)&forMarshaling->suggestedYcbcrModel,
+ sizeof(VkSamplerYcbcrModelConversion));
+ vkStream->write((VkSamplerYcbcrRange*)&forMarshaling->suggestedYcbcrRange,
+ sizeof(VkSamplerYcbcrRange));
+ vkStream->write((VkChromaLocation*)&forMarshaling->suggestedXChromaOffset,
+ sizeof(VkChromaLocation));
+ vkStream->write((VkChromaLocation*)&forMarshaling->suggestedYChromaOffset,
+ sizeof(VkChromaLocation));
}
void unmarshal_VkBufferCollectionPropertiesFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferCollectionPropertiesFUCHSIA* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferCollectionPropertiesFUCHSIA* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -27228,150 +24411,152 @@
vkStream->read((uint32_t*)&forUnmarshaling->bufferCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->createInfoIndex, sizeof(uint32_t));
vkStream->read((uint64_t*)&forUnmarshaling->sysmemPixelFormat, sizeof(uint64_t));
- vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->formatFeatures, sizeof(VkFormatFeatureFlags));
- unmarshal_VkSysmemColorSpaceFUCHSIA(vkStream, rootType, (VkSysmemColorSpaceFUCHSIA*)(&forUnmarshaling->sysmemColorSpaceIndex));
- unmarshal_VkComponentMapping(vkStream, rootType, (VkComponentMapping*)(&forUnmarshaling->samplerYcbcrConversionComponents));
- vkStream->read((VkSamplerYcbcrModelConversion*)&forUnmarshaling->suggestedYcbcrModel, sizeof(VkSamplerYcbcrModelConversion));
- vkStream->read((VkSamplerYcbcrRange*)&forUnmarshaling->suggestedYcbcrRange, sizeof(VkSamplerYcbcrRange));
- vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedXChromaOffset, sizeof(VkChromaLocation));
- vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedYChromaOffset, sizeof(VkChromaLocation));
+ vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->formatFeatures,
+ sizeof(VkFormatFeatureFlags));
+ unmarshal_VkSysmemColorSpaceFUCHSIA(
+ vkStream, rootType, (VkSysmemColorSpaceFUCHSIA*)(&forUnmarshaling->sysmemColorSpaceIndex));
+ unmarshal_VkComponentMapping(
+ vkStream, rootType,
+ (VkComponentMapping*)(&forUnmarshaling->samplerYcbcrConversionComponents));
+ vkStream->read((VkSamplerYcbcrModelConversion*)&forUnmarshaling->suggestedYcbcrModel,
+ sizeof(VkSamplerYcbcrModelConversion));
+ vkStream->read((VkSamplerYcbcrRange*)&forUnmarshaling->suggestedYcbcrRange,
+ sizeof(VkSamplerYcbcrRange));
+ vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedXChromaOffset,
+ sizeof(VkChromaLocation));
+ vkStream->read((VkChromaLocation*)&forUnmarshaling->suggestedYChromaOffset,
+ sizeof(VkChromaLocation));
}
void marshal_VkImageFormatConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageFormatConstraintsInfoFUCHSIA* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageFormatConstraintsInfoFUCHSIA* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkImageCreateInfo(vkStream, rootType, (VkImageCreateInfo*)(&forMarshaling->imageCreateInfo));
- vkStream->write((VkFormatFeatureFlags*)&forMarshaling->requiredFormatFeatures, sizeof(VkFormatFeatureFlags));
- vkStream->write((VkImageFormatConstraintsFlagsFUCHSIA*)&forMarshaling->flags, sizeof(VkImageFormatConstraintsFlagsFUCHSIA));
+ marshal_VkImageCreateInfo(vkStream, rootType,
+ (VkImageCreateInfo*)(&forMarshaling->imageCreateInfo));
+ vkStream->write((VkFormatFeatureFlags*)&forMarshaling->requiredFormatFeatures,
+ sizeof(VkFormatFeatureFlags));
+ vkStream->write((VkImageFormatConstraintsFlagsFUCHSIA*)&forMarshaling->flags,
+ sizeof(VkImageFormatConstraintsFlagsFUCHSIA));
vkStream->write((uint64_t*)&forMarshaling->sysmemPixelFormat, sizeof(uint64_t));
vkStream->write((uint32_t*)&forMarshaling->colorSpaceCount, sizeof(uint32_t));
- marshal_VkSysmemColorSpaceFUCHSIA(vkStream, rootType, (const VkSysmemColorSpaceFUCHSIA*)(forMarshaling->pColorSpaces));
+ marshal_VkSysmemColorSpaceFUCHSIA(
+ vkStream, rootType, (const VkSysmemColorSpaceFUCHSIA*)(forMarshaling->pColorSpaces));
}
void unmarshal_VkImageFormatConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageFormatConstraintsInfoFUCHSIA* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageFormatConstraintsInfoFUCHSIA* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkImageCreateInfo(vkStream, rootType, (VkImageCreateInfo*)(&forUnmarshaling->imageCreateInfo));
- vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->requiredFormatFeatures, sizeof(VkFormatFeatureFlags));
- vkStream->read((VkImageFormatConstraintsFlagsFUCHSIA*)&forUnmarshaling->flags, sizeof(VkImageFormatConstraintsFlagsFUCHSIA));
+ unmarshal_VkImageCreateInfo(vkStream, rootType,
+ (VkImageCreateInfo*)(&forUnmarshaling->imageCreateInfo));
+ vkStream->read((VkFormatFeatureFlags*)&forUnmarshaling->requiredFormatFeatures,
+ sizeof(VkFormatFeatureFlags));
+ vkStream->read((VkImageFormatConstraintsFlagsFUCHSIA*)&forUnmarshaling->flags,
+ sizeof(VkImageFormatConstraintsFlagsFUCHSIA));
vkStream->read((uint64_t*)&forUnmarshaling->sysmemPixelFormat, sizeof(uint64_t));
vkStream->read((uint32_t*)&forUnmarshaling->colorSpaceCount, sizeof(uint32_t));
- unmarshal_VkSysmemColorSpaceFUCHSIA(vkStream, rootType, (VkSysmemColorSpaceFUCHSIA*)(forUnmarshaling->pColorSpaces));
+ unmarshal_VkSysmemColorSpaceFUCHSIA(
+ vkStream, rootType, (VkSysmemColorSpaceFUCHSIA*)(forUnmarshaling->pColorSpaces));
}
-void marshal_VkImageConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageConstraintsInfoFUCHSIA* forMarshaling)
-{
+void marshal_VkImageConstraintsInfoFUCHSIA(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageConstraintsInfoFUCHSIA* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->formatConstraintsCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->formatConstraintsCount; ++i)
- {
- marshal_VkImageFormatConstraintsInfoFUCHSIA(vkStream, rootType, (const VkImageFormatConstraintsInfoFUCHSIA*)(forMarshaling->pFormatConstraints + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->formatConstraintsCount; ++i) {
+ marshal_VkImageFormatConstraintsInfoFUCHSIA(
+ vkStream, rootType,
+ (const VkImageFormatConstraintsInfoFUCHSIA*)(forMarshaling->pFormatConstraints +
+ i));
}
}
- marshal_VkBufferCollectionConstraintsInfoFUCHSIA(vkStream, rootType, (VkBufferCollectionConstraintsInfoFUCHSIA*)(&forMarshaling->bufferCollectionConstraints));
- vkStream->write((VkImageConstraintsInfoFlagsFUCHSIA*)&forMarshaling->flags, sizeof(VkImageConstraintsInfoFlagsFUCHSIA));
+ marshal_VkBufferCollectionConstraintsInfoFUCHSIA(
+ vkStream, rootType,
+ (VkBufferCollectionConstraintsInfoFUCHSIA*)(&forMarshaling->bufferCollectionConstraints));
+ vkStream->write((VkImageConstraintsInfoFlagsFUCHSIA*)&forMarshaling->flags,
+ sizeof(VkImageConstraintsInfoFlagsFUCHSIA));
}
-void unmarshal_VkImageConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageConstraintsInfoFUCHSIA* forUnmarshaling)
-{
+void unmarshal_VkImageConstraintsInfoFUCHSIA(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageConstraintsInfoFUCHSIA* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->formatConstraintsCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->formatConstraintsCount; ++i)
- {
- unmarshal_VkImageFormatConstraintsInfoFUCHSIA(vkStream, rootType, (VkImageFormatConstraintsInfoFUCHSIA*)(forUnmarshaling->pFormatConstraints + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->formatConstraintsCount; ++i) {
+ unmarshal_VkImageFormatConstraintsInfoFUCHSIA(
+ vkStream, rootType,
+ (VkImageFormatConstraintsInfoFUCHSIA*)(forUnmarshaling->pFormatConstraints + i));
}
}
- unmarshal_VkBufferCollectionConstraintsInfoFUCHSIA(vkStream, rootType, (VkBufferCollectionConstraintsInfoFUCHSIA*)(&forUnmarshaling->bufferCollectionConstraints));
- vkStream->read((VkImageConstraintsInfoFlagsFUCHSIA*)&forUnmarshaling->flags, sizeof(VkImageConstraintsInfoFlagsFUCHSIA));
+ unmarshal_VkBufferCollectionConstraintsInfoFUCHSIA(
+ vkStream, rootType,
+ (VkBufferCollectionConstraintsInfoFUCHSIA*)(&forUnmarshaling->bufferCollectionConstraints));
+ vkStream->read((VkImageConstraintsInfoFlagsFUCHSIA*)&forUnmarshaling->flags,
+ sizeof(VkImageConstraintsInfoFlagsFUCHSIA));
}
#endif
#ifdef VK_HUAWEI_subpass_shading
void marshal_VkSubpassShadingPipelineCreateInfoHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassShadingPipelineCreateInfoHUAWEI* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassShadingPipelineCreateInfoHUAWEI* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
}
void unmarshal_VkSubpassShadingPipelineCreateInfoHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubpassShadingPipelineCreateInfoHUAWEI* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubpassShadingPipelineCreateInfoHUAWEI* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_0, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkRenderPass(
+ &cgen_var_0, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
vkStream->read((uint32_t*)&forUnmarshaling->subpass, sizeof(uint32_t));
}
void marshal_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -27379,14 +24564,11 @@
}
void unmarshal_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -27394,46 +24576,39 @@
}
void marshal_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((uint32_t*)&forMarshaling->maxSubpassShadingWorkgroupSizeAspectRatio, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxSubpassShadingWorkgroupSizeAspectRatio,
+ sizeof(uint32_t));
}
void unmarshal_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((uint32_t*)&forUnmarshaling->maxSubpassShadingWorkgroupSizeAspectRatio, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxSubpassShadingWorkgroupSizeAspectRatio,
+ sizeof(uint32_t));
}
#endif
#ifdef VK_HUAWEI_invocation_mask
void marshal_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -27441,14 +24616,11 @@
}
void unmarshal_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -27457,51 +24629,44 @@
#endif
#ifdef VK_NV_external_memory_rdma
-void marshal_VkMemoryGetRemoteAddressInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryGetRemoteAddressInfoNV* forMarshaling)
-{
+void marshal_VkMemoryGetRemoteAddressInfoNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryGetRemoteAddressInfoNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
+ 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
}
-void unmarshal_VkMemoryGetRemoteAddressInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryGetRemoteAddressInfoNV* forUnmarshaling)
-{
+void unmarshal_VkMemoryGetRemoteAddressInfoNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryGetRemoteAddressInfoNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
- vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+ &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+ vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
}
void marshal_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -27509,14 +24674,11 @@
}
void unmarshal_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -27526,101 +24688,86 @@
#endif
#ifdef VK_EXT_extended_dynamic_state2
void marshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState2, sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState2LogicOp, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState2PatchControlPoints, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState2PatchControlPoints,
+ sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState2, sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState2LogicOp, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState2PatchControlPoints, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState2PatchControlPoints,
+ sizeof(VkBool32));
}
#endif
#ifdef VK_QNX_screen_surface
-void marshal_VkScreenSurfaceCreateInfoQNX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkScreenSurfaceCreateInfoQNX* forMarshaling)
-{
+void marshal_VkScreenSurfaceCreateInfoQNX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkScreenSurfaceCreateInfoQNX* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkScreenSurfaceCreateFlagsQNX*)&forMarshaling->flags, sizeof(VkScreenSurfaceCreateFlagsQNX));
+ vkStream->write((VkScreenSurfaceCreateFlagsQNX*)&forMarshaling->flags,
+ sizeof(VkScreenSurfaceCreateFlagsQNX));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->context;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->context)
- {
+ if (forMarshaling->context) {
vkStream->write((_screen_context*)forMarshaling->context, sizeof(_screen_context));
}
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->window;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->window)
- {
+ if (forMarshaling->window) {
vkStream->write((_screen_window*)forMarshaling->window, sizeof(_screen_window));
}
}
-void unmarshal_VkScreenSurfaceCreateInfoQNX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkScreenSurfaceCreateInfoQNX* forUnmarshaling)
-{
+void unmarshal_VkScreenSurfaceCreateInfoQNX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkScreenSurfaceCreateInfoQNX* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkScreenSurfaceCreateFlagsQNX*)&forUnmarshaling->flags, sizeof(VkScreenSurfaceCreateFlagsQNX));
+ vkStream->read((VkScreenSurfaceCreateFlagsQNX*)&forUnmarshaling->flags,
+ sizeof(VkScreenSurfaceCreateFlagsQNX));
// WARNING PTR CHECK
_screen_context* check_context;
check_context = (_screen_context*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->context)
- {
- if (!(check_context))
- {
- fprintf(stderr, "fatal: forUnmarshaling->context inconsistent between guest and host\n");
+ if (forUnmarshaling->context) {
+ if (!(check_context)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->context inconsistent between guest and host\n");
}
vkStream->read((_screen_context*)forUnmarshaling->context, sizeof(_screen_context));
}
// WARNING PTR CHECK
_screen_window* check_window;
check_window = (_screen_window*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->window)
- {
- if (!(check_window))
- {
+ if (forUnmarshaling->window) {
+ if (!(check_window)) {
fprintf(stderr, "fatal: forUnmarshaling->window inconsistent between guest and host\n");
}
vkStream->read((_screen_window*)forUnmarshaling->window, sizeof(_screen_window));
@@ -27630,14 +24777,11 @@
#endif
#ifdef VK_EXT_color_write_enable
void marshal_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceColorWriteEnableFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceColorWriteEnableFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -27645,14 +24789,11 @@
}
void unmarshal_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceColorWriteEnableFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceColorWriteEnableFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -27660,110 +24801,86 @@
}
void marshal_VkPipelineColorWriteCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineColorWriteCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineColorWriteCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
- vkStream->write((const VkBool32*)forMarshaling->pColorWriteEnables, forMarshaling->attachmentCount * sizeof(const VkBool32));
+ vkStream->write((const VkBool32*)forMarshaling->pColorWriteEnables,
+ forMarshaling->attachmentCount * sizeof(const VkBool32));
}
void unmarshal_VkPipelineColorWriteCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineColorWriteCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineColorWriteCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
- vkStream->read((VkBool32*)forUnmarshaling->pColorWriteEnables, forUnmarshaling->attachmentCount * sizeof(const VkBool32));
+ vkStream->read((VkBool32*)forUnmarshaling->pColorWriteEnables,
+ forUnmarshaling->attachmentCount * sizeof(const VkBool32));
}
#endif
#ifdef VK_GOOGLE_gfxstream
-void marshal_VkImportColorBufferGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportColorBufferGOOGLE* forMarshaling)
-{
+void marshal_VkImportColorBufferGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportColorBufferGOOGLE* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->colorBuffer, sizeof(uint32_t));
}
-void unmarshal_VkImportColorBufferGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportColorBufferGOOGLE* forUnmarshaling)
-{
+void unmarshal_VkImportColorBufferGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImportColorBufferGOOGLE* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
forUnmarshaling->sType = VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->colorBuffer, sizeof(uint32_t));
}
-void marshal_VkImportBufferGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportBufferGOOGLE* forMarshaling)
-{
+void marshal_VkImportBufferGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportBufferGOOGLE* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->buffer, sizeof(uint32_t));
}
-void unmarshal_VkImportBufferGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportBufferGOOGLE* forUnmarshaling)
-{
+void unmarshal_VkImportBufferGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImportBufferGOOGLE* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
forUnmarshaling->sType = VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->buffer, sizeof(uint32_t));
}
-void marshal_VkImportPhysicalAddressGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportPhysicalAddressGOOGLE* forMarshaling)
-{
+void marshal_VkImportPhysicalAddressGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportPhysicalAddressGOOGLE* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -27774,16 +24891,12 @@
vkStream->write((uint32_t*)&forMarshaling->tilingParameter, sizeof(uint32_t));
}
-void unmarshal_VkImportPhysicalAddressGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportPhysicalAddressGOOGLE* forUnmarshaling)
-{
+void unmarshal_VkImportPhysicalAddressGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImportPhysicalAddressGOOGLE* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
forUnmarshaling->sType = VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE;
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -27797,14 +24910,11 @@
#endif
#ifdef VK_EXT_global_priority_query
void marshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -27812,14 +24922,11 @@
}
void unmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -27827,48 +24934,41 @@
}
void marshal_VkQueueFamilyGlobalPriorityPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueueFamilyGlobalPriorityPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyGlobalPriorityPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint32_t*)&forMarshaling->priorityCount, sizeof(uint32_t));
- vkStream->write((VkQueueGlobalPriorityEXT*)forMarshaling->priorities, VK_MAX_GLOBAL_PRIORITY_SIZE_EXT * sizeof(VkQueueGlobalPriorityEXT));
+ vkStream->write((VkQueueGlobalPriorityEXT*)forMarshaling->priorities,
+ VK_MAX_GLOBAL_PRIORITY_SIZE_EXT * sizeof(VkQueueGlobalPriorityEXT));
}
void unmarshal_VkQueueFamilyGlobalPriorityPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkQueueFamilyGlobalPriorityPropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkQueueFamilyGlobalPriorityPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->priorityCount, sizeof(uint32_t));
- vkStream->read((VkQueueGlobalPriorityEXT*)forUnmarshaling->priorities, VK_MAX_GLOBAL_PRIORITY_SIZE_EXT * sizeof(VkQueueGlobalPriorityEXT));
+ vkStream->read((VkQueueGlobalPriorityEXT*)forUnmarshaling->priorities,
+ VK_MAX_GLOBAL_PRIORITY_SIZE_EXT * sizeof(VkQueueGlobalPriorityEXT));
}
#endif
#ifdef VK_EXT_multi_draw
void marshal_VkPhysicalDeviceMultiDrawFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiDrawFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMultiDrawFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -27876,14 +24976,11 @@
}
void unmarshal_VkPhysicalDeviceMultiDrawFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceMultiDrawFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMultiDrawFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -27891,14 +24988,11 @@
}
void marshal_VkPhysicalDeviceMultiDrawPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiDrawPropertiesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMultiDrawPropertiesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -27906,56 +25000,41 @@
}
void unmarshal_VkPhysicalDeviceMultiDrawPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceMultiDrawPropertiesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceMultiDrawPropertiesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->maxMultiDrawCount, sizeof(uint32_t));
}
-void marshal_VkMultiDrawInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMultiDrawInfoEXT* forMarshaling)
-{
+void marshal_VkMultiDrawInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMultiDrawInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->firstVertex, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->vertexCount, sizeof(uint32_t));
}
-void unmarshal_VkMultiDrawInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMultiDrawInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkMultiDrawInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMultiDrawInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->firstVertex, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->vertexCount, sizeof(uint32_t));
}
-void marshal_VkMultiDrawIndexedInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMultiDrawIndexedInfoEXT* forMarshaling)
-{
+void marshal_VkMultiDrawIndexedInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMultiDrawIndexedInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->firstIndex, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->indexCount, sizeof(uint32_t));
vkStream->write((int32_t*)&forMarshaling->vertexOffset, sizeof(int32_t));
}
-void unmarshal_VkMultiDrawIndexedInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMultiDrawIndexedInfoEXT* forUnmarshaling)
-{
+void unmarshal_VkMultiDrawIndexedInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMultiDrawIndexedInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->firstIndex, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->indexCount, sizeof(uint32_t));
@@ -27967,14 +25046,11 @@
#endif
#ifdef VK_EXT_border_color_swizzle
void marshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -27983,14 +25059,11 @@
}
void unmarshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -27999,48 +25072,41 @@
}
void marshal_VkSamplerBorderColorComponentMappingCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerBorderColorComponentMappingCreateInfoEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerBorderColorComponentMappingCreateInfoEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkComponentMapping(vkStream, rootType, (VkComponentMapping*)(&forMarshaling->components));
+ marshal_VkComponentMapping(vkStream, rootType,
+ (VkComponentMapping*)(&forMarshaling->components));
vkStream->write((VkBool32*)&forMarshaling->srgb, sizeof(VkBool32));
}
void unmarshal_VkSamplerBorderColorComponentMappingCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSamplerBorderColorComponentMappingCreateInfoEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSamplerBorderColorComponentMappingCreateInfoEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkComponentMapping(vkStream, rootType, (VkComponentMapping*)(&forUnmarshaling->components));
+ unmarshal_VkComponentMapping(vkStream, rootType,
+ (VkComponentMapping*)(&forUnmarshaling->components));
vkStream->read((VkBool32*)&forUnmarshaling->srgb, sizeof(VkBool32));
}
#endif
#ifdef VK_EXT_pageable_device_local_memory
void marshal_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -28048,14 +25114,11 @@
}
void unmarshal_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -28064,29 +25127,21 @@
#endif
#ifdef VK_KHR_acceleration_structure
-void marshal_VkDeviceOrHostAddressKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceOrHostAddressKHR* forMarshaling)
-{
+void marshal_VkDeviceOrHostAddressKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceOrHostAddressKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
}
-void unmarshal_VkDeviceOrHostAddressKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceOrHostAddressKHR* forUnmarshaling)
-{
+void unmarshal_VkDeviceOrHostAddressKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceOrHostAddressKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkDeviceAddress*)&forUnmarshaling->deviceAddress, sizeof(VkDeviceAddress));
}
void marshal_VkAccelerationStructureBuildRangeInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureBuildRangeInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureBuildRangeInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->primitiveCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->primitiveOffset, sizeof(uint32_t));
@@ -28095,10 +25150,8 @@
}
void unmarshal_VkAccelerationStructureBuildRangeInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureBuildRangeInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureBuildRangeInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->primitiveCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->primitiveOffset, sizeof(uint32_t));
@@ -28107,296 +25160,284 @@
}
void marshal_VkAccelerationStructureGeometryTrianglesDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryTrianglesDataKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureGeometryTrianglesDataKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkFormat*)&forMarshaling->vertexFormat, sizeof(VkFormat));
- marshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->vertexData));
+ marshal_VkDeviceOrHostAddressConstKHR(
+ vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->vertexData));
vkStream->write((VkDeviceSize*)&forMarshaling->vertexStride, sizeof(VkDeviceSize));
vkStream->write((uint32_t*)&forMarshaling->maxVertex, sizeof(uint32_t));
vkStream->write((VkIndexType*)&forMarshaling->indexType, sizeof(VkIndexType));
- marshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->indexData));
- marshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->transformData));
+ marshal_VkDeviceOrHostAddressConstKHR(
+ vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->indexData));
+ marshal_VkDeviceOrHostAddressConstKHR(
+ vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->transformData));
}
void unmarshal_VkAccelerationStructureGeometryTrianglesDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureGeometryTrianglesDataKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureGeometryTrianglesDataKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkFormat*)&forUnmarshaling->vertexFormat, sizeof(VkFormat));
- unmarshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->vertexData));
+ unmarshal_VkDeviceOrHostAddressConstKHR(
+ vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->vertexData));
vkStream->read((VkDeviceSize*)&forUnmarshaling->vertexStride, sizeof(VkDeviceSize));
vkStream->read((uint32_t*)&forUnmarshaling->maxVertex, sizeof(uint32_t));
vkStream->read((VkIndexType*)&forUnmarshaling->indexType, sizeof(VkIndexType));
- unmarshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->indexData));
- unmarshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->transformData));
+ unmarshal_VkDeviceOrHostAddressConstKHR(
+ vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->indexData));
+ unmarshal_VkDeviceOrHostAddressConstKHR(
+ vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->transformData));
}
void marshal_VkAccelerationStructureGeometryAabbsDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryAabbsDataKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureGeometryAabbsDataKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->data));
+ marshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType,
+ (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->data));
vkStream->write((VkDeviceSize*)&forMarshaling->stride, sizeof(VkDeviceSize));
}
void unmarshal_VkAccelerationStructureGeometryAabbsDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureGeometryAabbsDataKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureGeometryAabbsDataKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->data));
+ unmarshal_VkDeviceOrHostAddressConstKHR(
+ vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->data));
vkStream->read((VkDeviceSize*)&forUnmarshaling->stride, sizeof(VkDeviceSize));
}
void marshal_VkAccelerationStructureGeometryInstancesDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryInstancesDataKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureGeometryInstancesDataKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->arrayOfPointers, sizeof(VkBool32));
- marshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->data));
+ marshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType,
+ (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->data));
}
void unmarshal_VkAccelerationStructureGeometryInstancesDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureGeometryInstancesDataKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureGeometryInstancesDataKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->arrayOfPointers, sizeof(VkBool32));
- unmarshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->data));
+ unmarshal_VkDeviceOrHostAddressConstKHR(
+ vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->data));
}
void marshal_VkAccelerationStructureGeometryDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryDataKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureGeometryDataKHR* forMarshaling) {
(void)rootType;
- marshal_VkAccelerationStructureGeometryTrianglesDataKHR(vkStream, rootType, (VkAccelerationStructureGeometryTrianglesDataKHR*)(&forMarshaling->triangles));
+ marshal_VkAccelerationStructureGeometryTrianglesDataKHR(
+ vkStream, rootType,
+ (VkAccelerationStructureGeometryTrianglesDataKHR*)(&forMarshaling->triangles));
}
void unmarshal_VkAccelerationStructureGeometryDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureGeometryDataKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureGeometryDataKHR* forUnmarshaling) {
(void)rootType;
- unmarshal_VkAccelerationStructureGeometryTrianglesDataKHR(vkStream, rootType, (VkAccelerationStructureGeometryTrianglesDataKHR*)(&forUnmarshaling->triangles));
+ unmarshal_VkAccelerationStructureGeometryTrianglesDataKHR(
+ vkStream, rootType,
+ (VkAccelerationStructureGeometryTrianglesDataKHR*)(&forUnmarshaling->triangles));
}
void marshal_VkAccelerationStructureGeometryKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureGeometryKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkGeometryTypeKHR*)&forMarshaling->geometryType, sizeof(VkGeometryTypeKHR));
- marshal_VkAccelerationStructureGeometryDataKHR(vkStream, rootType, (VkAccelerationStructureGeometryDataKHR*)(&forMarshaling->geometry));
+ marshal_VkAccelerationStructureGeometryDataKHR(
+ vkStream, rootType, (VkAccelerationStructureGeometryDataKHR*)(&forMarshaling->geometry));
vkStream->write((VkGeometryFlagsKHR*)&forMarshaling->flags, sizeof(VkGeometryFlagsKHR));
}
void unmarshal_VkAccelerationStructureGeometryKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureGeometryKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureGeometryKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkGeometryTypeKHR*)&forUnmarshaling->geometryType, sizeof(VkGeometryTypeKHR));
- unmarshal_VkAccelerationStructureGeometryDataKHR(vkStream, rootType, (VkAccelerationStructureGeometryDataKHR*)(&forUnmarshaling->geometry));
+ unmarshal_VkAccelerationStructureGeometryDataKHR(
+ vkStream, rootType, (VkAccelerationStructureGeometryDataKHR*)(&forUnmarshaling->geometry));
vkStream->read((VkGeometryFlagsKHR*)&forUnmarshaling->flags, sizeof(VkGeometryFlagsKHR));
}
void marshal_VkAccelerationStructureBuildGeometryInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureBuildGeometryInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureBuildGeometryInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkAccelerationStructureTypeKHR*)&forMarshaling->type, sizeof(VkAccelerationStructureTypeKHR));
- vkStream->write((VkBuildAccelerationStructureFlagsKHR*)&forMarshaling->flags, sizeof(VkBuildAccelerationStructureFlagsKHR));
- vkStream->write((VkBuildAccelerationStructureModeKHR*)&forMarshaling->mode, sizeof(VkBuildAccelerationStructureModeKHR));
+ vkStream->write((VkAccelerationStructureTypeKHR*)&forMarshaling->type,
+ sizeof(VkAccelerationStructureTypeKHR));
+ vkStream->write((VkBuildAccelerationStructureFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkBuildAccelerationStructureFlagsKHR));
+ vkStream->write((VkBuildAccelerationStructureModeKHR*)&forMarshaling->mode,
+ sizeof(VkBuildAccelerationStructureModeKHR));
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(&forMarshaling->srcAccelerationStructure, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(
+ &forMarshaling->srcAccelerationStructure, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
uint64_t cgen_var_1;
- vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(&forMarshaling->dstAccelerationStructure, &cgen_var_1, 1);
+ vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(
+ &forMarshaling->dstAccelerationStructure, &cgen_var_1, 1);
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
vkStream->write((uint32_t*)&forMarshaling->geometryCount, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pGeometries;
vkStream->putBe64(cgen_var_2);
- if (forMarshaling->pGeometries)
- {
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->geometryCount; ++i)
- {
- marshal_VkAccelerationStructureGeometryKHR(vkStream, rootType, (const VkAccelerationStructureGeometryKHR*)(forMarshaling->pGeometries + i));
+ if (forMarshaling->pGeometries) {
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->geometryCount; ++i) {
+ marshal_VkAccelerationStructureGeometryKHR(
+ vkStream, rootType,
+ (const VkAccelerationStructureGeometryKHR*)(forMarshaling->pGeometries + i));
}
}
}
- marshal_VkDeviceOrHostAddressKHR(vkStream, rootType, (VkDeviceOrHostAddressKHR*)(&forMarshaling->scratchData));
+ marshal_VkDeviceOrHostAddressKHR(vkStream, rootType,
+ (VkDeviceOrHostAddressKHR*)(&forMarshaling->scratchData));
}
void unmarshal_VkAccelerationStructureBuildGeometryInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureBuildGeometryInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureBuildGeometryInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkAccelerationStructureTypeKHR*)&forUnmarshaling->type, sizeof(VkAccelerationStructureTypeKHR));
- vkStream->read((VkBuildAccelerationStructureFlagsKHR*)&forUnmarshaling->flags, sizeof(VkBuildAccelerationStructureFlagsKHR));
- vkStream->read((VkBuildAccelerationStructureModeKHR*)&forUnmarshaling->mode, sizeof(VkBuildAccelerationStructureModeKHR));
+ vkStream->read((VkAccelerationStructureTypeKHR*)&forUnmarshaling->type,
+ sizeof(VkAccelerationStructureTypeKHR));
+ vkStream->read((VkBuildAccelerationStructureFlagsKHR*)&forUnmarshaling->flags,
+ sizeof(VkBuildAccelerationStructureFlagsKHR));
+ vkStream->read((VkBuildAccelerationStructureModeKHR*)&forUnmarshaling->mode,
+ sizeof(VkBuildAccelerationStructureModeKHR));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(&cgen_var_0, (VkAccelerationStructureKHR*)&forUnmarshaling->srcAccelerationStructure, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(
+ &cgen_var_0, (VkAccelerationStructureKHR*)&forUnmarshaling->srcAccelerationStructure, 1);
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(&cgen_var_1, (VkAccelerationStructureKHR*)&forUnmarshaling->dstAccelerationStructure, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(
+ &cgen_var_1, (VkAccelerationStructureKHR*)&forUnmarshaling->dstAccelerationStructure, 1);
vkStream->read((uint32_t*)&forUnmarshaling->geometryCount, sizeof(uint32_t));
// WARNING PTR CHECK
const VkAccelerationStructureGeometryKHR* check_pGeometries;
check_pGeometries = (const VkAccelerationStructureGeometryKHR*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pGeometries)
- {
- if (!(check_pGeometries))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pGeometries inconsistent between guest and host\n");
+ if (forUnmarshaling->pGeometries) {
+ if (!(check_pGeometries)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pGeometries inconsistent between guest and host\n");
}
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->geometryCount; ++i)
- {
- unmarshal_VkAccelerationStructureGeometryKHR(vkStream, rootType, (VkAccelerationStructureGeometryKHR*)(forUnmarshaling->pGeometries + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->geometryCount; ++i) {
+ unmarshal_VkAccelerationStructureGeometryKHR(
+ vkStream, rootType,
+ (VkAccelerationStructureGeometryKHR*)(forUnmarshaling->pGeometries + i));
}
}
}
- unmarshal_VkDeviceOrHostAddressKHR(vkStream, rootType, (VkDeviceOrHostAddressKHR*)(&forUnmarshaling->scratchData));
+ unmarshal_VkDeviceOrHostAddressKHR(vkStream, rootType,
+ (VkDeviceOrHostAddressKHR*)(&forUnmarshaling->scratchData));
}
void marshal_VkAccelerationStructureCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureCreateInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureCreateInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkAccelerationStructureCreateFlagsKHR*)&forMarshaling->createFlags, sizeof(VkAccelerationStructureCreateFlagsKHR));
+ vkStream->write((VkAccelerationStructureCreateFlagsKHR*)&forMarshaling->createFlags,
+ sizeof(VkAccelerationStructureCreateFlagsKHR));
uint64_t cgen_var_0;
vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
- vkStream->write((VkAccelerationStructureTypeKHR*)&forMarshaling->type, sizeof(VkAccelerationStructureTypeKHR));
+ vkStream->write((VkAccelerationStructureTypeKHR*)&forMarshaling->type,
+ sizeof(VkAccelerationStructureTypeKHR));
vkStream->write((VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
}
void unmarshal_VkAccelerationStructureCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureCreateInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureCreateInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkAccelerationStructureCreateFlagsKHR*)&forUnmarshaling->createFlags, sizeof(VkAccelerationStructureCreateFlagsKHR));
+ vkStream->read((VkAccelerationStructureCreateFlagsKHR*)&forUnmarshaling->createFlags,
+ sizeof(VkAccelerationStructureCreateFlagsKHR));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0, (VkBuffer*)&forUnmarshaling->buffer, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+ (VkBuffer*)&forUnmarshaling->buffer, 1);
vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
- vkStream->read((VkAccelerationStructureTypeKHR*)&forUnmarshaling->type, sizeof(VkAccelerationStructureTypeKHR));
+ vkStream->read((VkAccelerationStructureTypeKHR*)&forUnmarshaling->type,
+ sizeof(VkAccelerationStructureTypeKHR));
vkStream->read((VkDeviceAddress*)&forUnmarshaling->deviceAddress, sizeof(VkDeviceAddress));
}
void marshal_VkWriteDescriptorSetAccelerationStructureKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWriteDescriptorSetAccelerationStructureKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWriteDescriptorSetAccelerationStructureKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -28404,323 +25445,323 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAccelerationStructures;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pAccelerationStructures)
- {
- if (forMarshaling->accelerationStructureCount)
- {
+ if (forMarshaling->pAccelerationStructures) {
+ if (forMarshaling->accelerationStructureCount) {
uint64_t* cgen_var_0_0;
vkStream->alloc((void**)&cgen_var_0_0, forMarshaling->accelerationStructureCount * 8);
- vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(forMarshaling->pAccelerationStructures, cgen_var_0_0, forMarshaling->accelerationStructureCount);
+ vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(
+ forMarshaling->pAccelerationStructures, cgen_var_0_0,
+ forMarshaling->accelerationStructureCount);
vkStream->write((uint64_t*)cgen_var_0_0, forMarshaling->accelerationStructureCount * 8);
}
}
}
void unmarshal_VkWriteDescriptorSetAccelerationStructureKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkWriteDescriptorSetAccelerationStructureKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkWriteDescriptorSetAccelerationStructureKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint32_t*)&forUnmarshaling->accelerationStructureCount, sizeof(uint32_t));
// WARNING PTR CHECK
const VkAccelerationStructureKHR* check_pAccelerationStructures;
- check_pAccelerationStructures = (const VkAccelerationStructureKHR*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pAccelerationStructures)
- {
- if (!(check_pAccelerationStructures))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pAccelerationStructures inconsistent between guest and host\n");
+ check_pAccelerationStructures =
+ (const VkAccelerationStructureKHR*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pAccelerationStructures) {
+ if (!(check_pAccelerationStructures)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pAccelerationStructures inconsistent between guest "
+ "and host\n");
}
- if (forUnmarshaling->accelerationStructureCount)
- {
+ if (forUnmarshaling->accelerationStructureCount) {
uint64_t* cgen_var_0_0;
vkStream->alloc((void**)&cgen_var_0_0, forUnmarshaling->accelerationStructureCount * 8);
- vkStream->read((uint64_t*)cgen_var_0_0, forUnmarshaling->accelerationStructureCount * 8);
- vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(cgen_var_0_0, (VkAccelerationStructureKHR*)forUnmarshaling->pAccelerationStructures, forUnmarshaling->accelerationStructureCount);
+ vkStream->read((uint64_t*)cgen_var_0_0,
+ forUnmarshaling->accelerationStructureCount * 8);
+ vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(
+ cgen_var_0_0, (VkAccelerationStructureKHR*)forUnmarshaling->pAccelerationStructures,
+ forUnmarshaling->accelerationStructureCount);
}
}
}
void marshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceAccelerationStructureFeaturesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceAccelerationStructureFeaturesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->accelerationStructure, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->accelerationStructureCaptureReplay, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->accelerationStructureIndirectBuild, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->accelerationStructureCaptureReplay,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->accelerationStructureIndirectBuild,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->accelerationStructureHostCommands, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->descriptorBindingAccelerationStructureUpdateAfterBind, sizeof(VkBool32));
+ vkStream->write(
+ (VkBool32*)&forMarshaling->descriptorBindingAccelerationStructureUpdateAfterBind,
+ sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceAccelerationStructureFeaturesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceAccelerationStructureFeaturesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->accelerationStructure, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->accelerationStructureCaptureReplay, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->accelerationStructureIndirectBuild, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->accelerationStructureHostCommands, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingAccelerationStructureUpdateAfterBind, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->accelerationStructureCaptureReplay,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->accelerationStructureIndirectBuild,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->accelerationStructureHostCommands,
+ sizeof(VkBool32));
+ vkStream->read(
+ (VkBool32*)&forUnmarshaling->descriptorBindingAccelerationStructureUpdateAfterBind,
+ sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceAccelerationStructurePropertiesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceAccelerationStructurePropertiesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((uint64_t*)&forMarshaling->maxGeometryCount, sizeof(uint64_t));
vkStream->write((uint64_t*)&forMarshaling->maxInstanceCount, sizeof(uint64_t));
vkStream->write((uint64_t*)&forMarshaling->maxPrimitiveCount, sizeof(uint64_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorAccelerationStructures, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindAccelerationStructures, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetAccelerationStructures, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindAccelerationStructures, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->minAccelerationStructureScratchOffsetAlignment, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorAccelerationStructures,
+ sizeof(uint32_t));
+ vkStream->write(
+ (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindAccelerationStructures,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetAccelerationStructures,
+ sizeof(uint32_t));
+ vkStream->write(
+ (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindAccelerationStructures,
+ sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->minAccelerationStructureScratchOffsetAlignment,
+ sizeof(uint32_t));
}
void unmarshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceAccelerationStructurePropertiesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceAccelerationStructurePropertiesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((uint64_t*)&forUnmarshaling->maxGeometryCount, sizeof(uint64_t));
vkStream->read((uint64_t*)&forUnmarshaling->maxInstanceCount, sizeof(uint64_t));
vkStream->read((uint64_t*)&forUnmarshaling->maxPrimitiveCount, sizeof(uint64_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorAccelerationStructures, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindAccelerationStructures, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetAccelerationStructures, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindAccelerationStructures, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->minAccelerationStructureScratchOffsetAlignment, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorAccelerationStructures,
+ sizeof(uint32_t));
+ vkStream->read(
+ (uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindAccelerationStructures,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetAccelerationStructures,
+ sizeof(uint32_t));
+ vkStream->read(
+ (uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindAccelerationStructures,
+ sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->minAccelerationStructureScratchOffsetAlignment,
+ sizeof(uint32_t));
}
void marshal_VkAccelerationStructureDeviceAddressInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureDeviceAddressInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureDeviceAddressInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(&forMarshaling->accelerationStructure, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(
+ &forMarshaling->accelerationStructure, &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
}
void unmarshal_VkAccelerationStructureDeviceAddressInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureDeviceAddressInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureDeviceAddressInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(&cgen_var_0, (VkAccelerationStructureKHR*)&forUnmarshaling->accelerationStructure, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(
+ &cgen_var_0, (VkAccelerationStructureKHR*)&forUnmarshaling->accelerationStructure, 1);
}
void marshal_VkAccelerationStructureVersionInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureVersionInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureVersionInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((const uint8_t*)forMarshaling->pVersionData, 2*VK_UUID_SIZE * sizeof(const uint8_t));
+ vkStream->write((const uint8_t*)forMarshaling->pVersionData,
+ 2 * VK_UUID_SIZE * sizeof(const uint8_t));
}
void unmarshal_VkAccelerationStructureVersionInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureVersionInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureVersionInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((uint8_t*)forUnmarshaling->pVersionData, 2*VK_UUID_SIZE * sizeof(const uint8_t));
+ vkStream->read((uint8_t*)forUnmarshaling->pVersionData,
+ 2 * VK_UUID_SIZE * sizeof(const uint8_t));
}
void marshal_VkCopyAccelerationStructureToMemoryInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyAccelerationStructureToMemoryInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyAccelerationStructureToMemoryInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(&forMarshaling->src, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(&forMarshaling->src,
+ &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- marshal_VkDeviceOrHostAddressKHR(vkStream, rootType, (VkDeviceOrHostAddressKHR*)(&forMarshaling->dst));
- vkStream->write((VkCopyAccelerationStructureModeKHR*)&forMarshaling->mode, sizeof(VkCopyAccelerationStructureModeKHR));
+ marshal_VkDeviceOrHostAddressKHR(vkStream, rootType,
+ (VkDeviceOrHostAddressKHR*)(&forMarshaling->dst));
+ vkStream->write((VkCopyAccelerationStructureModeKHR*)&forMarshaling->mode,
+ sizeof(VkCopyAccelerationStructureModeKHR));
}
void unmarshal_VkCopyAccelerationStructureToMemoryInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCopyAccelerationStructureToMemoryInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyAccelerationStructureToMemoryInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(&cgen_var_0, (VkAccelerationStructureKHR*)&forUnmarshaling->src, 1);
- unmarshal_VkDeviceOrHostAddressKHR(vkStream, rootType, (VkDeviceOrHostAddressKHR*)(&forUnmarshaling->dst));
- vkStream->read((VkCopyAccelerationStructureModeKHR*)&forUnmarshaling->mode, sizeof(VkCopyAccelerationStructureModeKHR));
+ vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(
+ &cgen_var_0, (VkAccelerationStructureKHR*)&forUnmarshaling->src, 1);
+ unmarshal_VkDeviceOrHostAddressKHR(vkStream, rootType,
+ (VkDeviceOrHostAddressKHR*)(&forUnmarshaling->dst));
+ vkStream->read((VkCopyAccelerationStructureModeKHR*)&forUnmarshaling->mode,
+ sizeof(VkCopyAccelerationStructureModeKHR));
}
void marshal_VkCopyMemoryToAccelerationStructureInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyMemoryToAccelerationStructureInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyMemoryToAccelerationStructureInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- marshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->src));
+ marshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType,
+ (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->src));
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(&forMarshaling->dst, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(&forMarshaling->dst,
+ &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->write((VkCopyAccelerationStructureModeKHR*)&forMarshaling->mode, sizeof(VkCopyAccelerationStructureModeKHR));
+ vkStream->write((VkCopyAccelerationStructureModeKHR*)&forMarshaling->mode,
+ sizeof(VkCopyAccelerationStructureModeKHR));
}
void unmarshal_VkCopyMemoryToAccelerationStructureInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCopyMemoryToAccelerationStructureInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyMemoryToAccelerationStructureInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- unmarshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->src));
+ unmarshal_VkDeviceOrHostAddressConstKHR(
+ vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->src));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(&cgen_var_0, (VkAccelerationStructureKHR*)&forUnmarshaling->dst, 1);
- vkStream->read((VkCopyAccelerationStructureModeKHR*)&forUnmarshaling->mode, sizeof(VkCopyAccelerationStructureModeKHR));
+ vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(
+ &cgen_var_0, (VkAccelerationStructureKHR*)&forUnmarshaling->dst, 1);
+ vkStream->read((VkCopyAccelerationStructureModeKHR*)&forUnmarshaling->mode,
+ sizeof(VkCopyAccelerationStructureModeKHR));
}
void marshal_VkCopyAccelerationStructureInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyAccelerationStructureInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyAccelerationStructureInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
uint64_t cgen_var_0;
- vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(&forMarshaling->src, &cgen_var_0, 1);
+ vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(&forMarshaling->src,
+ &cgen_var_0, 1);
vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
uint64_t cgen_var_1;
- vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(&forMarshaling->dst, &cgen_var_1, 1);
+ vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(&forMarshaling->dst,
+ &cgen_var_1, 1);
vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->write((VkCopyAccelerationStructureModeKHR*)&forMarshaling->mode, sizeof(VkCopyAccelerationStructureModeKHR));
+ vkStream->write((VkCopyAccelerationStructureModeKHR*)&forMarshaling->mode,
+ sizeof(VkCopyAccelerationStructureModeKHR));
}
void unmarshal_VkCopyAccelerationStructureInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCopyAccelerationStructureInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyAccelerationStructureInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
uint64_t cgen_var_0;
vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(&cgen_var_0, (VkAccelerationStructureKHR*)&forUnmarshaling->src, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(
+ &cgen_var_0, (VkAccelerationStructureKHR*)&forUnmarshaling->src, 1);
uint64_t cgen_var_1;
vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(&cgen_var_1, (VkAccelerationStructureKHR*)&forUnmarshaling->dst, 1);
- vkStream->read((VkCopyAccelerationStructureModeKHR*)&forUnmarshaling->mode, sizeof(VkCopyAccelerationStructureModeKHR));
+ vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(
+ &cgen_var_1, (VkAccelerationStructureKHR*)&forUnmarshaling->dst, 1);
+ vkStream->read((VkCopyAccelerationStructureModeKHR*)&forUnmarshaling->mode,
+ sizeof(VkCopyAccelerationStructureModeKHR));
}
void marshal_VkAccelerationStructureBuildSizesInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureBuildSizesInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureBuildSizesInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -28730,18 +25771,16 @@
}
void unmarshal_VkAccelerationStructureBuildSizesInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureBuildSizesInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureBuildSizesInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkDeviceSize*)&forUnmarshaling->accelerationStructureSize, sizeof(VkDeviceSize));
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->accelerationStructureSize,
+ sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->updateScratchSize, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->buildScratchSize, sizeof(VkDeviceSize));
}
@@ -28749,18 +25788,16 @@
#endif
#ifdef VK_KHR_ray_tracing_pipeline
void marshal_VkRayTracingShaderGroupCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRayTracingShaderGroupCreateInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRayTracingShaderGroupCreateInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
- vkStream->write((VkRayTracingShaderGroupTypeKHR*)&forMarshaling->type, sizeof(VkRayTracingShaderGroupTypeKHR));
+ vkStream->write((VkRayTracingShaderGroupTypeKHR*)&forMarshaling->type,
+ sizeof(VkRayTracingShaderGroupTypeKHR));
vkStream->write((uint32_t*)&forMarshaling->generalShader, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->closestHitShader, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->anyHitShader, sizeof(uint32_t));
@@ -28768,25 +25805,23 @@
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pShaderGroupCaptureReplayHandle;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pShaderGroupCaptureReplayHandle)
- {
- vkStream->write((const void*)forMarshaling->pShaderGroupCaptureReplayHandle, sizeof(const uint8_t));
+ if (forMarshaling->pShaderGroupCaptureReplayHandle) {
+ vkStream->write((const void*)forMarshaling->pShaderGroupCaptureReplayHandle,
+ sizeof(const uint8_t));
}
}
void unmarshal_VkRayTracingShaderGroupCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRayTracingShaderGroupCreateInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRayTracingShaderGroupCreateInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
- vkStream->read((VkRayTracingShaderGroupTypeKHR*)&forUnmarshaling->type, sizeof(VkRayTracingShaderGroupTypeKHR));
+ vkStream->read((VkRayTracingShaderGroupTypeKHR*)&forUnmarshaling->type,
+ sizeof(VkRayTracingShaderGroupTypeKHR));
vkStream->read((uint32_t*)&forUnmarshaling->generalShader, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->closestHitShader, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->anyHitShader, sizeof(uint32_t));
@@ -28794,25 +25829,23 @@
// WARNING PTR CHECK
const void* check_pShaderGroupCaptureReplayHandle;
check_pShaderGroupCaptureReplayHandle = (const void*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pShaderGroupCaptureReplayHandle)
- {
- if (!(check_pShaderGroupCaptureReplayHandle))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pShaderGroupCaptureReplayHandle inconsistent between guest and host\n");
+ if (forUnmarshaling->pShaderGroupCaptureReplayHandle) {
+ if (!(check_pShaderGroupCaptureReplayHandle)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pShaderGroupCaptureReplayHandle inconsistent between "
+ "guest and host\n");
}
- vkStream->read((void*)forUnmarshaling->pShaderGroupCaptureReplayHandle, sizeof(const uint8_t));
+ vkStream->read((void*)forUnmarshaling->pShaderGroupCaptureReplayHandle,
+ sizeof(const uint8_t));
}
}
void marshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRayTracingPipelineInterfaceCreateInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRayTracingPipelineInterfaceCreateInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -28821,14 +25854,11 @@
}
void unmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRayTracingPipelineInterfaceCreateInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRayTracingPipelineInterfaceCreateInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -28837,184 +25867,188 @@
}
void marshal_VkRayTracingPipelineCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRayTracingPipelineCreateInfoKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRayTracingPipelineCreateInfoKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkPipelineCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags));
vkStream->write((uint32_t*)&forMarshaling->stageCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i)
- {
- marshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i) {
+ marshal_VkPipelineShaderStageCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->groupCount, sizeof(uint32_t));
- if (forMarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->groupCount; ++i)
- {
- marshal_VkRayTracingShaderGroupCreateInfoKHR(vkStream, rootType, (const VkRayTracingShaderGroupCreateInfoKHR*)(forMarshaling->pGroups + i));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->groupCount; ++i) {
+ marshal_VkRayTracingShaderGroupCreateInfoKHR(
+ vkStream, rootType,
+ (const VkRayTracingShaderGroupCreateInfoKHR*)(forMarshaling->pGroups + i));
}
}
vkStream->write((uint32_t*)&forMarshaling->maxPipelineRayRecursionDepth, sizeof(uint32_t));
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pLibraryInfo;
vkStream->putBe64(cgen_var_0);
- if (forMarshaling->pLibraryInfo)
- {
- marshal_VkPipelineLibraryCreateInfoKHR(vkStream, rootType, (const VkPipelineLibraryCreateInfoKHR*)(forMarshaling->pLibraryInfo));
+ if (forMarshaling->pLibraryInfo) {
+ marshal_VkPipelineLibraryCreateInfoKHR(
+ vkStream, rootType,
+ (const VkPipelineLibraryCreateInfoKHR*)(forMarshaling->pLibraryInfo));
}
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pLibraryInterface;
vkStream->putBe64(cgen_var_1);
- if (forMarshaling->pLibraryInterface)
- {
- marshal_VkRayTracingPipelineInterfaceCreateInfoKHR(vkStream, rootType, (const VkRayTracingPipelineInterfaceCreateInfoKHR*)(forMarshaling->pLibraryInterface));
+ if (forMarshaling->pLibraryInterface) {
+ marshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ vkStream, rootType,
+ (const VkRayTracingPipelineInterfaceCreateInfoKHR*)(forMarshaling->pLibraryInterface));
}
// WARNING PTR CHECK
uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pDynamicState;
vkStream->putBe64(cgen_var_2);
- if (forMarshaling->pDynamicState)
- {
- marshal_VkPipelineDynamicStateCreateInfo(vkStream, rootType, (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState));
+ if (forMarshaling->pDynamicState) {
+ marshal_VkPipelineDynamicStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState));
}
uint64_t cgen_var_3;
- vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_3, 1);
+ vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_3,
+ 1);
vkStream->write((uint64_t*)&cgen_var_3, 1 * 8);
uint64_t cgen_var_4;
- vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle, &cgen_var_4, 1);
+ vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle,
+ &cgen_var_4, 1);
vkStream->write((uint64_t*)&cgen_var_4, 1 * 8);
vkStream->write((int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
}
void unmarshal_VkRayTracingPipelineCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRayTracingPipelineCreateInfoKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRayTracingPipelineCreateInfoKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkPipelineCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCreateFlags));
vkStream->read((uint32_t*)&forUnmarshaling->stageCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->stageCount; ++i)
- {
- unmarshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->stageCount; ++i) {
+ unmarshal_VkPipelineShaderStageCreateInfo(
+ vkStream, rootType,
+ (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->groupCount, sizeof(uint32_t));
- if (forUnmarshaling)
- {
- for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->groupCount; ++i)
- {
- unmarshal_VkRayTracingShaderGroupCreateInfoKHR(vkStream, rootType, (VkRayTracingShaderGroupCreateInfoKHR*)(forUnmarshaling->pGroups + i));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->groupCount; ++i) {
+ unmarshal_VkRayTracingShaderGroupCreateInfoKHR(
+ vkStream, rootType,
+ (VkRayTracingShaderGroupCreateInfoKHR*)(forUnmarshaling->pGroups + i));
}
}
vkStream->read((uint32_t*)&forUnmarshaling->maxPipelineRayRecursionDepth, sizeof(uint32_t));
// WARNING PTR CHECK
const VkPipelineLibraryCreateInfoKHR* check_pLibraryInfo;
check_pLibraryInfo = (const VkPipelineLibraryCreateInfoKHR*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pLibraryInfo)
- {
- if (!(check_pLibraryInfo))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pLibraryInfo inconsistent between guest and host\n");
+ if (forUnmarshaling->pLibraryInfo) {
+ if (!(check_pLibraryInfo)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pLibraryInfo inconsistent between guest and host\n");
}
- unmarshal_VkPipelineLibraryCreateInfoKHR(vkStream, rootType, (VkPipelineLibraryCreateInfoKHR*)(forUnmarshaling->pLibraryInfo));
+ unmarshal_VkPipelineLibraryCreateInfoKHR(
+ vkStream, rootType, (VkPipelineLibraryCreateInfoKHR*)(forUnmarshaling->pLibraryInfo));
}
// WARNING PTR CHECK
const VkRayTracingPipelineInterfaceCreateInfoKHR* check_pLibraryInterface;
- check_pLibraryInterface = (const VkRayTracingPipelineInterfaceCreateInfoKHR*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pLibraryInterface)
- {
- if (!(check_pLibraryInterface))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pLibraryInterface inconsistent between guest and host\n");
+ check_pLibraryInterface =
+ (const VkRayTracingPipelineInterfaceCreateInfoKHR*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pLibraryInterface) {
+ if (!(check_pLibraryInterface)) {
+ fprintf(
+ stderr,
+ "fatal: forUnmarshaling->pLibraryInterface inconsistent between guest and host\n");
}
- unmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(vkStream, rootType, (VkRayTracingPipelineInterfaceCreateInfoKHR*)(forUnmarshaling->pLibraryInterface));
+ unmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ vkStream, rootType,
+ (VkRayTracingPipelineInterfaceCreateInfoKHR*)(forUnmarshaling->pLibraryInterface));
}
// WARNING PTR CHECK
const VkPipelineDynamicStateCreateInfo* check_pDynamicState;
check_pDynamicState = (const VkPipelineDynamicStateCreateInfo*)(uintptr_t)vkStream->getBe64();
- if (forUnmarshaling->pDynamicState)
- {
- if (!(check_pDynamicState))
- {
- fprintf(stderr, "fatal: forUnmarshaling->pDynamicState inconsistent between guest and host\n");
+ if (forUnmarshaling->pDynamicState) {
+ if (!(check_pDynamicState)) {
+ fprintf(stderr,
+ "fatal: forUnmarshaling->pDynamicState inconsistent between guest and host\n");
}
- unmarshal_VkPipelineDynamicStateCreateInfo(vkStream, rootType, (VkPipelineDynamicStateCreateInfo*)(forUnmarshaling->pDynamicState));
+ unmarshal_VkPipelineDynamicStateCreateInfo(
+ vkStream, rootType,
+ (VkPipelineDynamicStateCreateInfo*)(forUnmarshaling->pDynamicState));
}
uint64_t cgen_var_3;
vkStream->read((uint64_t*)&cgen_var_3, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_3, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(
+ &cgen_var_3, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
uint64_t cgen_var_4;
vkStream->read((uint64_t*)&cgen_var_4, 1 * 8);
- vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_4, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
+ vkStream->handleMapping()->mapHandles_u64_VkPipeline(
+ &cgen_var_4, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
vkStream->read((int32_t*)&forUnmarshaling->basePipelineIndex, sizeof(int32_t));
}
void marshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
vkStream->write((VkBool32*)&forMarshaling->rayTracingPipeline, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->rayTracingPipelineShaderGroupHandleCaptureReplay, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->rayTracingPipelineShaderGroupHandleCaptureReplayMixed, sizeof(VkBool32));
- vkStream->write((VkBool32*)&forMarshaling->rayTracingPipelineTraceRaysIndirect, sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->rayTracingPipelineShaderGroupHandleCaptureReplay,
+ sizeof(VkBool32));
+ vkStream->write(
+ (VkBool32*)&forMarshaling->rayTracingPipelineShaderGroupHandleCaptureReplayMixed,
+ sizeof(VkBool32));
+ vkStream->write((VkBool32*)&forMarshaling->rayTracingPipelineTraceRaysIndirect,
+ sizeof(VkBool32));
vkStream->write((VkBool32*)&forMarshaling->rayTraversalPrimitiveCulling, sizeof(VkBool32));
}
void unmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
vkStream->read((VkBool32*)&forUnmarshaling->rayTracingPipeline, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->rayTracingPipelineShaderGroupHandleCaptureReplay, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->rayTracingPipelineShaderGroupHandleCaptureReplayMixed, sizeof(VkBool32));
- vkStream->read((VkBool32*)&forUnmarshaling->rayTracingPipelineTraceRaysIndirect, sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->rayTracingPipelineShaderGroupHandleCaptureReplay,
+ sizeof(VkBool32));
+ vkStream->read(
+ (VkBool32*)&forUnmarshaling->rayTracingPipelineShaderGroupHandleCaptureReplayMixed,
+ sizeof(VkBool32));
+ vkStream->read((VkBool32*)&forUnmarshaling->rayTracingPipelineTraceRaysIndirect,
+ sizeof(VkBool32));
vkStream->read((VkBool32*)&forUnmarshaling->rayTraversalPrimitiveCulling, sizeof(VkBool32));
}
void marshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -29022,21 +26056,19 @@
vkStream->write((uint32_t*)&forMarshaling->maxRayRecursionDepth, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxShaderGroupStride, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->shaderGroupBaseAlignment, sizeof(uint32_t));
- vkStream->write((uint32_t*)&forMarshaling->shaderGroupHandleCaptureReplaySize, sizeof(uint32_t));
+ vkStream->write((uint32_t*)&forMarshaling->shaderGroupHandleCaptureReplaySize,
+ sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxRayDispatchInvocationCount, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->shaderGroupHandleAlignment, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->maxRayHitAttributeSize, sizeof(uint32_t));
}
void unmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -29044,50 +26076,40 @@
vkStream->read((uint32_t*)&forUnmarshaling->maxRayRecursionDepth, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxShaderGroupStride, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->shaderGroupBaseAlignment, sizeof(uint32_t));
- vkStream->read((uint32_t*)&forUnmarshaling->shaderGroupHandleCaptureReplaySize, sizeof(uint32_t));
+ vkStream->read((uint32_t*)&forUnmarshaling->shaderGroupHandleCaptureReplaySize,
+ sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxRayDispatchInvocationCount, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->shaderGroupHandleAlignment, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->maxRayHitAttributeSize, sizeof(uint32_t));
}
-void marshal_VkStridedDeviceAddressRegionKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkStridedDeviceAddressRegionKHR* forMarshaling)
-{
+void marshal_VkStridedDeviceAddressRegionKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkStridedDeviceAddressRegionKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
vkStream->write((VkDeviceSize*)&forMarshaling->stride, sizeof(VkDeviceSize));
vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
}
-void unmarshal_VkStridedDeviceAddressRegionKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkStridedDeviceAddressRegionKHR* forUnmarshaling)
-{
+void unmarshal_VkStridedDeviceAddressRegionKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkStridedDeviceAddressRegionKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkDeviceAddress*)&forUnmarshaling->deviceAddress, sizeof(VkDeviceAddress));
vkStream->read((VkDeviceSize*)&forUnmarshaling->stride, sizeof(VkDeviceSize));
vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
}
-void marshal_VkTraceRaysIndirectCommandKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkTraceRaysIndirectCommandKHR* forMarshaling)
-{
+void marshal_VkTraceRaysIndirectCommandKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkTraceRaysIndirectCommandKHR* forMarshaling) {
(void)rootType;
vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
vkStream->write((uint32_t*)&forMarshaling->depth, sizeof(uint32_t));
}
-void unmarshal_VkTraceRaysIndirectCommandKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkTraceRaysIndirectCommandKHR* forUnmarshaling)
-{
+void unmarshal_VkTraceRaysIndirectCommandKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkTraceRaysIndirectCommandKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
@@ -29097,14 +26119,11 @@
#endif
#ifdef VK_KHR_ray_query
void marshal_VkPhysicalDeviceRayQueryFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRayQueryFeaturesKHR* forMarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRayQueryFeaturesKHR* forMarshaling) {
(void)rootType;
vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
@@ -29112,14 +26131,11 @@
}
void unmarshal_VkPhysicalDeviceRayQueryFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceRayQueryFeaturesKHR* forUnmarshaling)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceRayQueryFeaturesKHR* forUnmarshaling) {
(void)rootType;
vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forUnmarshaling->sType;
}
unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
@@ -29127,1557 +26143,1924 @@
}
#endif
-void marshal_extension_struct(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const void* structExtension)
-{
+void marshal_extension_struct(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const void* structExtension) {
VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension);
- size_t currExtSize = goldfish_vk_extension_struct_size_with_stream_features(vkStream->getFeatureBits(), rootType, structExtension);
- if (!currExtSize && structExtension)
- {
+ size_t currExtSize = goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, structExtension);
+ if (!currExtSize && structExtension) {
// unknown struct extension; skip and call on its pNext field
marshal_extension_struct(vkStream, rootType, (void*)structAccess->pNext);
return;
- }
- else
- {
+ } else {
// known or null extension struct
vkStream->putBe32(currExtSize);
- if (!currExtSize)
- {
+ if (!currExtSize) {
// exit if this was a null extension struct (size == 0 in this branch)
return;
}
}
vkStream->write(structExtension, sizeof(VkStructureType));
- if (!structExtension)
- {
+ if (!structExtension) {
return;
}
uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension);
- switch(structType)
- {
+ switch (structType) {
#ifdef VK_VERSION_1_1
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
- {
- marshal_VkPhysicalDeviceSubgroupProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
+ marshal_VkPhysicalDeviceSubgroupProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
- {
- marshal_VkPhysicalDevice16BitStorageFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
+ marshal_VkPhysicalDevice16BitStorageFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
- {
- marshal_VkMemoryDedicatedRequirements(vkStream, rootType, reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension));
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
+ marshal_VkMemoryDedicatedRequirements(
+ vkStream, rootType,
+ reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
- {
- marshal_VkMemoryDedicatedAllocateInfo(vkStream, rootType, reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: {
+ marshal_VkMemoryDedicatedAllocateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
- {
- marshal_VkMemoryAllocateFlagsInfo(vkStream, rootType, reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: {
+ marshal_VkMemoryAllocateFlagsInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
- {
- marshal_VkDeviceGroupRenderPassBeginInfo(vkStream, rootType, reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: {
+ marshal_VkDeviceGroupRenderPassBeginInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
- {
- marshal_VkDeviceGroupCommandBufferBeginInfo(vkStream, rootType, reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: {
+ marshal_VkDeviceGroupCommandBufferBeginInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
- {
- marshal_VkDeviceGroupSubmitInfo(vkStream, rootType, reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: {
+ marshal_VkDeviceGroupSubmitInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
- {
- marshal_VkDeviceGroupBindSparseInfo(vkStream, rootType, reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: {
+ marshal_VkDeviceGroupBindSparseInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
- {
- marshal_VkBindBufferMemoryDeviceGroupInfo(vkStream, rootType, reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: {
+ marshal_VkBindBufferMemoryDeviceGroupInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
- {
- marshal_VkBindImageMemoryDeviceGroupInfo(vkStream, rootType, reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: {
+ marshal_VkBindImageMemoryDeviceGroupInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
- {
- marshal_VkDeviceGroupDeviceCreateInfo(vkStream, rootType, reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: {
+ marshal_VkDeviceGroupDeviceCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
- {
- marshal_VkPhysicalDeviceFeatures2(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
+ marshal_VkPhysicalDeviceFeatures2(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
- {
- marshal_VkPhysicalDevicePointClippingProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: {
+ marshal_VkPhysicalDevicePointClippingProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
- {
- marshal_VkRenderPassInputAttachmentAspectCreateInfo(vkStream, rootType, reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: {
+ marshal_VkRenderPassInputAttachmentAspectCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
- {
- marshal_VkImageViewUsageCreateInfo(vkStream, rootType, reinterpret_cast<const VkImageViewUsageCreateInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: {
+ marshal_VkImageViewUsageCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkImageViewUsageCreateInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
- {
- marshal_VkPipelineTessellationDomainOriginStateCreateInfo(vkStream, rootType, reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: {
+ marshal_VkPipelineTessellationDomainOriginStateCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
- {
- marshal_VkRenderPassMultiviewCreateInfo(vkStream, rootType, reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: {
+ marshal_VkRenderPassMultiviewCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
- {
- marshal_VkPhysicalDeviceMultiviewFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
+ marshal_VkPhysicalDeviceMultiviewFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
- {
- marshal_VkPhysicalDeviceMultiviewProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: {
+ marshal_VkPhysicalDeviceMultiviewProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
- {
- marshal_VkPhysicalDeviceVariablePointersFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
+ marshal_VkPhysicalDeviceVariablePointersFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
- {
- marshal_VkPhysicalDeviceProtectedMemoryFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
+ marshal_VkPhysicalDeviceProtectedMemoryFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
- {
- marshal_VkPhysicalDeviceProtectedMemoryProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: {
+ marshal_VkPhysicalDeviceProtectedMemoryProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
- {
- marshal_VkProtectedSubmitInfo(vkStream, rootType, reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: {
+ marshal_VkProtectedSubmitInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
- {
- marshal_VkSamplerYcbcrConversionInfo(vkStream, rootType, reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: {
+ marshal_VkSamplerYcbcrConversionInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
- {
- marshal_VkBindImagePlaneMemoryInfo(vkStream, rootType, reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: {
+ marshal_VkBindImagePlaneMemoryInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
- {
- marshal_VkImagePlaneMemoryRequirementsInfo(vkStream, rootType, reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: {
+ marshal_VkImagePlaneMemoryRequirementsInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
- {
- marshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
+ marshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
- {
- marshal_VkSamplerYcbcrConversionImageFormatProperties(vkStream, rootType, reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(structExtension));
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: {
+ marshal_VkSamplerYcbcrConversionImageFormatProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
- {
- marshal_VkPhysicalDeviceExternalImageFormatInfo(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: {
+ marshal_VkPhysicalDeviceExternalImageFormatInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
- {
- marshal_VkExternalImageFormatProperties(vkStream, rootType, reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension));
+ case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: {
+ marshal_VkExternalImageFormatProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
- {
- marshal_VkPhysicalDeviceIDProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: {
+ marshal_VkPhysicalDeviceIDProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
- {
- marshal_VkExternalMemoryImageCreateInfo(vkStream, rootType, reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: {
+ marshal_VkExternalMemoryImageCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
- {
- marshal_VkExternalMemoryBufferCreateInfo(vkStream, rootType, reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: {
+ marshal_VkExternalMemoryBufferCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
- {
- marshal_VkExportMemoryAllocateInfo(vkStream, rootType, reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: {
+ marshal_VkExportMemoryAllocateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
- {
- marshal_VkExportFenceCreateInfo(vkStream, rootType, reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: {
+ marshal_VkExportFenceCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
- {
- marshal_VkExportSemaphoreCreateInfo(vkStream, rootType, reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: {
+ marshal_VkExportSemaphoreCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
- {
- marshal_VkPhysicalDeviceMaintenance3Properties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: {
+ marshal_VkPhysicalDeviceMaintenance3Properties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
- {
- marshal_VkPhysicalDeviceShaderDrawParametersFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
+ marshal_VkPhysicalDeviceShaderDrawParametersFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(
+ structExtension));
break;
}
#endif
#ifdef VK_VERSION_1_2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
- {
- marshal_VkPhysicalDeviceVulkan11Features(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: {
+ marshal_VkPhysicalDeviceVulkan11Features(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
- {
- marshal_VkPhysicalDeviceVulkan11Properties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: {
+ marshal_VkPhysicalDeviceVulkan11Properties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
- {
- marshal_VkPhysicalDeviceVulkan12Features(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: {
+ marshal_VkPhysicalDeviceVulkan12Features(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
- {
- marshal_VkPhysicalDeviceVulkan12Properties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: {
+ marshal_VkPhysicalDeviceVulkan12Properties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
- {
- marshal_VkImageFormatListCreateInfo(vkStream, rootType, reinterpret_cast<const VkImageFormatListCreateInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: {
+ marshal_VkImageFormatListCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkImageFormatListCreateInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
- {
- marshal_VkPhysicalDevice8BitStorageFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: {
+ marshal_VkPhysicalDevice8BitStorageFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
- {
- marshal_VkPhysicalDeviceDriverProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: {
+ marshal_VkPhysicalDeviceDriverProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
- {
- marshal_VkPhysicalDeviceShaderAtomicInt64Features(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: {
+ marshal_VkPhysicalDeviceShaderAtomicInt64Features(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
- {
- marshal_VkPhysicalDeviceShaderFloat16Int8Features(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: {
+ marshal_VkPhysicalDeviceShaderFloat16Int8Features(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
- {
- marshal_VkPhysicalDeviceFloatControlsProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: {
+ marshal_VkPhysicalDeviceFloatControlsProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
- {
- marshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(vkStream, rootType, reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: {
+ marshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
- {
- marshal_VkPhysicalDeviceDescriptorIndexingFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: {
+ marshal_VkPhysicalDeviceDescriptorIndexingFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
- {
- marshal_VkPhysicalDeviceDescriptorIndexingProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: {
+ marshal_VkPhysicalDeviceDescriptorIndexingProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
- {
- marshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(vkStream, rootType, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: {
+ marshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
- {
- marshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(vkStream, rootType, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: {
+ marshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(
+ vkStream, rootType,
+ reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
- {
- marshal_VkSubpassDescriptionDepthStencilResolve(vkStream, rootType, reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(structExtension));
+ case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: {
+ marshal_VkSubpassDescriptionDepthStencilResolve(
+ vkStream, rootType,
+ reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
- {
- marshal_VkPhysicalDeviceDepthStencilResolveProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: {
+ marshal_VkPhysicalDeviceDepthStencilResolveProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
- {
- marshal_VkPhysicalDeviceScalarBlockLayoutFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: {
+ marshal_VkPhysicalDeviceScalarBlockLayoutFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
- {
- marshal_VkImageStencilUsageCreateInfo(vkStream, rootType, reinterpret_cast<const VkImageStencilUsageCreateInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: {
+ marshal_VkImageStencilUsageCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkImageStencilUsageCreateInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
- {
- marshal_VkSamplerReductionModeCreateInfo(vkStream, rootType, reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: {
+ marshal_VkSamplerReductionModeCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
- {
- marshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: {
+ marshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
- {
- marshal_VkPhysicalDeviceVulkanMemoryModelFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: {
+ marshal_VkPhysicalDeviceVulkanMemoryModelFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
- {
- marshal_VkPhysicalDeviceImagelessFramebufferFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: {
+ marshal_VkPhysicalDeviceImagelessFramebufferFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
- {
- marshal_VkFramebufferAttachmentsCreateInfo(vkStream, rootType, reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: {
+ marshal_VkFramebufferAttachmentsCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
- {
- marshal_VkRenderPassAttachmentBeginInfo(vkStream, rootType, reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: {
+ marshal_VkRenderPassAttachmentBeginInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
- {
- marshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: {
+ marshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
- {
- marshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: {
+ marshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
- {
- marshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: {
+ marshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
- {
- marshal_VkAttachmentReferenceStencilLayout(vkStream, rootType, reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(structExtension));
+ case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: {
+ marshal_VkAttachmentReferenceStencilLayout(
+ vkStream, rootType,
+ reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
- {
- marshal_VkAttachmentDescriptionStencilLayout(vkStream, rootType, reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(structExtension));
+ case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: {
+ marshal_VkAttachmentDescriptionStencilLayout(
+ vkStream, rootType,
+ reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
- {
- marshal_VkPhysicalDeviceHostQueryResetFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: {
+ marshal_VkPhysicalDeviceHostQueryResetFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
- {
- marshal_VkPhysicalDeviceTimelineSemaphoreFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: {
+ marshal_VkPhysicalDeviceTimelineSemaphoreFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
- {
- marshal_VkPhysicalDeviceTimelineSemaphoreProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: {
+ marshal_VkPhysicalDeviceTimelineSemaphoreProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
- {
- marshal_VkSemaphoreTypeCreateInfo(vkStream, rootType, reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: {
+ marshal_VkSemaphoreTypeCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
- {
- marshal_VkTimelineSemaphoreSubmitInfo(vkStream, rootType, reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: {
+ marshal_VkTimelineSemaphoreSubmitInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
- {
- marshal_VkPhysicalDeviceBufferDeviceAddressFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: {
+ marshal_VkPhysicalDeviceBufferDeviceAddressFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
- {
- marshal_VkBufferOpaqueCaptureAddressCreateInfo(vkStream, rootType, reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: {
+ marshal_VkBufferOpaqueCaptureAddressCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
- {
- marshal_VkMemoryOpaqueCaptureAddressAllocateInfo(vkStream, rootType, reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension));
+ case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: {
+ marshal_VkMemoryOpaqueCaptureAddressAllocateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_swapchain
- case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
- {
- marshal_VkImageSwapchainCreateInfoKHR(vkStream, rootType, reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
+ marshal_VkImageSwapchainCreateInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
- {
- marshal_VkBindImageMemorySwapchainInfoKHR(vkStream, rootType, reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: {
+ marshal_VkBindImageMemorySwapchainInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
- {
- marshal_VkDeviceGroupPresentInfoKHR(vkStream, rootType, reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: {
+ marshal_VkDeviceGroupPresentInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
- {
- marshal_VkDeviceGroupSwapchainCreateInfoKHR(vkStream, rootType, reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: {
+ marshal_VkDeviceGroupSwapchainCreateInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_display_swapchain
- case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
- {
- marshal_VkDisplayPresentInfoKHR(vkStream, rootType, reinterpret_cast<const VkDisplayPresentInfoKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: {
+ marshal_VkDisplayPresentInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkDisplayPresentInfoKHR*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_video_queue
- case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR:
- {
- marshal_VkVideoQueueFamilyProperties2KHR(vkStream, rootType, reinterpret_cast<const VkVideoQueueFamilyProperties2KHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: {
+ marshal_VkVideoQueueFamilyProperties2KHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoQueueFamilyProperties2KHR*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR:
- {
- marshal_VkVideoProfileKHR(vkStream, rootType, reinterpret_cast<const VkVideoProfileKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR: {
+ marshal_VkVideoProfileKHR(vkStream, rootType,
+ reinterpret_cast<const VkVideoProfileKHR*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR:
- {
- marshal_VkVideoProfilesKHR(vkStream, rootType, reinterpret_cast<const VkVideoProfilesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR: {
+ marshal_VkVideoProfilesKHR(
+ vkStream, rootType, reinterpret_cast<const VkVideoProfilesKHR*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_dynamic_rendering
- case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR:
- {
- marshal_VkPipelineRenderingCreateInfoKHR(vkStream, rootType, reinterpret_cast<const VkPipelineRenderingCreateInfoKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: {
+ marshal_VkPipelineRenderingCreateInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRenderingCreateInfoKHR*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR:
- {
- marshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: {
+ marshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR:
- {
- marshal_VkCommandBufferInheritanceRenderingInfoKHR(vkStream, rootType, reinterpret_cast<const VkCommandBufferInheritanceRenderingInfoKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: {
+ marshal_VkCommandBufferInheritanceRenderingInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkCommandBufferInheritanceRenderingInfoKHR*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
- {
- marshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(vkStream, rootType, reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
+ marshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
- {
- marshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(vkStream, rootType, reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
+ marshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
- {
- marshal_VkAttachmentSampleCountInfoAMD(vkStream, rootType, reinterpret_cast<const VkAttachmentSampleCountInfoAMD*>(structExtension));
+ case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
+ marshal_VkAttachmentSampleCountInfoAMD(
+ vkStream, rootType,
+ reinterpret_cast<const VkAttachmentSampleCountInfoAMD*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
- {
- marshal_VkMultiviewPerViewAttributesInfoNVX(vkStream, rootType, reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX*>(structExtension));
+ case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
+ marshal_VkMultiviewPerViewAttributesInfoNVX(
+ vkStream, rootType,
+ reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_external_memory_win32
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
- {
- marshal_VkImportMemoryWin32HandleInfoKHR(vkStream, rootType, reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
+ marshal_VkImportMemoryWin32HandleInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
- {
- marshal_VkExportMemoryWin32HandleInfoKHR(vkStream, rootType, reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
+ marshal_VkExportMemoryWin32HandleInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_external_memory_fd
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
- {
- marshal_VkImportMemoryFdInfoKHR(vkStream, rootType, reinterpret_cast<const VkImportMemoryFdInfoKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: {
+ marshal_VkImportMemoryFdInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportMemoryFdInfoKHR*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_win32_keyed_mutex
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
- {
- marshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(vkStream, rootType, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: {
+ marshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_external_semaphore_win32
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
- {
- marshal_VkExportSemaphoreWin32HandleInfoKHR(vkStream, rootType, reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: {
+ marshal_VkExportSemaphoreWin32HandleInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
- {
- marshal_VkD3D12FenceSubmitInfoKHR(vkStream, rootType, reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: {
+ marshal_VkD3D12FenceSubmitInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_push_descriptor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
- {
- marshal_VkPhysicalDevicePushDescriptorPropertiesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: {
+ marshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(
+ structExtension));
break;
}
#endif
#ifdef VK_KHR_incremental_present
- case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
- {
- marshal_VkPresentRegionsKHR(vkStream, rootType, reinterpret_cast<const VkPresentRegionsKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: {
+ marshal_VkPresentRegionsKHR(
+ vkStream, rootType, reinterpret_cast<const VkPresentRegionsKHR*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_shared_presentable_image
- case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
- {
- marshal_VkSharedPresentSurfaceCapabilitiesKHR(vkStream, rootType, reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
+ marshal_VkSharedPresentSurfaceCapabilitiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_external_fence_win32
- case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
- {
- marshal_VkExportFenceWin32HandleInfoKHR(vkStream, rootType, reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: {
+ marshal_VkExportFenceWin32HandleInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_performance_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
- {
- marshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: {
+ marshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
- {
- marshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: {
+ marshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
- {
- marshal_VkQueryPoolPerformanceCreateInfoKHR(vkStream, rootType, reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: {
+ marshal_VkQueryPoolPerformanceCreateInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
- {
- marshal_VkPerformanceQuerySubmitInfoKHR(vkStream, rootType, reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: {
+ marshal_VkPerformanceQuerySubmitInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_portability_subset
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
- {
- marshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
+ marshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
- {
- marshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
+ marshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(
+ structExtension));
break;
}
#endif
#ifdef VK_KHR_shader_clock
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
- {
- marshal_VkPhysicalDeviceShaderClockFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
+ marshal_VkPhysicalDeviceShaderClockFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_shader_terminate_invocation
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR:
- {
- marshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: {
+ marshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(
+ structExtension));
break;
}
#endif
#ifdef VK_KHR_fragment_shading_rate
- case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
- {
- marshal_VkFragmentShadingRateAttachmentInfoKHR(vkStream, rootType, reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
+ marshal_VkFragmentShadingRateAttachmentInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
- {
- marshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(vkStream, rootType, reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: {
+ marshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
- {
- marshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: {
+ marshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
- {
- marshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: {
+ marshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(
+ structExtension));
break;
}
#endif
#ifdef VK_KHR_surface_protected_capabilities
- case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
- {
- marshal_VkSurfaceProtectedCapabilitiesKHR(vkStream, rootType, reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: {
+ marshal_VkSurfaceProtectedCapabilitiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_present_wait
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
- {
- marshal_VkPhysicalDevicePresentWaitFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: {
+ marshal_VkPhysicalDevicePresentWaitFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
- {
- marshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: {
+ marshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(
+ structExtension));
break;
}
#endif
#ifdef VK_KHR_shader_integer_dot_product
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR:
- {
- marshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: {
+ marshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR:
- {
- marshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: {
+ marshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(
+ structExtension));
break;
}
#endif
#ifdef VK_KHR_present_id
- case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
- {
- marshal_VkPresentIdKHR(vkStream, rootType, reinterpret_cast<const VkPresentIdKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: {
+ marshal_VkPresentIdKHR(vkStream, rootType,
+ reinterpret_cast<const VkPresentIdKHR*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
- {
- marshal_VkPhysicalDevicePresentIdFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: {
+ marshal_VkPhysicalDevicePresentIdFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_video_encode_queue
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
- {
- marshal_VkVideoEncodeRateControlInfoKHR(vkStream, rootType, reinterpret_cast<const VkVideoEncodeRateControlInfoKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
+ marshal_VkVideoEncodeRateControlInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeRateControlInfoKHR*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_synchronization2
- case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR:
- {
- marshal_VkMemoryBarrier2KHR(vkStream, rootType, reinterpret_cast<const VkMemoryBarrier2KHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: {
+ marshal_VkMemoryBarrier2KHR(
+ vkStream, rootType, reinterpret_cast<const VkMemoryBarrier2KHR*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR:
- {
- marshal_VkPhysicalDeviceSynchronization2FeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSynchronization2FeaturesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: {
+ marshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSynchronization2FeaturesKHR*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
- {
- marshal_VkQueueFamilyCheckpointProperties2NV(vkStream, rootType, reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension));
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
+ marshal_VkQueueFamilyCheckpointProperties2NV(
+ vkStream, rootType,
+ reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
- {
- marshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
+ marshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<
+ const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(
+ structExtension));
break;
}
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR:
- {
- marshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: {
+ marshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(
+ structExtension));
break;
}
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
- {
- marshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
+ marshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(
+ structExtension));
break;
}
#endif
#ifdef VK_KHR_format_feature_flags2
- case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR:
- {
- marshal_VkFormatProperties3KHR(vkStream, rootType, reinterpret_cast<const VkFormatProperties3KHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: {
+ marshal_VkFormatProperties3KHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkFormatProperties3KHR*>(structExtension));
break;
}
#endif
#ifdef VK_KHR_maintenance4
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR:
- {
- marshal_VkPhysicalDeviceMaintenance4FeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: {
+ marshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR:
- {
- marshal_VkPhysicalDeviceMaintenance4PropertiesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: {
+ marshal_VkPhysicalDeviceMaintenance4PropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance4PropertiesKHR*>(
+ structExtension));
break;
}
#endif
#ifdef VK_ANDROID_native_buffer
- case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
- {
- marshal_VkNativeBufferANDROID(vkStream, rootType, reinterpret_cast<const VkNativeBufferANDROID*>(structExtension));
+ case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
+ marshal_VkNativeBufferANDROID(
+ vkStream, rootType,
+ reinterpret_cast<const VkNativeBufferANDROID*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_debug_report
- case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
- {
- marshal_VkDebugReportCallbackCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: {
+ marshal_VkDebugReportCallbackCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(structExtension));
break;
}
#endif
#ifdef VK_AMD_rasterization_order
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
- {
- marshal_VkPipelineRasterizationStateRasterizationOrderAMD(vkStream, rootType, reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: {
+ marshal_VkPipelineRasterizationStateRasterizationOrderAMD(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(
+ structExtension));
break;
}
#endif
#ifdef VK_NV_dedicated_allocation
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
- {
- marshal_VkDedicatedAllocationImageCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: {
+ marshal_VkDedicatedAllocationImageCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
- {
- marshal_VkDedicatedAllocationBufferCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: {
+ marshal_VkDedicatedAllocationBufferCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
- {
- marshal_VkDedicatedAllocationMemoryAllocateInfoNV(vkStream, rootType, reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: {
+ marshal_VkDedicatedAllocationMemoryAllocateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_transform_feedback
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
- {
- marshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: {
+ marshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
- {
- marshal_VkPipelineRasterizationStateStreamCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: {
+ marshal_VkPipelineRasterizationStateStreamCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_video_encode_h264
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT:
- {
- marshal_VkVideoEncodeH264CapabilitiesEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH264CapabilitiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
+ marshal_VkVideoEncodeH264CapabilitiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH264CapabilitiesEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT:
- {
- marshal_VkVideoEncodeH264SessionCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: {
+ marshal_VkVideoEncodeH264SessionCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- marshal_VkVideoEncodeH264SessionParametersAddInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ marshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- marshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ marshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT:
- {
- marshal_VkVideoEncodeH264VclFrameInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH264VclFrameInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
+ marshal_VkVideoEncodeH264VclFrameInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH264VclFrameInfoEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT:
- {
- marshal_VkVideoEncodeH264EmitPictureParametersEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: {
+ marshal_VkVideoEncodeH264EmitPictureParametersEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH264EmitPictureParametersEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT:
- {
- marshal_VkVideoEncodeH264ProfileEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH264ProfileEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT: {
+ marshal_VkVideoEncodeH264ProfileEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH264ProfileEXT*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_video_encode_h265
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT:
- {
- marshal_VkVideoEncodeH265CapabilitiesEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH265CapabilitiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
+ marshal_VkVideoEncodeH265CapabilitiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH265CapabilitiesEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT:
- {
- marshal_VkVideoEncodeH265SessionCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: {
+ marshal_VkVideoEncodeH265SessionCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- marshal_VkVideoEncodeH265SessionParametersAddInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ marshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- marshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ marshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT:
- {
- marshal_VkVideoEncodeH265VclFrameInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH265VclFrameInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
+ marshal_VkVideoEncodeH265VclFrameInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH265VclFrameInfoEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT:
- {
- marshal_VkVideoEncodeH265EmitPictureParametersEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: {
+ marshal_VkVideoEncodeH265EmitPictureParametersEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH265EmitPictureParametersEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT:
- {
- marshal_VkVideoEncodeH265ProfileEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH265ProfileEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT: {
+ marshal_VkVideoEncodeH265ProfileEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH265ProfileEXT*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_video_decode_h264
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT:
- {
- marshal_VkVideoDecodeH264ProfileEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH264ProfileEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT: {
+ marshal_VkVideoDecodeH264ProfileEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH264ProfileEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT:
- {
- marshal_VkVideoDecodeH264CapabilitiesEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH264CapabilitiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: {
+ marshal_VkVideoDecodeH264CapabilitiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH264CapabilitiesEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT:
- {
- marshal_VkVideoDecodeH264SessionCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: {
+ marshal_VkVideoDecodeH264SessionCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- marshal_VkVideoDecodeH264SessionParametersAddInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ marshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- marshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ marshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT:
- {
- marshal_VkVideoDecodeH264PictureInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH264PictureInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: {
+ marshal_VkVideoDecodeH264PictureInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH264PictureInfoEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT:
- {
- marshal_VkVideoDecodeH264MvcEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH264MvcEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT: {
+ marshal_VkVideoDecodeH264MvcEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH264MvcEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT:
- {
- marshal_VkVideoDecodeH264DpbSlotInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: {
+ marshal_VkVideoDecodeH264DpbSlotInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension));
break;
}
#endif
#ifdef VK_AMD_texture_gather_bias_lod
- case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
- {
- marshal_VkTextureLODGatherFormatPropertiesAMD(vkStream, rootType, reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(structExtension));
+ case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
+ marshal_VkTextureLODGatherFormatPropertiesAMD(
+ vkStream, rootType,
+ reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(structExtension));
break;
}
#endif
#ifdef VK_NV_corner_sampled_image
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
- {
- marshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: {
+ marshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_NV_external_memory
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
- {
- marshal_VkExternalMemoryImageCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: {
+ marshal_VkExternalMemoryImageCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
- {
- marshal_VkExportMemoryAllocateInfoNV(vkStream, rootType, reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: {
+ marshal_VkExportMemoryAllocateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(structExtension));
break;
}
#endif
#ifdef VK_NV_external_memory_win32
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
- {
- marshal_VkImportMemoryWin32HandleInfoNV(vkStream, rootType, reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
+ marshal_VkImportMemoryWin32HandleInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
- {
- marshal_VkExportMemoryWin32HandleInfoNV(vkStream, rootType, reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
+ marshal_VkExportMemoryWin32HandleInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(structExtension));
break;
}
#endif
#ifdef VK_NV_win32_keyed_mutex
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
- {
- marshal_VkWin32KeyedMutexAcquireReleaseInfoNV(vkStream, rootType, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: {
+ marshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_validation_flags
- case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
- {
- marshal_VkValidationFlagsEXT(vkStream, rootType, reinterpret_cast<const VkValidationFlagsEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: {
+ marshal_VkValidationFlagsEXT(
+ vkStream, rootType, reinterpret_cast<const VkValidationFlagsEXT*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_astc_decode_mode
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
- {
- marshal_VkImageViewASTCDecodeModeEXT(vkStream, rootType, reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
+ marshal_VkImageViewASTCDecodeModeEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_conditional_rendering
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
- {
- marshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(vkStream, rootType, reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: {
+ marshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_NV_clip_space_w_scaling
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
- {
- marshal_VkPipelineViewportWScalingStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: {
+ marshal_VkPipelineViewportWScalingStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_display_control
- case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
- {
- marshal_VkSwapchainCounterCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: {
+ marshal_VkSwapchainCounterCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(structExtension));
break;
}
#endif
#ifdef VK_GOOGLE_display_timing
- case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
- {
- marshal_VkPresentTimesInfoGOOGLE(vkStream, rootType, reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(structExtension));
+ case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: {
+ marshal_VkPresentTimesInfoGOOGLE(
+ vkStream, rootType,
+ reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(structExtension));
break;
}
#endif
#ifdef VK_NVX_multiview_per_view_attributes
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
- {
- marshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: {
+ marshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(
+ structExtension));
break;
}
#endif
#ifdef VK_NV_viewport_swizzle
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
- {
- marshal_VkPipelineViewportSwizzleStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: {
+ marshal_VkPipelineViewportSwizzleStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_discard_rectangles
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
- {
- marshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: {
+ marshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
- {
- marshal_VkPipelineDiscardRectangleStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: {
+ marshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_conservative_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
- {
- marshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: {
+ marshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
- {
- marshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: {
+ marshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_depth_clip_enable
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
- {
- marshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ marshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_debug_utils
- case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
- {
- marshal_VkDebugUtilsMessengerCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
+ marshal_VkDebugUtilsMessengerCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(structExtension));
break;
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
- {
- marshal_VkAndroidHardwareBufferUsageANDROID(vkStream, rootType, reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(structExtension));
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: {
+ marshal_VkAndroidHardwareBufferUsageANDROID(
+ vkStream, rootType,
+ reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
- {
- marshal_VkAndroidHardwareBufferFormatPropertiesANDROID(vkStream, rootType, reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension));
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: {
+ marshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
+ vkStream, rootType,
+ reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
- {
- marshal_VkImportAndroidHardwareBufferInfoANDROID(vkStream, rootType, reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension));
+ case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: {
+ marshal_VkImportAndroidHardwareBufferInfoANDROID(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
- {
- marshal_VkExternalFormatANDROID(vkStream, rootType, reinterpret_cast<const VkExternalFormatANDROID*>(structExtension));
+ case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: {
+ marshal_VkExternalFormatANDROID(
+ vkStream, rootType,
+ reinterpret_cast<const VkExternalFormatANDROID*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
- {
- marshal_VkAndroidHardwareBufferFormatProperties2ANDROID(vkStream, rootType, reinterpret_cast<const VkAndroidHardwareBufferFormatProperties2ANDROID*>(structExtension));
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: {
+ marshal_VkAndroidHardwareBufferFormatProperties2ANDROID(
+ vkStream, rootType,
+ reinterpret_cast<const VkAndroidHardwareBufferFormatProperties2ANDROID*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_inline_uniform_block
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
- {
- marshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
+ marshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT:
- {
- marshal_VkWriteDescriptorSetInlineUniformBlockEXT(vkStream, rootType, reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
+ marshal_VkWriteDescriptorSetInlineUniformBlockEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT:
- {
- marshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
+ marshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_sample_locations
- case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
- {
- marshal_VkSampleLocationsInfoEXT(vkStream, rootType, reinterpret_cast<const VkSampleLocationsInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
+ marshal_VkSampleLocationsInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkSampleLocationsInfoEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
- {
- marshal_VkRenderPassSampleLocationsBeginInfoEXT(vkStream, rootType, reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: {
+ marshal_VkRenderPassSampleLocationsBeginInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
- {
- marshal_VkPipelineSampleLocationsStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: {
+ marshal_VkPipelineSampleLocationsStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
- {
- marshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: {
+ marshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_blend_operation_advanced
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
- {
- marshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: {
+ marshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
- {
- marshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: {
+ marshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_NV_fragment_coverage_to_color
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
- {
- marshal_VkPipelineCoverageToColorStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: {
+ marshal_VkPipelineCoverageToColorStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_NV_framebuffer_mixed_samples
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
- {
- marshal_VkPipelineCoverageModulationStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: {
+ marshal_VkPipelineCoverageModulationStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_NV_shader_sm_builtins
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
- {
- marshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: {
+ marshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
- {
- marshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: {
+ marshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_image_drm_format_modifier
- case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
- {
- marshal_VkDrmFormatModifierPropertiesListEXT(vkStream, rootType, reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: {
+ marshal_VkDrmFormatModifierPropertiesListEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
- {
- marshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: {
+ marshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
- {
- marshal_VkImageDrmFormatModifierListCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: {
+ marshal_VkImageDrmFormatModifierListCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
- {
- marshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: {
+ marshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
- {
- marshal_VkDrmFormatModifierPropertiesList2EXT(vkStream, rootType, reinterpret_cast<const VkDrmFormatModifierPropertiesList2EXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: {
+ marshal_VkDrmFormatModifierPropertiesList2EXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkDrmFormatModifierPropertiesList2EXT*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_validation_cache
- case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
- {
- marshal_VkShaderModuleValidationCacheCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: {
+ marshal_VkShaderModuleValidationCacheCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_NV_shading_rate_image
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
- {
- marshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: {
+ marshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
- {
- marshal_VkPhysicalDeviceShadingRateImageFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: {
+ marshal_VkPhysicalDeviceShadingRateImageFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
- {
- marshal_VkPhysicalDeviceShadingRateImagePropertiesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: {
+ marshal_VkPhysicalDeviceShadingRateImagePropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
- {
- marshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: {
+ marshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_NV_ray_tracing
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
- {
- marshal_VkWriteDescriptorSetAccelerationStructureNV(vkStream, rootType, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: {
+ marshal_VkWriteDescriptorSetAccelerationStructureNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
- {
- marshal_VkPhysicalDeviceRayTracingPropertiesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: {
+ marshal_VkPhysicalDeviceRayTracingPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension));
break;
}
#endif
#ifdef VK_NV_representative_fragment_test
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
- {
- marshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: {
+ marshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
- {
- marshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: {
+ marshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_filter_cubic
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
- {
- marshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: {
+ marshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
- {
- marshal_VkFilterCubicImageViewImageFormatPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: {
+ marshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_global_priority
- case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
- {
- marshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
+ marshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_external_memory_host
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
- {
- marshal_VkImportMemoryHostPointerInfoEXT(vkStream, rootType, reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
+ marshal_VkImportMemoryHostPointerInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
- {
- marshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: {
+ marshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_AMD_pipeline_compiler_control
- case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
- {
- marshal_VkPipelineCompilerControlCreateInfoAMD(vkStream, rootType, reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: {
+ marshal_VkPipelineCompilerControlCreateInfoAMD(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>(structExtension));
break;
}
#endif
#ifdef VK_AMD_shader_core_properties
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
- {
- marshal_VkPhysicalDeviceShaderCorePropertiesAMD(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: {
+ marshal_VkPhysicalDeviceShaderCorePropertiesAMD(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_video_decode_h265
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT:
- {
- marshal_VkVideoDecodeH265ProfileEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH265ProfileEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT: {
+ marshal_VkVideoDecodeH265ProfileEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH265ProfileEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT:
- {
- marshal_VkVideoDecodeH265CapabilitiesEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH265CapabilitiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: {
+ marshal_VkVideoDecodeH265CapabilitiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH265CapabilitiesEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT:
- {
- marshal_VkVideoDecodeH265SessionCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: {
+ marshal_VkVideoDecodeH265SessionCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- marshal_VkVideoDecodeH265SessionParametersAddInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ marshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- marshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ marshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT:
- {
- marshal_VkVideoDecodeH265PictureInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH265PictureInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: {
+ marshal_VkVideoDecodeH265PictureInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH265PictureInfoEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT:
- {
- marshal_VkVideoDecodeH265DpbSlotInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: {
+ marshal_VkVideoDecodeH265DpbSlotInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension));
break;
}
#endif
#ifdef VK_AMD_memory_overallocation_behavior
- case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
- {
- marshal_VkDeviceMemoryOverallocationCreateInfoAMD(vkStream, rootType, reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension));
+ case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
+ marshal_VkDeviceMemoryOverallocationCreateInfoAMD(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_vertex_attribute_divisor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
- {
- marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
+ marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
- {
- marshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: {
+ marshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_GGP_frame_token
- case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
- {
- marshal_VkPresentFrameTokenGGP(vkStream, rootType, reinterpret_cast<const VkPresentFrameTokenGGP*>(structExtension));
+ case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: {
+ marshal_VkPresentFrameTokenGGP(
+ vkStream, rootType,
+ reinterpret_cast<const VkPresentFrameTokenGGP*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_pipeline_creation_feedback
- case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT:
- {
- marshal_VkPipelineCreationFeedbackCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
+ marshal_VkPipelineCreationFeedbackCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension));
break;
}
#endif
#ifdef VK_NV_compute_shader_derivatives
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
- {
- marshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
+ marshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_NV_mesh_shader
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
- {
- marshal_VkPhysicalDeviceMeshShaderFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: {
+ marshal_VkPhysicalDeviceMeshShaderFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
- {
- marshal_VkPhysicalDeviceMeshShaderPropertiesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: {
+ marshal_VkPhysicalDeviceMeshShaderPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension));
break;
}
#endif
#ifdef VK_NV_fragment_shader_barycentric
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV:
- {
- marshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
+ marshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_NV_shader_image_footprint
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
- {
- marshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
+ marshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_NV_scissor_exclusive
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
- {
- marshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: {
+ marshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
- {
- marshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: {
+ marshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
- {
- marshal_VkQueueFamilyCheckpointPropertiesNV(vkStream, rootType, reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: {
+ marshal_VkQueueFamilyCheckpointPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(structExtension));
break;
}
#endif
#ifdef VK_INTEL_shader_integer_functions2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
- {
- marshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: {
+ marshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(
+ structExtension));
break;
}
#endif
#ifdef VK_INTEL_performance_query
- case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
- {
- marshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(vkStream, rootType, reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension));
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: {
+ marshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(
+ vkStream, rootType,
+ reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_pci_bus_info
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
- {
- marshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: {
+ marshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension));
break;
}
#endif
#ifdef VK_AMD_display_native_hdr
- case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
- {
- marshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(vkStream, rootType, reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension));
+ case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: {
+ marshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
+ vkStream, rootType,
+ reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
- {
- marshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(vkStream, rootType, reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension));
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: {
+ marshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(
+ vkStream, rootType,
+ reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_fragment_density_map
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
- {
- marshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
+ marshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
- {
- marshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: {
+ marshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
- marshal_VkImportColorBufferGOOGLE(vkStream, rootType, reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension));
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
+ marshal_VkImportColorBufferGOOGLE(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension));
break;
}
- default:
- {
- marshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension));
+ default: {
+ marshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension));
break;
}
}
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2:
- {
- marshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: {
+ marshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
- marshal_VkImportPhysicalAddressGOOGLE(vkStream, rootType, reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension));
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
+ marshal_VkImportPhysicalAddressGOOGLE(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension));
break;
}
- default:
- {
- marshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension));
+ default: {
+ marshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
+ structExtension));
break;
}
}
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
- {
- marshal_VkRenderPassFragmentDensityMapCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: {
+ marshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2:
- {
- marshal_VkRenderPassFragmentDensityMapCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: {
+ marshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
- marshal_VkImportBufferGOOGLE(vkStream, rootType, reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension));
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
+ marshal_VkImportBufferGOOGLE(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension));
break;
}
- default:
- {
- marshal_VkRenderPassFragmentDensityMapCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension));
+ default: {
+ marshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension));
break;
}
}
@@ -30685,648 +28068,809 @@
}
#endif
#ifdef VK_EXT_subgroup_size_control
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
- {
- marshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: {
+ marshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:
- {
- marshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: {
+ marshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_AMD_shader_core_properties2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
- {
- marshal_VkPhysicalDeviceShaderCoreProperties2AMD(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
+ marshal_VkPhysicalDeviceShaderCoreProperties2AMD(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension));
break;
}
#endif
#ifdef VK_AMD_device_coherent_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
- {
- marshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: {
+ marshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_shader_image_atomic_int64
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_memory_budget
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
- {
- marshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: {
+ marshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_memory_priority
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
- {
- marshal_VkMemoryPriorityAllocateInfoEXT(vkStream, rootType, reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: {
+ marshal_VkMemoryPriorityAllocateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>(structExtension));
break;
}
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
- {
- marshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: {
+ marshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_buffer_device_address
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
- {
- marshal_VkBufferDeviceAddressCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: {
+ marshal_VkBufferDeviceAddressCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_validation_features
- case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
- {
- marshal_VkValidationFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkValidationFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: {
+ marshal_VkValidationFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkValidationFeaturesEXT*>(structExtension));
break;
}
#endif
#ifdef VK_NV_cooperative_matrix
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
- {
- marshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: {
+ marshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
- {
- marshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: {
+ marshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_NV_coverage_reduction_mode
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
- {
- marshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: {
+ marshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
- {
- marshal_VkPipelineCoverageReductionStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: {
+ marshal_VkPipelineCoverageReductionStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_fragment_shader_interlock
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_ycbcr_image_arrays
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_provoking_vertex
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceProvokingVertexFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceProvokingVertexFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
- {
- marshal_VkPhysicalDeviceProvokingVertexPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: {
+ marshal_VkPhysicalDeviceProvokingVertexPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
- {
- marshal_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: {
+ marshal_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_full_screen_exclusive
- case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
- {
- marshal_VkSurfaceFullScreenExclusiveInfoEXT(vkStream, rootType, reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: {
+ marshal_VkSurfaceFullScreenExclusiveInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
- {
- marshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(vkStream, rootType, reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: {
+ marshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
- {
- marshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(vkStream, rootType, reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: {
+ marshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_line_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
- {
- marshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: {
+ marshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
- {
- marshal_VkPipelineRasterizationLineStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: {
+ marshal_VkPipelineRasterizationLineStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_shader_atomic_float
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_index_type_uint8
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_shader_atomic_float2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_NV_device_generated_commands
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
- {
- marshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: {
+ marshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
- {
- marshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: {
+ marshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
- {
- marshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: {
+ marshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_NV_inherited_viewport_scissor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
- {
- marshal_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: {
+ marshal_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
- {
- marshal_VkCommandBufferInheritanceViewportScissorInfoNV(vkStream, rootType, reinterpret_cast<const VkCommandBufferInheritanceViewportScissorInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: {
+ marshal_VkCommandBufferInheritanceViewportScissorInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkCommandBufferInheritanceViewportScissorInfoNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_texel_buffer_alignment
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
- {
- marshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
+ marshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_QCOM_render_pass_transform
- case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
- {
- marshal_VkRenderPassTransformBeginInfoQCOM(vkStream, rootType, reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>(structExtension));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
+ marshal_VkRenderPassTransformBeginInfoQCOM(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
- {
- marshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(vkStream, rootType, reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(structExtension));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: {
+ marshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
+ vkStream, rootType,
+ reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_device_memory_report
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
- {
- marshal_VkDeviceDeviceMemoryReportCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: {
+ marshal_VkDeviceDeviceMemoryReportCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_robustness2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceRobustness2FeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceRobustness2FeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
- {
- marshal_VkPhysicalDeviceRobustness2PropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: {
+ marshal_VkPhysicalDeviceRobustness2PropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_custom_border_color
- case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
- {
- marshal_VkSamplerCustomBorderColorCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: {
+ marshal_VkSamplerCustomBorderColorCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
- {
- marshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: {
+ marshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_private_data
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT:
- {
- marshal_VkPhysicalDevicePrivateDataFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
+ marshal_VkPhysicalDevicePrivateDataFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
- {
- marshal_VkDevicePrivateDataCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkDevicePrivateDataCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: {
+ marshal_VkDevicePrivateDataCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkDevicePrivateDataCreateInfoEXT*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT:
- {
- marshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
+ marshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_NV_device_diagnostics_config
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
- {
- marshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: {
+ marshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
- {
- marshal_VkDeviceDiagnosticsConfigCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: {
+ marshal_VkDeviceDiagnosticsConfigCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension));
break;
}
#endif
#ifdef VK_NV_fragment_shading_rate_enums
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
- {
- marshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
+ marshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
- {
- marshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: {
+ marshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
- {
- marshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: {
+ marshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_NV_ray_tracing_motion_blur
- case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
- {
- marshal_VkAccelerationStructureGeometryMotionTrianglesDataNV(vkStream, rootType, reinterpret_cast<const VkAccelerationStructureGeometryMotionTrianglesDataNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: {
+ marshal_VkAccelerationStructureGeometryMotionTrianglesDataNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkAccelerationStructureGeometryMotionTrianglesDataNV*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
- {
- marshal_VkAccelerationStructureMotionInfoNV(vkStream, rootType, reinterpret_cast<const VkAccelerationStructureMotionInfoNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: {
+ marshal_VkAccelerationStructureMotionInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkAccelerationStructureMotionInfoNV*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
- {
- marshal_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: {
+ marshal_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_fragment_density_map2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
- {
- marshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: {
+ marshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_QCOM_rotated_copy_commands
- case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
- {
- marshal_VkCopyCommandTransformInfoQCOM(vkStream, rootType, reinterpret_cast<const VkCopyCommandTransformInfoQCOM*>(structExtension));
+ case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: {
+ marshal_VkCopyCommandTransformInfoQCOM(
+ vkStream, rootType,
+ reinterpret_cast<const VkCopyCommandTransformInfoQCOM*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_image_robustness
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_4444_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
- {
- marshal_VkPhysicalDevice4444FormatsFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: {
+ marshal_VkPhysicalDevice4444FormatsFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_rgba10x6_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_VALVE_mutable_descriptor_type
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE:
- {
- marshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: {
+ marshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE:
- {
- marshal_VkMutableDescriptorTypeCreateInfoVALVE(vkStream, rootType, reinterpret_cast<const VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension));
+ case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: {
+ marshal_VkMutableDescriptorTypeCreateInfoVALVE(
+ vkStream, rootType,
+ reinterpret_cast<const VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_physical_device_drm
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
- {
- marshal_VkPhysicalDeviceDrmPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDrmPropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: {
+ marshal_VkPhysicalDeviceDrmPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDrmPropertiesEXT*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_primitive_topology_list_restart
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
- {
- marshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
+ marshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_FUCHSIA_external_memory
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
- {
- marshal_VkImportMemoryZirconHandleInfoFUCHSIA(vkStream, rootType, reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA*>(structExtension));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: {
+ marshal_VkImportMemoryZirconHandleInfoFUCHSIA(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA*>(structExtension));
break;
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
- {
- marshal_VkImportMemoryBufferCollectionFUCHSIA(vkStream, rootType, reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIA*>(structExtension));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: {
+ marshal_VkImportMemoryBufferCollectionFUCHSIA(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIA*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
- {
- marshal_VkBufferCollectionImageCreateInfoFUCHSIA(vkStream, rootType, reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIA*>(structExtension));
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: {
+ marshal_VkBufferCollectionImageCreateInfoFUCHSIA(
+ vkStream, rootType,
+ reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIA*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
- {
- marshal_VkBufferCollectionBufferCreateInfoFUCHSIA(vkStream, rootType, reinterpret_cast<const VkBufferCollectionBufferCreateInfoFUCHSIA*>(structExtension));
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: {
+ marshal_VkBufferCollectionBufferCreateInfoFUCHSIA(
+ vkStream, rootType,
+ reinterpret_cast<const VkBufferCollectionBufferCreateInfoFUCHSIA*>(
+ structExtension));
break;
}
#endif
#ifdef VK_HUAWEI_subpass_shading
- case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
- {
- marshal_VkSubpassShadingPipelineCreateInfoHUAWEI(vkStream, rootType, reinterpret_cast<const VkSubpassShadingPipelineCreateInfoHUAWEI*>(structExtension));
+ case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: {
+ marshal_VkSubpassShadingPipelineCreateInfoHUAWEI(
+ vkStream, rootType,
+ reinterpret_cast<const VkSubpassShadingPipelineCreateInfoHUAWEI*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
- {
- marshal_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: {
+ marshal_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
- {
- marshal_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: {
+ marshal_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(
+ structExtension));
break;
}
#endif
#ifdef VK_HUAWEI_invocation_mask
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
- {
- marshal_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: {
+ marshal_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(
+ structExtension));
break;
}
#endif
#ifdef VK_NV_external_memory_rdma
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
- {
- marshal_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: {
+ marshal_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_extended_dynamic_state2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_color_write_enable
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceColorWriteEnableFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
- {
- marshal_VkPipelineColorWriteCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineColorWriteCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: {
+ marshal_VkPipelineColorWriteCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineColorWriteCreateInfoEXT*>(structExtension));
break;
}
#endif
#ifdef VK_GOOGLE_gfxstream
- case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
- {
- marshal_VkImportColorBufferGOOGLE(vkStream, rootType, reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension));
+ case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
+ marshal_VkImportColorBufferGOOGLE(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
- {
- marshal_VkImportBufferGOOGLE(vkStream, rootType, reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension));
+ case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE: {
+ marshal_VkImportBufferGOOGLE(
+ vkStream, rootType, reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
- {
- marshal_VkImportPhysicalAddressGOOGLE(vkStream, rootType, reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension));
+ case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE: {
+ marshal_VkImportPhysicalAddressGOOGLE(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_global_priority_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT:
- {
- marshal_VkQueueFamilyGlobalPriorityPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: {
+ marshal_VkQueueFamilyGlobalPriorityPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_multi_draw
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceMultiDrawFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceMultiDrawFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT*>(structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
- {
- marshal_VkPhysicalDeviceMultiDrawPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMultiDrawPropertiesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: {
+ marshal_VkPhysicalDeviceMultiDrawPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMultiDrawPropertiesEXT*>(structExtension));
break;
}
#endif
#ifdef VK_EXT_border_color_swizzle
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
- {
- marshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
+ marshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
- {
- marshal_VkSamplerBorderColorComponentMappingCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkSamplerBorderColorComponentMappingCreateInfoEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: {
+ marshal_VkSamplerBorderColorComponentMappingCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkSamplerBorderColorComponentMappingCreateInfoEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_EXT_pageable_device_local_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
- {
- marshal_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: {
+ marshal_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(
+ structExtension));
break;
}
#endif
#ifdef VK_KHR_acceleration_structure
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
- {
- marshal_VkWriteDescriptorSetAccelerationStructureKHR(vkStream, rootType, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
+ marshal_VkWriteDescriptorSetAccelerationStructureKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
- {
- marshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: {
+ marshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
- {
- marshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: {
+ marshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(
+ structExtension));
break;
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
- {
- marshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
+ marshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
+ structExtension));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
- {
- marshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: {
+ marshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(
+ structExtension));
break;
}
#endif
#ifdef VK_KHR_ray_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
- {
- marshal_VkPhysicalDeviceRayQueryFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: {
+ marshal_VkPhysicalDeviceRayQueryFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension));
break;
}
#endif
- default:
- {
+ default: {
// fatal; the switch is only taken if the extension struct is known
abort();
}
}
}
-void unmarshal_extension_struct(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- void* structExtension_out)
-{
+void unmarshal_extension_struct(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ void* structExtension_out) {
VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension_out);
- size_t currExtSize = goldfish_vk_extension_struct_size_with_stream_features(vkStream->getFeatureBits(), rootType, structExtension_out);
- if (!currExtSize && structExtension_out)
- {
+ size_t currExtSize = goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, structExtension_out);
+ if (!currExtSize && structExtension_out) {
// unknown struct extension; skip and call on its pNext field
unmarshal_extension_struct(vkStream, rootType, (void*)structAccess->pNext);
return;
- }
- else
- {
+ } else {
// known or null extension struct
vkStream->getBe32();
- if (!currExtSize)
- {
+ if (!currExtSize) {
// exit if this was a null extension struct (size == 0 in this branch)
return;
}
@@ -31334,1533 +28878,1878 @@
uint64_t pNext_placeholder;
vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
(void)pNext_placeholder;
- if (!structExtension_out)
- {
+ if (!structExtension_out) {
return;
}
uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension_out);
- switch(structType)
- {
+ switch (structType) {
#ifdef VK_VERSION_1_1
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
- {
- unmarshal_VkPhysicalDeviceSubgroupProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
+ unmarshal_VkPhysicalDeviceSubgroupProperties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
- {
- unmarshal_VkPhysicalDevice16BitStorageFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
+ unmarshal_VkPhysicalDevice16BitStorageFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
- {
- unmarshal_VkMemoryDedicatedRequirements(vkStream, rootType, reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
+ unmarshal_VkMemoryDedicatedRequirements(
+ vkStream, rootType,
+ reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
- {
- unmarshal_VkMemoryDedicatedAllocateInfo(vkStream, rootType, reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: {
+ unmarshal_VkMemoryDedicatedAllocateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
- {
- unmarshal_VkMemoryAllocateFlagsInfo(vkStream, rootType, reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: {
+ unmarshal_VkMemoryAllocateFlagsInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
- {
- unmarshal_VkDeviceGroupRenderPassBeginInfo(vkStream, rootType, reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: {
+ unmarshal_VkDeviceGroupRenderPassBeginInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
- {
- unmarshal_VkDeviceGroupCommandBufferBeginInfo(vkStream, rootType, reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: {
+ unmarshal_VkDeviceGroupCommandBufferBeginInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
- {
- unmarshal_VkDeviceGroupSubmitInfo(vkStream, rootType, reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: {
+ unmarshal_VkDeviceGroupSubmitInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
- {
- unmarshal_VkDeviceGroupBindSparseInfo(vkStream, rootType, reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: {
+ unmarshal_VkDeviceGroupBindSparseInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
- {
- unmarshal_VkBindBufferMemoryDeviceGroupInfo(vkStream, rootType, reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: {
+ unmarshal_VkBindBufferMemoryDeviceGroupInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
- {
- unmarshal_VkBindImageMemoryDeviceGroupInfo(vkStream, rootType, reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: {
+ unmarshal_VkBindImageMemoryDeviceGroupInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
- {
- unmarshal_VkDeviceGroupDeviceCreateInfo(vkStream, rootType, reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: {
+ unmarshal_VkDeviceGroupDeviceCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
- {
- unmarshal_VkPhysicalDeviceFeatures2(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
+ unmarshal_VkPhysicalDeviceFeatures2(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
- {
- unmarshal_VkPhysicalDevicePointClippingProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: {
+ unmarshal_VkPhysicalDevicePointClippingProperties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
- {
- unmarshal_VkRenderPassInputAttachmentAspectCreateInfo(vkStream, rootType, reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: {
+ unmarshal_VkRenderPassInputAttachmentAspectCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
- {
- unmarshal_VkImageViewUsageCreateInfo(vkStream, rootType, reinterpret_cast<VkImageViewUsageCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: {
+ unmarshal_VkImageViewUsageCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkImageViewUsageCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
- {
- unmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(vkStream, rootType, reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: {
+ unmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
- {
- unmarshal_VkRenderPassMultiviewCreateInfo(vkStream, rootType, reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: {
+ unmarshal_VkRenderPassMultiviewCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
- {
- unmarshal_VkPhysicalDeviceMultiviewFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
+ unmarshal_VkPhysicalDeviceMultiviewFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
- {
- unmarshal_VkPhysicalDeviceMultiviewProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: {
+ unmarshal_VkPhysicalDeviceMultiviewProperties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
- {
- unmarshal_VkPhysicalDeviceVariablePointersFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
+ unmarshal_VkPhysicalDeviceVariablePointersFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
- {
- unmarshal_VkPhysicalDeviceProtectedMemoryFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
+ unmarshal_VkPhysicalDeviceProtectedMemoryFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
- {
- unmarshal_VkPhysicalDeviceProtectedMemoryProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: {
+ unmarshal_VkPhysicalDeviceProtectedMemoryProperties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
- {
- unmarshal_VkProtectedSubmitInfo(vkStream, rootType, reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: {
+ unmarshal_VkProtectedSubmitInfo(
+ vkStream, rootType, reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
- {
- unmarshal_VkSamplerYcbcrConversionInfo(vkStream, rootType, reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: {
+ unmarshal_VkSamplerYcbcrConversionInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
- {
- unmarshal_VkBindImagePlaneMemoryInfo(vkStream, rootType, reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: {
+ unmarshal_VkBindImagePlaneMemoryInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
- {
- unmarshal_VkImagePlaneMemoryRequirementsInfo(vkStream, rootType, reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: {
+ unmarshal_VkImagePlaneMemoryRequirementsInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
- {
- unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
+ unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
- {
- unmarshal_VkSamplerYcbcrConversionImageFormatProperties(vkStream, rootType, reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: {
+ unmarshal_VkSamplerYcbcrConversionImageFormatProperties(
+ vkStream, rootType,
+ reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
- {
- unmarshal_VkPhysicalDeviceExternalImageFormatInfo(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: {
+ unmarshal_VkPhysicalDeviceExternalImageFormatInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
- {
- unmarshal_VkExternalImageFormatProperties(vkStream, rootType, reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: {
+ unmarshal_VkExternalImageFormatProperties(
+ vkStream, rootType,
+ reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
- {
- unmarshal_VkPhysicalDeviceIDProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: {
+ unmarshal_VkPhysicalDeviceIDProperties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
- {
- unmarshal_VkExternalMemoryImageCreateInfo(vkStream, rootType, reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: {
+ unmarshal_VkExternalMemoryImageCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
- {
- unmarshal_VkExternalMemoryBufferCreateInfo(vkStream, rootType, reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: {
+ unmarshal_VkExternalMemoryBufferCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
- {
- unmarshal_VkExportMemoryAllocateInfo(vkStream, rootType, reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: {
+ unmarshal_VkExportMemoryAllocateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
- {
- unmarshal_VkExportFenceCreateInfo(vkStream, rootType, reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: {
+ unmarshal_VkExportFenceCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
- {
- unmarshal_VkExportSemaphoreCreateInfo(vkStream, rootType, reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: {
+ unmarshal_VkExportSemaphoreCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
- {
- unmarshal_VkPhysicalDeviceMaintenance3Properties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: {
+ unmarshal_VkPhysicalDeviceMaintenance3Properties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
- {
- unmarshal_VkPhysicalDeviceShaderDrawParametersFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
+ unmarshal_VkPhysicalDeviceShaderDrawParametersFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_VERSION_1_2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
- {
- unmarshal_VkPhysicalDeviceVulkan11Features(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceVulkan11Features*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: {
+ unmarshal_VkPhysicalDeviceVulkan11Features(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceVulkan11Features*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
- {
- unmarshal_VkPhysicalDeviceVulkan11Properties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceVulkan11Properties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: {
+ unmarshal_VkPhysicalDeviceVulkan11Properties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceVulkan11Properties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
- {
- unmarshal_VkPhysicalDeviceVulkan12Features(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceVulkan12Features*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: {
+ unmarshal_VkPhysicalDeviceVulkan12Features(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceVulkan12Features*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
- {
- unmarshal_VkPhysicalDeviceVulkan12Properties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceVulkan12Properties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: {
+ unmarshal_VkPhysicalDeviceVulkan12Properties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceVulkan12Properties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
- {
- unmarshal_VkImageFormatListCreateInfo(vkStream, rootType, reinterpret_cast<VkImageFormatListCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: {
+ unmarshal_VkImageFormatListCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkImageFormatListCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
- {
- unmarshal_VkPhysicalDevice8BitStorageFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDevice8BitStorageFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: {
+ unmarshal_VkPhysicalDevice8BitStorageFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevice8BitStorageFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
- {
- unmarshal_VkPhysicalDeviceDriverProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDriverProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: {
+ unmarshal_VkPhysicalDeviceDriverProperties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceDriverProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
- {
- unmarshal_VkPhysicalDeviceShaderAtomicInt64Features(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: {
+ unmarshal_VkPhysicalDeviceShaderAtomicInt64Features(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
- {
- unmarshal_VkPhysicalDeviceShaderFloat16Int8Features(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: {
+ unmarshal_VkPhysicalDeviceShaderFloat16Int8Features(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
- {
- unmarshal_VkPhysicalDeviceFloatControlsProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceFloatControlsProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: {
+ unmarshal_VkPhysicalDeviceFloatControlsProperties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceFloatControlsProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
- {
- unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(vkStream, rootType, reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: {
+ unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
- {
- unmarshal_VkPhysicalDeviceDescriptorIndexingFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: {
+ unmarshal_VkPhysicalDeviceDescriptorIndexingFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
- {
- unmarshal_VkPhysicalDeviceDescriptorIndexingProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: {
+ unmarshal_VkPhysicalDeviceDescriptorIndexingProperties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
- {
- unmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(vkStream, rootType, reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: {
+ unmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
- {
- unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(vkStream, rootType, reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: {
+ unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(
+ vkStream, rootType,
+ reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
- {
- unmarshal_VkSubpassDescriptionDepthStencilResolve(vkStream, rootType, reinterpret_cast<VkSubpassDescriptionDepthStencilResolve*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: {
+ unmarshal_VkSubpassDescriptionDepthStencilResolve(
+ vkStream, rootType,
+ reinterpret_cast<VkSubpassDescriptionDepthStencilResolve*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
- {
- unmarshal_VkPhysicalDeviceDepthStencilResolveProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: {
+ unmarshal_VkPhysicalDeviceDepthStencilResolveProperties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
- {
- unmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: {
+ unmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
- {
- unmarshal_VkImageStencilUsageCreateInfo(vkStream, rootType, reinterpret_cast<VkImageStencilUsageCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: {
+ unmarshal_VkImageStencilUsageCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkImageStencilUsageCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
- {
- unmarshal_VkSamplerReductionModeCreateInfo(vkStream, rootType, reinterpret_cast<VkSamplerReductionModeCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: {
+ unmarshal_VkSamplerReductionModeCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkSamplerReductionModeCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
- {
- unmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: {
+ unmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
- {
- unmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: {
+ unmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
- {
- unmarshal_VkPhysicalDeviceImagelessFramebufferFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: {
+ unmarshal_VkPhysicalDeviceImagelessFramebufferFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
- {
- unmarshal_VkFramebufferAttachmentsCreateInfo(vkStream, rootType, reinterpret_cast<VkFramebufferAttachmentsCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: {
+ unmarshal_VkFramebufferAttachmentsCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkFramebufferAttachmentsCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
- {
- unmarshal_VkRenderPassAttachmentBeginInfo(vkStream, rootType, reinterpret_cast<VkRenderPassAttachmentBeginInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: {
+ unmarshal_VkRenderPassAttachmentBeginInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkRenderPassAttachmentBeginInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
- {
- unmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: {
+ unmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
- {
- unmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: {
+ unmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
- {
- unmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: {
+ unmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
- {
- unmarshal_VkAttachmentReferenceStencilLayout(vkStream, rootType, reinterpret_cast<VkAttachmentReferenceStencilLayout*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: {
+ unmarshal_VkAttachmentReferenceStencilLayout(
+ vkStream, rootType,
+ reinterpret_cast<VkAttachmentReferenceStencilLayout*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
- {
- unmarshal_VkAttachmentDescriptionStencilLayout(vkStream, rootType, reinterpret_cast<VkAttachmentDescriptionStencilLayout*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: {
+ unmarshal_VkAttachmentDescriptionStencilLayout(
+ vkStream, rootType,
+ reinterpret_cast<VkAttachmentDescriptionStencilLayout*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
- {
- unmarshal_VkPhysicalDeviceHostQueryResetFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: {
+ unmarshal_VkPhysicalDeviceHostQueryResetFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
- {
- unmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: {
+ unmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
- {
- unmarshal_VkPhysicalDeviceTimelineSemaphoreProperties(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: {
+ unmarshal_VkPhysicalDeviceTimelineSemaphoreProperties(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
- {
- unmarshal_VkSemaphoreTypeCreateInfo(vkStream, rootType, reinterpret_cast<VkSemaphoreTypeCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: {
+ unmarshal_VkSemaphoreTypeCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkSemaphoreTypeCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
- {
- unmarshal_VkTimelineSemaphoreSubmitInfo(vkStream, rootType, reinterpret_cast<VkTimelineSemaphoreSubmitInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: {
+ unmarshal_VkTimelineSemaphoreSubmitInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkTimelineSemaphoreSubmitInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
- {
- unmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: {
+ unmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
- {
- unmarshal_VkBufferOpaqueCaptureAddressCreateInfo(vkStream, rootType, reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: {
+ unmarshal_VkBufferOpaqueCaptureAddressCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
- {
- unmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo(vkStream, rootType, reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: {
+ unmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo(
+ vkStream, rootType,
+ reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_swapchain
- case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
- {
- unmarshal_VkImageSwapchainCreateInfoKHR(vkStream, rootType, reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
+ unmarshal_VkImageSwapchainCreateInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
- {
- unmarshal_VkBindImageMemorySwapchainInfoKHR(vkStream, rootType, reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: {
+ unmarshal_VkBindImageMemorySwapchainInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
- {
- unmarshal_VkDeviceGroupPresentInfoKHR(vkStream, rootType, reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: {
+ unmarshal_VkDeviceGroupPresentInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
- {
- unmarshal_VkDeviceGroupSwapchainCreateInfoKHR(vkStream, rootType, reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: {
+ unmarshal_VkDeviceGroupSwapchainCreateInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_display_swapchain
- case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
- {
- unmarshal_VkDisplayPresentInfoKHR(vkStream, rootType, reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: {
+ unmarshal_VkDisplayPresentInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_video_queue
- case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR:
- {
- unmarshal_VkVideoQueueFamilyProperties2KHR(vkStream, rootType, reinterpret_cast<VkVideoQueueFamilyProperties2KHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: {
+ unmarshal_VkVideoQueueFamilyProperties2KHR(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoQueueFamilyProperties2KHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR:
- {
- unmarshal_VkVideoProfileKHR(vkStream, rootType, reinterpret_cast<VkVideoProfileKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR: {
+ unmarshal_VkVideoProfileKHR(vkStream, rootType,
+ reinterpret_cast<VkVideoProfileKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR:
- {
- unmarshal_VkVideoProfilesKHR(vkStream, rootType, reinterpret_cast<VkVideoProfilesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR: {
+ unmarshal_VkVideoProfilesKHR(
+ vkStream, rootType, reinterpret_cast<VkVideoProfilesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_dynamic_rendering
- case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR:
- {
- unmarshal_VkPipelineRenderingCreateInfoKHR(vkStream, rootType, reinterpret_cast<VkPipelineRenderingCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: {
+ unmarshal_VkPipelineRenderingCreateInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineRenderingCreateInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR:
- {
- unmarshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: {
+ unmarshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR:
- {
- unmarshal_VkCommandBufferInheritanceRenderingInfoKHR(vkStream, rootType, reinterpret_cast<VkCommandBufferInheritanceRenderingInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: {
+ unmarshal_VkCommandBufferInheritanceRenderingInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkCommandBufferInheritanceRenderingInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
- {
- unmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(vkStream, rootType, reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
+ unmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
- {
- unmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(vkStream, rootType, reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
+ unmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
- {
- unmarshal_VkAttachmentSampleCountInfoAMD(vkStream, rootType, reinterpret_cast<VkAttachmentSampleCountInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
+ unmarshal_VkAttachmentSampleCountInfoAMD(
+ vkStream, rootType,
+ reinterpret_cast<VkAttachmentSampleCountInfoAMD*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
- {
- unmarshal_VkMultiviewPerViewAttributesInfoNVX(vkStream, rootType, reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
+ unmarshal_VkMultiviewPerViewAttributesInfoNVX(
+ vkStream, rootType,
+ reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_memory_win32
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
- {
- unmarshal_VkImportMemoryWin32HandleInfoKHR(vkStream, rootType, reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
+ unmarshal_VkImportMemoryWin32HandleInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
- {
- unmarshal_VkExportMemoryWin32HandleInfoKHR(vkStream, rootType, reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
+ unmarshal_VkExportMemoryWin32HandleInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_memory_fd
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
- {
- unmarshal_VkImportMemoryFdInfoKHR(vkStream, rootType, reinterpret_cast<VkImportMemoryFdInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: {
+ unmarshal_VkImportMemoryFdInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkImportMemoryFdInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_win32_keyed_mutex
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
- {
- unmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(vkStream, rootType, reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: {
+ unmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_semaphore_win32
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
- {
- unmarshal_VkExportSemaphoreWin32HandleInfoKHR(vkStream, rootType, reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: {
+ unmarshal_VkExportSemaphoreWin32HandleInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
- {
- unmarshal_VkD3D12FenceSubmitInfoKHR(vkStream, rootType, reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: {
+ unmarshal_VkD3D12FenceSubmitInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_push_descriptor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
- {
- unmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: {
+ unmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_incremental_present
- case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
- {
- unmarshal_VkPresentRegionsKHR(vkStream, rootType, reinterpret_cast<VkPresentRegionsKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: {
+ unmarshal_VkPresentRegionsKHR(
+ vkStream, rootType, reinterpret_cast<VkPresentRegionsKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shared_presentable_image
- case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
- {
- unmarshal_VkSharedPresentSurfaceCapabilitiesKHR(vkStream, rootType, reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
+ unmarshal_VkSharedPresentSurfaceCapabilitiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_fence_win32
- case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
- {
- unmarshal_VkExportFenceWin32HandleInfoKHR(vkStream, rootType, reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: {
+ unmarshal_VkExportFenceWin32HandleInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_performance_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
- {
- unmarshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: {
+ unmarshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
- {
- unmarshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: {
+ unmarshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
- {
- unmarshal_VkQueryPoolPerformanceCreateInfoKHR(vkStream, rootType, reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: {
+ unmarshal_VkQueryPoolPerformanceCreateInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
- {
- unmarshal_VkPerformanceQuerySubmitInfoKHR(vkStream, rootType, reinterpret_cast<VkPerformanceQuerySubmitInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: {
+ unmarshal_VkPerformanceQuerySubmitInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPerformanceQuerySubmitInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_portability_subset
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
- {
- unmarshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
+ unmarshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
- {
- unmarshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
+ unmarshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shader_clock
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
- {
- unmarshal_VkPhysicalDeviceShaderClockFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
+ unmarshal_VkPhysicalDeviceShaderClockFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shader_terminate_invocation
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR:
- {
- unmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: {
+ unmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_fragment_shading_rate
- case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
- {
- unmarshal_VkFragmentShadingRateAttachmentInfoKHR(vkStream, rootType, reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
+ unmarshal_VkFragmentShadingRateAttachmentInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
- {
- unmarshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(vkStream, rootType, reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: {
+ unmarshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
- {
- unmarshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: {
+ unmarshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
- {
- unmarshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: {
+ unmarshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_surface_protected_capabilities
- case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
- {
- unmarshal_VkSurfaceProtectedCapabilitiesKHR(vkStream, rootType, reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: {
+ unmarshal_VkSurfaceProtectedCapabilitiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_present_wait
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
- {
- unmarshal_VkPhysicalDevicePresentWaitFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDevicePresentWaitFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: {
+ unmarshal_VkPhysicalDevicePresentWaitFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevicePresentWaitFeaturesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
- {
- unmarshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: {
+ unmarshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shader_integer_dot_product
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR:
- {
- unmarshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: {
+ unmarshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR:
- {
- unmarshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: {
+ unmarshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_present_id
- case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
- {
- unmarshal_VkPresentIdKHR(vkStream, rootType, reinterpret_cast<VkPresentIdKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: {
+ unmarshal_VkPresentIdKHR(vkStream, rootType,
+ reinterpret_cast<VkPresentIdKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
- {
- unmarshal_VkPhysicalDevicePresentIdFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDevicePresentIdFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: {
+ unmarshal_VkPhysicalDevicePresentIdFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevicePresentIdFeaturesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_video_encode_queue
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
- {
- unmarshal_VkVideoEncodeRateControlInfoKHR(vkStream, rootType, reinterpret_cast<VkVideoEncodeRateControlInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
+ unmarshal_VkVideoEncodeRateControlInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoEncodeRateControlInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_synchronization2
- case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR:
- {
- unmarshal_VkMemoryBarrier2KHR(vkStream, rootType, reinterpret_cast<VkMemoryBarrier2KHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: {
+ unmarshal_VkMemoryBarrier2KHR(
+ vkStream, rootType, reinterpret_cast<VkMemoryBarrier2KHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR:
- {
- unmarshal_VkPhysicalDeviceSynchronization2FeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceSynchronization2FeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: {
+ unmarshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceSynchronization2FeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
- {
- unmarshal_VkQueueFamilyCheckpointProperties2NV(vkStream, rootType, reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
+ unmarshal_VkQueueFamilyCheckpointProperties2NV(
+ vkStream, rootType,
+ reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
- {
- unmarshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
+ unmarshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR:
- {
- unmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: {
+ unmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
- {
- unmarshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
+ unmarshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_format_feature_flags2
- case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR:
- {
- unmarshal_VkFormatProperties3KHR(vkStream, rootType, reinterpret_cast<VkFormatProperties3KHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: {
+ unmarshal_VkFormatProperties3KHR(
+ vkStream, rootType, reinterpret_cast<VkFormatProperties3KHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_maintenance4
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR:
- {
- unmarshal_VkPhysicalDeviceMaintenance4FeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: {
+ unmarshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR:
- {
- unmarshal_VkPhysicalDeviceMaintenance4PropertiesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: {
+ unmarshal_VkPhysicalDeviceMaintenance4PropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_ANDROID_native_buffer
- case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
- {
- unmarshal_VkNativeBufferANDROID(vkStream, rootType, reinterpret_cast<VkNativeBufferANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
+ unmarshal_VkNativeBufferANDROID(
+ vkStream, rootType, reinterpret_cast<VkNativeBufferANDROID*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_debug_report
- case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
- {
- unmarshal_VkDebugReportCallbackCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: {
+ unmarshal_VkDebugReportCallbackCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_rasterization_order
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
- {
- unmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(vkStream, rootType, reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: {
+ unmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_dedicated_allocation
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
- {
- unmarshal_VkDedicatedAllocationImageCreateInfoNV(vkStream, rootType, reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: {
+ unmarshal_VkDedicatedAllocationImageCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
- {
- unmarshal_VkDedicatedAllocationBufferCreateInfoNV(vkStream, rootType, reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: {
+ unmarshal_VkDedicatedAllocationBufferCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
- {
- unmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(vkStream, rootType, reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: {
+ unmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_transform_feedback
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
- {
- unmarshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: {
+ unmarshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
- {
- unmarshal_VkPipelineRasterizationStateStreamCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: {
+ unmarshal_VkPipelineRasterizationStateStreamCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_video_encode_h264
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT:
- {
- unmarshal_VkVideoEncodeH264CapabilitiesEXT(vkStream, rootType, reinterpret_cast<VkVideoEncodeH264CapabilitiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
+ unmarshal_VkVideoEncodeH264CapabilitiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoEncodeH264CapabilitiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT:
- {
- unmarshal_VkVideoEncodeH264SessionCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: {
+ unmarshal_VkVideoEncodeH264SessionCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- unmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(vkStream, rootType, reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ unmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- unmarshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ unmarshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT:
- {
- unmarshal_VkVideoEncodeH264VclFrameInfoEXT(vkStream, rootType, reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
+ unmarshal_VkVideoEncodeH264VclFrameInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT:
- {
- unmarshal_VkVideoEncodeH264EmitPictureParametersEXT(vkStream, rootType, reinterpret_cast<VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: {
+ unmarshal_VkVideoEncodeH264EmitPictureParametersEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT:
- {
- unmarshal_VkVideoEncodeH264ProfileEXT(vkStream, rootType, reinterpret_cast<VkVideoEncodeH264ProfileEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT: {
+ unmarshal_VkVideoEncodeH264ProfileEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoEncodeH264ProfileEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_video_encode_h265
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT:
- {
- unmarshal_VkVideoEncodeH265CapabilitiesEXT(vkStream, rootType, reinterpret_cast<VkVideoEncodeH265CapabilitiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
+ unmarshal_VkVideoEncodeH265CapabilitiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoEncodeH265CapabilitiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT:
- {
- unmarshal_VkVideoEncodeH265SessionCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: {
+ unmarshal_VkVideoEncodeH265SessionCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- unmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(vkStream, rootType, reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ unmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- unmarshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ unmarshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT:
- {
- unmarshal_VkVideoEncodeH265VclFrameInfoEXT(vkStream, rootType, reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
+ unmarshal_VkVideoEncodeH265VclFrameInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT:
- {
- unmarshal_VkVideoEncodeH265EmitPictureParametersEXT(vkStream, rootType, reinterpret_cast<VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: {
+ unmarshal_VkVideoEncodeH265EmitPictureParametersEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT:
- {
- unmarshal_VkVideoEncodeH265ProfileEXT(vkStream, rootType, reinterpret_cast<VkVideoEncodeH265ProfileEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT: {
+ unmarshal_VkVideoEncodeH265ProfileEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoEncodeH265ProfileEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_video_decode_h264
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT:
- {
- unmarshal_VkVideoDecodeH264ProfileEXT(vkStream, rootType, reinterpret_cast<VkVideoDecodeH264ProfileEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT: {
+ unmarshal_VkVideoDecodeH264ProfileEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoDecodeH264ProfileEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT:
- {
- unmarshal_VkVideoDecodeH264CapabilitiesEXT(vkStream, rootType, reinterpret_cast<VkVideoDecodeH264CapabilitiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: {
+ unmarshal_VkVideoDecodeH264CapabilitiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoDecodeH264CapabilitiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT:
- {
- unmarshal_VkVideoDecodeH264SessionCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: {
+ unmarshal_VkVideoDecodeH264SessionCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- unmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(vkStream, rootType, reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ unmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- unmarshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ unmarshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT:
- {
- unmarshal_VkVideoDecodeH264PictureInfoEXT(vkStream, rootType, reinterpret_cast<VkVideoDecodeH264PictureInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: {
+ unmarshal_VkVideoDecodeH264PictureInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoDecodeH264PictureInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT:
- {
- unmarshal_VkVideoDecodeH264MvcEXT(vkStream, rootType, reinterpret_cast<VkVideoDecodeH264MvcEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT: {
+ unmarshal_VkVideoDecodeH264MvcEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoDecodeH264MvcEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT:
- {
- unmarshal_VkVideoDecodeH264DpbSlotInfoEXT(vkStream, rootType, reinterpret_cast<VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: {
+ unmarshal_VkVideoDecodeH264DpbSlotInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_texture_gather_bias_lod
- case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
- {
- unmarshal_VkTextureLODGatherFormatPropertiesAMD(vkStream, rootType, reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
+ unmarshal_VkTextureLODGatherFormatPropertiesAMD(
+ vkStream, rootType,
+ reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_corner_sampled_image
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
- {
- unmarshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: {
+ unmarshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_external_memory
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
- {
- unmarshal_VkExternalMemoryImageCreateInfoNV(vkStream, rootType, reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: {
+ unmarshal_VkExternalMemoryImageCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
- {
- unmarshal_VkExportMemoryAllocateInfoNV(vkStream, rootType, reinterpret_cast<VkExportMemoryAllocateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: {
+ unmarshal_VkExportMemoryAllocateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkExportMemoryAllocateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_external_memory_win32
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
- {
- unmarshal_VkImportMemoryWin32HandleInfoNV(vkStream, rootType, reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
+ unmarshal_VkImportMemoryWin32HandleInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
- {
- unmarshal_VkExportMemoryWin32HandleInfoNV(vkStream, rootType, reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
+ unmarshal_VkExportMemoryWin32HandleInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_win32_keyed_mutex
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
- {
- unmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(vkStream, rootType, reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: {
+ unmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_validation_flags
- case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
- {
- unmarshal_VkValidationFlagsEXT(vkStream, rootType, reinterpret_cast<VkValidationFlagsEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: {
+ unmarshal_VkValidationFlagsEXT(
+ vkStream, rootType, reinterpret_cast<VkValidationFlagsEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_astc_decode_mode
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
- {
- unmarshal_VkImageViewASTCDecodeModeEXT(vkStream, rootType, reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
+ unmarshal_VkImageViewASTCDecodeModeEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_conditional_rendering
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
- {
- unmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(vkStream, rootType, reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: {
+ unmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_clip_space_w_scaling
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
- {
- unmarshal_VkPipelineViewportWScalingStateCreateInfoNV(vkStream, rootType, reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: {
+ unmarshal_VkPipelineViewportWScalingStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_display_control
- case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
- {
- unmarshal_VkSwapchainCounterCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: {
+ unmarshal_VkSwapchainCounterCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_GOOGLE_display_timing
- case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
- {
- unmarshal_VkPresentTimesInfoGOOGLE(vkStream, rootType, reinterpret_cast<VkPresentTimesInfoGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: {
+ unmarshal_VkPresentTimesInfoGOOGLE(
+ vkStream, rootType,
+ reinterpret_cast<VkPresentTimesInfoGOOGLE*>(structExtension_out));
break;
}
#endif
#ifdef VK_NVX_multiview_per_view_attributes
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
- {
- unmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: {
+ unmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_viewport_swizzle
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
- {
- unmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(vkStream, rootType, reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: {
+ unmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_discard_rectangles
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
- {
- unmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: {
+ unmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
- {
- unmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: {
+ unmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_conservative_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
- {
- unmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: {
+ unmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
- {
- unmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: {
+ unmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_depth_clip_enable
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
- {
- unmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ unmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_debug_utils
- case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
- {
- unmarshal_VkDebugUtilsMessengerCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
+ unmarshal_VkDebugUtilsMessengerCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
- {
- unmarshal_VkAndroidHardwareBufferUsageANDROID(vkStream, rootType, reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: {
+ unmarshal_VkAndroidHardwareBufferUsageANDROID(
+ vkStream, rootType,
+ reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
- {
- unmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(vkStream, rootType, reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: {
+ unmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
+ vkStream, rootType,
+ reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
- {
- unmarshal_VkImportAndroidHardwareBufferInfoANDROID(vkStream, rootType, reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: {
+ unmarshal_VkImportAndroidHardwareBufferInfoANDROID(
+ vkStream, rootType,
+ reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
- {
- unmarshal_VkExternalFormatANDROID(vkStream, rootType, reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: {
+ unmarshal_VkExternalFormatANDROID(
+ vkStream, rootType,
+ reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
- {
- unmarshal_VkAndroidHardwareBufferFormatProperties2ANDROID(vkStream, rootType, reinterpret_cast<VkAndroidHardwareBufferFormatProperties2ANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: {
+ unmarshal_VkAndroidHardwareBufferFormatProperties2ANDROID(
+ vkStream, rootType,
+ reinterpret_cast<VkAndroidHardwareBufferFormatProperties2ANDROID*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_inline_uniform_block
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
- {
- unmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
+ unmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT:
- {
- unmarshal_VkWriteDescriptorSetInlineUniformBlockEXT(vkStream, rootType, reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
+ unmarshal_VkWriteDescriptorSetInlineUniformBlockEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT:
- {
- unmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
+ unmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_sample_locations
- case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
- {
- unmarshal_VkSampleLocationsInfoEXT(vkStream, rootType, reinterpret_cast<VkSampleLocationsInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
+ unmarshal_VkSampleLocationsInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkSampleLocationsInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
- {
- unmarshal_VkRenderPassSampleLocationsBeginInfoEXT(vkStream, rootType, reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: {
+ unmarshal_VkRenderPassSampleLocationsBeginInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
- {
- unmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: {
+ unmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
- {
- unmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: {
+ unmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_blend_operation_advanced
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
- {
- unmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: {
+ unmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
- {
- unmarshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: {
+ unmarshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_fragment_coverage_to_color
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
- {
- unmarshal_VkPipelineCoverageToColorStateCreateInfoNV(vkStream, rootType, reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: {
+ unmarshal_VkPipelineCoverageToColorStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_framebuffer_mixed_samples
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
- {
- unmarshal_VkPipelineCoverageModulationStateCreateInfoNV(vkStream, rootType, reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: {
+ unmarshal_VkPipelineCoverageModulationStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_shader_sm_builtins
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
- {
- unmarshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: {
+ unmarshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
- {
- unmarshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: {
+ unmarshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_image_drm_format_modifier
- case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
- {
- unmarshal_VkDrmFormatModifierPropertiesListEXT(vkStream, rootType, reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: {
+ unmarshal_VkDrmFormatModifierPropertiesListEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
- {
- unmarshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: {
+ unmarshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
- {
- unmarshal_VkImageDrmFormatModifierListCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: {
+ unmarshal_VkImageDrmFormatModifierListCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
- {
- unmarshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: {
+ unmarshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
- {
- unmarshal_VkDrmFormatModifierPropertiesList2EXT(vkStream, rootType, reinterpret_cast<VkDrmFormatModifierPropertiesList2EXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: {
+ unmarshal_VkDrmFormatModifierPropertiesList2EXT(
+ vkStream, rootType,
+ reinterpret_cast<VkDrmFormatModifierPropertiesList2EXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_validation_cache
- case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
- {
- unmarshal_VkShaderModuleValidationCacheCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: {
+ unmarshal_VkShaderModuleValidationCacheCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_shading_rate_image
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
- {
- unmarshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(vkStream, rootType, reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: {
+ unmarshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
- {
- unmarshal_VkPhysicalDeviceShadingRateImageFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: {
+ unmarshal_VkPhysicalDeviceShadingRateImageFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
- {
- unmarshal_VkPhysicalDeviceShadingRateImagePropertiesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: {
+ unmarshal_VkPhysicalDeviceShadingRateImagePropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
- {
- unmarshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(vkStream, rootType, reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: {
+ unmarshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_ray_tracing
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
- {
- unmarshal_VkWriteDescriptorSetAccelerationStructureNV(vkStream, rootType, reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: {
+ unmarshal_VkWriteDescriptorSetAccelerationStructureNV(
+ vkStream, rootType,
+ reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
- {
- unmarshal_VkPhysicalDeviceRayTracingPropertiesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: {
+ unmarshal_VkPhysicalDeviceRayTracingPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_representative_fragment_test
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
- {
- unmarshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: {
+ unmarshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
- {
- unmarshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(vkStream, rootType, reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: {
+ unmarshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_filter_cubic
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
- {
- unmarshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: {
+ unmarshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
- {
- unmarshal_VkFilterCubicImageViewImageFormatPropertiesEXT(vkStream, rootType, reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: {
+ unmarshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_global_priority
- case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
- {
- unmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
+ unmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_external_memory_host
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
- {
- unmarshal_VkImportMemoryHostPointerInfoEXT(vkStream, rootType, reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
+ unmarshal_VkImportMemoryHostPointerInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
- {
- unmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: {
+ unmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_AMD_pipeline_compiler_control
- case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
- {
- unmarshal_VkPipelineCompilerControlCreateInfoAMD(vkStream, rootType, reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: {
+ unmarshal_VkPipelineCompilerControlCreateInfoAMD(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_shader_core_properties
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
- {
- unmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: {
+ unmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_video_decode_h265
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT:
- {
- unmarshal_VkVideoDecodeH265ProfileEXT(vkStream, rootType, reinterpret_cast<VkVideoDecodeH265ProfileEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT: {
+ unmarshal_VkVideoDecodeH265ProfileEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoDecodeH265ProfileEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT:
- {
- unmarshal_VkVideoDecodeH265CapabilitiesEXT(vkStream, rootType, reinterpret_cast<VkVideoDecodeH265CapabilitiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: {
+ unmarshal_VkVideoDecodeH265CapabilitiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoDecodeH265CapabilitiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT:
- {
- unmarshal_VkVideoDecodeH265SessionCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: {
+ unmarshal_VkVideoDecodeH265SessionCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- unmarshal_VkVideoDecodeH265SessionParametersAddInfoEXT(vkStream, rootType, reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ unmarshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- unmarshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ unmarshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT:
- {
- unmarshal_VkVideoDecodeH265PictureInfoEXT(vkStream, rootType, reinterpret_cast<VkVideoDecodeH265PictureInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: {
+ unmarshal_VkVideoDecodeH265PictureInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoDecodeH265PictureInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT:
- {
- unmarshal_VkVideoDecodeH265DpbSlotInfoEXT(vkStream, rootType, reinterpret_cast<VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: {
+ unmarshal_VkVideoDecodeH265DpbSlotInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_memory_overallocation_behavior
- case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
- {
- unmarshal_VkDeviceMemoryOverallocationCreateInfoAMD(vkStream, rootType, reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
+ unmarshal_VkDeviceMemoryOverallocationCreateInfoAMD(
+ vkStream, rootType,
+ reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_vertex_attribute_divisor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
- {
- unmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
+ unmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
- {
- unmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: {
+ unmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_GGP_frame_token
- case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
- {
- unmarshal_VkPresentFrameTokenGGP(vkStream, rootType, reinterpret_cast<VkPresentFrameTokenGGP*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: {
+ unmarshal_VkPresentFrameTokenGGP(
+ vkStream, rootType, reinterpret_cast<VkPresentFrameTokenGGP*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_pipeline_creation_feedback
- case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT:
- {
- unmarshal_VkPipelineCreationFeedbackCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
+ unmarshal_VkPipelineCreationFeedbackCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_compute_shader_derivatives
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
- {
- unmarshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
+ unmarshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_mesh_shader
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
- {
- unmarshal_VkPhysicalDeviceMeshShaderFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: {
+ unmarshal_VkPhysicalDeviceMeshShaderFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
- {
- unmarshal_VkPhysicalDeviceMeshShaderPropertiesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: {
+ unmarshal_VkPhysicalDeviceMeshShaderPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_fragment_shader_barycentric
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV:
- {
- unmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
+ unmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_shader_image_footprint
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
- {
- unmarshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
+ unmarshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_scissor_exclusive
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
- {
- unmarshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(vkStream, rootType, reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: {
+ unmarshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
- {
- unmarshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: {
+ unmarshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
- {
- unmarshal_VkQueueFamilyCheckpointPropertiesNV(vkStream, rootType, reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: {
+ unmarshal_VkQueueFamilyCheckpointPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_INTEL_shader_integer_functions2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
- {
- unmarshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: {
+ unmarshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_INTEL_performance_query
- case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
- {
- unmarshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(vkStream, rootType, reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: {
+ unmarshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(
+ vkStream, rootType,
+ reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_pci_bus_info
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
- {
- unmarshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: {
+ unmarshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_display_native_hdr
- case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
- {
- unmarshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(vkStream, rootType, reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: {
+ unmarshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
+ vkStream, rootType,
+ reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
- {
- unmarshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(vkStream, rootType, reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: {
+ unmarshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(
+ vkStream, rootType,
+ reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_fragment_density_map
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
- {
- unmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
+ unmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
- {
- unmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: {
+ unmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
- unmarshal_VkImportColorBufferGOOGLE(vkStream, rootType, reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
+ unmarshal_VkImportColorBufferGOOGLE(
+ vkStream, rootType,
+ reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
break;
}
- default:
- {
- unmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension_out));
+ default: {
+ unmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension_out));
break;
}
}
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2:
- {
- unmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: {
+ unmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
- unmarshal_VkImportPhysicalAddressGOOGLE(vkStream, rootType, reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
+ unmarshal_VkImportPhysicalAddressGOOGLE(
+ vkStream, rootType,
+ reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
break;
}
- default:
- {
- unmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension_out));
+ default: {
+ unmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
+ structExtension_out));
break;
}
}
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
- {
- unmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: {
+ unmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2:
- {
- unmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: {
+ unmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
- unmarshal_VkImportBufferGOOGLE(vkStream, rootType, reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
+ unmarshal_VkImportBufferGOOGLE(
+ vkStream, rootType,
+ reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
break;
}
- default:
- {
- unmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension_out));
+ default: {
+ unmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension_out));
break;
}
}
@@ -32868,3326 +30757,2942 @@
}
#endif
#ifdef VK_EXT_subgroup_size_control
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
- {
- unmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: {
+ unmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:
- {
- unmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: {
+ unmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_AMD_shader_core_properties2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
- {
- unmarshal_VkPhysicalDeviceShaderCoreProperties2AMD(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
+ unmarshal_VkPhysicalDeviceShaderCoreProperties2AMD(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_device_coherent_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
- {
- unmarshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: {
+ unmarshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_shader_image_atomic_int64
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_memory_budget
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
- {
- unmarshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: {
+ unmarshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_memory_priority
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
- {
- unmarshal_VkMemoryPriorityAllocateInfoEXT(vkStream, rootType, reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: {
+ unmarshal_VkMemoryPriorityAllocateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
- {
- unmarshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: {
+ unmarshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_buffer_device_address
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
- {
- unmarshal_VkBufferDeviceAddressCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: {
+ unmarshal_VkBufferDeviceAddressCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_validation_features
- case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
- {
- unmarshal_VkValidationFeaturesEXT(vkStream, rootType, reinterpret_cast<VkValidationFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: {
+ unmarshal_VkValidationFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkValidationFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_cooperative_matrix
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
- {
- unmarshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: {
+ unmarshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
- {
- unmarshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: {
+ unmarshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_coverage_reduction_mode
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
- {
- unmarshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: {
+ unmarshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
- {
- unmarshal_VkPipelineCoverageReductionStateCreateInfoNV(vkStream, rootType, reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: {
+ unmarshal_VkPipelineCoverageReductionStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_fragment_shader_interlock
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_ycbcr_image_arrays
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_provoking_vertex
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceProvokingVertexFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceProvokingVertexFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
- {
- unmarshal_VkPhysicalDeviceProvokingVertexPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceProvokingVertexPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: {
+ unmarshal_VkPhysicalDeviceProvokingVertexPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceProvokingVertexPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
- {
- unmarshal_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: {
+ unmarshal_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_full_screen_exclusive
- case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
- {
- unmarshal_VkSurfaceFullScreenExclusiveInfoEXT(vkStream, rootType, reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: {
+ unmarshal_VkSurfaceFullScreenExclusiveInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
- {
- unmarshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(vkStream, rootType, reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: {
+ unmarshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
- {
- unmarshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(vkStream, rootType, reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: {
+ unmarshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_line_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
- {
- unmarshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: {
+ unmarshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
- {
- unmarshal_VkPipelineRasterizationLineStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: {
+ unmarshal_VkPipelineRasterizationLineStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_shader_atomic_float
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_index_type_uint8
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_shader_atomic_float2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_device_generated_commands
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
- {
- unmarshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: {
+ unmarshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
- {
- unmarshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: {
+ unmarshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
- {
- unmarshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(vkStream, rootType, reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: {
+ unmarshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_inherited_viewport_scissor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
- {
- unmarshal_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: {
+ unmarshal_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
- {
- unmarshal_VkCommandBufferInheritanceViewportScissorInfoNV(vkStream, rootType, reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: {
+ unmarshal_VkCommandBufferInheritanceViewportScissorInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_texel_buffer_alignment
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
- {
- unmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
+ unmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_QCOM_render_pass_transform
- case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
- {
- unmarshal_VkRenderPassTransformBeginInfoQCOM(vkStream, rootType, reinterpret_cast<VkRenderPassTransformBeginInfoQCOM*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
+ unmarshal_VkRenderPassTransformBeginInfoQCOM(
+ vkStream, rootType,
+ reinterpret_cast<VkRenderPassTransformBeginInfoQCOM*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
- {
- unmarshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(vkStream, rootType, reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: {
+ unmarshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
+ vkStream, rootType,
+ reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_device_memory_report
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
- {
- unmarshal_VkDeviceDeviceMemoryReportCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: {
+ unmarshal_VkDeviceDeviceMemoryReportCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_robustness2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceRobustness2FeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceRobustness2FeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
- {
- unmarshal_VkPhysicalDeviceRobustness2PropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: {
+ unmarshal_VkPhysicalDeviceRobustness2PropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_custom_border_color
- case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
- {
- unmarshal_VkSamplerCustomBorderColorCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: {
+ unmarshal_VkSamplerCustomBorderColorCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
- {
- unmarshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: {
+ unmarshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_private_data
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
+ unmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
- {
- unmarshal_VkDevicePrivateDataCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkDevicePrivateDataCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: {
+ unmarshal_VkDevicePrivateDataCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkDevicePrivateDataCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
+ unmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_device_diagnostics_config
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
- {
- unmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: {
+ unmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
- {
- unmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(vkStream, rootType, reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: {
+ unmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_fragment_shading_rate_enums
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
- {
- unmarshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
+ unmarshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
- {
- unmarshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: {
+ unmarshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
- {
- unmarshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(vkStream, rootType, reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: {
+ unmarshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_ray_tracing_motion_blur
- case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
- {
- unmarshal_VkAccelerationStructureGeometryMotionTrianglesDataNV(vkStream, rootType, reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: {
+ unmarshal_VkAccelerationStructureGeometryMotionTrianglesDataNV(
+ vkStream, rootType,
+ reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
- {
- unmarshal_VkAccelerationStructureMotionInfoNV(vkStream, rootType, reinterpret_cast<VkAccelerationStructureMotionInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: {
+ unmarshal_VkAccelerationStructureMotionInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<VkAccelerationStructureMotionInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
- {
- unmarshal_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: {
+ unmarshal_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_fragment_density_map2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
- {
- unmarshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: {
+ unmarshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_QCOM_rotated_copy_commands
- case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
- {
- unmarshal_VkCopyCommandTransformInfoQCOM(vkStream, rootType, reinterpret_cast<VkCopyCommandTransformInfoQCOM*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: {
+ unmarshal_VkCopyCommandTransformInfoQCOM(
+ vkStream, rootType,
+ reinterpret_cast<VkCopyCommandTransformInfoQCOM*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_image_robustness
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_4444_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDevice4444FormatsFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: {
+ unmarshal_VkPhysicalDevice4444FormatsFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_rgba10x6_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_VALVE_mutable_descriptor_type
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE:
- {
- unmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: {
+ unmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE:
- {
- unmarshal_VkMutableDescriptorTypeCreateInfoVALVE(vkStream, rootType, reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: {
+ unmarshal_VkMutableDescriptorTypeCreateInfoVALVE(
+ vkStream, rootType,
+ reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_physical_device_drm
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
- {
- unmarshal_VkPhysicalDeviceDrmPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceDrmPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: {
+ unmarshal_VkPhysicalDeviceDrmPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceDrmPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_primitive_topology_list_restart
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
+ unmarshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_FUCHSIA_external_memory
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
- {
- unmarshal_VkImportMemoryZirconHandleInfoFUCHSIA(vkStream, rootType, reinterpret_cast<VkImportMemoryZirconHandleInfoFUCHSIA*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: {
+ unmarshal_VkImportMemoryZirconHandleInfoFUCHSIA(
+ vkStream, rootType,
+ reinterpret_cast<VkImportMemoryZirconHandleInfoFUCHSIA*>(structExtension_out));
break;
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
- {
- unmarshal_VkImportMemoryBufferCollectionFUCHSIA(vkStream, rootType, reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIA*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: {
+ unmarshal_VkImportMemoryBufferCollectionFUCHSIA(
+ vkStream, rootType,
+ reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIA*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
- {
- unmarshal_VkBufferCollectionImageCreateInfoFUCHSIA(vkStream, rootType, reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: {
+ unmarshal_VkBufferCollectionImageCreateInfoFUCHSIA(
+ vkStream, rootType,
+ reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
- {
- unmarshal_VkBufferCollectionBufferCreateInfoFUCHSIA(vkStream, rootType, reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: {
+ unmarshal_VkBufferCollectionBufferCreateInfoFUCHSIA(
+ vkStream, rootType,
+ reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA*>(structExtension_out));
break;
}
#endif
#ifdef VK_HUAWEI_subpass_shading
- case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
- {
- unmarshal_VkSubpassShadingPipelineCreateInfoHUAWEI(vkStream, rootType, reinterpret_cast<VkSubpassShadingPipelineCreateInfoHUAWEI*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: {
+ unmarshal_VkSubpassShadingPipelineCreateInfoHUAWEI(
+ vkStream, rootType,
+ reinterpret_cast<VkSubpassShadingPipelineCreateInfoHUAWEI*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
- {
- unmarshal_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: {
+ unmarshal_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
- {
- unmarshal_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: {
+ unmarshal_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_HUAWEI_invocation_mask
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
- {
- unmarshal_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: {
+ unmarshal_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_external_memory_rdma
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
- {
- unmarshal_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: {
+ unmarshal_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_extended_dynamic_state2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_color_write_enable
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceColorWriteEnableFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
- {
- unmarshal_VkPipelineColorWriteCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkPipelineColorWriteCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: {
+ unmarshal_VkPipelineColorWriteCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPipelineColorWriteCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_GOOGLE_gfxstream
- case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
- {
- unmarshal_VkImportColorBufferGOOGLE(vkStream, rootType, reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
+ unmarshal_VkImportColorBufferGOOGLE(
+ vkStream, rootType,
+ reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
- {
- unmarshal_VkImportBufferGOOGLE(vkStream, rootType, reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE: {
+ unmarshal_VkImportBufferGOOGLE(
+ vkStream, rootType, reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
- {
- unmarshal_VkImportPhysicalAddressGOOGLE(vkStream, rootType, reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE: {
+ unmarshal_VkImportPhysicalAddressGOOGLE(
+ vkStream, rootType,
+ reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_global_priority_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT:
- {
- unmarshal_VkQueueFamilyGlobalPriorityPropertiesEXT(vkStream, rootType, reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: {
+ unmarshal_VkQueueFamilyGlobalPriorityPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_multi_draw
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceMultiDrawFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceMultiDrawFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceMultiDrawFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceMultiDrawFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
- {
- unmarshal_VkPhysicalDeviceMultiDrawPropertiesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceMultiDrawPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: {
+ unmarshal_VkPhysicalDeviceMultiDrawPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceMultiDrawPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_border_color_swizzle
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
+ unmarshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
- {
- unmarshal_VkSamplerBorderColorComponentMappingCreateInfoEXT(vkStream, rootType, reinterpret_cast<VkSamplerBorderColorComponentMappingCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: {
+ unmarshal_VkSamplerBorderColorComponentMappingCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkSamplerBorderColorComponentMappingCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_pageable_device_local_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
- {
- unmarshal_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(vkStream, rootType, reinterpret_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: {
+ unmarshal_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_acceleration_structure
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
- {
- unmarshal_VkWriteDescriptorSetAccelerationStructureKHR(vkStream, rootType, reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
+ unmarshal_VkWriteDescriptorSetAccelerationStructureKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
- {
- unmarshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: {
+ unmarshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
- {
- unmarshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: {
+ unmarshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
- {
- unmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
+ unmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
- {
- unmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: {
+ unmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_ray_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
- {
- unmarshal_VkPhysicalDeviceRayQueryFeaturesKHR(vkStream, rootType, reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: {
+ unmarshal_VkPhysicalDeviceRayQueryFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension_out));
break;
}
#endif
- default:
- {
+ default: {
// fatal; the switch is only taken if the extension struct is known
abort();
}
}
}
-const char* api_opcode_to_string(
- const uint32_t opcode)
-{
- switch(opcode)
- {
+const char* api_opcode_to_string(const uint32_t opcode) {
+ switch (opcode) {
#ifdef VK_VERSION_1_0
- case OP_vkCreateInstance:
- {
+ case OP_vkCreateInstance: {
return "OP_vkCreateInstance";
}
- case OP_vkDestroyInstance:
- {
+ case OP_vkDestroyInstance: {
return "OP_vkDestroyInstance";
}
- case OP_vkEnumeratePhysicalDevices:
- {
+ case OP_vkEnumeratePhysicalDevices: {
return "OP_vkEnumeratePhysicalDevices";
}
- case OP_vkGetPhysicalDeviceFeatures:
- {
+ case OP_vkGetPhysicalDeviceFeatures: {
return "OP_vkGetPhysicalDeviceFeatures";
}
- case OP_vkGetPhysicalDeviceFormatProperties:
- {
+ case OP_vkGetPhysicalDeviceFormatProperties: {
return "OP_vkGetPhysicalDeviceFormatProperties";
}
- case OP_vkGetPhysicalDeviceImageFormatProperties:
- {
+ case OP_vkGetPhysicalDeviceImageFormatProperties: {
return "OP_vkGetPhysicalDeviceImageFormatProperties";
}
- case OP_vkGetPhysicalDeviceProperties:
- {
+ case OP_vkGetPhysicalDeviceProperties: {
return "OP_vkGetPhysicalDeviceProperties";
}
- case OP_vkGetPhysicalDeviceQueueFamilyProperties:
- {
+ case OP_vkGetPhysicalDeviceQueueFamilyProperties: {
return "OP_vkGetPhysicalDeviceQueueFamilyProperties";
}
- case OP_vkGetPhysicalDeviceMemoryProperties:
- {
+ case OP_vkGetPhysicalDeviceMemoryProperties: {
return "OP_vkGetPhysicalDeviceMemoryProperties";
}
- case OP_vkGetInstanceProcAddr:
- {
+ case OP_vkGetInstanceProcAddr: {
return "OP_vkGetInstanceProcAddr";
}
- case OP_vkGetDeviceProcAddr:
- {
+ case OP_vkGetDeviceProcAddr: {
return "OP_vkGetDeviceProcAddr";
}
- case OP_vkCreateDevice:
- {
+ case OP_vkCreateDevice: {
return "OP_vkCreateDevice";
}
- case OP_vkDestroyDevice:
- {
+ case OP_vkDestroyDevice: {
return "OP_vkDestroyDevice";
}
- case OP_vkEnumerateInstanceExtensionProperties:
- {
+ case OP_vkEnumerateInstanceExtensionProperties: {
return "OP_vkEnumerateInstanceExtensionProperties";
}
- case OP_vkEnumerateDeviceExtensionProperties:
- {
+ case OP_vkEnumerateDeviceExtensionProperties: {
return "OP_vkEnumerateDeviceExtensionProperties";
}
- case OP_vkEnumerateInstanceLayerProperties:
- {
+ case OP_vkEnumerateInstanceLayerProperties: {
return "OP_vkEnumerateInstanceLayerProperties";
}
- case OP_vkEnumerateDeviceLayerProperties:
- {
+ case OP_vkEnumerateDeviceLayerProperties: {
return "OP_vkEnumerateDeviceLayerProperties";
}
- case OP_vkGetDeviceQueue:
- {
+ case OP_vkGetDeviceQueue: {
return "OP_vkGetDeviceQueue";
}
- case OP_vkQueueSubmit:
- {
+ case OP_vkQueueSubmit: {
return "OP_vkQueueSubmit";
}
- case OP_vkQueueWaitIdle:
- {
+ case OP_vkQueueWaitIdle: {
return "OP_vkQueueWaitIdle";
}
- case OP_vkDeviceWaitIdle:
- {
+ case OP_vkDeviceWaitIdle: {
return "OP_vkDeviceWaitIdle";
}
- case OP_vkAllocateMemory:
- {
+ case OP_vkAllocateMemory: {
return "OP_vkAllocateMemory";
}
- case OP_vkFreeMemory:
- {
+ case OP_vkFreeMemory: {
return "OP_vkFreeMemory";
}
- case OP_vkMapMemory:
- {
+ case OP_vkMapMemory: {
return "OP_vkMapMemory";
}
- case OP_vkUnmapMemory:
- {
+ case OP_vkUnmapMemory: {
return "OP_vkUnmapMemory";
}
- case OP_vkFlushMappedMemoryRanges:
- {
+ case OP_vkFlushMappedMemoryRanges: {
return "OP_vkFlushMappedMemoryRanges";
}
- case OP_vkInvalidateMappedMemoryRanges:
- {
+ case OP_vkInvalidateMappedMemoryRanges: {
return "OP_vkInvalidateMappedMemoryRanges";
}
- case OP_vkGetDeviceMemoryCommitment:
- {
+ case OP_vkGetDeviceMemoryCommitment: {
return "OP_vkGetDeviceMemoryCommitment";
}
- case OP_vkBindBufferMemory:
- {
+ case OP_vkBindBufferMemory: {
return "OP_vkBindBufferMemory";
}
- case OP_vkBindImageMemory:
- {
+ case OP_vkBindImageMemory: {
return "OP_vkBindImageMemory";
}
- case OP_vkGetBufferMemoryRequirements:
- {
+ case OP_vkGetBufferMemoryRequirements: {
return "OP_vkGetBufferMemoryRequirements";
}
- case OP_vkGetImageMemoryRequirements:
- {
+ case OP_vkGetImageMemoryRequirements: {
return "OP_vkGetImageMemoryRequirements";
}
- case OP_vkGetImageSparseMemoryRequirements:
- {
+ case OP_vkGetImageSparseMemoryRequirements: {
return "OP_vkGetImageSparseMemoryRequirements";
}
- case OP_vkGetPhysicalDeviceSparseImageFormatProperties:
- {
+ case OP_vkGetPhysicalDeviceSparseImageFormatProperties: {
return "OP_vkGetPhysicalDeviceSparseImageFormatProperties";
}
- case OP_vkQueueBindSparse:
- {
+ case OP_vkQueueBindSparse: {
return "OP_vkQueueBindSparse";
}
- case OP_vkCreateFence:
- {
+ case OP_vkCreateFence: {
return "OP_vkCreateFence";
}
- case OP_vkDestroyFence:
- {
+ case OP_vkDestroyFence: {
return "OP_vkDestroyFence";
}
- case OP_vkResetFences:
- {
+ case OP_vkResetFences: {
return "OP_vkResetFences";
}
- case OP_vkGetFenceStatus:
- {
+ case OP_vkGetFenceStatus: {
return "OP_vkGetFenceStatus";
}
- case OP_vkWaitForFences:
- {
+ case OP_vkWaitForFences: {
return "OP_vkWaitForFences";
}
- case OP_vkCreateSemaphore:
- {
+ case OP_vkCreateSemaphore: {
return "OP_vkCreateSemaphore";
}
- case OP_vkDestroySemaphore:
- {
+ case OP_vkDestroySemaphore: {
return "OP_vkDestroySemaphore";
}
- case OP_vkCreateEvent:
- {
+ case OP_vkCreateEvent: {
return "OP_vkCreateEvent";
}
- case OP_vkDestroyEvent:
- {
+ case OP_vkDestroyEvent: {
return "OP_vkDestroyEvent";
}
- case OP_vkGetEventStatus:
- {
+ case OP_vkGetEventStatus: {
return "OP_vkGetEventStatus";
}
- case OP_vkSetEvent:
- {
+ case OP_vkSetEvent: {
return "OP_vkSetEvent";
}
- case OP_vkResetEvent:
- {
+ case OP_vkResetEvent: {
return "OP_vkResetEvent";
}
- case OP_vkCreateQueryPool:
- {
+ case OP_vkCreateQueryPool: {
return "OP_vkCreateQueryPool";
}
- case OP_vkDestroyQueryPool:
- {
+ case OP_vkDestroyQueryPool: {
return "OP_vkDestroyQueryPool";
}
- case OP_vkGetQueryPoolResults:
- {
+ case OP_vkGetQueryPoolResults: {
return "OP_vkGetQueryPoolResults";
}
- case OP_vkCreateBuffer:
- {
+ case OP_vkCreateBuffer: {
return "OP_vkCreateBuffer";
}
- case OP_vkDestroyBuffer:
- {
+ case OP_vkDestroyBuffer: {
return "OP_vkDestroyBuffer";
}
- case OP_vkCreateBufferView:
- {
+ case OP_vkCreateBufferView: {
return "OP_vkCreateBufferView";
}
- case OP_vkDestroyBufferView:
- {
+ case OP_vkDestroyBufferView: {
return "OP_vkDestroyBufferView";
}
- case OP_vkCreateImage:
- {
+ case OP_vkCreateImage: {
return "OP_vkCreateImage";
}
- case OP_vkDestroyImage:
- {
+ case OP_vkDestroyImage: {
return "OP_vkDestroyImage";
}
- case OP_vkGetImageSubresourceLayout:
- {
+ case OP_vkGetImageSubresourceLayout: {
return "OP_vkGetImageSubresourceLayout";
}
- case OP_vkCreateImageView:
- {
+ case OP_vkCreateImageView: {
return "OP_vkCreateImageView";
}
- case OP_vkDestroyImageView:
- {
+ case OP_vkDestroyImageView: {
return "OP_vkDestroyImageView";
}
- case OP_vkCreateShaderModule:
- {
+ case OP_vkCreateShaderModule: {
return "OP_vkCreateShaderModule";
}
- case OP_vkDestroyShaderModule:
- {
+ case OP_vkDestroyShaderModule: {
return "OP_vkDestroyShaderModule";
}
- case OP_vkCreatePipelineCache:
- {
+ case OP_vkCreatePipelineCache: {
return "OP_vkCreatePipelineCache";
}
- case OP_vkDestroyPipelineCache:
- {
+ case OP_vkDestroyPipelineCache: {
return "OP_vkDestroyPipelineCache";
}
- case OP_vkGetPipelineCacheData:
- {
+ case OP_vkGetPipelineCacheData: {
return "OP_vkGetPipelineCacheData";
}
- case OP_vkMergePipelineCaches:
- {
+ case OP_vkMergePipelineCaches: {
return "OP_vkMergePipelineCaches";
}
- case OP_vkCreateGraphicsPipelines:
- {
+ case OP_vkCreateGraphicsPipelines: {
return "OP_vkCreateGraphicsPipelines";
}
- case OP_vkCreateComputePipelines:
- {
+ case OP_vkCreateComputePipelines: {
return "OP_vkCreateComputePipelines";
}
- case OP_vkDestroyPipeline:
- {
+ case OP_vkDestroyPipeline: {
return "OP_vkDestroyPipeline";
}
- case OP_vkCreatePipelineLayout:
- {
+ case OP_vkCreatePipelineLayout: {
return "OP_vkCreatePipelineLayout";
}
- case OP_vkDestroyPipelineLayout:
- {
+ case OP_vkDestroyPipelineLayout: {
return "OP_vkDestroyPipelineLayout";
}
- case OP_vkCreateSampler:
- {
+ case OP_vkCreateSampler: {
return "OP_vkCreateSampler";
}
- case OP_vkDestroySampler:
- {
+ case OP_vkDestroySampler: {
return "OP_vkDestroySampler";
}
- case OP_vkCreateDescriptorSetLayout:
- {
+ case OP_vkCreateDescriptorSetLayout: {
return "OP_vkCreateDescriptorSetLayout";
}
- case OP_vkDestroyDescriptorSetLayout:
- {
+ case OP_vkDestroyDescriptorSetLayout: {
return "OP_vkDestroyDescriptorSetLayout";
}
- case OP_vkCreateDescriptorPool:
- {
+ case OP_vkCreateDescriptorPool: {
return "OP_vkCreateDescriptorPool";
}
- case OP_vkDestroyDescriptorPool:
- {
+ case OP_vkDestroyDescriptorPool: {
return "OP_vkDestroyDescriptorPool";
}
- case OP_vkResetDescriptorPool:
- {
+ case OP_vkResetDescriptorPool: {
return "OP_vkResetDescriptorPool";
}
- case OP_vkAllocateDescriptorSets:
- {
+ case OP_vkAllocateDescriptorSets: {
return "OP_vkAllocateDescriptorSets";
}
- case OP_vkFreeDescriptorSets:
- {
+ case OP_vkFreeDescriptorSets: {
return "OP_vkFreeDescriptorSets";
}
- case OP_vkUpdateDescriptorSets:
- {
+ case OP_vkUpdateDescriptorSets: {
return "OP_vkUpdateDescriptorSets";
}
- case OP_vkCreateFramebuffer:
- {
+ case OP_vkCreateFramebuffer: {
return "OP_vkCreateFramebuffer";
}
- case OP_vkDestroyFramebuffer:
- {
+ case OP_vkDestroyFramebuffer: {
return "OP_vkDestroyFramebuffer";
}
- case OP_vkCreateRenderPass:
- {
+ case OP_vkCreateRenderPass: {
return "OP_vkCreateRenderPass";
}
- case OP_vkDestroyRenderPass:
- {
+ case OP_vkDestroyRenderPass: {
return "OP_vkDestroyRenderPass";
}
- case OP_vkGetRenderAreaGranularity:
- {
+ case OP_vkGetRenderAreaGranularity: {
return "OP_vkGetRenderAreaGranularity";
}
- case OP_vkCreateCommandPool:
- {
+ case OP_vkCreateCommandPool: {
return "OP_vkCreateCommandPool";
}
- case OP_vkDestroyCommandPool:
- {
+ case OP_vkDestroyCommandPool: {
return "OP_vkDestroyCommandPool";
}
- case OP_vkResetCommandPool:
- {
+ case OP_vkResetCommandPool: {
return "OP_vkResetCommandPool";
}
- case OP_vkAllocateCommandBuffers:
- {
+ case OP_vkAllocateCommandBuffers: {
return "OP_vkAllocateCommandBuffers";
}
- case OP_vkFreeCommandBuffers:
- {
+ case OP_vkFreeCommandBuffers: {
return "OP_vkFreeCommandBuffers";
}
- case OP_vkBeginCommandBuffer:
- {
+ case OP_vkBeginCommandBuffer: {
return "OP_vkBeginCommandBuffer";
}
- case OP_vkEndCommandBuffer:
- {
+ case OP_vkEndCommandBuffer: {
return "OP_vkEndCommandBuffer";
}
- case OP_vkResetCommandBuffer:
- {
+ case OP_vkResetCommandBuffer: {
return "OP_vkResetCommandBuffer";
}
- case OP_vkCmdBindPipeline:
- {
+ case OP_vkCmdBindPipeline: {
return "OP_vkCmdBindPipeline";
}
- case OP_vkCmdSetViewport:
- {
+ case OP_vkCmdSetViewport: {
return "OP_vkCmdSetViewport";
}
- case OP_vkCmdSetScissor:
- {
+ case OP_vkCmdSetScissor: {
return "OP_vkCmdSetScissor";
}
- case OP_vkCmdSetLineWidth:
- {
+ case OP_vkCmdSetLineWidth: {
return "OP_vkCmdSetLineWidth";
}
- case OP_vkCmdSetDepthBias:
- {
+ case OP_vkCmdSetDepthBias: {
return "OP_vkCmdSetDepthBias";
}
- case OP_vkCmdSetBlendConstants:
- {
+ case OP_vkCmdSetBlendConstants: {
return "OP_vkCmdSetBlendConstants";
}
- case OP_vkCmdSetDepthBounds:
- {
+ case OP_vkCmdSetDepthBounds: {
return "OP_vkCmdSetDepthBounds";
}
- case OP_vkCmdSetStencilCompareMask:
- {
+ case OP_vkCmdSetStencilCompareMask: {
return "OP_vkCmdSetStencilCompareMask";
}
- case OP_vkCmdSetStencilWriteMask:
- {
+ case OP_vkCmdSetStencilWriteMask: {
return "OP_vkCmdSetStencilWriteMask";
}
- case OP_vkCmdSetStencilReference:
- {
+ case OP_vkCmdSetStencilReference: {
return "OP_vkCmdSetStencilReference";
}
- case OP_vkCmdBindDescriptorSets:
- {
+ case OP_vkCmdBindDescriptorSets: {
return "OP_vkCmdBindDescriptorSets";
}
- case OP_vkCmdBindIndexBuffer:
- {
+ case OP_vkCmdBindIndexBuffer: {
return "OP_vkCmdBindIndexBuffer";
}
- case OP_vkCmdBindVertexBuffers:
- {
+ case OP_vkCmdBindVertexBuffers: {
return "OP_vkCmdBindVertexBuffers";
}
- case OP_vkCmdDraw:
- {
+ case OP_vkCmdDraw: {
return "OP_vkCmdDraw";
}
- case OP_vkCmdDrawIndexed:
- {
+ case OP_vkCmdDrawIndexed: {
return "OP_vkCmdDrawIndexed";
}
- case OP_vkCmdDrawIndirect:
- {
+ case OP_vkCmdDrawIndirect: {
return "OP_vkCmdDrawIndirect";
}
- case OP_vkCmdDrawIndexedIndirect:
- {
+ case OP_vkCmdDrawIndexedIndirect: {
return "OP_vkCmdDrawIndexedIndirect";
}
- case OP_vkCmdDispatch:
- {
+ case OP_vkCmdDispatch: {
return "OP_vkCmdDispatch";
}
- case OP_vkCmdDispatchIndirect:
- {
+ case OP_vkCmdDispatchIndirect: {
return "OP_vkCmdDispatchIndirect";
}
- case OP_vkCmdCopyBuffer:
- {
+ case OP_vkCmdCopyBuffer: {
return "OP_vkCmdCopyBuffer";
}
- case OP_vkCmdCopyImage:
- {
+ case OP_vkCmdCopyImage: {
return "OP_vkCmdCopyImage";
}
- case OP_vkCmdBlitImage:
- {
+ case OP_vkCmdBlitImage: {
return "OP_vkCmdBlitImage";
}
- case OP_vkCmdCopyBufferToImage:
- {
+ case OP_vkCmdCopyBufferToImage: {
return "OP_vkCmdCopyBufferToImage";
}
- case OP_vkCmdCopyImageToBuffer:
- {
+ case OP_vkCmdCopyImageToBuffer: {
return "OP_vkCmdCopyImageToBuffer";
}
- case OP_vkCmdUpdateBuffer:
- {
+ case OP_vkCmdUpdateBuffer: {
return "OP_vkCmdUpdateBuffer";
}
- case OP_vkCmdFillBuffer:
- {
+ case OP_vkCmdFillBuffer: {
return "OP_vkCmdFillBuffer";
}
- case OP_vkCmdClearColorImage:
- {
+ case OP_vkCmdClearColorImage: {
return "OP_vkCmdClearColorImage";
}
- case OP_vkCmdClearDepthStencilImage:
- {
+ case OP_vkCmdClearDepthStencilImage: {
return "OP_vkCmdClearDepthStencilImage";
}
- case OP_vkCmdClearAttachments:
- {
+ case OP_vkCmdClearAttachments: {
return "OP_vkCmdClearAttachments";
}
- case OP_vkCmdResolveImage:
- {
+ case OP_vkCmdResolveImage: {
return "OP_vkCmdResolveImage";
}
- case OP_vkCmdSetEvent:
- {
+ case OP_vkCmdSetEvent: {
return "OP_vkCmdSetEvent";
}
- case OP_vkCmdResetEvent:
- {
+ case OP_vkCmdResetEvent: {
return "OP_vkCmdResetEvent";
}
- case OP_vkCmdWaitEvents:
- {
+ case OP_vkCmdWaitEvents: {
return "OP_vkCmdWaitEvents";
}
- case OP_vkCmdPipelineBarrier:
- {
+ case OP_vkCmdPipelineBarrier: {
return "OP_vkCmdPipelineBarrier";
}
- case OP_vkCmdBeginQuery:
- {
+ case OP_vkCmdBeginQuery: {
return "OP_vkCmdBeginQuery";
}
- case OP_vkCmdEndQuery:
- {
+ case OP_vkCmdEndQuery: {
return "OP_vkCmdEndQuery";
}
- case OP_vkCmdResetQueryPool:
- {
+ case OP_vkCmdResetQueryPool: {
return "OP_vkCmdResetQueryPool";
}
- case OP_vkCmdWriteTimestamp:
- {
+ case OP_vkCmdWriteTimestamp: {
return "OP_vkCmdWriteTimestamp";
}
- case OP_vkCmdCopyQueryPoolResults:
- {
+ case OP_vkCmdCopyQueryPoolResults: {
return "OP_vkCmdCopyQueryPoolResults";
}
- case OP_vkCmdPushConstants:
- {
+ case OP_vkCmdPushConstants: {
return "OP_vkCmdPushConstants";
}
- case OP_vkCmdBeginRenderPass:
- {
+ case OP_vkCmdBeginRenderPass: {
return "OP_vkCmdBeginRenderPass";
}
- case OP_vkCmdNextSubpass:
- {
+ case OP_vkCmdNextSubpass: {
return "OP_vkCmdNextSubpass";
}
- case OP_vkCmdEndRenderPass:
- {
+ case OP_vkCmdEndRenderPass: {
return "OP_vkCmdEndRenderPass";
}
- case OP_vkCmdExecuteCommands:
- {
+ case OP_vkCmdExecuteCommands: {
return "OP_vkCmdExecuteCommands";
}
#endif
#ifdef VK_VERSION_1_1
- case OP_vkEnumerateInstanceVersion:
- {
+ case OP_vkEnumerateInstanceVersion: {
return "OP_vkEnumerateInstanceVersion";
}
- case OP_vkBindBufferMemory2:
- {
+ case OP_vkBindBufferMemory2: {
return "OP_vkBindBufferMemory2";
}
- case OP_vkBindImageMemory2:
- {
+ case OP_vkBindImageMemory2: {
return "OP_vkBindImageMemory2";
}
- case OP_vkGetDeviceGroupPeerMemoryFeatures:
- {
+ case OP_vkGetDeviceGroupPeerMemoryFeatures: {
return "OP_vkGetDeviceGroupPeerMemoryFeatures";
}
- case OP_vkCmdSetDeviceMask:
- {
+ case OP_vkCmdSetDeviceMask: {
return "OP_vkCmdSetDeviceMask";
}
- case OP_vkCmdDispatchBase:
- {
+ case OP_vkCmdDispatchBase: {
return "OP_vkCmdDispatchBase";
}
- case OP_vkEnumeratePhysicalDeviceGroups:
- {
+ case OP_vkEnumeratePhysicalDeviceGroups: {
return "OP_vkEnumeratePhysicalDeviceGroups";
}
- case OP_vkGetImageMemoryRequirements2:
- {
+ case OP_vkGetImageMemoryRequirements2: {
return "OP_vkGetImageMemoryRequirements2";
}
- case OP_vkGetBufferMemoryRequirements2:
- {
+ case OP_vkGetBufferMemoryRequirements2: {
return "OP_vkGetBufferMemoryRequirements2";
}
- case OP_vkGetImageSparseMemoryRequirements2:
- {
+ case OP_vkGetImageSparseMemoryRequirements2: {
return "OP_vkGetImageSparseMemoryRequirements2";
}
- case OP_vkGetPhysicalDeviceFeatures2:
- {
+ case OP_vkGetPhysicalDeviceFeatures2: {
return "OP_vkGetPhysicalDeviceFeatures2";
}
- case OP_vkGetPhysicalDeviceProperties2:
- {
+ case OP_vkGetPhysicalDeviceProperties2: {
return "OP_vkGetPhysicalDeviceProperties2";
}
- case OP_vkGetPhysicalDeviceFormatProperties2:
- {
+ case OP_vkGetPhysicalDeviceFormatProperties2: {
return "OP_vkGetPhysicalDeviceFormatProperties2";
}
- case OP_vkGetPhysicalDeviceImageFormatProperties2:
- {
+ case OP_vkGetPhysicalDeviceImageFormatProperties2: {
return "OP_vkGetPhysicalDeviceImageFormatProperties2";
}
- case OP_vkGetPhysicalDeviceQueueFamilyProperties2:
- {
+ case OP_vkGetPhysicalDeviceQueueFamilyProperties2: {
return "OP_vkGetPhysicalDeviceQueueFamilyProperties2";
}
- case OP_vkGetPhysicalDeviceMemoryProperties2:
- {
+ case OP_vkGetPhysicalDeviceMemoryProperties2: {
return "OP_vkGetPhysicalDeviceMemoryProperties2";
}
- case OP_vkGetPhysicalDeviceSparseImageFormatProperties2:
- {
+ case OP_vkGetPhysicalDeviceSparseImageFormatProperties2: {
return "OP_vkGetPhysicalDeviceSparseImageFormatProperties2";
}
- case OP_vkTrimCommandPool:
- {
+ case OP_vkTrimCommandPool: {
return "OP_vkTrimCommandPool";
}
- case OP_vkGetDeviceQueue2:
- {
+ case OP_vkGetDeviceQueue2: {
return "OP_vkGetDeviceQueue2";
}
- case OP_vkCreateSamplerYcbcrConversion:
- {
+ case OP_vkCreateSamplerYcbcrConversion: {
return "OP_vkCreateSamplerYcbcrConversion";
}
- case OP_vkDestroySamplerYcbcrConversion:
- {
+ case OP_vkDestroySamplerYcbcrConversion: {
return "OP_vkDestroySamplerYcbcrConversion";
}
- case OP_vkCreateDescriptorUpdateTemplate:
- {
+ case OP_vkCreateDescriptorUpdateTemplate: {
return "OP_vkCreateDescriptorUpdateTemplate";
}
- case OP_vkDestroyDescriptorUpdateTemplate:
- {
+ case OP_vkDestroyDescriptorUpdateTemplate: {
return "OP_vkDestroyDescriptorUpdateTemplate";
}
- case OP_vkUpdateDescriptorSetWithTemplate:
- {
+ case OP_vkUpdateDescriptorSetWithTemplate: {
return "OP_vkUpdateDescriptorSetWithTemplate";
}
- case OP_vkGetPhysicalDeviceExternalBufferProperties:
- {
+ case OP_vkGetPhysicalDeviceExternalBufferProperties: {
return "OP_vkGetPhysicalDeviceExternalBufferProperties";
}
- case OP_vkGetPhysicalDeviceExternalFenceProperties:
- {
+ case OP_vkGetPhysicalDeviceExternalFenceProperties: {
return "OP_vkGetPhysicalDeviceExternalFenceProperties";
}
- case OP_vkGetPhysicalDeviceExternalSemaphoreProperties:
- {
+ case OP_vkGetPhysicalDeviceExternalSemaphoreProperties: {
return "OP_vkGetPhysicalDeviceExternalSemaphoreProperties";
}
- case OP_vkGetDescriptorSetLayoutSupport:
- {
+ case OP_vkGetDescriptorSetLayoutSupport: {
return "OP_vkGetDescriptorSetLayoutSupport";
}
#endif
#ifdef VK_KHR_surface
- case OP_vkDestroySurfaceKHR:
- {
+ case OP_vkDestroySurfaceKHR: {
return "OP_vkDestroySurfaceKHR";
}
- case OP_vkGetPhysicalDeviceSurfaceSupportKHR:
- {
+ case OP_vkGetPhysicalDeviceSurfaceSupportKHR: {
return "OP_vkGetPhysicalDeviceSurfaceSupportKHR";
}
- case OP_vkGetPhysicalDeviceSurfaceCapabilitiesKHR:
- {
+ case OP_vkGetPhysicalDeviceSurfaceCapabilitiesKHR: {
return "OP_vkGetPhysicalDeviceSurfaceCapabilitiesKHR";
}
- case OP_vkGetPhysicalDeviceSurfaceFormatsKHR:
- {
+ case OP_vkGetPhysicalDeviceSurfaceFormatsKHR: {
return "OP_vkGetPhysicalDeviceSurfaceFormatsKHR";
}
- case OP_vkGetPhysicalDeviceSurfacePresentModesKHR:
- {
+ case OP_vkGetPhysicalDeviceSurfacePresentModesKHR: {
return "OP_vkGetPhysicalDeviceSurfacePresentModesKHR";
}
#endif
#ifdef VK_KHR_swapchain
- case OP_vkCreateSwapchainKHR:
- {
+ case OP_vkCreateSwapchainKHR: {
return "OP_vkCreateSwapchainKHR";
}
- case OP_vkDestroySwapchainKHR:
- {
+ case OP_vkDestroySwapchainKHR: {
return "OP_vkDestroySwapchainKHR";
}
- case OP_vkGetSwapchainImagesKHR:
- {
+ case OP_vkGetSwapchainImagesKHR: {
return "OP_vkGetSwapchainImagesKHR";
}
- case OP_vkAcquireNextImageKHR:
- {
+ case OP_vkAcquireNextImageKHR: {
return "OP_vkAcquireNextImageKHR";
}
- case OP_vkQueuePresentKHR:
- {
+ case OP_vkQueuePresentKHR: {
return "OP_vkQueuePresentKHR";
}
- case OP_vkGetDeviceGroupPresentCapabilitiesKHR:
- {
+ case OP_vkGetDeviceGroupPresentCapabilitiesKHR: {
return "OP_vkGetDeviceGroupPresentCapabilitiesKHR";
}
- case OP_vkGetDeviceGroupSurfacePresentModesKHR:
- {
+ case OP_vkGetDeviceGroupSurfacePresentModesKHR: {
return "OP_vkGetDeviceGroupSurfacePresentModesKHR";
}
- case OP_vkGetPhysicalDevicePresentRectanglesKHR:
- {
+ case OP_vkGetPhysicalDevicePresentRectanglesKHR: {
return "OP_vkGetPhysicalDevicePresentRectanglesKHR";
}
- case OP_vkAcquireNextImage2KHR:
- {
+ case OP_vkAcquireNextImage2KHR: {
return "OP_vkAcquireNextImage2KHR";
}
#endif
#ifdef VK_KHR_display
- case OP_vkGetPhysicalDeviceDisplayPropertiesKHR:
- {
+ case OP_vkGetPhysicalDeviceDisplayPropertiesKHR: {
return "OP_vkGetPhysicalDeviceDisplayPropertiesKHR";
}
- case OP_vkGetPhysicalDeviceDisplayPlanePropertiesKHR:
- {
+ case OP_vkGetPhysicalDeviceDisplayPlanePropertiesKHR: {
return "OP_vkGetPhysicalDeviceDisplayPlanePropertiesKHR";
}
- case OP_vkGetDisplayPlaneSupportedDisplaysKHR:
- {
+ case OP_vkGetDisplayPlaneSupportedDisplaysKHR: {
return "OP_vkGetDisplayPlaneSupportedDisplaysKHR";
}
- case OP_vkGetDisplayModePropertiesKHR:
- {
+ case OP_vkGetDisplayModePropertiesKHR: {
return "OP_vkGetDisplayModePropertiesKHR";
}
- case OP_vkCreateDisplayModeKHR:
- {
+ case OP_vkCreateDisplayModeKHR: {
return "OP_vkCreateDisplayModeKHR";
}
- case OP_vkGetDisplayPlaneCapabilitiesKHR:
- {
+ case OP_vkGetDisplayPlaneCapabilitiesKHR: {
return "OP_vkGetDisplayPlaneCapabilitiesKHR";
}
- case OP_vkCreateDisplayPlaneSurfaceKHR:
- {
+ case OP_vkCreateDisplayPlaneSurfaceKHR: {
return "OP_vkCreateDisplayPlaneSurfaceKHR";
}
#endif
#ifdef VK_KHR_display_swapchain
- case OP_vkCreateSharedSwapchainsKHR:
- {
+ case OP_vkCreateSharedSwapchainsKHR: {
return "OP_vkCreateSharedSwapchainsKHR";
}
#endif
#ifdef VK_KHR_xlib_surface
- case OP_vkCreateXlibSurfaceKHR:
- {
+ case OP_vkCreateXlibSurfaceKHR: {
return "OP_vkCreateXlibSurfaceKHR";
}
- case OP_vkGetPhysicalDeviceXlibPresentationSupportKHR:
- {
+ case OP_vkGetPhysicalDeviceXlibPresentationSupportKHR: {
return "OP_vkGetPhysicalDeviceXlibPresentationSupportKHR";
}
#endif
#ifdef VK_KHR_xcb_surface
- case OP_vkCreateXcbSurfaceKHR:
- {
+ case OP_vkCreateXcbSurfaceKHR: {
return "OP_vkCreateXcbSurfaceKHR";
}
- case OP_vkGetPhysicalDeviceXcbPresentationSupportKHR:
- {
+ case OP_vkGetPhysicalDeviceXcbPresentationSupportKHR: {
return "OP_vkGetPhysicalDeviceXcbPresentationSupportKHR";
}
#endif
#ifdef VK_KHR_wayland_surface
- case OP_vkCreateWaylandSurfaceKHR:
- {
+ case OP_vkCreateWaylandSurfaceKHR: {
return "OP_vkCreateWaylandSurfaceKHR";
}
- case OP_vkGetPhysicalDeviceWaylandPresentationSupportKHR:
- {
+ case OP_vkGetPhysicalDeviceWaylandPresentationSupportKHR: {
return "OP_vkGetPhysicalDeviceWaylandPresentationSupportKHR";
}
#endif
#ifdef VK_KHR_android_surface
- case OP_vkCreateAndroidSurfaceKHR:
- {
+ case OP_vkCreateAndroidSurfaceKHR: {
return "OP_vkCreateAndroidSurfaceKHR";
}
#endif
#ifdef VK_KHR_win32_surface
- case OP_vkCreateWin32SurfaceKHR:
- {
+ case OP_vkCreateWin32SurfaceKHR: {
return "OP_vkCreateWin32SurfaceKHR";
}
- case OP_vkGetPhysicalDeviceWin32PresentationSupportKHR:
- {
+ case OP_vkGetPhysicalDeviceWin32PresentationSupportKHR: {
return "OP_vkGetPhysicalDeviceWin32PresentationSupportKHR";
}
#endif
#ifdef VK_KHR_get_physical_device_properties2
- case OP_vkGetPhysicalDeviceFeatures2KHR:
- {
+ case OP_vkGetPhysicalDeviceFeatures2KHR: {
return "OP_vkGetPhysicalDeviceFeatures2KHR";
}
- case OP_vkGetPhysicalDeviceProperties2KHR:
- {
+ case OP_vkGetPhysicalDeviceProperties2KHR: {
return "OP_vkGetPhysicalDeviceProperties2KHR";
}
- case OP_vkGetPhysicalDeviceFormatProperties2KHR:
- {
+ case OP_vkGetPhysicalDeviceFormatProperties2KHR: {
return "OP_vkGetPhysicalDeviceFormatProperties2KHR";
}
- case OP_vkGetPhysicalDeviceImageFormatProperties2KHR:
- {
+ case OP_vkGetPhysicalDeviceImageFormatProperties2KHR: {
return "OP_vkGetPhysicalDeviceImageFormatProperties2KHR";
}
- case OP_vkGetPhysicalDeviceQueueFamilyProperties2KHR:
- {
+ case OP_vkGetPhysicalDeviceQueueFamilyProperties2KHR: {
return "OP_vkGetPhysicalDeviceQueueFamilyProperties2KHR";
}
- case OP_vkGetPhysicalDeviceMemoryProperties2KHR:
- {
+ case OP_vkGetPhysicalDeviceMemoryProperties2KHR: {
return "OP_vkGetPhysicalDeviceMemoryProperties2KHR";
}
- case OP_vkGetPhysicalDeviceSparseImageFormatProperties2KHR:
- {
+ case OP_vkGetPhysicalDeviceSparseImageFormatProperties2KHR: {
return "OP_vkGetPhysicalDeviceSparseImageFormatProperties2KHR";
}
#endif
#ifdef VK_KHR_device_group
- case OP_vkGetDeviceGroupPeerMemoryFeaturesKHR:
- {
+ case OP_vkGetDeviceGroupPeerMemoryFeaturesKHR: {
return "OP_vkGetDeviceGroupPeerMemoryFeaturesKHR";
}
- case OP_vkCmdSetDeviceMaskKHR:
- {
+ case OP_vkCmdSetDeviceMaskKHR: {
return "OP_vkCmdSetDeviceMaskKHR";
}
- case OP_vkCmdDispatchBaseKHR:
- {
+ case OP_vkCmdDispatchBaseKHR: {
return "OP_vkCmdDispatchBaseKHR";
}
#endif
#ifdef VK_KHR_maintenance1
- case OP_vkTrimCommandPoolKHR:
- {
+ case OP_vkTrimCommandPoolKHR: {
return "OP_vkTrimCommandPoolKHR";
}
#endif
#ifdef VK_KHR_device_group_creation
- case OP_vkEnumeratePhysicalDeviceGroupsKHR:
- {
+ case OP_vkEnumeratePhysicalDeviceGroupsKHR: {
return "OP_vkEnumeratePhysicalDeviceGroupsKHR";
}
#endif
#ifdef VK_KHR_external_memory_capabilities
- case OP_vkGetPhysicalDeviceExternalBufferPropertiesKHR:
- {
+ case OP_vkGetPhysicalDeviceExternalBufferPropertiesKHR: {
return "OP_vkGetPhysicalDeviceExternalBufferPropertiesKHR";
}
#endif
#ifdef VK_KHR_external_memory_win32
- case OP_vkGetMemoryWin32HandleKHR:
- {
+ case OP_vkGetMemoryWin32HandleKHR: {
return "OP_vkGetMemoryWin32HandleKHR";
}
- case OP_vkGetMemoryWin32HandlePropertiesKHR:
- {
+ case OP_vkGetMemoryWin32HandlePropertiesKHR: {
return "OP_vkGetMemoryWin32HandlePropertiesKHR";
}
#endif
#ifdef VK_KHR_external_memory_fd
- case OP_vkGetMemoryFdKHR:
- {
+ case OP_vkGetMemoryFdKHR: {
return "OP_vkGetMemoryFdKHR";
}
- case OP_vkGetMemoryFdPropertiesKHR:
- {
+ case OP_vkGetMemoryFdPropertiesKHR: {
return "OP_vkGetMemoryFdPropertiesKHR";
}
#endif
#ifdef VK_KHR_external_semaphore_capabilities
- case OP_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR:
- {
+ case OP_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR: {
return "OP_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR";
}
#endif
#ifdef VK_KHR_external_semaphore_win32
- case OP_vkImportSemaphoreWin32HandleKHR:
- {
+ case OP_vkImportSemaphoreWin32HandleKHR: {
return "OP_vkImportSemaphoreWin32HandleKHR";
}
- case OP_vkGetSemaphoreWin32HandleKHR:
- {
+ case OP_vkGetSemaphoreWin32HandleKHR: {
return "OP_vkGetSemaphoreWin32HandleKHR";
}
#endif
#ifdef VK_KHR_external_semaphore_fd
- case OP_vkImportSemaphoreFdKHR:
- {
+ case OP_vkImportSemaphoreFdKHR: {
return "OP_vkImportSemaphoreFdKHR";
}
- case OP_vkGetSemaphoreFdKHR:
- {
+ case OP_vkGetSemaphoreFdKHR: {
return "OP_vkGetSemaphoreFdKHR";
}
#endif
#ifdef VK_KHR_push_descriptor
- case OP_vkCmdPushDescriptorSetKHR:
- {
+ case OP_vkCmdPushDescriptorSetKHR: {
return "OP_vkCmdPushDescriptorSetKHR";
}
- case OP_vkCmdPushDescriptorSetWithTemplateKHR:
- {
+ case OP_vkCmdPushDescriptorSetWithTemplateKHR: {
return "OP_vkCmdPushDescriptorSetWithTemplateKHR";
}
#endif
#ifdef VK_KHR_descriptor_update_template
- case OP_vkCreateDescriptorUpdateTemplateKHR:
- {
+ case OP_vkCreateDescriptorUpdateTemplateKHR: {
return "OP_vkCreateDescriptorUpdateTemplateKHR";
}
- case OP_vkDestroyDescriptorUpdateTemplateKHR:
- {
+ case OP_vkDestroyDescriptorUpdateTemplateKHR: {
return "OP_vkDestroyDescriptorUpdateTemplateKHR";
}
- case OP_vkUpdateDescriptorSetWithTemplateKHR:
- {
+ case OP_vkUpdateDescriptorSetWithTemplateKHR: {
return "OP_vkUpdateDescriptorSetWithTemplateKHR";
}
#endif
#ifdef VK_KHR_create_renderpass2
- case OP_vkCreateRenderPass2KHR:
- {
+ case OP_vkCreateRenderPass2KHR: {
return "OP_vkCreateRenderPass2KHR";
}
- case OP_vkCmdBeginRenderPass2KHR:
- {
+ case OP_vkCmdBeginRenderPass2KHR: {
return "OP_vkCmdBeginRenderPass2KHR";
}
- case OP_vkCmdNextSubpass2KHR:
- {
+ case OP_vkCmdNextSubpass2KHR: {
return "OP_vkCmdNextSubpass2KHR";
}
- case OP_vkCmdEndRenderPass2KHR:
- {
+ case OP_vkCmdEndRenderPass2KHR: {
return "OP_vkCmdEndRenderPass2KHR";
}
#endif
#ifdef VK_KHR_shared_presentable_image
- case OP_vkGetSwapchainStatusKHR:
- {
+ case OP_vkGetSwapchainStatusKHR: {
return "OP_vkGetSwapchainStatusKHR";
}
#endif
#ifdef VK_KHR_external_fence_capabilities
- case OP_vkGetPhysicalDeviceExternalFencePropertiesKHR:
- {
+ case OP_vkGetPhysicalDeviceExternalFencePropertiesKHR: {
return "OP_vkGetPhysicalDeviceExternalFencePropertiesKHR";
}
#endif
#ifdef VK_KHR_external_fence_win32
- case OP_vkImportFenceWin32HandleKHR:
- {
+ case OP_vkImportFenceWin32HandleKHR: {
return "OP_vkImportFenceWin32HandleKHR";
}
- case OP_vkGetFenceWin32HandleKHR:
- {
+ case OP_vkGetFenceWin32HandleKHR: {
return "OP_vkGetFenceWin32HandleKHR";
}
#endif
#ifdef VK_KHR_external_fence_fd
- case OP_vkImportFenceFdKHR:
- {
+ case OP_vkImportFenceFdKHR: {
return "OP_vkImportFenceFdKHR";
}
- case OP_vkGetFenceFdKHR:
- {
+ case OP_vkGetFenceFdKHR: {
return "OP_vkGetFenceFdKHR";
}
#endif
#ifdef VK_KHR_get_surface_capabilities2
- case OP_vkGetPhysicalDeviceSurfaceCapabilities2KHR:
- {
+ case OP_vkGetPhysicalDeviceSurfaceCapabilities2KHR: {
return "OP_vkGetPhysicalDeviceSurfaceCapabilities2KHR";
}
- case OP_vkGetPhysicalDeviceSurfaceFormats2KHR:
- {
+ case OP_vkGetPhysicalDeviceSurfaceFormats2KHR: {
return "OP_vkGetPhysicalDeviceSurfaceFormats2KHR";
}
#endif
#ifdef VK_KHR_get_display_properties2
- case OP_vkGetPhysicalDeviceDisplayProperties2KHR:
- {
+ case OP_vkGetPhysicalDeviceDisplayProperties2KHR: {
return "OP_vkGetPhysicalDeviceDisplayProperties2KHR";
}
- case OP_vkGetPhysicalDeviceDisplayPlaneProperties2KHR:
- {
+ case OP_vkGetPhysicalDeviceDisplayPlaneProperties2KHR: {
return "OP_vkGetPhysicalDeviceDisplayPlaneProperties2KHR";
}
- case OP_vkGetDisplayModeProperties2KHR:
- {
+ case OP_vkGetDisplayModeProperties2KHR: {
return "OP_vkGetDisplayModeProperties2KHR";
}
- case OP_vkGetDisplayPlaneCapabilities2KHR:
- {
+ case OP_vkGetDisplayPlaneCapabilities2KHR: {
return "OP_vkGetDisplayPlaneCapabilities2KHR";
}
#endif
#ifdef VK_KHR_get_memory_requirements2
- case OP_vkGetImageMemoryRequirements2KHR:
- {
+ case OP_vkGetImageMemoryRequirements2KHR: {
return "OP_vkGetImageMemoryRequirements2KHR";
}
- case OP_vkGetBufferMemoryRequirements2KHR:
- {
+ case OP_vkGetBufferMemoryRequirements2KHR: {
return "OP_vkGetBufferMemoryRequirements2KHR";
}
- case OP_vkGetImageSparseMemoryRequirements2KHR:
- {
+ case OP_vkGetImageSparseMemoryRequirements2KHR: {
return "OP_vkGetImageSparseMemoryRequirements2KHR";
}
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
- case OP_vkCreateSamplerYcbcrConversionKHR:
- {
+ case OP_vkCreateSamplerYcbcrConversionKHR: {
return "OP_vkCreateSamplerYcbcrConversionKHR";
}
- case OP_vkDestroySamplerYcbcrConversionKHR:
- {
+ case OP_vkDestroySamplerYcbcrConversionKHR: {
return "OP_vkDestroySamplerYcbcrConversionKHR";
}
#endif
#ifdef VK_KHR_bind_memory2
- case OP_vkBindBufferMemory2KHR:
- {
+ case OP_vkBindBufferMemory2KHR: {
return "OP_vkBindBufferMemory2KHR";
}
- case OP_vkBindImageMemory2KHR:
- {
+ case OP_vkBindImageMemory2KHR: {
return "OP_vkBindImageMemory2KHR";
}
#endif
#ifdef VK_KHR_maintenance3
- case OP_vkGetDescriptorSetLayoutSupportKHR:
- {
+ case OP_vkGetDescriptorSetLayoutSupportKHR: {
return "OP_vkGetDescriptorSetLayoutSupportKHR";
}
#endif
#ifdef VK_KHR_draw_indirect_count
- case OP_vkCmdDrawIndirectCountKHR:
- {
+ case OP_vkCmdDrawIndirectCountKHR: {
return "OP_vkCmdDrawIndirectCountKHR";
}
- case OP_vkCmdDrawIndexedIndirectCountKHR:
- {
+ case OP_vkCmdDrawIndexedIndirectCountKHR: {
return "OP_vkCmdDrawIndexedIndirectCountKHR";
}
#endif
#ifdef VK_ANDROID_native_buffer
- case OP_vkGetSwapchainGrallocUsageANDROID:
- {
+ case OP_vkGetSwapchainGrallocUsageANDROID: {
return "OP_vkGetSwapchainGrallocUsageANDROID";
}
- case OP_vkAcquireImageANDROID:
- {
+ case OP_vkAcquireImageANDROID: {
return "OP_vkAcquireImageANDROID";
}
- case OP_vkQueueSignalReleaseImageANDROID:
- {
+ case OP_vkQueueSignalReleaseImageANDROID: {
return "OP_vkQueueSignalReleaseImageANDROID";
}
#endif
#ifdef VK_EXT_debug_report
- case OP_vkCreateDebugReportCallbackEXT:
- {
+ case OP_vkCreateDebugReportCallbackEXT: {
return "OP_vkCreateDebugReportCallbackEXT";
}
- case OP_vkDestroyDebugReportCallbackEXT:
- {
+ case OP_vkDestroyDebugReportCallbackEXT: {
return "OP_vkDestroyDebugReportCallbackEXT";
}
- case OP_vkDebugReportMessageEXT:
- {
+ case OP_vkDebugReportMessageEXT: {
return "OP_vkDebugReportMessageEXT";
}
#endif
#ifdef VK_EXT_debug_marker
- case OP_vkDebugMarkerSetObjectTagEXT:
- {
+ case OP_vkDebugMarkerSetObjectTagEXT: {
return "OP_vkDebugMarkerSetObjectTagEXT";
}
- case OP_vkDebugMarkerSetObjectNameEXT:
- {
+ case OP_vkDebugMarkerSetObjectNameEXT: {
return "OP_vkDebugMarkerSetObjectNameEXT";
}
- case OP_vkCmdDebugMarkerBeginEXT:
- {
+ case OP_vkCmdDebugMarkerBeginEXT: {
return "OP_vkCmdDebugMarkerBeginEXT";
}
- case OP_vkCmdDebugMarkerEndEXT:
- {
+ case OP_vkCmdDebugMarkerEndEXT: {
return "OP_vkCmdDebugMarkerEndEXT";
}
- case OP_vkCmdDebugMarkerInsertEXT:
- {
+ case OP_vkCmdDebugMarkerInsertEXT: {
return "OP_vkCmdDebugMarkerInsertEXT";
}
#endif
#ifdef VK_AMD_draw_indirect_count
- case OP_vkCmdDrawIndirectCountAMD:
- {
+ case OP_vkCmdDrawIndirectCountAMD: {
return "OP_vkCmdDrawIndirectCountAMD";
}
- case OP_vkCmdDrawIndexedIndirectCountAMD:
- {
+ case OP_vkCmdDrawIndexedIndirectCountAMD: {
return "OP_vkCmdDrawIndexedIndirectCountAMD";
}
#endif
#ifdef VK_AMD_shader_info
- case OP_vkGetShaderInfoAMD:
- {
+ case OP_vkGetShaderInfoAMD: {
return "OP_vkGetShaderInfoAMD";
}
#endif
#ifdef VK_NV_external_memory_capabilities
- case OP_vkGetPhysicalDeviceExternalImageFormatPropertiesNV:
- {
+ case OP_vkGetPhysicalDeviceExternalImageFormatPropertiesNV: {
return "OP_vkGetPhysicalDeviceExternalImageFormatPropertiesNV";
}
#endif
#ifdef VK_NV_external_memory_win32
- case OP_vkGetMemoryWin32HandleNV:
- {
+ case OP_vkGetMemoryWin32HandleNV: {
return "OP_vkGetMemoryWin32HandleNV";
}
#endif
#ifdef VK_NN_vi_surface
- case OP_vkCreateViSurfaceNN:
- {
+ case OP_vkCreateViSurfaceNN: {
return "OP_vkCreateViSurfaceNN";
}
#endif
#ifdef VK_EXT_conditional_rendering
- case OP_vkCmdBeginConditionalRenderingEXT:
- {
+ case OP_vkCmdBeginConditionalRenderingEXT: {
return "OP_vkCmdBeginConditionalRenderingEXT";
}
- case OP_vkCmdEndConditionalRenderingEXT:
- {
+ case OP_vkCmdEndConditionalRenderingEXT: {
return "OP_vkCmdEndConditionalRenderingEXT";
}
#endif
#ifdef VK_NV_clip_space_w_scaling
- case OP_vkCmdSetViewportWScalingNV:
- {
+ case OP_vkCmdSetViewportWScalingNV: {
return "OP_vkCmdSetViewportWScalingNV";
}
#endif
#ifdef VK_EXT_direct_mode_display
- case OP_vkReleaseDisplayEXT:
- {
+ case OP_vkReleaseDisplayEXT: {
return "OP_vkReleaseDisplayEXT";
}
#endif
#ifdef VK_EXT_acquire_xlib_display
- case OP_vkAcquireXlibDisplayEXT:
- {
+ case OP_vkAcquireXlibDisplayEXT: {
return "OP_vkAcquireXlibDisplayEXT";
}
- case OP_vkGetRandROutputDisplayEXT:
- {
+ case OP_vkGetRandROutputDisplayEXT: {
return "OP_vkGetRandROutputDisplayEXT";
}
#endif
#ifdef VK_EXT_display_surface_counter
- case OP_vkGetPhysicalDeviceSurfaceCapabilities2EXT:
- {
+ case OP_vkGetPhysicalDeviceSurfaceCapabilities2EXT: {
return "OP_vkGetPhysicalDeviceSurfaceCapabilities2EXT";
}
#endif
#ifdef VK_EXT_display_control
- case OP_vkDisplayPowerControlEXT:
- {
+ case OP_vkDisplayPowerControlEXT: {
return "OP_vkDisplayPowerControlEXT";
}
- case OP_vkRegisterDeviceEventEXT:
- {
+ case OP_vkRegisterDeviceEventEXT: {
return "OP_vkRegisterDeviceEventEXT";
}
- case OP_vkRegisterDisplayEventEXT:
- {
+ case OP_vkRegisterDisplayEventEXT: {
return "OP_vkRegisterDisplayEventEXT";
}
- case OP_vkGetSwapchainCounterEXT:
- {
+ case OP_vkGetSwapchainCounterEXT: {
return "OP_vkGetSwapchainCounterEXT";
}
#endif
#ifdef VK_GOOGLE_display_timing
- case OP_vkGetRefreshCycleDurationGOOGLE:
- {
+ case OP_vkGetRefreshCycleDurationGOOGLE: {
return "OP_vkGetRefreshCycleDurationGOOGLE";
}
- case OP_vkGetPastPresentationTimingGOOGLE:
- {
+ case OP_vkGetPastPresentationTimingGOOGLE: {
return "OP_vkGetPastPresentationTimingGOOGLE";
}
#endif
#ifdef VK_EXT_discard_rectangles
- case OP_vkCmdSetDiscardRectangleEXT:
- {
+ case OP_vkCmdSetDiscardRectangleEXT: {
return "OP_vkCmdSetDiscardRectangleEXT";
}
#endif
#ifdef VK_EXT_hdr_metadata
- case OP_vkSetHdrMetadataEXT:
- {
+ case OP_vkSetHdrMetadataEXT: {
return "OP_vkSetHdrMetadataEXT";
}
#endif
#ifdef VK_MVK_ios_surface
- case OP_vkCreateIOSSurfaceMVK:
- {
+ case OP_vkCreateIOSSurfaceMVK: {
return "OP_vkCreateIOSSurfaceMVK";
}
#endif
#ifdef VK_MVK_macos_surface
- case OP_vkCreateMacOSSurfaceMVK:
- {
+ case OP_vkCreateMacOSSurfaceMVK: {
return "OP_vkCreateMacOSSurfaceMVK";
}
#endif
#ifdef VK_EXT_debug_utils
- case OP_vkSetDebugUtilsObjectNameEXT:
- {
+ case OP_vkSetDebugUtilsObjectNameEXT: {
return "OP_vkSetDebugUtilsObjectNameEXT";
}
- case OP_vkSetDebugUtilsObjectTagEXT:
- {
+ case OP_vkSetDebugUtilsObjectTagEXT: {
return "OP_vkSetDebugUtilsObjectTagEXT";
}
- case OP_vkQueueBeginDebugUtilsLabelEXT:
- {
+ case OP_vkQueueBeginDebugUtilsLabelEXT: {
return "OP_vkQueueBeginDebugUtilsLabelEXT";
}
- case OP_vkQueueEndDebugUtilsLabelEXT:
- {
+ case OP_vkQueueEndDebugUtilsLabelEXT: {
return "OP_vkQueueEndDebugUtilsLabelEXT";
}
- case OP_vkQueueInsertDebugUtilsLabelEXT:
- {
+ case OP_vkQueueInsertDebugUtilsLabelEXT: {
return "OP_vkQueueInsertDebugUtilsLabelEXT";
}
- case OP_vkCmdBeginDebugUtilsLabelEXT:
- {
+ case OP_vkCmdBeginDebugUtilsLabelEXT: {
return "OP_vkCmdBeginDebugUtilsLabelEXT";
}
- case OP_vkCmdEndDebugUtilsLabelEXT:
- {
+ case OP_vkCmdEndDebugUtilsLabelEXT: {
return "OP_vkCmdEndDebugUtilsLabelEXT";
}
- case OP_vkCmdInsertDebugUtilsLabelEXT:
- {
+ case OP_vkCmdInsertDebugUtilsLabelEXT: {
return "OP_vkCmdInsertDebugUtilsLabelEXT";
}
- case OP_vkCreateDebugUtilsMessengerEXT:
- {
+ case OP_vkCreateDebugUtilsMessengerEXT: {
return "OP_vkCreateDebugUtilsMessengerEXT";
}
- case OP_vkDestroyDebugUtilsMessengerEXT:
- {
+ case OP_vkDestroyDebugUtilsMessengerEXT: {
return "OP_vkDestroyDebugUtilsMessengerEXT";
}
- case OP_vkSubmitDebugUtilsMessageEXT:
- {
+ case OP_vkSubmitDebugUtilsMessageEXT: {
return "OP_vkSubmitDebugUtilsMessageEXT";
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
- case OP_vkGetAndroidHardwareBufferPropertiesANDROID:
- {
+ case OP_vkGetAndroidHardwareBufferPropertiesANDROID: {
return "OP_vkGetAndroidHardwareBufferPropertiesANDROID";
}
- case OP_vkGetMemoryAndroidHardwareBufferANDROID:
- {
+ case OP_vkGetMemoryAndroidHardwareBufferANDROID: {
return "OP_vkGetMemoryAndroidHardwareBufferANDROID";
}
#endif
#ifdef VK_EXT_sample_locations
- case OP_vkCmdSetSampleLocationsEXT:
- {
+ case OP_vkCmdSetSampleLocationsEXT: {
return "OP_vkCmdSetSampleLocationsEXT";
}
- case OP_vkGetPhysicalDeviceMultisamplePropertiesEXT:
- {
+ case OP_vkGetPhysicalDeviceMultisamplePropertiesEXT: {
return "OP_vkGetPhysicalDeviceMultisamplePropertiesEXT";
}
#endif
#ifdef VK_EXT_validation_cache
- case OP_vkCreateValidationCacheEXT:
- {
+ case OP_vkCreateValidationCacheEXT: {
return "OP_vkCreateValidationCacheEXT";
}
- case OP_vkDestroyValidationCacheEXT:
- {
+ case OP_vkDestroyValidationCacheEXT: {
return "OP_vkDestroyValidationCacheEXT";
}
- case OP_vkMergeValidationCachesEXT:
- {
+ case OP_vkMergeValidationCachesEXT: {
return "OP_vkMergeValidationCachesEXT";
}
- case OP_vkGetValidationCacheDataEXT:
- {
+ case OP_vkGetValidationCacheDataEXT: {
return "OP_vkGetValidationCacheDataEXT";
}
#endif
#ifdef VK_EXT_external_memory_host
- case OP_vkGetMemoryHostPointerPropertiesEXT:
- {
+ case OP_vkGetMemoryHostPointerPropertiesEXT: {
return "OP_vkGetMemoryHostPointerPropertiesEXT";
}
#endif
#ifdef VK_AMD_buffer_marker
- case OP_vkCmdWriteBufferMarkerAMD:
- {
+ case OP_vkCmdWriteBufferMarkerAMD: {
return "OP_vkCmdWriteBufferMarkerAMD";
}
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
- case OP_vkCmdSetCheckpointNV:
- {
+ case OP_vkCmdSetCheckpointNV: {
return "OP_vkCmdSetCheckpointNV";
}
- case OP_vkGetQueueCheckpointDataNV:
- {
+ case OP_vkGetQueueCheckpointDataNV: {
return "OP_vkGetQueueCheckpointDataNV";
}
#endif
#ifdef VK_GOOGLE_gfxstream
- case OP_vkMapMemoryIntoAddressSpaceGOOGLE:
- {
+ case OP_vkMapMemoryIntoAddressSpaceGOOGLE: {
return "OP_vkMapMemoryIntoAddressSpaceGOOGLE";
}
- case OP_vkRegisterImageColorBufferGOOGLE:
- {
+ case OP_vkRegisterImageColorBufferGOOGLE: {
return "OP_vkRegisterImageColorBufferGOOGLE";
}
- case OP_vkRegisterBufferColorBufferGOOGLE:
- {
+ case OP_vkRegisterBufferColorBufferGOOGLE: {
return "OP_vkRegisterBufferColorBufferGOOGLE";
}
- case OP_vkUpdateDescriptorSetWithTemplateSizedGOOGLE:
- {
+ case OP_vkUpdateDescriptorSetWithTemplateSizedGOOGLE: {
return "OP_vkUpdateDescriptorSetWithTemplateSizedGOOGLE";
}
- case OP_vkBeginCommandBufferAsyncGOOGLE:
- {
+ case OP_vkBeginCommandBufferAsyncGOOGLE: {
return "OP_vkBeginCommandBufferAsyncGOOGLE";
}
- case OP_vkEndCommandBufferAsyncGOOGLE:
- {
+ case OP_vkEndCommandBufferAsyncGOOGLE: {
return "OP_vkEndCommandBufferAsyncGOOGLE";
}
- case OP_vkResetCommandBufferAsyncGOOGLE:
- {
+ case OP_vkResetCommandBufferAsyncGOOGLE: {
return "OP_vkResetCommandBufferAsyncGOOGLE";
}
- case OP_vkCommandBufferHostSyncGOOGLE:
- {
+ case OP_vkCommandBufferHostSyncGOOGLE: {
return "OP_vkCommandBufferHostSyncGOOGLE";
}
- case OP_vkCreateImageWithRequirementsGOOGLE:
- {
+ case OP_vkCreateImageWithRequirementsGOOGLE: {
return "OP_vkCreateImageWithRequirementsGOOGLE";
}
- case OP_vkCreateBufferWithRequirementsGOOGLE:
- {
+ case OP_vkCreateBufferWithRequirementsGOOGLE: {
return "OP_vkCreateBufferWithRequirementsGOOGLE";
}
- case OP_vkGetMemoryHostAddressInfoGOOGLE:
- {
+ case OP_vkGetMemoryHostAddressInfoGOOGLE: {
return "OP_vkGetMemoryHostAddressInfoGOOGLE";
}
- case OP_vkFreeMemorySyncGOOGLE:
- {
+ case OP_vkFreeMemorySyncGOOGLE: {
return "OP_vkFreeMemorySyncGOOGLE";
}
- case OP_vkQueueHostSyncGOOGLE:
- {
+ case OP_vkQueueHostSyncGOOGLE: {
return "OP_vkQueueHostSyncGOOGLE";
}
- case OP_vkQueueSubmitAsyncGOOGLE:
- {
+ case OP_vkQueueSubmitAsyncGOOGLE: {
return "OP_vkQueueSubmitAsyncGOOGLE";
}
- case OP_vkQueueWaitIdleAsyncGOOGLE:
- {
+ case OP_vkQueueWaitIdleAsyncGOOGLE: {
return "OP_vkQueueWaitIdleAsyncGOOGLE";
}
- case OP_vkQueueBindSparseAsyncGOOGLE:
- {
+ case OP_vkQueueBindSparseAsyncGOOGLE: {
return "OP_vkQueueBindSparseAsyncGOOGLE";
}
- case OP_vkGetLinearImageLayoutGOOGLE:
- {
+ case OP_vkGetLinearImageLayoutGOOGLE: {
return "OP_vkGetLinearImageLayoutGOOGLE";
}
#endif
#ifdef VK_MVK_moltenvk
- case OP_vkGetMTLDeviceMVK:
- {
+ case OP_vkGetMTLDeviceMVK: {
return "OP_vkGetMTLDeviceMVK";
}
- case OP_vkSetMTLTextureMVK:
- {
+ case OP_vkSetMTLTextureMVK: {
return "OP_vkSetMTLTextureMVK";
}
- case OP_vkGetMTLTextureMVK:
- {
+ case OP_vkGetMTLTextureMVK: {
return "OP_vkGetMTLTextureMVK";
}
- case OP_vkGetMTLBufferMVK:
- {
+ case OP_vkGetMTLBufferMVK: {
return "OP_vkGetMTLBufferMVK";
}
- case OP_vkUseIOSurfaceMVK:
- {
+ case OP_vkUseIOSurfaceMVK: {
return "OP_vkUseIOSurfaceMVK";
}
- case OP_vkGetIOSurfaceMVK:
- {
+ case OP_vkGetIOSurfaceMVK: {
return "OP_vkGetIOSurfaceMVK";
}
#endif
#ifdef VK_GOOGLE_gfxstream
- case OP_vkQueueFlushCommandsGOOGLE:
- {
+ case OP_vkQueueFlushCommandsGOOGLE: {
return "OP_vkQueueFlushCommandsGOOGLE";
}
#endif
#ifdef VK_KHR_dynamic_rendering
- case OP_vkCmdEndRenderingKHR:
- {
+ case OP_vkCmdEndRenderingKHR: {
return "OP_vkCmdEndRenderingKHR";
}
#endif
#ifdef VK_EXT_full_screen_exclusive
- case OP_vkAcquireFullScreenExclusiveModeEXT:
- {
+ case OP_vkAcquireFullScreenExclusiveModeEXT: {
return "OP_vkAcquireFullScreenExclusiveModeEXT";
}
#endif
#ifdef VK_KHR_synchronization2
- case OP_vkCmdPipelineBarrier2KHR:
- {
+ case OP_vkCmdPipelineBarrier2KHR: {
return "OP_vkCmdPipelineBarrier2KHR";
}
#endif
#ifdef VK_KHR_maintenance4
- case OP_vkGetDeviceBufferMemoryRequirementsKHR:
- {
+ case OP_vkGetDeviceBufferMemoryRequirementsKHR: {
return "OP_vkGetDeviceBufferMemoryRequirementsKHR";
}
#endif
#ifdef VK_EXT_color_write_enable
- case OP_vkCmdSetColorWriteEnableEXT:
- {
+ case OP_vkCmdSetColorWriteEnableEXT: {
return "OP_vkCmdSetColorWriteEnableEXT";
}
#endif
#ifdef VK_NV_ray_tracing
- case OP_vkBindAccelerationStructureMemoryNV:
- {
+ case OP_vkBindAccelerationStructureMemoryNV: {
return "OP_vkBindAccelerationStructureMemoryNV";
}
#endif
#ifdef VK_INTEL_performance_query
- case OP_vkInitializePerformanceApiINTEL:
- {
+ case OP_vkInitializePerformanceApiINTEL: {
return "OP_vkInitializePerformanceApiINTEL";
}
#endif
#ifdef VK_KHR_deferred_host_operations
- case OP_vkGetDeferredOperationMaxConcurrencyKHR:
- {
+ case OP_vkGetDeferredOperationMaxConcurrencyKHR: {
return "OP_vkGetDeferredOperationMaxConcurrencyKHR";
}
#endif
#ifdef VK_EXT_calibrated_timestamps
- case OP_vkGetCalibratedTimestampsEXT:
- {
+ case OP_vkGetCalibratedTimestampsEXT: {
return "OP_vkGetCalibratedTimestampsEXT";
}
#endif
#ifdef VK_NV_ray_tracing
- case OP_vkCreateRayTracingPipelinesNV:
- {
+ case OP_vkCreateRayTracingPipelinesNV: {
return "OP_vkCreateRayTracingPipelinesNV";
}
#endif
#ifdef VK_KHR_acceleration_structure
- case OP_vkCmdCopyMemoryToAccelerationStructureKHR:
- {
+ case OP_vkCmdCopyMemoryToAccelerationStructureKHR: {
return "OP_vkCmdCopyMemoryToAccelerationStructureKHR";
}
#endif
#ifdef VK_KHR_fragment_shading_rate
- case OP_vkCmdSetFragmentShadingRateKHR:
- {
+ case OP_vkCmdSetFragmentShadingRateKHR: {
return "OP_vkCmdSetFragmentShadingRateKHR";
}
#endif
#ifdef VK_NVX_image_view_handle
- case OP_vkGetImageViewHandleNVX:
- {
+ case OP_vkGetImageViewHandleNVX: {
return "OP_vkGetImageViewHandleNVX";
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case OP_vkCmdSetScissorWithCountEXT:
- {
+ case OP_vkCmdSetScissorWithCountEXT: {
return "OP_vkCmdSetScissorWithCountEXT";
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
- case OP_vkGetRayTracingShaderGroupStackSizeKHR:
- {
+ case OP_vkGetRayTracingShaderGroupStackSizeKHR: {
return "OP_vkGetRayTracingShaderGroupStackSizeKHR";
}
#endif
#ifdef VK_EXT_full_screen_exclusive
- case OP_vkGetDeviceGroupSurfacePresentModes2EXT:
- {
+ case OP_vkGetDeviceGroupSurfacePresentModes2EXT: {
return "OP_vkGetDeviceGroupSurfacePresentModes2EXT";
}
#endif
#ifdef VK_NV_mesh_shader
- case OP_vkCmdDrawMeshTasksNV:
- {
+ case OP_vkCmdDrawMeshTasksNV: {
return "OP_vkCmdDrawMeshTasksNV";
}
#endif
#ifdef VK_NVX_binary_import
- case OP_vkCreateCuFunctionNVX:
- {
+ case OP_vkCreateCuFunctionNVX: {
return "OP_vkCreateCuFunctionNVX";
}
#endif
#ifdef VK_NV_ray_tracing
- case OP_vkCmdWriteAccelerationStructuresPropertiesNV:
- {
+ case OP_vkCmdWriteAccelerationStructuresPropertiesNV: {
return "OP_vkCmdWriteAccelerationStructuresPropertiesNV";
}
#endif
#ifdef VK_EXT_extended_dynamic_state2
- case OP_vkCmdSetPatchControlPointsEXT:
- {
+ case OP_vkCmdSetPatchControlPointsEXT: {
return "OP_vkCmdSetPatchControlPointsEXT";
}
#endif
#ifdef VK_EXT_private_data
- case OP_vkDestroyPrivateDataSlotEXT:
- {
+ case OP_vkDestroyPrivateDataSlotEXT: {
return "OP_vkDestroyPrivateDataSlotEXT";
}
#endif
#ifdef VK_NV_ray_tracing
- case OP_vkCmdTraceRaysNV:
- {
+ case OP_vkCmdTraceRaysNV: {
return "OP_vkCmdTraceRaysNV";
}
#endif
#ifdef VK_NVX_image_view_handle
- case OP_vkGetImageViewAddressNVX:
- {
+ case OP_vkGetImageViewAddressNVX: {
return "OP_vkGetImageViewAddressNVX";
}
#endif
#ifdef VK_NV_ray_tracing
- case OP_vkCmdCopyAccelerationStructureNV:
- {
+ case OP_vkCmdCopyAccelerationStructureNV: {
return "OP_vkCmdCopyAccelerationStructureNV";
}
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
- case OP_vkCmdSetVertexInputEXT:
- {
+ case OP_vkCmdSetVertexInputEXT: {
return "OP_vkCmdSetVertexInputEXT";
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
- case OP_vkCmdTraceRaysIndirectKHR:
- {
+ case OP_vkCmdTraceRaysIndirectKHR: {
return "OP_vkCmdTraceRaysIndirectKHR";
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case OP_vkCmdSetFrontFaceEXT:
- {
+ case OP_vkCmdSetFrontFaceEXT: {
return "OP_vkCmdSetFrontFaceEXT";
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
- case OP_vkSetBufferCollectionBufferConstraintsFUCHSIA:
- {
+ case OP_vkSetBufferCollectionBufferConstraintsFUCHSIA: {
return "OP_vkSetBufferCollectionBufferConstraintsFUCHSIA";
}
#endif
#ifdef VK_FUCHSIA_external_memory
- case OP_vkGetMemoryZirconHandlePropertiesFUCHSIA:
- {
+ case OP_vkGetMemoryZirconHandlePropertiesFUCHSIA: {
return "OP_vkGetMemoryZirconHandlePropertiesFUCHSIA";
}
#endif
#ifdef VK_INTEL_performance_query
- case OP_vkGetPerformanceParameterINTEL:
- {
+ case OP_vkGetPerformanceParameterINTEL: {
return "OP_vkGetPerformanceParameterINTEL";
}
#endif
#ifdef VK_GOOGLE_gfxstream
- case OP_vkCollectDescriptorPoolIdsGOOGLE:
- {
+ case OP_vkCollectDescriptorPoolIdsGOOGLE: {
return "OP_vkCollectDescriptorPoolIdsGOOGLE";
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
- case OP_vkCmdTraceRaysKHR:
- {
+ case OP_vkCmdTraceRaysKHR: {
return "OP_vkCmdTraceRaysKHR";
}
#endif
#ifdef VK_FUCHSIA_external_memory
- case OP_vkGetMemoryZirconHandleFUCHSIA:
- {
+ case OP_vkGetMemoryZirconHandleFUCHSIA: {
return "OP_vkGetMemoryZirconHandleFUCHSIA";
}
#endif
#ifdef VK_NV_shading_rate_image
- case OP_vkCmdSetViewportShadingRatePaletteNV:
- {
+ case OP_vkCmdSetViewportShadingRatePaletteNV: {
return "OP_vkCmdSetViewportShadingRatePaletteNV";
}
#endif
#ifdef VK_KHR_deferred_host_operations
- case OP_vkDestroyDeferredOperationKHR:
- {
+ case OP_vkDestroyDeferredOperationKHR: {
return "OP_vkDestroyDeferredOperationKHR";
}
#endif
#ifdef VK_KHR_video_queue
- case OP_vkBindVideoSessionMemoryKHR:
- {
+ case OP_vkBindVideoSessionMemoryKHR: {
return "OP_vkBindVideoSessionMemoryKHR";
}
#endif
#ifdef VK_KHR_deferred_host_operations
- case OP_vkDeferredOperationJoinKHR:
- {
+ case OP_vkDeferredOperationJoinKHR: {
return "OP_vkDeferredOperationJoinKHR";
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case OP_vkCmdSetDepthWriteEnableEXT:
- {
+ case OP_vkCmdSetDepthWriteEnableEXT: {
return "OP_vkCmdSetDepthWriteEnableEXT";
}
#endif
#ifdef VK_KHR_buffer_device_address
- case OP_vkGetBufferDeviceAddressKHR:
- {
+ case OP_vkGetBufferDeviceAddressKHR: {
return "OP_vkGetBufferDeviceAddressKHR";
}
#endif
#ifdef VK_KHR_acceleration_structure
- case OP_vkGetAccelerationStructureBuildSizesKHR:
- {
+ case OP_vkGetAccelerationStructureBuildSizesKHR: {
return "OP_vkGetAccelerationStructureBuildSizesKHR";
}
#endif
#ifdef VK_NVX_binary_import
- case OP_vkCmdCuLaunchKernelNVX:
- {
+ case OP_vkCmdCuLaunchKernelNVX: {
return "OP_vkCmdCuLaunchKernelNVX";
}
#endif
#ifdef VK_NV_ray_tracing
- case OP_vkGetAccelerationStructureMemoryRequirementsNV:
- {
+ case OP_vkGetAccelerationStructureMemoryRequirementsNV: {
return "OP_vkGetAccelerationStructureMemoryRequirementsNV";
}
#endif
#ifdef VK_HUAWEI_subpass_shading
- case OP_vkCmdSubpassShadingHUAWEI:
- {
+ case OP_vkCmdSubpassShadingHUAWEI: {
return "OP_vkCmdSubpassShadingHUAWEI";
}
#endif
#ifdef VK_EXT_directfb_surface
- case OP_vkCreateDirectFBSurfaceEXT:
- {
+ case OP_vkCreateDirectFBSurfaceEXT: {
return "OP_vkCreateDirectFBSurfaceEXT";
}
#endif
#ifdef VK_VERSION_1_2
- case OP_vkCmdEndRenderPass2:
- {
+ case OP_vkCmdEndRenderPass2: {
return "OP_vkCmdEndRenderPass2";
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
- case OP_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR:
- {
+ case OP_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR: {
return "OP_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR";
}
#endif
#ifdef VK_VERSION_1_2
- case OP_vkGetBufferDeviceAddress:
- {
+ case OP_vkGetBufferDeviceAddress: {
return "OP_vkGetBufferDeviceAddress";
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case OP_vkCmdSetDepthBoundsTestEnableEXT:
- {
+ case OP_vkCmdSetDepthBoundsTestEnableEXT: {
return "OP_vkCmdSetDepthBoundsTestEnableEXT";
}
#endif
#ifdef VK_KHR_acceleration_structure
- case OP_vkGetAccelerationStructureDeviceAddressKHR:
- {
+ case OP_vkGetAccelerationStructureDeviceAddressKHR: {
return "OP_vkGetAccelerationStructureDeviceAddressKHR";
}
- case OP_vkCmdCopyAccelerationStructureToMemoryKHR:
- {
+ case OP_vkCmdCopyAccelerationStructureToMemoryKHR: {
return "OP_vkCmdCopyAccelerationStructureToMemoryKHR";
}
#endif
#ifdef VK_NV_mesh_shader
- case OP_vkCmdDrawMeshTasksIndirectCountNV:
- {
+ case OP_vkCmdDrawMeshTasksIndirectCountNV: {
return "OP_vkCmdDrawMeshTasksIndirectCountNV";
}
#endif
#ifdef VK_KHR_performance_query
- case OP_vkReleaseProfilingLockKHR:
- {
+ case OP_vkReleaseProfilingLockKHR: {
return "OP_vkReleaseProfilingLockKHR";
}
#endif
#ifdef VK_KHR_acceleration_structure
- case OP_vkDestroyAccelerationStructureKHR:
- {
+ case OP_vkDestroyAccelerationStructureKHR: {
return "OP_vkDestroyAccelerationStructureKHR";
}
#endif
#ifdef VK_EXT_pageable_device_local_memory
- case OP_vkSetDeviceMemoryPriorityEXT:
- {
+ case OP_vkSetDeviceMemoryPriorityEXT: {
return "OP_vkSetDeviceMemoryPriorityEXT";
}
#endif
#ifdef VK_EXT_buffer_device_address
- case OP_vkGetBufferDeviceAddressEXT:
- {
+ case OP_vkGetBufferDeviceAddressEXT: {
return "OP_vkGetBufferDeviceAddressEXT";
}
#endif
#ifdef VK_QNX_screen_surface
- case OP_vkCreateScreenSurfaceQNX:
- {
+ case OP_vkCreateScreenSurfaceQNX: {
return "OP_vkCreateScreenSurfaceQNX";
}
#endif
#ifdef VK_KHR_synchronization2
- case OP_vkCmdWriteBufferMarker2AMD:
- {
+ case OP_vkCmdWriteBufferMarker2AMD: {
return "OP_vkCmdWriteBufferMarker2AMD";
}
#endif
#ifdef VK_VERSION_1_2
- case OP_vkWaitSemaphores:
- {
+ case OP_vkWaitSemaphores: {
return "OP_vkWaitSemaphores";
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
- case OP_vkDestroyBufferCollectionFUCHSIA:
- {
+ case OP_vkDestroyBufferCollectionFUCHSIA: {
return "OP_vkDestroyBufferCollectionFUCHSIA";
}
#endif
#ifdef VK_EXT_private_data
- case OP_vkSetPrivateDataEXT:
- {
+ case OP_vkSetPrivateDataEXT: {
return "OP_vkSetPrivateDataEXT";
}
#endif
#ifdef VK_HUAWEI_subpass_shading
- case OP_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI:
- {
+ case OP_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI: {
return "OP_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI";
}
#endif
#ifdef VK_NV_scissor_exclusive
- case OP_vkCmdSetExclusiveScissorNV:
- {
+ case OP_vkCmdSetExclusiveScissorNV: {
return "OP_vkCmdSetExclusiveScissorNV";
}
#endif
#ifdef VK_KHR_copy_commands2
- case OP_vkCmdCopyImage2KHR:
- {
+ case OP_vkCmdCopyImage2KHR: {
return "OP_vkCmdCopyImage2KHR";
}
#endif
#ifdef VK_NVX_binary_import
- case OP_vkCreateCuModuleNVX:
- {
+ case OP_vkCreateCuModuleNVX: {
return "OP_vkCreateCuModuleNVX";
}
#endif
#ifdef VK_KHR_video_queue
- case OP_vkCreateVideoSessionKHR:
- {
+ case OP_vkCreateVideoSessionKHR: {
return "OP_vkCreateVideoSessionKHR";
}
#endif
#ifdef VK_KHR_timeline_semaphore
- case OP_vkGetSemaphoreCounterValueKHR:
- {
+ case OP_vkGetSemaphoreCounterValueKHR: {
return "OP_vkGetSemaphoreCounterValueKHR";
}
#endif
#ifdef VK_NV_ray_tracing
- case OP_vkGetRayTracingShaderGroupHandlesNV:
- {
+ case OP_vkGetRayTracingShaderGroupHandlesNV: {
return "OP_vkGetRayTracingShaderGroupHandlesNV";
}
#endif
#ifdef VK_VERSION_1_2
- case OP_vkGetBufferOpaqueCaptureAddress:
- {
+ case OP_vkGetBufferOpaqueCaptureAddress: {
return "OP_vkGetBufferOpaqueCaptureAddress";
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case OP_vkCmdSetDepthTestEnableEXT:
- {
+ case OP_vkCmdSetDepthTestEnableEXT: {
return "OP_vkCmdSetDepthTestEnableEXT";
}
#endif
#ifdef VK_NV_device_generated_commands
- case OP_vkCmdExecuteGeneratedCommandsNV:
- {
+ case OP_vkCmdExecuteGeneratedCommandsNV: {
return "OP_vkCmdExecuteGeneratedCommandsNV";
}
#endif
#ifdef VK_VERSION_1_2
- case OP_vkCmdBeginRenderPass2:
- {
+ case OP_vkCmdBeginRenderPass2: {
return "OP_vkCmdBeginRenderPass2";
}
#endif
#ifdef VK_EXT_private_data
- case OP_vkCreatePrivateDataSlotEXT:
- {
+ case OP_vkCreatePrivateDataSlotEXT: {
return "OP_vkCreatePrivateDataSlotEXT";
}
#endif
#ifdef VK_NV_shading_rate_image
- case OP_vkCmdSetCoarseSampleOrderNV:
- {
+ case OP_vkCmdSetCoarseSampleOrderNV: {
return "OP_vkCmdSetCoarseSampleOrderNV";
}
#endif
#ifdef VK_KHR_video_queue
- case OP_vkDestroyVideoSessionParametersKHR:
- {
+ case OP_vkDestroyVideoSessionParametersKHR: {
return "OP_vkDestroyVideoSessionParametersKHR";
}
#endif
#ifdef VK_NV_shading_rate_image
- case OP_vkCmdBindShadingRateImageNV:
- {
+ case OP_vkCmdBindShadingRateImageNV: {
return "OP_vkCmdBindShadingRateImageNV";
}
#endif
#ifdef VK_KHR_performance_query
- case OP_vkAcquireProfilingLockKHR:
- {
+ case OP_vkAcquireProfilingLockKHR: {
return "OP_vkAcquireProfilingLockKHR";
}
#endif
#ifdef VK_KHR_video_queue
- case OP_vkDestroyVideoSessionKHR:
- {
+ case OP_vkDestroyVideoSessionKHR: {
return "OP_vkDestroyVideoSessionKHR";
}
- case OP_vkCmdBeginVideoCodingKHR:
- {
+ case OP_vkCmdBeginVideoCodingKHR: {
return "OP_vkCmdBeginVideoCodingKHR";
}
#endif
#ifdef VK_KHR_acceleration_structure
- case OP_vkCopyAccelerationStructureKHR:
- {
+ case OP_vkCopyAccelerationStructureKHR: {
return "OP_vkCopyAccelerationStructureKHR";
}
#endif
#ifdef VK_GGP_stream_descriptor_surface
- case OP_vkCreateStreamDescriptorSurfaceGGP:
- {
+ case OP_vkCreateStreamDescriptorSurfaceGGP: {
return "OP_vkCreateStreamDescriptorSurfaceGGP";
}
#endif
#ifdef VK_KHR_acceleration_structure
- case OP_vkBuildAccelerationStructuresKHR:
- {
+ case OP_vkBuildAccelerationStructuresKHR: {
return "OP_vkBuildAccelerationStructuresKHR";
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
- case OP_vkGetBufferCollectionPropertiesFUCHSIA:
- {
+ case OP_vkGetBufferCollectionPropertiesFUCHSIA: {
return "OP_vkGetBufferCollectionPropertiesFUCHSIA";
}
#endif
#ifdef VK_EXT_host_query_reset
- case OP_vkResetQueryPoolEXT:
- {
+ case OP_vkResetQueryPoolEXT: {
return "OP_vkResetQueryPoolEXT";
}
#endif
#ifdef VK_KHR_maintenance4
- case OP_vkGetDeviceImageMemoryRequirementsKHR:
- {
+ case OP_vkGetDeviceImageMemoryRequirementsKHR: {
return "OP_vkGetDeviceImageMemoryRequirementsKHR";
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case OP_vkCmdBindVertexBuffers2EXT:
- {
+ case OP_vkCmdBindVertexBuffers2EXT: {
return "OP_vkCmdBindVertexBuffers2EXT";
}
#endif
#ifdef VK_GOOGLE_gfxstream
- case OP_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE:
- {
+ case OP_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE: {
return "OP_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE";
}
#endif
#ifdef VK_VERSION_1_2
- case OP_vkCmdNextSubpass2:
- {
+ case OP_vkCmdNextSubpass2: {
return "OP_vkCmdNextSubpass2";
}
#endif
#ifdef VK_KHR_synchronization2
- case OP_vkCmdWaitEvents2KHR:
- {
+ case OP_vkCmdWaitEvents2KHR: {
return "OP_vkCmdWaitEvents2KHR";
}
#endif
#ifdef VK_VERSION_1_2
- case OP_vkCmdDrawIndexedIndirectCount:
- {
+ case OP_vkCmdDrawIndexedIndirectCount: {
return "OP_vkCmdDrawIndexedIndirectCount";
}
#endif
#ifdef VK_EXT_extended_dynamic_state2
- case OP_vkCmdSetRasterizerDiscardEnableEXT:
- {
+ case OP_vkCmdSetRasterizerDiscardEnableEXT: {
return "OP_vkCmdSetRasterizerDiscardEnableEXT";
}
#endif
#ifdef VK_INTEL_performance_query
- case OP_vkAcquirePerformanceConfigurationINTEL:
- {
+ case OP_vkAcquirePerformanceConfigurationINTEL: {
return "OP_vkAcquirePerformanceConfigurationINTEL";
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
- case OP_vkCreateRayTracingPipelinesKHR:
- {
+ case OP_vkCreateRayTracingPipelinesKHR: {
return "OP_vkCreateRayTracingPipelinesKHR";
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case OP_vkCmdSetDepthCompareOpEXT:
- {
+ case OP_vkCmdSetDepthCompareOpEXT: {
return "OP_vkCmdSetDepthCompareOpEXT";
}
#endif
#ifdef VK_KHR_copy_commands2
- case OP_vkCmdCopyBuffer2KHR:
- {
+ case OP_vkCmdCopyBuffer2KHR: {
return "OP_vkCmdCopyBuffer2KHR";
}
#endif
#ifdef VK_KHR_video_queue
- case OP_vkGetPhysicalDeviceVideoCapabilitiesKHR:
- {
+ case OP_vkGetPhysicalDeviceVideoCapabilitiesKHR: {
return "OP_vkGetPhysicalDeviceVideoCapabilitiesKHR";
}
#endif
#ifdef VK_FUCHSIA_external_semaphore
- case OP_vkGetSemaphoreZirconHandleFUCHSIA:
- {
+ case OP_vkGetSemaphoreZirconHandleFUCHSIA: {
return "OP_vkGetSemaphoreZirconHandleFUCHSIA";
}
#endif
#ifdef VK_KHR_copy_commands2
- case OP_vkCmdCopyBufferToImage2KHR:
- {
+ case OP_vkCmdCopyBufferToImage2KHR: {
return "OP_vkCmdCopyBufferToImage2KHR";
}
#endif
#ifdef VK_NV_device_generated_commands
- case OP_vkGetGeneratedCommandsMemoryRequirementsNV:
- {
+ case OP_vkGetGeneratedCommandsMemoryRequirementsNV: {
return "OP_vkGetGeneratedCommandsMemoryRequirementsNV";
}
#endif
#ifdef VK_EXT_acquire_drm_display
- case OP_vkAcquireDrmDisplayEXT:
- {
+ case OP_vkAcquireDrmDisplayEXT: {
return "OP_vkAcquireDrmDisplayEXT";
}
#endif
#ifdef VK_EXT_image_drm_format_modifier
- case OP_vkGetImageDrmFormatModifierPropertiesEXT:
- {
+ case OP_vkGetImageDrmFormatModifierPropertiesEXT: {
return "OP_vkGetImageDrmFormatModifierPropertiesEXT";
}
#endif
#ifdef VK_INTEL_performance_query
- case OP_vkCmdSetPerformanceOverrideINTEL:
- {
+ case OP_vkCmdSetPerformanceOverrideINTEL: {
return "OP_vkCmdSetPerformanceOverrideINTEL";
}
#endif
#ifdef VK_VERSION_1_2
- case OP_vkResetQueryPool:
- {
+ case OP_vkResetQueryPool: {
return "OP_vkResetQueryPool";
}
#endif
#ifdef VK_KHR_copy_commands2
- case OP_vkCmdCopyImageToBuffer2KHR:
- {
+ case OP_vkCmdCopyImageToBuffer2KHR: {
return "OP_vkCmdCopyImageToBuffer2KHR";
}
#endif
#ifdef VK_KHR_synchronization2
- case OP_vkCmdWriteTimestamp2KHR:
- {
+ case OP_vkCmdWriteTimestamp2KHR: {
return "OP_vkCmdWriteTimestamp2KHR";
}
#endif
#ifdef VK_NV_ray_tracing
- case OP_vkDestroyAccelerationStructureNV:
- {
+ case OP_vkDestroyAccelerationStructureNV: {
return "OP_vkDestroyAccelerationStructureNV";
}
#endif
#ifdef VK_INTEL_performance_query
- case OP_vkReleasePerformanceConfigurationINTEL:
- {
+ case OP_vkReleasePerformanceConfigurationINTEL: {
return "OP_vkReleasePerformanceConfigurationINTEL";
}
#endif
#ifdef VK_KHR_video_queue
- case OP_vkCmdControlVideoCodingKHR:
- {
+ case OP_vkCmdControlVideoCodingKHR: {
return "OP_vkCmdControlVideoCodingKHR";
}
#endif
#ifdef VK_NVX_binary_import
- case OP_vkDestroyCuFunctionNVX:
- {
+ case OP_vkDestroyCuFunctionNVX: {
return "OP_vkDestroyCuFunctionNVX";
}
#endif
#ifdef VK_KHR_copy_commands2
- case OP_vkCmdResolveImage2KHR:
- {
+ case OP_vkCmdResolveImage2KHR: {
return "OP_vkCmdResolveImage2KHR";
}
#endif
#ifdef VK_EXT_metal_surface
- case OP_vkCreateMetalSurfaceEXT:
- {
+ case OP_vkCreateMetalSurfaceEXT: {
return "OP_vkCreateMetalSurfaceEXT";
}
#endif
#ifdef VK_KHR_acceleration_structure
- case OP_vkCopyAccelerationStructureToMemoryKHR:
- {
+ case OP_vkCopyAccelerationStructureToMemoryKHR: {
return "OP_vkCopyAccelerationStructureToMemoryKHR";
}
#endif
#ifdef VK_KHR_video_queue
- case OP_vkGetVideoSessionMemoryRequirementsKHR:
- {
+ case OP_vkGetVideoSessionMemoryRequirementsKHR: {
return "OP_vkGetVideoSessionMemoryRequirementsKHR";
}
#endif
#ifdef VK_NV_external_memory_rdma
- case OP_vkGetMemoryRemoteAddressNV:
- {
+ case OP_vkGetMemoryRemoteAddressNV: {
return "OP_vkGetMemoryRemoteAddressNV";
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case OP_vkCmdSetViewportWithCountEXT:
- {
+ case OP_vkCmdSetViewportWithCountEXT: {
return "OP_vkCmdSetViewportWithCountEXT";
}
#endif
#ifdef VK_EXT_full_screen_exclusive
- case OP_vkReleaseFullScreenExclusiveModeEXT:
- {
+ case OP_vkReleaseFullScreenExclusiveModeEXT: {
return "OP_vkReleaseFullScreenExclusiveModeEXT";
}
#endif
#ifdef VK_KHR_acceleration_structure
- case OP_vkCmdBuildAccelerationStructuresIndirectKHR:
- {
+ case OP_vkCmdBuildAccelerationStructuresIndirectKHR: {
return "OP_vkCmdBuildAccelerationStructuresIndirectKHR";
}
#endif
#ifdef VK_QNX_screen_surface
- case OP_vkGetPhysicalDeviceScreenPresentationSupportQNX:
- {
+ case OP_vkGetPhysicalDeviceScreenPresentationSupportQNX: {
return "OP_vkGetPhysicalDeviceScreenPresentationSupportQNX";
}
#endif
#ifdef VK_KHR_acceleration_structure
- case OP_vkCreateAccelerationStructureKHR:
- {
+ case OP_vkCreateAccelerationStructureKHR: {
return "OP_vkCreateAccelerationStructureKHR";
}
#endif
#ifdef VK_EXT_extended_dynamic_state2
- case OP_vkCmdSetDepthBiasEnableEXT:
- {
+ case OP_vkCmdSetDepthBiasEnableEXT: {
return "OP_vkCmdSetDepthBiasEnableEXT";
}
#endif
#ifdef VK_NV_ray_tracing
- case OP_vkCreateAccelerationStructureNV:
- {
+ case OP_vkCreateAccelerationStructureNV: {
return "OP_vkCreateAccelerationStructureNV";
}
#endif
#ifdef VK_KHR_copy_commands2
- case OP_vkCmdBlitImage2KHR:
- {
+ case OP_vkCmdBlitImage2KHR: {
return "OP_vkCmdBlitImage2KHR";
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
- case OP_vkCmdSetRayTracingPipelineStackSizeKHR:
- {
+ case OP_vkCmdSetRayTracingPipelineStackSizeKHR: {
return "OP_vkCmdSetRayTracingPipelineStackSizeKHR";
}
#endif
#ifdef VK_VERSION_1_2
- case OP_vkGetDeviceMemoryOpaqueCaptureAddress:
- {
+ case OP_vkGetDeviceMemoryOpaqueCaptureAddress: {
return "OP_vkGetDeviceMemoryOpaqueCaptureAddress";
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case OP_vkCmdSetPrimitiveTopologyEXT:
- {
+ case OP_vkCmdSetPrimitiveTopologyEXT: {
return "OP_vkCmdSetPrimitiveTopologyEXT";
}
#endif
#ifdef VK_KHR_video_queue
- case OP_vkUpdateVideoSessionParametersKHR:
- {
+ case OP_vkUpdateVideoSessionParametersKHR: {
return "OP_vkUpdateVideoSessionParametersKHR";
}
#endif
#ifdef VK_INTEL_performance_query
- case OP_vkCmdSetPerformanceStreamMarkerINTEL:
- {
+ case OP_vkCmdSetPerformanceStreamMarkerINTEL: {
return "OP_vkCmdSetPerformanceStreamMarkerINTEL";
}
#endif
#ifdef VK_KHR_acceleration_structure
- case OP_vkCopyMemoryToAccelerationStructureKHR:
- {
+ case OP_vkCopyMemoryToAccelerationStructureKHR: {
return "OP_vkCopyMemoryToAccelerationStructureKHR";
}
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
- case OP_vkCreateImagePipeSurfaceFUCHSIA:
- {
+ case OP_vkCreateImagePipeSurfaceFUCHSIA: {
return "OP_vkCreateImagePipeSurfaceFUCHSIA";
}
#endif
#ifdef VK_KHR_video_queue
- case OP_vkGetPhysicalDeviceVideoFormatPropertiesKHR:
- {
+ case OP_vkGetPhysicalDeviceVideoFormatPropertiesKHR: {
return "OP_vkGetPhysicalDeviceVideoFormatPropertiesKHR";
}
#endif
#ifdef VK_KHR_present_wait
- case OP_vkWaitForPresentKHR:
- {
+ case OP_vkWaitForPresentKHR: {
return "OP_vkWaitForPresentKHR";
}
#endif
#ifdef VK_EXT_multi_draw
- case OP_vkCmdDrawMultiEXT:
- {
+ case OP_vkCmdDrawMultiEXT: {
return "OP_vkCmdDrawMultiEXT";
}
#endif
#ifdef VK_KHR_deferred_host_operations
- case OP_vkGetDeferredOperationResultKHR:
- {
+ case OP_vkGetDeferredOperationResultKHR: {
return "OP_vkGetDeferredOperationResultKHR";
}
#endif
#ifdef VK_EXT_line_rasterization
- case OP_vkCmdSetLineStippleEXT:
- {
+ case OP_vkCmdSetLineStippleEXT: {
return "OP_vkCmdSetLineStippleEXT";
}
#endif
#ifdef VK_KHR_timeline_semaphore
- case OP_vkWaitSemaphoresKHR:
- {
+ case OP_vkWaitSemaphoresKHR: {
return "OP_vkWaitSemaphoresKHR";
}
#endif
#ifdef VK_NV_fragment_shading_rate_enums
- case OP_vkCmdSetFragmentShadingRateEnumNV:
- {
+ case OP_vkCmdSetFragmentShadingRateEnumNV: {
return "OP_vkCmdSetFragmentShadingRateEnumNV";
}
#endif
#ifdef VK_KHR_video_queue
- case OP_vkCreateVideoSessionParametersKHR:
- {
+ case OP_vkCreateVideoSessionParametersKHR: {
return "OP_vkCreateVideoSessionParametersKHR";
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case OP_vkCmdSetCullModeEXT:
- {
+ case OP_vkCmdSetCullModeEXT: {
return "OP_vkCmdSetCullModeEXT";
}
#endif
#ifdef VK_KHR_acceleration_structure
- case OP_vkGetDeviceAccelerationStructureCompatibilityKHR:
- {
+ case OP_vkGetDeviceAccelerationStructureCompatibilityKHR: {
return "OP_vkGetDeviceAccelerationStructureCompatibilityKHR";
}
#endif
#ifdef VK_VERSION_1_2
- case OP_vkGetSemaphoreCounterValue:
- {
+ case OP_vkGetSemaphoreCounterValue: {
return "OP_vkGetSemaphoreCounterValue";
}
#endif
#ifdef VK_EXT_extended_dynamic_state2
- case OP_vkCmdSetLogicOpEXT:
- {
+ case OP_vkCmdSetLogicOpEXT: {
return "OP_vkCmdSetLogicOpEXT";
}
#endif
#ifdef VK_AMD_display_native_hdr
- case OP_vkSetLocalDimmingAMD:
- {
+ case OP_vkSetLocalDimmingAMD: {
return "OP_vkSetLocalDimmingAMD";
}
#endif
#ifdef VK_EXT_transform_feedback
- case OP_vkCmdBindTransformFeedbackBuffersEXT:
- {
+ case OP_vkCmdBindTransformFeedbackBuffersEXT: {
return "OP_vkCmdBindTransformFeedbackBuffersEXT";
}
#endif
#ifdef VK_GOOGLE_gfxstream
- case OP_vkQueueCommitDescriptorSetUpdatesGOOGLE:
- {
+ case OP_vkQueueCommitDescriptorSetUpdatesGOOGLE: {
return "OP_vkQueueCommitDescriptorSetUpdatesGOOGLE";
}
#endif
#ifdef VK_EXT_full_screen_exclusive
- case OP_vkGetPhysicalDeviceSurfacePresentModes2EXT:
- {
+ case OP_vkGetPhysicalDeviceSurfacePresentModes2EXT: {
return "OP_vkGetPhysicalDeviceSurfacePresentModes2EXT";
}
#endif
#ifdef VK_NV_ray_tracing
- case OP_vkCmdBuildAccelerationStructureNV:
- {
+ case OP_vkCmdBuildAccelerationStructureNV: {
return "OP_vkCmdBuildAccelerationStructureNV";
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
- case OP_vkGetPipelineExecutablePropertiesKHR:
- {
+ case OP_vkGetPipelineExecutablePropertiesKHR: {
return "OP_vkGetPipelineExecutablePropertiesKHR";
}
#endif
#ifdef VK_NV_ray_tracing
- case OP_vkGetAccelerationStructureHandleNV:
- {
+ case OP_vkGetAccelerationStructureHandleNV: {
return "OP_vkGetAccelerationStructureHandleNV";
}
#endif
#ifdef VK_KHR_timeline_semaphore
- case OP_vkSignalSemaphoreKHR:
- {
+ case OP_vkSignalSemaphoreKHR: {
return "OP_vkSignalSemaphoreKHR";
}
#endif
#ifdef VK_INTEL_performance_query
- case OP_vkCmdSetPerformanceMarkerINTEL:
- {
+ case OP_vkCmdSetPerformanceMarkerINTEL: {
return "OP_vkCmdSetPerformanceMarkerINTEL";
}
#endif
#ifdef VK_NV_device_generated_commands
- case OP_vkCmdBindPipelineShaderGroupNV:
- {
+ case OP_vkCmdBindPipelineShaderGroupNV: {
return "OP_vkCmdBindPipelineShaderGroupNV";
}
#endif
#ifdef VK_KHR_synchronization2
- case OP_vkCmdSetEvent2KHR:
- {
+ case OP_vkCmdSetEvent2KHR: {
return "OP_vkCmdSetEvent2KHR";
}
#endif
#ifdef VK_VERSION_1_2
- case OP_vkSignalSemaphore:
- {
+ case OP_vkSignalSemaphore: {
return "OP_vkSignalSemaphore";
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
- case OP_vkGetPipelineExecutableStatisticsKHR:
- {
+ case OP_vkGetPipelineExecutableStatisticsKHR: {
return "OP_vkGetPipelineExecutableStatisticsKHR";
}
#endif
#ifdef VK_KHR_acceleration_structure
- case OP_vkCmdWriteAccelerationStructuresPropertiesKHR:
- {
+ case OP_vkCmdWriteAccelerationStructuresPropertiesKHR: {
return "OP_vkCmdWriteAccelerationStructuresPropertiesKHR";
}
#endif
#ifdef VK_NV_ray_tracing
- case OP_vkGetRayTracingShaderGroupHandlesKHR:
- {
+ case OP_vkGetRayTracingShaderGroupHandlesKHR: {
return "OP_vkGetRayTracingShaderGroupHandlesKHR";
}
#endif
#ifdef VK_EXT_transform_feedback
- case OP_vkCmdEndTransformFeedbackEXT:
- {
+ case OP_vkCmdEndTransformFeedbackEXT: {
return "OP_vkCmdEndTransformFeedbackEXT";
}
#endif
#ifdef VK_KHR_acceleration_structure
- case OP_vkCmdBuildAccelerationStructuresKHR:
- {
+ case OP_vkCmdBuildAccelerationStructuresKHR: {
return "OP_vkCmdBuildAccelerationStructuresKHR";
}
#endif
#ifdef VK_KHR_fragment_shading_rate
- case OP_vkGetPhysicalDeviceFragmentShadingRatesKHR:
- {
+ case OP_vkGetPhysicalDeviceFragmentShadingRatesKHR: {
return "OP_vkGetPhysicalDeviceFragmentShadingRatesKHR";
}
#endif
#ifdef VK_NVX_binary_import
- case OP_vkDestroyCuModuleNVX:
- {
+ case OP_vkDestroyCuModuleNVX: {
return "OP_vkDestroyCuModuleNVX";
}
#endif
#ifdef VK_NV_mesh_shader
- case OP_vkCmdDrawMeshTasksIndirectNV:
- {
+ case OP_vkCmdDrawMeshTasksIndirectNV: {
return "OP_vkCmdDrawMeshTasksIndirectNV";
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
- case OP_vkGetPipelineExecutableInternalRepresentationsKHR:
- {
+ case OP_vkGetPipelineExecutableInternalRepresentationsKHR: {
return "OP_vkGetPipelineExecutableInternalRepresentationsKHR";
}
#endif
#ifdef VK_NV_acquire_winrt_display
- case OP_vkAcquireWinrtDisplayNV:
- {
+ case OP_vkAcquireWinrtDisplayNV: {
return "OP_vkAcquireWinrtDisplayNV";
}
#endif
#ifdef VK_KHR_deferred_host_operations
- case OP_vkCreateDeferredOperationKHR:
- {
+ case OP_vkCreateDeferredOperationKHR: {
return "OP_vkCreateDeferredOperationKHR";
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
- case OP_vkSetBufferCollectionImageConstraintsFUCHSIA:
- {
+ case OP_vkSetBufferCollectionImageConstraintsFUCHSIA: {
return "OP_vkSetBufferCollectionImageConstraintsFUCHSIA";
}
#endif
#ifdef VK_KHR_maintenance4
- case OP_vkGetDeviceImageSparseMemoryRequirementsKHR:
- {
+ case OP_vkGetDeviceImageSparseMemoryRequirementsKHR: {
return "OP_vkGetDeviceImageSparseMemoryRequirementsKHR";
}
#endif
#ifdef VK_KHR_video_decode_queue
- case OP_vkCmdDecodeVideoKHR:
- {
+ case OP_vkCmdDecodeVideoKHR: {
return "OP_vkCmdDecodeVideoKHR";
}
#endif
#ifdef VK_EXT_transform_feedback
- case OP_vkCmdBeginQueryIndexedEXT:
- {
+ case OP_vkCmdBeginQueryIndexedEXT: {
return "OP_vkCmdBeginQueryIndexedEXT";
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case OP_vkCmdSetStencilOpEXT:
- {
+ case OP_vkCmdSetStencilOpEXT: {
return "OP_vkCmdSetStencilOpEXT";
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
- case OP_vkCreateBufferCollectionFUCHSIA:
- {
+ case OP_vkCreateBufferCollectionFUCHSIA: {
return "OP_vkCreateBufferCollectionFUCHSIA";
}
#endif
#ifdef VK_NV_ray_tracing
- case OP_vkCompileDeferredNV:
- {
+ case OP_vkCompileDeferredNV: {
return "OP_vkCompileDeferredNV";
}
#endif
#ifdef VK_KHR_acceleration_structure
- case OP_vkCmdCopyAccelerationStructureKHR:
- {
+ case OP_vkCmdCopyAccelerationStructureKHR: {
return "OP_vkCmdCopyAccelerationStructureKHR";
}
#endif
#ifdef VK_VERSION_1_2
- case OP_vkCreateRenderPass2:
- {
+ case OP_vkCreateRenderPass2: {
return "OP_vkCreateRenderPass2";
}
#endif
#ifdef VK_EXT_transform_feedback
- case OP_vkCmdEndQueryIndexedEXT:
- {
+ case OP_vkCmdEndQueryIndexedEXT: {
return "OP_vkCmdEndQueryIndexedEXT";
}
#endif
#ifdef VK_KHR_video_queue
- case OP_vkCmdEndVideoCodingKHR:
- {
+ case OP_vkCmdEndVideoCodingKHR: {
return "OP_vkCmdEndVideoCodingKHR";
}
#endif
#ifdef VK_KHR_performance_query
- case OP_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR:
- {
+ case OP_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR: {
return "OP_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR";
}
#endif
#ifdef VK_EXT_tooling_info
- case OP_vkGetPhysicalDeviceToolPropertiesEXT:
- {
+ case OP_vkGetPhysicalDeviceToolPropertiesEXT: {
return "OP_vkGetPhysicalDeviceToolPropertiesEXT";
}
#endif
#ifdef VK_GOOGLE_gfxstream
- case OP_vkGetLinearImageLayout2GOOGLE:
- {
+ case OP_vkGetLinearImageLayout2GOOGLE: {
return "OP_vkGetLinearImageLayout2GOOGLE";
}
#endif
#ifdef VK_EXT_acquire_drm_display
- case OP_vkGetDrmDisplayEXT:
- {
+ case OP_vkGetDrmDisplayEXT: {
return "OP_vkGetDrmDisplayEXT";
}
#endif
#ifdef VK_VERSION_1_2
- case OP_vkCmdDrawIndirectCount:
- {
+ case OP_vkCmdDrawIndirectCount: {
return "OP_vkCmdDrawIndirectCount";
}
#endif
#ifdef VK_KHR_synchronization2
- case OP_vkCmdResetEvent2KHR:
- {
+ case OP_vkCmdResetEvent2KHR: {
return "OP_vkCmdResetEvent2KHR";
}
#endif
#ifdef VK_EXT_multi_draw
- case OP_vkCmdDrawMultiIndexedEXT:
- {
+ case OP_vkCmdDrawMultiIndexedEXT: {
return "OP_vkCmdDrawMultiIndexedEXT";
}
#endif
#ifdef VK_EXT_transform_feedback
- case OP_vkCmdDrawIndirectByteCountEXT:
- {
+ case OP_vkCmdDrawIndirectByteCountEXT: {
return "OP_vkCmdDrawIndirectByteCountEXT";
}
#endif
#ifdef VK_NV_device_generated_commands
- case OP_vkCreateIndirectCommandsLayoutNV:
- {
+ case OP_vkCreateIndirectCommandsLayoutNV: {
return "OP_vkCreateIndirectCommandsLayoutNV";
}
#endif
#ifdef VK_EXT_directfb_surface
- case OP_vkGetPhysicalDeviceDirectFBPresentationSupportEXT:
- {
+ case OP_vkGetPhysicalDeviceDirectFBPresentationSupportEXT: {
return "OP_vkGetPhysicalDeviceDirectFBPresentationSupportEXT";
}
#endif
#ifdef VK_KHR_buffer_device_address
- case OP_vkGetBufferOpaqueCaptureAddressKHR:
- {
+ case OP_vkGetBufferOpaqueCaptureAddressKHR: {
return "OP_vkGetBufferOpaqueCaptureAddressKHR";
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case OP_vkCmdSetStencilTestEnableEXT:
- {
+ case OP_vkCmdSetStencilTestEnableEXT: {
return "OP_vkCmdSetStencilTestEnableEXT";
}
#endif
#ifdef VK_NV_cooperative_matrix
- case OP_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV:
- {
+ case OP_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV: {
return "OP_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV";
}
#endif
#ifdef VK_KHR_acceleration_structure
- case OP_vkWriteAccelerationStructuresPropertiesKHR:
- {
+ case OP_vkWriteAccelerationStructuresPropertiesKHR: {
return "OP_vkWriteAccelerationStructuresPropertiesKHR";
}
#endif
#ifdef VK_EXT_private_data
- case OP_vkGetPrivateDataEXT:
- {
+ case OP_vkGetPrivateDataEXT: {
return "OP_vkGetPrivateDataEXT";
}
#endif
#ifdef VK_NV_coverage_reduction_mode
- case OP_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV:
- {
+ case OP_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV: {
return "OP_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV";
}
#endif
#ifdef VK_KHR_synchronization2
- case OP_vkGetQueueCheckpointData2NV:
- {
+ case OP_vkGetQueueCheckpointData2NV: {
return "OP_vkGetQueueCheckpointData2NV";
}
#endif
#ifdef VK_NV_device_generated_commands
- case OP_vkDestroyIndirectCommandsLayoutNV:
- {
+ case OP_vkDestroyIndirectCommandsLayoutNV: {
return "OP_vkDestroyIndirectCommandsLayoutNV";
}
#endif
#ifdef VK_KHR_synchronization2
- case OP_vkQueueSubmit2KHR:
- {
+ case OP_vkQueueSubmit2KHR: {
return "OP_vkQueueSubmit2KHR";
}
#endif
#ifdef VK_NV_acquire_winrt_display
- case OP_vkGetWinrtDisplayNV:
- {
+ case OP_vkGetWinrtDisplayNV: {
return "OP_vkGetWinrtDisplayNV";
}
#endif
#ifdef VK_EXT_transform_feedback
- case OP_vkCmdBeginTransformFeedbackEXT:
- {
+ case OP_vkCmdBeginTransformFeedbackEXT: {
return "OP_vkCmdBeginTransformFeedbackEXT";
}
#endif
#ifdef VK_KHR_buffer_device_address
- case OP_vkGetDeviceMemoryOpaqueCaptureAddressKHR:
- {
+ case OP_vkGetDeviceMemoryOpaqueCaptureAddressKHR: {
return "OP_vkGetDeviceMemoryOpaqueCaptureAddressKHR";
}
#endif
#ifdef VK_INTEL_performance_query
- case OP_vkQueueSetPerformanceConfigurationINTEL:
- {
+ case OP_vkQueueSetPerformanceConfigurationINTEL: {
return "OP_vkQueueSetPerformanceConfigurationINTEL";
}
#endif
#ifdef VK_EXT_calibrated_timestamps
- case OP_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT:
- {
+ case OP_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT: {
return "OP_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT";
}
#endif
#ifdef VK_KHR_video_encode_queue
- case OP_vkCmdEncodeVideoKHR:
- {
+ case OP_vkCmdEncodeVideoKHR: {
return "OP_vkCmdEncodeVideoKHR";
}
#endif
#ifdef VK_INTEL_performance_query
- case OP_vkUninitializePerformanceApiINTEL:
- {
+ case OP_vkUninitializePerformanceApiINTEL: {
return "OP_vkUninitializePerformanceApiINTEL";
}
#endif
#ifdef VK_NV_device_generated_commands
- case OP_vkCmdPreprocessGeneratedCommandsNV:
- {
+ case OP_vkCmdPreprocessGeneratedCommandsNV: {
return "OP_vkCmdPreprocessGeneratedCommandsNV";
}
#endif
#ifdef VK_KHR_dynamic_rendering
- case OP_vkCmdBeginRenderingKHR:
- {
+ case OP_vkCmdBeginRenderingKHR: {
return "OP_vkCmdBeginRenderingKHR";
}
#endif
#ifdef VK_EXT_headless_surface
- case OP_vkCreateHeadlessSurfaceEXT:
- {
+ case OP_vkCreateHeadlessSurfaceEXT: {
return "OP_vkCreateHeadlessSurfaceEXT";
}
#endif
#ifdef VK_KHR_performance_query
- case OP_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR:
- {
+ case OP_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR: {
return "OP_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR";
}
#endif
#ifdef VK_HUAWEI_invocation_mask
- case OP_vkCmdBindInvocationMaskHUAWEI:
- {
+ case OP_vkCmdBindInvocationMaskHUAWEI: {
return "OP_vkCmdBindInvocationMaskHUAWEI";
}
#endif
#ifdef VK_FUCHSIA_external_semaphore
- case OP_vkImportSemaphoreZirconHandleFUCHSIA:
- {
+ case OP_vkImportSemaphoreZirconHandleFUCHSIA: {
return "OP_vkImportSemaphoreZirconHandleFUCHSIA";
}
#endif
#ifdef VK_EXT_extended_dynamic_state2
- case OP_vkCmdSetPrimitiveRestartEnableEXT:
- {
+ case OP_vkCmdSetPrimitiveRestartEnableEXT: {
return "OP_vkCmdSetPrimitiveRestartEnableEXT";
}
#endif
- default:
- {
+ default: {
return "OP_UNKNOWN_API_CALL";
}
}
}
-
-} // namespace goldfish_vk
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_marshaling_guest.h b/system/vulkan_enc/goldfish_vk_marshaling_guest.h
index cfa5b43..8797207 100644
--- a/system/vulkan_enc/goldfish_vk_marshaling_guest.h
+++ b/system/vulkan_enc/goldfish_vk_marshaling_guest.h
@@ -14,25 +14,28 @@
// limitations under the License.
// Autogenerated module goldfish_vk_marshaling_guest
-// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal -o ../qemu/android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+//
+// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
+// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
-// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
-
+//
+// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
+// $CEREAL_OUTPUT_DIR
+//
#pragma once
-
#include <vulkan/vulkan.h>
-
-#include "vk_platform_compat.h"
-
+#include "VulkanStreamGuest.h"
#include "goldfish_vk_marshaling_guest.h"
#include "goldfish_vk_private_defs.h"
-#include "VulkanStreamGuest.h"
+#include "vk_platform_compat.h"
+#include "vulkan_gfxstream.h"
// Stuff we are not going to use but if included,
// will cause compile errors. These are Android Vulkan
@@ -41,289 +44,180 @@
#undef VK_KHR_android_surface
#undef VK_ANDROID_external_memory_android_hardware_buffer
-
namespace goldfish_vk {
-
#ifdef VK_VERSION_1_0
-void marshal_VkExtent2D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExtent2D* forMarshaling);
+void marshal_VkExtent2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExtent2D* forMarshaling);
-void unmarshal_VkExtent2D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExtent2D* forUnmarshaling);
+void unmarshal_VkExtent2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExtent2D* forUnmarshaling);
-void marshal_VkExtent3D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExtent3D* forMarshaling);
+void marshal_VkExtent3D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExtent3D* forMarshaling);
-void unmarshal_VkExtent3D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExtent3D* forUnmarshaling);
+void unmarshal_VkExtent3D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExtent3D* forUnmarshaling);
-void marshal_VkOffset2D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkOffset2D* forMarshaling);
+void marshal_VkOffset2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkOffset2D* forMarshaling);
-void unmarshal_VkOffset2D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkOffset2D* forUnmarshaling);
+void unmarshal_VkOffset2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkOffset2D* forUnmarshaling);
-void marshal_VkOffset3D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkOffset3D* forMarshaling);
+void marshal_VkOffset3D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkOffset3D* forMarshaling);
-void unmarshal_VkOffset3D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkOffset3D* forUnmarshaling);
+void unmarshal_VkOffset3D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkOffset3D* forUnmarshaling);
-void marshal_VkRect2D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRect2D* forMarshaling);
+void marshal_VkRect2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRect2D* forMarshaling);
-void unmarshal_VkRect2D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRect2D* forUnmarshaling);
+void unmarshal_VkRect2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRect2D* forUnmarshaling);
-void marshal_VkBaseInStructure(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBaseInStructure* forMarshaling);
+void marshal_VkBaseInStructure(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBaseInStructure* forMarshaling);
-void unmarshal_VkBaseInStructure(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBaseInStructure* forUnmarshaling);
+void unmarshal_VkBaseInStructure(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBaseInStructure* forUnmarshaling);
-void marshal_VkBaseOutStructure(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBaseOutStructure* forMarshaling);
+void marshal_VkBaseOutStructure(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBaseOutStructure* forMarshaling);
-void unmarshal_VkBaseOutStructure(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBaseOutStructure* forUnmarshaling);
+void unmarshal_VkBaseOutStructure(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBaseOutStructure* forUnmarshaling);
-void marshal_VkBufferMemoryBarrier(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferMemoryBarrier* forMarshaling);
+void marshal_VkBufferMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferMemoryBarrier* forMarshaling);
-void unmarshal_VkBufferMemoryBarrier(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferMemoryBarrier* forUnmarshaling);
+void unmarshal_VkBufferMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferMemoryBarrier* forUnmarshaling);
-void marshal_VkDispatchIndirectCommand(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDispatchIndirectCommand* forMarshaling);
+void marshal_VkDispatchIndirectCommand(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDispatchIndirectCommand* forMarshaling);
-void unmarshal_VkDispatchIndirectCommand(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDispatchIndirectCommand* forUnmarshaling);
+void unmarshal_VkDispatchIndirectCommand(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDispatchIndirectCommand* forUnmarshaling);
-void marshal_VkDrawIndexedIndirectCommand(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrawIndexedIndirectCommand* forMarshaling);
+void marshal_VkDrawIndexedIndirectCommand(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrawIndexedIndirectCommand* forMarshaling);
-void unmarshal_VkDrawIndexedIndirectCommand(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDrawIndexedIndirectCommand* forUnmarshaling);
+void unmarshal_VkDrawIndexedIndirectCommand(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDrawIndexedIndirectCommand* forUnmarshaling);
-void marshal_VkDrawIndirectCommand(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrawIndirectCommand* forMarshaling);
+void marshal_VkDrawIndirectCommand(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrawIndirectCommand* forMarshaling);
-void unmarshal_VkDrawIndirectCommand(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDrawIndirectCommand* forUnmarshaling);
+void unmarshal_VkDrawIndirectCommand(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDrawIndirectCommand* forUnmarshaling);
-void marshal_VkImageSubresourceRange(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageSubresourceRange* forMarshaling);
+void marshal_VkImageSubresourceRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSubresourceRange* forMarshaling);
-void unmarshal_VkImageSubresourceRange(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageSubresourceRange* forUnmarshaling);
+void unmarshal_VkImageSubresourceRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageSubresourceRange* forUnmarshaling);
-void marshal_VkImageMemoryBarrier(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageMemoryBarrier* forMarshaling);
+void marshal_VkImageMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageMemoryBarrier* forMarshaling);
-void unmarshal_VkImageMemoryBarrier(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageMemoryBarrier* forUnmarshaling);
+void unmarshal_VkImageMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageMemoryBarrier* forUnmarshaling);
-void marshal_VkMemoryBarrier(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryBarrier* forMarshaling);
+void marshal_VkMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryBarrier* forMarshaling);
-void unmarshal_VkMemoryBarrier(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryBarrier* forUnmarshaling);
+void unmarshal_VkMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryBarrier* forUnmarshaling);
-void marshal_VkPipelineCacheHeaderVersionOne(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCacheHeaderVersionOne* forMarshaling);
+void marshal_VkPipelineCacheHeaderVersionOne(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCacheHeaderVersionOne* forMarshaling);
-void unmarshal_VkPipelineCacheHeaderVersionOne(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineCacheHeaderVersionOne* forUnmarshaling);
+void unmarshal_VkPipelineCacheHeaderVersionOne(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPipelineCacheHeaderVersionOne* forUnmarshaling);
-void marshal_VkAllocationCallbacks(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAllocationCallbacks* forMarshaling);
+void marshal_VkAllocationCallbacks(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAllocationCallbacks* forMarshaling);
-void unmarshal_VkAllocationCallbacks(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAllocationCallbacks* forUnmarshaling);
+void unmarshal_VkAllocationCallbacks(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAllocationCallbacks* forUnmarshaling);
-void marshal_VkApplicationInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkApplicationInfo* forMarshaling);
+void marshal_VkApplicationInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkApplicationInfo* forMarshaling);
-void unmarshal_VkApplicationInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkApplicationInfo* forUnmarshaling);
+void unmarshal_VkApplicationInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkApplicationInfo* forUnmarshaling);
-void marshal_VkFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFormatProperties* forMarshaling);
+void marshal_VkFormatProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFormatProperties* forMarshaling);
-void unmarshal_VkFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkFormatProperties* forUnmarshaling);
+void unmarshal_VkFormatProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkFormatProperties* forUnmarshaling);
-void marshal_VkImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageFormatProperties* forMarshaling);
+void marshal_VkImageFormatProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageFormatProperties* forMarshaling);
-void unmarshal_VkImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageFormatProperties* forUnmarshaling);
+void unmarshal_VkImageFormatProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageFormatProperties* forUnmarshaling);
-void marshal_VkInstanceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkInstanceCreateInfo* forMarshaling);
+void marshal_VkInstanceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkInstanceCreateInfo* forMarshaling);
-void unmarshal_VkInstanceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkInstanceCreateInfo* forUnmarshaling);
+void unmarshal_VkInstanceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkInstanceCreateInfo* forUnmarshaling);
-void marshal_VkMemoryHeap(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryHeap* forMarshaling);
+void marshal_VkMemoryHeap(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryHeap* forMarshaling);
-void unmarshal_VkMemoryHeap(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryHeap* forUnmarshaling);
+void unmarshal_VkMemoryHeap(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryHeap* forUnmarshaling);
-void marshal_VkMemoryType(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryType* forMarshaling);
+void marshal_VkMemoryType(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryType* forMarshaling);
-void unmarshal_VkMemoryType(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryType* forUnmarshaling);
+void unmarshal_VkMemoryType(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryType* forUnmarshaling);
-void marshal_VkPhysicalDeviceFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFeatures* forMarshaling);
+void marshal_VkPhysicalDeviceFeatures(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFeatures* forMarshaling);
-void unmarshal_VkPhysicalDeviceFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceFeatures* forUnmarshaling);
+void unmarshal_VkPhysicalDeviceFeatures(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceFeatures* forUnmarshaling);
-void marshal_VkPhysicalDeviceLimits(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceLimits* forMarshaling);
+void marshal_VkPhysicalDeviceLimits(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceLimits* forMarshaling);
-void unmarshal_VkPhysicalDeviceLimits(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceLimits* forUnmarshaling);
+void unmarshal_VkPhysicalDeviceLimits(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceLimits* forUnmarshaling);
void marshal_VkPhysicalDeviceMemoryProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceMemoryProperties* forMarshaling);
-void unmarshal_VkPhysicalDeviceMemoryProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceMemoryProperties* forUnmarshaling);
+void unmarshal_VkPhysicalDeviceMemoryProperties(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPhysicalDeviceMemoryProperties* forUnmarshaling);
void marshal_VkPhysicalDeviceSparseProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceSparseProperties* forMarshaling);
-void unmarshal_VkPhysicalDeviceSparseProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceSparseProperties* forUnmarshaling);
+void unmarshal_VkPhysicalDeviceSparseProperties(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPhysicalDeviceSparseProperties* forUnmarshaling);
-void marshal_VkPhysicalDeviceProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceProperties* forMarshaling);
+void marshal_VkPhysicalDeviceProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceProperties* forMarshaling);
-void unmarshal_VkPhysicalDeviceProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceProperties* forUnmarshaling);
+void unmarshal_VkPhysicalDeviceProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceProperties* forUnmarshaling);
-void marshal_VkQueueFamilyProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueueFamilyProperties* forMarshaling);
+void marshal_VkQueueFamilyProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyProperties* forMarshaling);
-void unmarshal_VkQueueFamilyProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkQueueFamilyProperties* forUnmarshaling);
+void unmarshal_VkQueueFamilyProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkQueueFamilyProperties* forUnmarshaling);
#define OP_vkCreateInstance 20000
#define OP_vkDestroyInstance 20001
@@ -336,85 +230,57 @@
#define OP_vkGetPhysicalDeviceMemoryProperties 20008
#define OP_vkGetInstanceProcAddr 20009
#define OP_vkGetDeviceProcAddr 20010
-void marshal_VkDeviceQueueCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceQueueCreateInfo* forMarshaling);
+void marshal_VkDeviceQueueCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceQueueCreateInfo* forMarshaling);
-void unmarshal_VkDeviceQueueCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceQueueCreateInfo* forUnmarshaling);
+void unmarshal_VkDeviceQueueCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceQueueCreateInfo* forUnmarshaling);
-void marshal_VkDeviceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceCreateInfo* forMarshaling);
+void marshal_VkDeviceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceCreateInfo* forMarshaling);
-void unmarshal_VkDeviceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceCreateInfo* forUnmarshaling);
+void unmarshal_VkDeviceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceCreateInfo* forUnmarshaling);
#define OP_vkCreateDevice 20011
#define OP_vkDestroyDevice 20012
-void marshal_VkExtensionProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExtensionProperties* forMarshaling);
+void marshal_VkExtensionProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExtensionProperties* forMarshaling);
-void unmarshal_VkExtensionProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExtensionProperties* forUnmarshaling);
+void unmarshal_VkExtensionProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExtensionProperties* forUnmarshaling);
#define OP_vkEnumerateInstanceExtensionProperties 20013
#define OP_vkEnumerateDeviceExtensionProperties 20014
-void marshal_VkLayerProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkLayerProperties* forMarshaling);
+void marshal_VkLayerProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkLayerProperties* forMarshaling);
-void unmarshal_VkLayerProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkLayerProperties* forUnmarshaling);
+void unmarshal_VkLayerProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkLayerProperties* forUnmarshaling);
#define OP_vkEnumerateInstanceLayerProperties 20015
#define OP_vkEnumerateDeviceLayerProperties 20016
-void marshal_VkSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubmitInfo* forMarshaling);
+void marshal_VkSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubmitInfo* forMarshaling);
-void unmarshal_VkSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubmitInfo* forUnmarshaling);
+void unmarshal_VkSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubmitInfo* forUnmarshaling);
#define OP_vkGetDeviceQueue 20017
#define OP_vkQueueSubmit 20018
#define OP_vkQueueWaitIdle 20019
#define OP_vkDeviceWaitIdle 20020
-void marshal_VkMappedMemoryRange(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMappedMemoryRange* forMarshaling);
+void marshal_VkMappedMemoryRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMappedMemoryRange* forMarshaling);
-void unmarshal_VkMappedMemoryRange(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMappedMemoryRange* forUnmarshaling);
+void unmarshal_VkMappedMemoryRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMappedMemoryRange* forUnmarshaling);
-void marshal_VkMemoryAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryAllocateInfo* forMarshaling);
+void marshal_VkMemoryAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryAllocateInfo* forMarshaling);
-void unmarshal_VkMemoryAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryAllocateInfo* forUnmarshaling);
+void unmarshal_VkMemoryAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryAllocateInfo* forUnmarshaling);
#define OP_vkAllocateMemory 20021
#define OP_vkFreeMemory 20022
@@ -423,579 +289,395 @@
#define OP_vkFlushMappedMemoryRanges 20025
#define OP_vkInvalidateMappedMemoryRanges 20026
#define OP_vkGetDeviceMemoryCommitment 20027
-void marshal_VkMemoryRequirements(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryRequirements* forMarshaling);
+void marshal_VkMemoryRequirements(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryRequirements* forMarshaling);
-void unmarshal_VkMemoryRequirements(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryRequirements* forUnmarshaling);
+void unmarshal_VkMemoryRequirements(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryRequirements* forUnmarshaling);
#define OP_vkBindBufferMemory 20028
#define OP_vkBindImageMemory 20029
#define OP_vkGetBufferMemoryRequirements 20030
#define OP_vkGetImageMemoryRequirements 20031
-void marshal_VkSparseMemoryBind(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseMemoryBind* forMarshaling);
+void marshal_VkSparseMemoryBind(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseMemoryBind* forMarshaling);
-void unmarshal_VkSparseMemoryBind(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSparseMemoryBind* forUnmarshaling);
+void unmarshal_VkSparseMemoryBind(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSparseMemoryBind* forUnmarshaling);
-void marshal_VkSparseBufferMemoryBindInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseBufferMemoryBindInfo* forMarshaling);
+void marshal_VkSparseBufferMemoryBindInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseBufferMemoryBindInfo* forMarshaling);
-void unmarshal_VkSparseBufferMemoryBindInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSparseBufferMemoryBindInfo* forUnmarshaling);
+void unmarshal_VkSparseBufferMemoryBindInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSparseBufferMemoryBindInfo* forUnmarshaling);
void marshal_VkSparseImageOpaqueMemoryBindInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkSparseImageOpaqueMemoryBindInfo* forMarshaling);
void unmarshal_VkSparseImageOpaqueMemoryBindInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkSparseImageOpaqueMemoryBindInfo* forUnmarshaling);
-void marshal_VkImageSubresource(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageSubresource* forMarshaling);
+void marshal_VkImageSubresource(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSubresource* forMarshaling);
-void unmarshal_VkImageSubresource(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageSubresource* forUnmarshaling);
+void unmarshal_VkImageSubresource(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageSubresource* forUnmarshaling);
-void marshal_VkSparseImageMemoryBind(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageMemoryBind* forMarshaling);
+void marshal_VkSparseImageMemoryBind(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageMemoryBind* forMarshaling);
-void unmarshal_VkSparseImageMemoryBind(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSparseImageMemoryBind* forUnmarshaling);
+void unmarshal_VkSparseImageMemoryBind(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSparseImageMemoryBind* forUnmarshaling);
-void marshal_VkSparseImageMemoryBindInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageMemoryBindInfo* forMarshaling);
+void marshal_VkSparseImageMemoryBindInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageMemoryBindInfo* forMarshaling);
-void unmarshal_VkSparseImageMemoryBindInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSparseImageMemoryBindInfo* forUnmarshaling);
+void unmarshal_VkSparseImageMemoryBindInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSparseImageMemoryBindInfo* forUnmarshaling);
-void marshal_VkBindSparseInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindSparseInfo* forMarshaling);
+void marshal_VkBindSparseInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindSparseInfo* forMarshaling);
-void unmarshal_VkBindSparseInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBindSparseInfo* forUnmarshaling);
+void unmarshal_VkBindSparseInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBindSparseInfo* forUnmarshaling);
-void marshal_VkSparseImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageFormatProperties* forMarshaling);
+void marshal_VkSparseImageFormatProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageFormatProperties* forMarshaling);
-void unmarshal_VkSparseImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSparseImageFormatProperties* forUnmarshaling);
+void unmarshal_VkSparseImageFormatProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSparseImageFormatProperties* forUnmarshaling);
-void marshal_VkSparseImageMemoryRequirements(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageMemoryRequirements* forMarshaling);
+void marshal_VkSparseImageMemoryRequirements(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageMemoryRequirements* forMarshaling);
-void unmarshal_VkSparseImageMemoryRequirements(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSparseImageMemoryRequirements* forUnmarshaling);
+void unmarshal_VkSparseImageMemoryRequirements(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkSparseImageMemoryRequirements* forUnmarshaling);
#define OP_vkGetImageSparseMemoryRequirements 20032
#define OP_vkGetPhysicalDeviceSparseImageFormatProperties 20033
#define OP_vkQueueBindSparse 20034
-void marshal_VkFenceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFenceCreateInfo* forMarshaling);
+void marshal_VkFenceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFenceCreateInfo* forMarshaling);
-void unmarshal_VkFenceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkFenceCreateInfo* forUnmarshaling);
+void unmarshal_VkFenceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkFenceCreateInfo* forUnmarshaling);
#define OP_vkCreateFence 20035
#define OP_vkDestroyFence 20036
#define OP_vkResetFences 20037
#define OP_vkGetFenceStatus 20038
#define OP_vkWaitForFences 20039
-void marshal_VkSemaphoreCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreCreateInfo* forMarshaling);
+void marshal_VkSemaphoreCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreCreateInfo* forMarshaling);
-void unmarshal_VkSemaphoreCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSemaphoreCreateInfo* forUnmarshaling);
+void unmarshal_VkSemaphoreCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSemaphoreCreateInfo* forUnmarshaling);
#define OP_vkCreateSemaphore 20040
#define OP_vkDestroySemaphore 20041
-void marshal_VkEventCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkEventCreateInfo* forMarshaling);
+void marshal_VkEventCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkEventCreateInfo* forMarshaling);
-void unmarshal_VkEventCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkEventCreateInfo* forUnmarshaling);
+void unmarshal_VkEventCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkEventCreateInfo* forUnmarshaling);
#define OP_vkCreateEvent 20042
#define OP_vkDestroyEvent 20043
#define OP_vkGetEventStatus 20044
#define OP_vkSetEvent 20045
#define OP_vkResetEvent 20046
-void marshal_VkQueryPoolCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueryPoolCreateInfo* forMarshaling);
+void marshal_VkQueryPoolCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueryPoolCreateInfo* forMarshaling);
-void unmarshal_VkQueryPoolCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkQueryPoolCreateInfo* forUnmarshaling);
+void unmarshal_VkQueryPoolCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkQueryPoolCreateInfo* forUnmarshaling);
#define OP_vkCreateQueryPool 20047
#define OP_vkDestroyQueryPool 20048
#define OP_vkGetQueryPoolResults 20049
-void marshal_VkBufferCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCreateInfo* forMarshaling);
+void marshal_VkBufferCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCreateInfo* forMarshaling);
-void unmarshal_VkBufferCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferCreateInfo* forUnmarshaling);
+void unmarshal_VkBufferCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferCreateInfo* forUnmarshaling);
#define OP_vkCreateBuffer 20050
#define OP_vkDestroyBuffer 20051
-void marshal_VkBufferViewCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferViewCreateInfo* forMarshaling);
+void marshal_VkBufferViewCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferViewCreateInfo* forMarshaling);
-void unmarshal_VkBufferViewCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferViewCreateInfo* forUnmarshaling);
+void unmarshal_VkBufferViewCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferViewCreateInfo* forUnmarshaling);
#define OP_vkCreateBufferView 20052
#define OP_vkDestroyBufferView 20053
-void marshal_VkImageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageCreateInfo* forMarshaling);
+void marshal_VkImageCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageCreateInfo* forMarshaling);
-void unmarshal_VkImageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageCreateInfo* forUnmarshaling);
+void unmarshal_VkImageCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageCreateInfo* forUnmarshaling);
-void marshal_VkSubresourceLayout(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubresourceLayout* forMarshaling);
+void marshal_VkSubresourceLayout(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubresourceLayout* forMarshaling);
-void unmarshal_VkSubresourceLayout(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubresourceLayout* forUnmarshaling);
+void unmarshal_VkSubresourceLayout(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubresourceLayout* forUnmarshaling);
#define OP_vkCreateImage 20054
#define OP_vkDestroyImage 20055
#define OP_vkGetImageSubresourceLayout 20056
-void marshal_VkComponentMapping(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkComponentMapping* forMarshaling);
+void marshal_VkComponentMapping(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkComponentMapping* forMarshaling);
-void unmarshal_VkComponentMapping(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkComponentMapping* forUnmarshaling);
+void unmarshal_VkComponentMapping(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkComponentMapping* forUnmarshaling);
-void marshal_VkImageViewCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageViewCreateInfo* forMarshaling);
+void marshal_VkImageViewCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageViewCreateInfo* forMarshaling);
-void unmarshal_VkImageViewCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageViewCreateInfo* forUnmarshaling);
+void unmarshal_VkImageViewCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageViewCreateInfo* forUnmarshaling);
#define OP_vkCreateImageView 20057
#define OP_vkDestroyImageView 20058
-void marshal_VkShaderModuleCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkShaderModuleCreateInfo* forMarshaling);
+void marshal_VkShaderModuleCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkShaderModuleCreateInfo* forMarshaling);
-void unmarshal_VkShaderModuleCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkShaderModuleCreateInfo* forUnmarshaling);
+void unmarshal_VkShaderModuleCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkShaderModuleCreateInfo* forUnmarshaling);
#define OP_vkCreateShaderModule 20059
#define OP_vkDestroyShaderModule 20060
-void marshal_VkPipelineCacheCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCacheCreateInfo* forMarshaling);
+void marshal_VkPipelineCacheCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCacheCreateInfo* forMarshaling);
-void unmarshal_VkPipelineCacheCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineCacheCreateInfo* forUnmarshaling);
+void unmarshal_VkPipelineCacheCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineCacheCreateInfo* forUnmarshaling);
#define OP_vkCreatePipelineCache 20061
#define OP_vkDestroyPipelineCache 20062
#define OP_vkGetPipelineCacheData 20063
#define OP_vkMergePipelineCaches 20064
-void marshal_VkSpecializationMapEntry(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSpecializationMapEntry* forMarshaling);
+void marshal_VkSpecializationMapEntry(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSpecializationMapEntry* forMarshaling);
-void unmarshal_VkSpecializationMapEntry(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSpecializationMapEntry* forUnmarshaling);
+void unmarshal_VkSpecializationMapEntry(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSpecializationMapEntry* forUnmarshaling);
-void marshal_VkSpecializationInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSpecializationInfo* forMarshaling);
+void marshal_VkSpecializationInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSpecializationInfo* forMarshaling);
-void unmarshal_VkSpecializationInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSpecializationInfo* forUnmarshaling);
+void unmarshal_VkSpecializationInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSpecializationInfo* forUnmarshaling);
-void marshal_VkPipelineShaderStageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineShaderStageCreateInfo* forMarshaling);
+void marshal_VkPipelineShaderStageCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineShaderStageCreateInfo* forMarshaling);
-void unmarshal_VkPipelineShaderStageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineShaderStageCreateInfo* forUnmarshaling);
+void unmarshal_VkPipelineShaderStageCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPipelineShaderStageCreateInfo* forUnmarshaling);
-void marshal_VkComputePipelineCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkComputePipelineCreateInfo* forMarshaling);
+void marshal_VkComputePipelineCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkComputePipelineCreateInfo* forMarshaling);
-void unmarshal_VkComputePipelineCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkComputePipelineCreateInfo* forUnmarshaling);
+void unmarshal_VkComputePipelineCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkComputePipelineCreateInfo* forUnmarshaling);
-void marshal_VkVertexInputBindingDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVertexInputBindingDescription* forMarshaling);
+void marshal_VkVertexInputBindingDescription(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVertexInputBindingDescription* forMarshaling);
-void unmarshal_VkVertexInputBindingDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVertexInputBindingDescription* forUnmarshaling);
+void unmarshal_VkVertexInputBindingDescription(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVertexInputBindingDescription* forUnmarshaling);
void marshal_VkVertexInputAttributeDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVertexInputAttributeDescription* forMarshaling);
void unmarshal_VkVertexInputAttributeDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVertexInputAttributeDescription* forUnmarshaling);
void marshal_VkPipelineVertexInputStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineVertexInputStateCreateInfo* forMarshaling);
void unmarshal_VkPipelineVertexInputStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineVertexInputStateCreateInfo* forUnmarshaling);
void marshal_VkPipelineInputAssemblyStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineInputAssemblyStateCreateInfo* forMarshaling);
void unmarshal_VkPipelineInputAssemblyStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineInputAssemblyStateCreateInfo* forUnmarshaling);
void marshal_VkPipelineTessellationStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineTessellationStateCreateInfo* forMarshaling);
void unmarshal_VkPipelineTessellationStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineTessellationStateCreateInfo* forUnmarshaling);
-void marshal_VkViewport(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkViewport* forMarshaling);
+void marshal_VkViewport(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkViewport* forMarshaling);
-void unmarshal_VkViewport(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkViewport* forUnmarshaling);
+void unmarshal_VkViewport(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkViewport* forUnmarshaling);
void marshal_VkPipelineViewportStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineViewportStateCreateInfo* forMarshaling);
void unmarshal_VkPipelineViewportStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineViewportStateCreateInfo* forUnmarshaling);
void marshal_VkPipelineRasterizationStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineRasterizationStateCreateInfo* forMarshaling);
void unmarshal_VkPipelineRasterizationStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineRasterizationStateCreateInfo* forUnmarshaling);
void marshal_VkPipelineMultisampleStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineMultisampleStateCreateInfo* forMarshaling);
void unmarshal_VkPipelineMultisampleStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineMultisampleStateCreateInfo* forUnmarshaling);
-void marshal_VkStencilOpState(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkStencilOpState* forMarshaling);
+void marshal_VkStencilOpState(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkStencilOpState* forMarshaling);
-void unmarshal_VkStencilOpState(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkStencilOpState* forUnmarshaling);
+void unmarshal_VkStencilOpState(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkStencilOpState* forUnmarshaling);
void marshal_VkPipelineDepthStencilStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineDepthStencilStateCreateInfo* forMarshaling);
void unmarshal_VkPipelineDepthStencilStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineDepthStencilStateCreateInfo* forUnmarshaling);
void marshal_VkPipelineColorBlendAttachmentState(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineColorBlendAttachmentState* forMarshaling);
void unmarshal_VkPipelineColorBlendAttachmentState(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineColorBlendAttachmentState* forUnmarshaling);
void marshal_VkPipelineColorBlendStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineColorBlendStateCreateInfo* forMarshaling);
void unmarshal_VkPipelineColorBlendStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineColorBlendStateCreateInfo* forUnmarshaling);
void marshal_VkPipelineDynamicStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineDynamicStateCreateInfo* forMarshaling);
-void unmarshal_VkPipelineDynamicStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineDynamicStateCreateInfo* forUnmarshaling);
+void unmarshal_VkPipelineDynamicStateCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPipelineDynamicStateCreateInfo* forUnmarshaling);
-void marshal_VkGraphicsPipelineCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGraphicsPipelineCreateInfo* forMarshaling);
+void marshal_VkGraphicsPipelineCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGraphicsPipelineCreateInfo* forMarshaling);
-void unmarshal_VkGraphicsPipelineCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkGraphicsPipelineCreateInfo* forUnmarshaling);
+void unmarshal_VkGraphicsPipelineCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkGraphicsPipelineCreateInfo* forUnmarshaling);
#define OP_vkCreateGraphicsPipelines 20065
#define OP_vkCreateComputePipelines 20066
#define OP_vkDestroyPipeline 20067
-void marshal_VkPushConstantRange(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPushConstantRange* forMarshaling);
+void marshal_VkPushConstantRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPushConstantRange* forMarshaling);
-void unmarshal_VkPushConstantRange(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPushConstantRange* forUnmarshaling);
+void unmarshal_VkPushConstantRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPushConstantRange* forUnmarshaling);
-void marshal_VkPipelineLayoutCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineLayoutCreateInfo* forMarshaling);
+void marshal_VkPipelineLayoutCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineLayoutCreateInfo* forMarshaling);
-void unmarshal_VkPipelineLayoutCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineLayoutCreateInfo* forUnmarshaling);
+void unmarshal_VkPipelineLayoutCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineLayoutCreateInfo* forUnmarshaling);
#define OP_vkCreatePipelineLayout 20068
#define OP_vkDestroyPipelineLayout 20069
-void marshal_VkSamplerCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerCreateInfo* forMarshaling);
+void marshal_VkSamplerCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerCreateInfo* forMarshaling);
-void unmarshal_VkSamplerCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSamplerCreateInfo* forUnmarshaling);
+void unmarshal_VkSamplerCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSamplerCreateInfo* forUnmarshaling);
#define OP_vkCreateSampler 20070
#define OP_vkDestroySampler 20071
-void marshal_VkCopyDescriptorSet(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyDescriptorSet* forMarshaling);
+void marshal_VkCopyDescriptorSet(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyDescriptorSet* forMarshaling);
-void unmarshal_VkCopyDescriptorSet(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCopyDescriptorSet* forUnmarshaling);
+void unmarshal_VkCopyDescriptorSet(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyDescriptorSet* forUnmarshaling);
-void marshal_VkDescriptorBufferInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorBufferInfo* forMarshaling);
+void marshal_VkDescriptorBufferInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorBufferInfo* forMarshaling);
-void unmarshal_VkDescriptorBufferInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorBufferInfo* forUnmarshaling);
+void unmarshal_VkDescriptorBufferInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDescriptorBufferInfo* forUnmarshaling);
-void marshal_VkDescriptorImageInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorImageInfo* forMarshaling);
+void marshal_VkDescriptorImageInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorImageInfo* forMarshaling);
-void unmarshal_VkDescriptorImageInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorImageInfo* forUnmarshaling);
+void unmarshal_VkDescriptorImageInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDescriptorImageInfo* forUnmarshaling);
-void marshal_VkDescriptorPoolSize(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorPoolSize* forMarshaling);
+void marshal_VkDescriptorPoolSize(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorPoolSize* forMarshaling);
-void unmarshal_VkDescriptorPoolSize(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorPoolSize* forUnmarshaling);
+void unmarshal_VkDescriptorPoolSize(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDescriptorPoolSize* forUnmarshaling);
-void marshal_VkDescriptorPoolCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorPoolCreateInfo* forMarshaling);
+void marshal_VkDescriptorPoolCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorPoolCreateInfo* forMarshaling);
-void unmarshal_VkDescriptorPoolCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorPoolCreateInfo* forUnmarshaling);
+void unmarshal_VkDescriptorPoolCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDescriptorPoolCreateInfo* forUnmarshaling);
-void marshal_VkDescriptorSetAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetAllocateInfo* forMarshaling);
+void marshal_VkDescriptorSetAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorSetAllocateInfo* forMarshaling);
-void unmarshal_VkDescriptorSetAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorSetAllocateInfo* forUnmarshaling);
+void unmarshal_VkDescriptorSetAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDescriptorSetAllocateInfo* forUnmarshaling);
-void marshal_VkDescriptorSetLayoutBinding(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetLayoutBinding* forMarshaling);
+void marshal_VkDescriptorSetLayoutBinding(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorSetLayoutBinding* forMarshaling);
-void unmarshal_VkDescriptorSetLayoutBinding(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorSetLayoutBinding* forUnmarshaling);
+void unmarshal_VkDescriptorSetLayoutBinding(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDescriptorSetLayoutBinding* forUnmarshaling);
-void marshal_VkDescriptorSetLayoutCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetLayoutCreateInfo* forMarshaling);
+void marshal_VkDescriptorSetLayoutCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorSetLayoutCreateInfo* forMarshaling);
-void unmarshal_VkDescriptorSetLayoutCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorSetLayoutCreateInfo* forUnmarshaling);
+void unmarshal_VkDescriptorSetLayoutCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkDescriptorSetLayoutCreateInfo* forUnmarshaling);
-void marshal_VkWriteDescriptorSet(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWriteDescriptorSet* forMarshaling);
+void marshal_VkWriteDescriptorSet(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWriteDescriptorSet* forMarshaling);
-void unmarshal_VkWriteDescriptorSet(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkWriteDescriptorSet* forUnmarshaling);
+void unmarshal_VkWriteDescriptorSet(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkWriteDescriptorSet* forUnmarshaling);
#define OP_vkCreateDescriptorSetLayout 20072
#define OP_vkDestroyDescriptorSetLayout 20073
@@ -1005,238 +687,150 @@
#define OP_vkAllocateDescriptorSets 20077
#define OP_vkFreeDescriptorSets 20078
#define OP_vkUpdateDescriptorSets 20079
-void marshal_VkAttachmentDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentDescription* forMarshaling);
+void marshal_VkAttachmentDescription(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentDescription* forMarshaling);
-void unmarshal_VkAttachmentDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAttachmentDescription* forUnmarshaling);
+void unmarshal_VkAttachmentDescription(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAttachmentDescription* forUnmarshaling);
-void marshal_VkAttachmentReference(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentReference* forMarshaling);
+void marshal_VkAttachmentReference(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentReference* forMarshaling);
-void unmarshal_VkAttachmentReference(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAttachmentReference* forUnmarshaling);
+void unmarshal_VkAttachmentReference(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAttachmentReference* forUnmarshaling);
-void marshal_VkFramebufferCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFramebufferCreateInfo* forMarshaling);
+void marshal_VkFramebufferCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFramebufferCreateInfo* forMarshaling);
-void unmarshal_VkFramebufferCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkFramebufferCreateInfo* forUnmarshaling);
+void unmarshal_VkFramebufferCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkFramebufferCreateInfo* forUnmarshaling);
-void marshal_VkSubpassDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassDescription* forMarshaling);
+void marshal_VkSubpassDescription(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassDescription* forMarshaling);
-void unmarshal_VkSubpassDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubpassDescription* forUnmarshaling);
+void unmarshal_VkSubpassDescription(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubpassDescription* forUnmarshaling);
-void marshal_VkSubpassDependency(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassDependency* forMarshaling);
+void marshal_VkSubpassDependency(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassDependency* forMarshaling);
-void unmarshal_VkSubpassDependency(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubpassDependency* forUnmarshaling);
+void unmarshal_VkSubpassDependency(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubpassDependency* forUnmarshaling);
-void marshal_VkRenderPassCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassCreateInfo* forMarshaling);
+void marshal_VkRenderPassCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassCreateInfo* forMarshaling);
-void unmarshal_VkRenderPassCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRenderPassCreateInfo* forUnmarshaling);
+void unmarshal_VkRenderPassCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderPassCreateInfo* forUnmarshaling);
#define OP_vkCreateFramebuffer 20080
#define OP_vkDestroyFramebuffer 20081
#define OP_vkCreateRenderPass 20082
#define OP_vkDestroyRenderPass 20083
#define OP_vkGetRenderAreaGranularity 20084
-void marshal_VkCommandPoolCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandPoolCreateInfo* forMarshaling);
+void marshal_VkCommandPoolCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandPoolCreateInfo* forMarshaling);
-void unmarshal_VkCommandPoolCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCommandPoolCreateInfo* forUnmarshaling);
+void unmarshal_VkCommandPoolCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCommandPoolCreateInfo* forUnmarshaling);
#define OP_vkCreateCommandPool 20085
#define OP_vkDestroyCommandPool 20086
#define OP_vkResetCommandPool 20087
-void marshal_VkCommandBufferAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferAllocateInfo* forMarshaling);
+void marshal_VkCommandBufferAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferAllocateInfo* forMarshaling);
-void unmarshal_VkCommandBufferAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCommandBufferAllocateInfo* forUnmarshaling);
+void unmarshal_VkCommandBufferAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCommandBufferAllocateInfo* forUnmarshaling);
-void marshal_VkCommandBufferInheritanceInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferInheritanceInfo* forMarshaling);
+void marshal_VkCommandBufferInheritanceInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferInheritanceInfo* forMarshaling);
-void unmarshal_VkCommandBufferInheritanceInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCommandBufferInheritanceInfo* forUnmarshaling);
+void unmarshal_VkCommandBufferInheritanceInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCommandBufferInheritanceInfo* forUnmarshaling);
-void marshal_VkCommandBufferBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferBeginInfo* forMarshaling);
+void marshal_VkCommandBufferBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferBeginInfo* forMarshaling);
-void unmarshal_VkCommandBufferBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCommandBufferBeginInfo* forUnmarshaling);
+void unmarshal_VkCommandBufferBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCommandBufferBeginInfo* forUnmarshaling);
#define OP_vkAllocateCommandBuffers 20088
#define OP_vkFreeCommandBuffers 20089
#define OP_vkBeginCommandBuffer 20090
#define OP_vkEndCommandBuffer 20091
#define OP_vkResetCommandBuffer 20092
-void marshal_VkBufferCopy(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCopy* forMarshaling);
+void marshal_VkBufferCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCopy* forMarshaling);
-void unmarshal_VkBufferCopy(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferCopy* forUnmarshaling);
+void unmarshal_VkBufferCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferCopy* forUnmarshaling);
-void marshal_VkImageSubresourceLayers(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageSubresourceLayers* forMarshaling);
+void marshal_VkImageSubresourceLayers(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSubresourceLayers* forMarshaling);
-void unmarshal_VkImageSubresourceLayers(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageSubresourceLayers* forUnmarshaling);
+void unmarshal_VkImageSubresourceLayers(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageSubresourceLayers* forUnmarshaling);
-void marshal_VkBufferImageCopy(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferImageCopy* forMarshaling);
+void marshal_VkBufferImageCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferImageCopy* forMarshaling);
-void unmarshal_VkBufferImageCopy(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferImageCopy* forUnmarshaling);
+void unmarshal_VkBufferImageCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferImageCopy* forUnmarshaling);
-void marshal_VkClearColorValue(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkClearColorValue* forMarshaling);
+void marshal_VkClearColorValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkClearColorValue* forMarshaling);
-void unmarshal_VkClearColorValue(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkClearColorValue* forUnmarshaling);
+void unmarshal_VkClearColorValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkClearColorValue* forUnmarshaling);
-void marshal_VkClearDepthStencilValue(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkClearDepthStencilValue* forMarshaling);
+void marshal_VkClearDepthStencilValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkClearDepthStencilValue* forMarshaling);
-void unmarshal_VkClearDepthStencilValue(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkClearDepthStencilValue* forUnmarshaling);
+void unmarshal_VkClearDepthStencilValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkClearDepthStencilValue* forUnmarshaling);
-void marshal_VkClearValue(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkClearValue* forMarshaling);
+void marshal_VkClearValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkClearValue* forMarshaling);
-void unmarshal_VkClearValue(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkClearValue* forUnmarshaling);
+void unmarshal_VkClearValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkClearValue* forUnmarshaling);
-void marshal_VkClearAttachment(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkClearAttachment* forMarshaling);
+void marshal_VkClearAttachment(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkClearAttachment* forMarshaling);
-void unmarshal_VkClearAttachment(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkClearAttachment* forUnmarshaling);
+void unmarshal_VkClearAttachment(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkClearAttachment* forUnmarshaling);
-void marshal_VkClearRect(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkClearRect* forMarshaling);
+void marshal_VkClearRect(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkClearRect* forMarshaling);
-void unmarshal_VkClearRect(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkClearRect* forUnmarshaling);
+void unmarshal_VkClearRect(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkClearRect* forUnmarshaling);
-void marshal_VkImageBlit(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageBlit* forMarshaling);
+void marshal_VkImageBlit(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageBlit* forMarshaling);
-void unmarshal_VkImageBlit(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageBlit* forUnmarshaling);
+void unmarshal_VkImageBlit(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageBlit* forUnmarshaling);
-void marshal_VkImageCopy(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageCopy* forMarshaling);
+void marshal_VkImageCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageCopy* forMarshaling);
-void unmarshal_VkImageCopy(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageCopy* forUnmarshaling);
+void unmarshal_VkImageCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageCopy* forUnmarshaling);
-void marshal_VkImageResolve(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageResolve* forMarshaling);
+void marshal_VkImageResolve(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageResolve* forMarshaling);
-void unmarshal_VkImageResolve(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageResolve* forUnmarshaling);
+void unmarshal_VkImageResolve(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageResolve* forUnmarshaling);
-void marshal_VkRenderPassBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassBeginInfo* forMarshaling);
+void marshal_VkRenderPassBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassBeginInfo* forMarshaling);
-void unmarshal_VkRenderPassBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRenderPassBeginInfo* forUnmarshaling);
+void unmarshal_VkRenderPassBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderPassBeginInfo* forUnmarshaling);
#define OP_vkCmdBindPipeline 20093
#define OP_vkCmdSetViewport 20094
@@ -1286,302 +880,210 @@
#ifdef VK_VERSION_1_1
#define OP_vkEnumerateInstanceVersion 20137
void marshal_VkPhysicalDeviceSubgroupProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceSubgroupProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceSubgroupProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceSubgroupProperties* forUnmarshaling);
-void marshal_VkBindBufferMemoryInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindBufferMemoryInfo* forMarshaling);
+void marshal_VkBindBufferMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindBufferMemoryInfo* forMarshaling);
-void unmarshal_VkBindBufferMemoryInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBindBufferMemoryInfo* forUnmarshaling);
+void unmarshal_VkBindBufferMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBindBufferMemoryInfo* forUnmarshaling);
-void marshal_VkBindImageMemoryInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindImageMemoryInfo* forMarshaling);
+void marshal_VkBindImageMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindImageMemoryInfo* forMarshaling);
-void unmarshal_VkBindImageMemoryInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBindImageMemoryInfo* forUnmarshaling);
+void unmarshal_VkBindImageMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBindImageMemoryInfo* forUnmarshaling);
#define OP_vkBindBufferMemory2 20138
#define OP_vkBindImageMemory2 20139
void marshal_VkPhysicalDevice16BitStorageFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDevice16BitStorageFeatures* forMarshaling);
void unmarshal_VkPhysicalDevice16BitStorageFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDevice16BitStorageFeatures* forUnmarshaling);
-void marshal_VkMemoryDedicatedRequirements(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryDedicatedRequirements* forMarshaling);
+void marshal_VkMemoryDedicatedRequirements(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryDedicatedRequirements* forMarshaling);
-void unmarshal_VkMemoryDedicatedRequirements(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryDedicatedRequirements* forUnmarshaling);
+void unmarshal_VkMemoryDedicatedRequirements(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryDedicatedRequirements* forUnmarshaling);
-void marshal_VkMemoryDedicatedAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryDedicatedAllocateInfo* forMarshaling);
+void marshal_VkMemoryDedicatedAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryDedicatedAllocateInfo* forMarshaling);
-void unmarshal_VkMemoryDedicatedAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryDedicatedAllocateInfo* forUnmarshaling);
+void unmarshal_VkMemoryDedicatedAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryDedicatedAllocateInfo* forUnmarshaling);
-void marshal_VkMemoryAllocateFlagsInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryAllocateFlagsInfo* forMarshaling);
+void marshal_VkMemoryAllocateFlagsInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryAllocateFlagsInfo* forMarshaling);
-void unmarshal_VkMemoryAllocateFlagsInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryAllocateFlagsInfo* forUnmarshaling);
+void unmarshal_VkMemoryAllocateFlagsInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryAllocateFlagsInfo* forUnmarshaling);
void marshal_VkDeviceGroupRenderPassBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDeviceGroupRenderPassBeginInfo* forMarshaling);
-void unmarshal_VkDeviceGroupRenderPassBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceGroupRenderPassBeginInfo* forUnmarshaling);
+void unmarshal_VkDeviceGroupRenderPassBeginInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkDeviceGroupRenderPassBeginInfo* forUnmarshaling);
void marshal_VkDeviceGroupCommandBufferBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDeviceGroupCommandBufferBeginInfo* forMarshaling);
void unmarshal_VkDeviceGroupCommandBufferBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDeviceGroupCommandBufferBeginInfo* forUnmarshaling);
-void marshal_VkDeviceGroupSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupSubmitInfo* forMarshaling);
+void marshal_VkDeviceGroupSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupSubmitInfo* forMarshaling);
-void unmarshal_VkDeviceGroupSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceGroupSubmitInfo* forUnmarshaling);
+void unmarshal_VkDeviceGroupSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceGroupSubmitInfo* forUnmarshaling);
-void marshal_VkDeviceGroupBindSparseInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupBindSparseInfo* forMarshaling);
+void marshal_VkDeviceGroupBindSparseInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupBindSparseInfo* forMarshaling);
-void unmarshal_VkDeviceGroupBindSparseInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceGroupBindSparseInfo* forUnmarshaling);
+void unmarshal_VkDeviceGroupBindSparseInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceGroupBindSparseInfo* forUnmarshaling);
#define OP_vkGetDeviceGroupPeerMemoryFeatures 20140
#define OP_vkCmdSetDeviceMask 20141
#define OP_vkCmdDispatchBase 20142
void marshal_VkBindBufferMemoryDeviceGroupInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkBindBufferMemoryDeviceGroupInfo* forMarshaling);
void unmarshal_VkBindBufferMemoryDeviceGroupInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkBindBufferMemoryDeviceGroupInfo* forUnmarshaling);
void marshal_VkBindImageMemoryDeviceGroupInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkBindImageMemoryDeviceGroupInfo* forMarshaling);
-void unmarshal_VkBindImageMemoryDeviceGroupInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBindImageMemoryDeviceGroupInfo* forUnmarshaling);
+void unmarshal_VkBindImageMemoryDeviceGroupInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkBindImageMemoryDeviceGroupInfo* forUnmarshaling);
-void marshal_VkPhysicalDeviceGroupProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceGroupProperties* forMarshaling);
+void marshal_VkPhysicalDeviceGroupProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceGroupProperties* forMarshaling);
-void unmarshal_VkPhysicalDeviceGroupProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceGroupProperties* forUnmarshaling);
+void unmarshal_VkPhysicalDeviceGroupProperties(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPhysicalDeviceGroupProperties* forUnmarshaling);
-void marshal_VkDeviceGroupDeviceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupDeviceCreateInfo* forMarshaling);
+void marshal_VkDeviceGroupDeviceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupDeviceCreateInfo* forMarshaling);
-void unmarshal_VkDeviceGroupDeviceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceGroupDeviceCreateInfo* forUnmarshaling);
+void unmarshal_VkDeviceGroupDeviceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceGroupDeviceCreateInfo* forUnmarshaling);
#define OP_vkEnumeratePhysicalDeviceGroups 20143
-void marshal_VkBufferMemoryRequirementsInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferMemoryRequirementsInfo2* forMarshaling);
+void marshal_VkBufferMemoryRequirementsInfo2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferMemoryRequirementsInfo2* forMarshaling);
-void unmarshal_VkBufferMemoryRequirementsInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferMemoryRequirementsInfo2* forUnmarshaling);
+void unmarshal_VkBufferMemoryRequirementsInfo2(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkBufferMemoryRequirementsInfo2* forUnmarshaling);
-void marshal_VkImageMemoryRequirementsInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageMemoryRequirementsInfo2* forMarshaling);
+void marshal_VkImageMemoryRequirementsInfo2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageMemoryRequirementsInfo2* forMarshaling);
-void unmarshal_VkImageMemoryRequirementsInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageMemoryRequirementsInfo2* forUnmarshaling);
+void unmarshal_VkImageMemoryRequirementsInfo2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageMemoryRequirementsInfo2* forUnmarshaling);
void marshal_VkImageSparseMemoryRequirementsInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkImageSparseMemoryRequirementsInfo2* forMarshaling);
void unmarshal_VkImageSparseMemoryRequirementsInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkImageSparseMemoryRequirementsInfo2* forUnmarshaling);
-void marshal_VkMemoryRequirements2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryRequirements2* forMarshaling);
+void marshal_VkMemoryRequirements2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryRequirements2* forMarshaling);
-void unmarshal_VkMemoryRequirements2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryRequirements2* forUnmarshaling);
+void unmarshal_VkMemoryRequirements2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryRequirements2* forUnmarshaling);
void marshal_VkSparseImageMemoryRequirements2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkSparseImageMemoryRequirements2* forMarshaling);
-void unmarshal_VkSparseImageMemoryRequirements2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSparseImageMemoryRequirements2* forUnmarshaling);
+void unmarshal_VkSparseImageMemoryRequirements2(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkSparseImageMemoryRequirements2* forUnmarshaling);
#define OP_vkGetImageMemoryRequirements2 20144
#define OP_vkGetBufferMemoryRequirements2 20145
#define OP_vkGetImageSparseMemoryRequirements2 20146
-void marshal_VkPhysicalDeviceFeatures2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFeatures2* forMarshaling);
+void marshal_VkPhysicalDeviceFeatures2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFeatures2* forMarshaling);
-void unmarshal_VkPhysicalDeviceFeatures2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceFeatures2* forUnmarshaling);
+void unmarshal_VkPhysicalDeviceFeatures2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceFeatures2* forUnmarshaling);
-void marshal_VkPhysicalDeviceProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceProperties2* forMarshaling);
+void marshal_VkPhysicalDeviceProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceProperties2* forMarshaling);
-void unmarshal_VkPhysicalDeviceProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceProperties2* forUnmarshaling);
+void unmarshal_VkPhysicalDeviceProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceProperties2* forUnmarshaling);
-void marshal_VkFormatProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFormatProperties2* forMarshaling);
+void marshal_VkFormatProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFormatProperties2* forMarshaling);
-void unmarshal_VkFormatProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkFormatProperties2* forUnmarshaling);
+void unmarshal_VkFormatProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkFormatProperties2* forUnmarshaling);
-void marshal_VkImageFormatProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageFormatProperties2* forMarshaling);
+void marshal_VkImageFormatProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageFormatProperties2* forMarshaling);
-void unmarshal_VkImageFormatProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageFormatProperties2* forUnmarshaling);
+void unmarshal_VkImageFormatProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageFormatProperties2* forUnmarshaling);
void marshal_VkPhysicalDeviceImageFormatInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceImageFormatInfo2* forMarshaling);
-void unmarshal_VkPhysicalDeviceImageFormatInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceImageFormatInfo2* forUnmarshaling);
+void unmarshal_VkPhysicalDeviceImageFormatInfo2(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPhysicalDeviceImageFormatInfo2* forUnmarshaling);
-void marshal_VkQueueFamilyProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueueFamilyProperties2* forMarshaling);
+void marshal_VkQueueFamilyProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyProperties2* forMarshaling);
-void unmarshal_VkQueueFamilyProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkQueueFamilyProperties2* forUnmarshaling);
+void unmarshal_VkQueueFamilyProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkQueueFamilyProperties2* forUnmarshaling);
void marshal_VkPhysicalDeviceMemoryProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceMemoryProperties2* forMarshaling);
void unmarshal_VkPhysicalDeviceMemoryProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceMemoryProperties2* forUnmarshaling);
-void marshal_VkSparseImageFormatProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageFormatProperties2* forMarshaling);
+void marshal_VkSparseImageFormatProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageFormatProperties2* forMarshaling);
-void unmarshal_VkSparseImageFormatProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSparseImageFormatProperties2* forUnmarshaling);
+void unmarshal_VkSparseImageFormatProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSparseImageFormatProperties2* forUnmarshaling);
void marshal_VkPhysicalDeviceSparseImageFormatInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceSparseImageFormatInfo2* forMarshaling);
void unmarshal_VkPhysicalDeviceSparseImageFormatInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceSparseImageFormatInfo2* forUnmarshaling);
#define OP_vkGetPhysicalDeviceFeatures2 20147
@@ -1593,933 +1095,694 @@
#define OP_vkGetPhysicalDeviceSparseImageFormatProperties2 20153
#define OP_vkTrimCommandPool 20154
void marshal_VkPhysicalDevicePointClippingProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDevicePointClippingProperties* forMarshaling);
void unmarshal_VkPhysicalDevicePointClippingProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDevicePointClippingProperties* forUnmarshaling);
void marshal_VkInputAttachmentAspectReference(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkInputAttachmentAspectReference* forMarshaling);
-void unmarshal_VkInputAttachmentAspectReference(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkInputAttachmentAspectReference* forUnmarshaling);
+void unmarshal_VkInputAttachmentAspectReference(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkInputAttachmentAspectReference* forUnmarshaling);
void marshal_VkRenderPassInputAttachmentAspectCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkRenderPassInputAttachmentAspectCreateInfo* forMarshaling);
void unmarshal_VkRenderPassInputAttachmentAspectCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkRenderPassInputAttachmentAspectCreateInfo* forUnmarshaling);
-void marshal_VkImageViewUsageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageViewUsageCreateInfo* forMarshaling);
+void marshal_VkImageViewUsageCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageViewUsageCreateInfo* forMarshaling);
-void unmarshal_VkImageViewUsageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageViewUsageCreateInfo* forUnmarshaling);
+void unmarshal_VkImageViewUsageCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageViewUsageCreateInfo* forUnmarshaling);
void marshal_VkPipelineTessellationDomainOriginStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineTessellationDomainOriginStateCreateInfo* forMarshaling);
void unmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineTessellationDomainOriginStateCreateInfo* forUnmarshaling);
-void marshal_VkRenderPassMultiviewCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassMultiviewCreateInfo* forMarshaling);
+void marshal_VkRenderPassMultiviewCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassMultiviewCreateInfo* forMarshaling);
-void unmarshal_VkRenderPassMultiviewCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRenderPassMultiviewCreateInfo* forUnmarshaling);
+void unmarshal_VkRenderPassMultiviewCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkRenderPassMultiviewCreateInfo* forUnmarshaling);
void marshal_VkPhysicalDeviceMultiviewFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceMultiviewFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceMultiviewFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceMultiviewFeatures* forUnmarshaling);
void marshal_VkPhysicalDeviceMultiviewProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceMultiviewProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceMultiviewProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceMultiviewProperties* forUnmarshaling);
void marshal_VkPhysicalDeviceVariablePointersFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceVariablePointersFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceVariablePointersFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceVariablePointersFeatures* forUnmarshaling);
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceVariablePointersFeatures, marshal_VkPhysicalDeviceVariablePointerFeatures)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceVariablePointersFeatures,
+ marshal_VkPhysicalDeviceVariablePointerFeatures)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceVariablePointersFeatures, unmarshal_VkPhysicalDeviceVariablePointerFeatures)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceVariablePointersFeatures,
+ unmarshal_VkPhysicalDeviceVariablePointerFeatures)
void marshal_VkPhysicalDeviceProtectedMemoryFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceProtectedMemoryFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceProtectedMemoryFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceProtectedMemoryFeatures* forUnmarshaling);
void marshal_VkPhysicalDeviceProtectedMemoryProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceProtectedMemoryProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceProtectedMemoryProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceProtectedMemoryProperties* forUnmarshaling);
-void marshal_VkDeviceQueueInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceQueueInfo2* forMarshaling);
+void marshal_VkDeviceQueueInfo2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceQueueInfo2* forMarshaling);
-void unmarshal_VkDeviceQueueInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceQueueInfo2* forUnmarshaling);
+void unmarshal_VkDeviceQueueInfo2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceQueueInfo2* forUnmarshaling);
-void marshal_VkProtectedSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkProtectedSubmitInfo* forMarshaling);
+void marshal_VkProtectedSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkProtectedSubmitInfo* forMarshaling);
-void unmarshal_VkProtectedSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkProtectedSubmitInfo* forUnmarshaling);
+void unmarshal_VkProtectedSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkProtectedSubmitInfo* forUnmarshaling);
#define OP_vkGetDeviceQueue2 20155
void marshal_VkSamplerYcbcrConversionCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkSamplerYcbcrConversionCreateInfo* forMarshaling);
void unmarshal_VkSamplerYcbcrConversionCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkSamplerYcbcrConversionCreateInfo* forUnmarshaling);
-void marshal_VkSamplerYcbcrConversionInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerYcbcrConversionInfo* forMarshaling);
+void marshal_VkSamplerYcbcrConversionInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerYcbcrConversionInfo* forMarshaling);
-void unmarshal_VkSamplerYcbcrConversionInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSamplerYcbcrConversionInfo* forUnmarshaling);
+void unmarshal_VkSamplerYcbcrConversionInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSamplerYcbcrConversionInfo* forUnmarshaling);
-void marshal_VkBindImagePlaneMemoryInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindImagePlaneMemoryInfo* forMarshaling);
+void marshal_VkBindImagePlaneMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindImagePlaneMemoryInfo* forMarshaling);
-void unmarshal_VkBindImagePlaneMemoryInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBindImagePlaneMemoryInfo* forUnmarshaling);
+void unmarshal_VkBindImagePlaneMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBindImagePlaneMemoryInfo* forUnmarshaling);
void marshal_VkImagePlaneMemoryRequirementsInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkImagePlaneMemoryRequirementsInfo* forMarshaling);
void unmarshal_VkImagePlaneMemoryRequirementsInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkImagePlaneMemoryRequirementsInfo* forUnmarshaling);
void marshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceSamplerYcbcrConversionFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceSamplerYcbcrConversionFeatures* forUnmarshaling);
void marshal_VkSamplerYcbcrConversionImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkSamplerYcbcrConversionImageFormatProperties* forMarshaling);
void unmarshal_VkSamplerYcbcrConversionImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkSamplerYcbcrConversionImageFormatProperties* forUnmarshaling);
#define OP_vkCreateSamplerYcbcrConversion 20156
#define OP_vkDestroySamplerYcbcrConversion 20157
-void marshal_VkDescriptorUpdateTemplateEntry(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorUpdateTemplateEntry* forMarshaling);
+void marshal_VkDescriptorUpdateTemplateEntry(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorUpdateTemplateEntry* forMarshaling);
-void unmarshal_VkDescriptorUpdateTemplateEntry(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorUpdateTemplateEntry* forUnmarshaling);
+void unmarshal_VkDescriptorUpdateTemplateEntry(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkDescriptorUpdateTemplateEntry* forUnmarshaling);
void marshal_VkDescriptorUpdateTemplateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDescriptorUpdateTemplateCreateInfo* forMarshaling);
void unmarshal_VkDescriptorUpdateTemplateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDescriptorUpdateTemplateCreateInfo* forUnmarshaling);
#define OP_vkCreateDescriptorUpdateTemplate 20158
#define OP_vkDestroyDescriptorUpdateTemplate 20159
#define OP_vkUpdateDescriptorSetWithTemplate 20160
-void marshal_VkExternalMemoryProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalMemoryProperties* forMarshaling);
+void marshal_VkExternalMemoryProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalMemoryProperties* forMarshaling);
-void unmarshal_VkExternalMemoryProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExternalMemoryProperties* forUnmarshaling);
+void unmarshal_VkExternalMemoryProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExternalMemoryProperties* forUnmarshaling);
void marshal_VkPhysicalDeviceExternalImageFormatInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceExternalImageFormatInfo* forMarshaling);
void unmarshal_VkPhysicalDeviceExternalImageFormatInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceExternalImageFormatInfo* forUnmarshaling);
-void marshal_VkExternalImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalImageFormatProperties* forMarshaling);
+void marshal_VkExternalImageFormatProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalImageFormatProperties* forMarshaling);
-void unmarshal_VkExternalImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExternalImageFormatProperties* forUnmarshaling);
+void unmarshal_VkExternalImageFormatProperties(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkExternalImageFormatProperties* forUnmarshaling);
void marshal_VkPhysicalDeviceExternalBufferInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceExternalBufferInfo* forMarshaling);
void unmarshal_VkPhysicalDeviceExternalBufferInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceExternalBufferInfo* forUnmarshaling);
-void marshal_VkExternalBufferProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalBufferProperties* forMarshaling);
+void marshal_VkExternalBufferProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalBufferProperties* forMarshaling);
-void unmarshal_VkExternalBufferProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExternalBufferProperties* forUnmarshaling);
+void unmarshal_VkExternalBufferProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExternalBufferProperties* forUnmarshaling);
-void marshal_VkPhysicalDeviceIDProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceIDProperties* forMarshaling);
+void marshal_VkPhysicalDeviceIDProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceIDProperties* forMarshaling);
-void unmarshal_VkPhysicalDeviceIDProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceIDProperties* forUnmarshaling);
+void unmarshal_VkPhysicalDeviceIDProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceIDProperties* forUnmarshaling);
#define OP_vkGetPhysicalDeviceExternalBufferProperties 20161
-void marshal_VkExternalMemoryImageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalMemoryImageCreateInfo* forMarshaling);
+void marshal_VkExternalMemoryImageCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalMemoryImageCreateInfo* forMarshaling);
-void unmarshal_VkExternalMemoryImageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExternalMemoryImageCreateInfo* forUnmarshaling);
+void unmarshal_VkExternalMemoryImageCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkExternalMemoryImageCreateInfo* forUnmarshaling);
void marshal_VkExternalMemoryBufferCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkExternalMemoryBufferCreateInfo* forMarshaling);
-void unmarshal_VkExternalMemoryBufferCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExternalMemoryBufferCreateInfo* forUnmarshaling);
+void unmarshal_VkExternalMemoryBufferCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkExternalMemoryBufferCreateInfo* forUnmarshaling);
-void marshal_VkExportMemoryAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportMemoryAllocateInfo* forMarshaling);
+void marshal_VkExportMemoryAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportMemoryAllocateInfo* forMarshaling);
-void unmarshal_VkExportMemoryAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExportMemoryAllocateInfo* forUnmarshaling);
+void unmarshal_VkExportMemoryAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExportMemoryAllocateInfo* forUnmarshaling);
void marshal_VkPhysicalDeviceExternalFenceInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceExternalFenceInfo* forMarshaling);
void unmarshal_VkPhysicalDeviceExternalFenceInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceExternalFenceInfo* forUnmarshaling);
-void marshal_VkExternalFenceProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalFenceProperties* forMarshaling);
+void marshal_VkExternalFenceProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalFenceProperties* forMarshaling);
-void unmarshal_VkExternalFenceProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExternalFenceProperties* forUnmarshaling);
+void unmarshal_VkExternalFenceProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExternalFenceProperties* forUnmarshaling);
#define OP_vkGetPhysicalDeviceExternalFenceProperties 20162
-void marshal_VkExportFenceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportFenceCreateInfo* forMarshaling);
+void marshal_VkExportFenceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportFenceCreateInfo* forMarshaling);
-void unmarshal_VkExportFenceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExportFenceCreateInfo* forUnmarshaling);
+void unmarshal_VkExportFenceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExportFenceCreateInfo* forUnmarshaling);
-void marshal_VkExportSemaphoreCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportSemaphoreCreateInfo* forMarshaling);
+void marshal_VkExportSemaphoreCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportSemaphoreCreateInfo* forMarshaling);
-void unmarshal_VkExportSemaphoreCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExportSemaphoreCreateInfo* forUnmarshaling);
+void unmarshal_VkExportSemaphoreCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExportSemaphoreCreateInfo* forUnmarshaling);
void marshal_VkPhysicalDeviceExternalSemaphoreInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceExternalSemaphoreInfo* forMarshaling);
void unmarshal_VkPhysicalDeviceExternalSemaphoreInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceExternalSemaphoreInfo* forUnmarshaling);
-void marshal_VkExternalSemaphoreProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalSemaphoreProperties* forMarshaling);
+void marshal_VkExternalSemaphoreProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalSemaphoreProperties* forMarshaling);
-void unmarshal_VkExternalSemaphoreProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExternalSemaphoreProperties* forUnmarshaling);
+void unmarshal_VkExternalSemaphoreProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExternalSemaphoreProperties* forUnmarshaling);
#define OP_vkGetPhysicalDeviceExternalSemaphoreProperties 20163
void marshal_VkPhysicalDeviceMaintenance3Properties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceMaintenance3Properties* forMarshaling);
void unmarshal_VkPhysicalDeviceMaintenance3Properties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceMaintenance3Properties* forUnmarshaling);
-void marshal_VkDescriptorSetLayoutSupport(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetLayoutSupport* forMarshaling);
+void marshal_VkDescriptorSetLayoutSupport(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorSetLayoutSupport* forMarshaling);
-void unmarshal_VkDescriptorSetLayoutSupport(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDescriptorSetLayoutSupport* forUnmarshaling);
+void unmarshal_VkDescriptorSetLayoutSupport(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDescriptorSetLayoutSupport* forUnmarshaling);
#define OP_vkGetDescriptorSetLayoutSupport 20164
void marshal_VkPhysicalDeviceShaderDrawParametersFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderDrawParametersFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderDrawParametersFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShaderDrawParametersFeatures* forUnmarshaling);
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceShaderDrawParametersFeatures, marshal_VkPhysicalDeviceShaderDrawParameterFeatures)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceShaderDrawParametersFeatures,
+ marshal_VkPhysicalDeviceShaderDrawParameterFeatures)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceShaderDrawParametersFeatures, unmarshal_VkPhysicalDeviceShaderDrawParameterFeatures)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceShaderDrawParametersFeatures,
+ unmarshal_VkPhysicalDeviceShaderDrawParameterFeatures)
#endif
#ifdef VK_VERSION_1_2
void marshal_VkPhysicalDeviceVulkan11Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceVulkan11Features* forMarshaling);
-void unmarshal_VkPhysicalDeviceVulkan11Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceVulkan11Features* forUnmarshaling);
+void unmarshal_VkPhysicalDeviceVulkan11Features(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPhysicalDeviceVulkan11Features* forUnmarshaling);
void marshal_VkPhysicalDeviceVulkan11Properties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceVulkan11Properties* forMarshaling);
void unmarshal_VkPhysicalDeviceVulkan11Properties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceVulkan11Properties* forUnmarshaling);
void marshal_VkPhysicalDeviceVulkan12Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceVulkan12Features* forMarshaling);
-void unmarshal_VkPhysicalDeviceVulkan12Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceVulkan12Features* forUnmarshaling);
+void unmarshal_VkPhysicalDeviceVulkan12Features(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPhysicalDeviceVulkan12Features* forUnmarshaling);
-void marshal_VkConformanceVersion(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkConformanceVersion* forMarshaling);
+void marshal_VkConformanceVersion(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkConformanceVersion* forMarshaling);
-void unmarshal_VkConformanceVersion(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkConformanceVersion* forUnmarshaling);
+void unmarshal_VkConformanceVersion(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkConformanceVersion* forUnmarshaling);
void marshal_VkPhysicalDeviceVulkan12Properties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceVulkan12Properties* forMarshaling);
void unmarshal_VkPhysicalDeviceVulkan12Properties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceVulkan12Properties* forUnmarshaling);
-void marshal_VkImageFormatListCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageFormatListCreateInfo* forMarshaling);
+void marshal_VkImageFormatListCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageFormatListCreateInfo* forMarshaling);
-void unmarshal_VkImageFormatListCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageFormatListCreateInfo* forUnmarshaling);
+void unmarshal_VkImageFormatListCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageFormatListCreateInfo* forUnmarshaling);
#define OP_vkCmdDrawIndirectCount 282774587
#define OP_vkCmdDrawIndexedIndirectCount 245204359
-void marshal_VkAttachmentDescription2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentDescription2* forMarshaling);
+void marshal_VkAttachmentDescription2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentDescription2* forMarshaling);
-void unmarshal_VkAttachmentDescription2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAttachmentDescription2* forUnmarshaling);
+void unmarshal_VkAttachmentDescription2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAttachmentDescription2* forUnmarshaling);
-void marshal_VkAttachmentReference2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentReference2* forMarshaling);
+void marshal_VkAttachmentReference2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentReference2* forMarshaling);
-void unmarshal_VkAttachmentReference2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAttachmentReference2* forUnmarshaling);
+void unmarshal_VkAttachmentReference2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAttachmentReference2* forUnmarshaling);
-void marshal_VkSubpassDescription2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassDescription2* forMarshaling);
+void marshal_VkSubpassDescription2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassDescription2* forMarshaling);
-void unmarshal_VkSubpassDescription2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubpassDescription2* forUnmarshaling);
+void unmarshal_VkSubpassDescription2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubpassDescription2* forUnmarshaling);
-void marshal_VkSubpassDependency2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassDependency2* forMarshaling);
+void marshal_VkSubpassDependency2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassDependency2* forMarshaling);
-void unmarshal_VkSubpassDependency2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubpassDependency2* forUnmarshaling);
+void unmarshal_VkSubpassDependency2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubpassDependency2* forUnmarshaling);
-void marshal_VkRenderPassCreateInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassCreateInfo2* forMarshaling);
+void marshal_VkRenderPassCreateInfo2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassCreateInfo2* forMarshaling);
-void unmarshal_VkRenderPassCreateInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRenderPassCreateInfo2* forUnmarshaling);
+void unmarshal_VkRenderPassCreateInfo2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderPassCreateInfo2* forUnmarshaling);
-void marshal_VkSubpassBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassBeginInfo* forMarshaling);
+void marshal_VkSubpassBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassBeginInfo* forMarshaling);
-void unmarshal_VkSubpassBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubpassBeginInfo* forUnmarshaling);
+void unmarshal_VkSubpassBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubpassBeginInfo* forUnmarshaling);
-void marshal_VkSubpassEndInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassEndInfo* forMarshaling);
+void marshal_VkSubpassEndInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassEndInfo* forMarshaling);
-void unmarshal_VkSubpassEndInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubpassEndInfo* forUnmarshaling);
+void unmarshal_VkSubpassEndInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubpassEndInfo* forUnmarshaling);
#define OP_vkCreateRenderPass2 279590827
#define OP_vkCmdBeginRenderPass2 235222847
#define OP_vkCmdNextSubpass2 244873750
#define OP_vkCmdEndRenderPass2 221297834
void marshal_VkPhysicalDevice8BitStorageFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDevice8BitStorageFeatures* forMarshaling);
void unmarshal_VkPhysicalDevice8BitStorageFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDevice8BitStorageFeatures* forUnmarshaling);
void marshal_VkPhysicalDeviceDriverProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceDriverProperties* forMarshaling);
-void unmarshal_VkPhysicalDeviceDriverProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceDriverProperties* forUnmarshaling);
+void unmarshal_VkPhysicalDeviceDriverProperties(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPhysicalDeviceDriverProperties* forUnmarshaling);
void marshal_VkPhysicalDeviceShaderAtomicInt64Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicInt64Features* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderAtomicInt64Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShaderAtomicInt64Features* forUnmarshaling);
void marshal_VkPhysicalDeviceShaderFloat16Int8Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderFloat16Int8Features* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderFloat16Int8Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShaderFloat16Int8Features* forUnmarshaling);
void marshal_VkPhysicalDeviceFloatControlsProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceFloatControlsProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceFloatControlsProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceFloatControlsProperties* forUnmarshaling);
void marshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDescriptorSetLayoutBindingFlagsCreateInfo* forMarshaling);
void unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDescriptorSetLayoutBindingFlagsCreateInfo* forUnmarshaling);
void marshal_VkPhysicalDeviceDescriptorIndexingFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceDescriptorIndexingFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceDescriptorIndexingFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceDescriptorIndexingFeatures* forUnmarshaling);
void marshal_VkPhysicalDeviceDescriptorIndexingProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceDescriptorIndexingProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceDescriptorIndexingProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceDescriptorIndexingProperties* forUnmarshaling);
void marshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDescriptorSetVariableDescriptorCountAllocateInfo* forMarshaling);
void unmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDescriptorSetVariableDescriptorCountAllocateInfo* forUnmarshaling);
void marshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDescriptorSetVariableDescriptorCountLayoutSupport* forMarshaling);
void unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDescriptorSetVariableDescriptorCountLayoutSupport* forUnmarshaling);
void marshal_VkSubpassDescriptionDepthStencilResolve(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkSubpassDescriptionDepthStencilResolve* forMarshaling);
void unmarshal_VkSubpassDescriptionDepthStencilResolve(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkSubpassDescriptionDepthStencilResolve* forUnmarshaling);
void marshal_VkPhysicalDeviceDepthStencilResolveProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceDepthStencilResolveProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceDepthStencilResolveProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceDepthStencilResolveProperties* forUnmarshaling);
void marshal_VkPhysicalDeviceScalarBlockLayoutFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceScalarBlockLayoutFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceScalarBlockLayoutFeatures* forUnmarshaling);
-void marshal_VkImageStencilUsageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageStencilUsageCreateInfo* forMarshaling);
+void marshal_VkImageStencilUsageCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageStencilUsageCreateInfo* forMarshaling);
-void unmarshal_VkImageStencilUsageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageStencilUsageCreateInfo* forUnmarshaling);
+void unmarshal_VkImageStencilUsageCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageStencilUsageCreateInfo* forUnmarshaling);
void marshal_VkSamplerReductionModeCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkSamplerReductionModeCreateInfo* forMarshaling);
-void unmarshal_VkSamplerReductionModeCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSamplerReductionModeCreateInfo* forUnmarshaling);
+void unmarshal_VkSamplerReductionModeCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkSamplerReductionModeCreateInfo* forUnmarshaling);
void marshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceSamplerFilterMinmaxProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceSamplerFilterMinmaxProperties* forUnmarshaling);
void marshal_VkPhysicalDeviceVulkanMemoryModelFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceVulkanMemoryModelFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceVulkanMemoryModelFeatures* forUnmarshaling);
void marshal_VkPhysicalDeviceImagelessFramebufferFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceImagelessFramebufferFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceImagelessFramebufferFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceImagelessFramebufferFeatures* forUnmarshaling);
void marshal_VkFramebufferAttachmentImageInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkFramebufferAttachmentImageInfo* forMarshaling);
-void unmarshal_VkFramebufferAttachmentImageInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkFramebufferAttachmentImageInfo* forUnmarshaling);
+void unmarshal_VkFramebufferAttachmentImageInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkFramebufferAttachmentImageInfo* forUnmarshaling);
void marshal_VkFramebufferAttachmentsCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkFramebufferAttachmentsCreateInfo* forMarshaling);
void unmarshal_VkFramebufferAttachmentsCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkFramebufferAttachmentsCreateInfo* forUnmarshaling);
-void marshal_VkRenderPassAttachmentBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassAttachmentBeginInfo* forMarshaling);
+void marshal_VkRenderPassAttachmentBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassAttachmentBeginInfo* forMarshaling);
-void unmarshal_VkRenderPassAttachmentBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRenderPassAttachmentBeginInfo* forUnmarshaling);
+void unmarshal_VkRenderPassAttachmentBeginInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkRenderPassAttachmentBeginInfo* forUnmarshaling);
void marshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceUniformBufferStandardLayoutFeatures* forUnmarshaling);
void marshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* forUnmarshaling);
void marshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* forUnmarshaling);
void marshal_VkAttachmentReferenceStencilLayout(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAttachmentReferenceStencilLayout* forMarshaling);
void unmarshal_VkAttachmentReferenceStencilLayout(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAttachmentReferenceStencilLayout* forUnmarshaling);
void marshal_VkAttachmentDescriptionStencilLayout(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAttachmentDescriptionStencilLayout* forMarshaling);
void unmarshal_VkAttachmentDescriptionStencilLayout(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAttachmentDescriptionStencilLayout* forUnmarshaling);
void marshal_VkPhysicalDeviceHostQueryResetFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceHostQueryResetFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceHostQueryResetFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceHostQueryResetFeatures* forUnmarshaling);
#define OP_vkResetQueryPool 252097672
void marshal_VkPhysicalDeviceTimelineSemaphoreFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceTimelineSemaphoreFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceTimelineSemaphoreFeatures* forUnmarshaling);
void marshal_VkPhysicalDeviceTimelineSemaphoreProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceTimelineSemaphoreProperties* forMarshaling);
void unmarshal_VkPhysicalDeviceTimelineSemaphoreProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceTimelineSemaphoreProperties* forUnmarshaling);
-void marshal_VkSemaphoreTypeCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreTypeCreateInfo* forMarshaling);
+void marshal_VkSemaphoreTypeCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreTypeCreateInfo* forMarshaling);
-void unmarshal_VkSemaphoreTypeCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSemaphoreTypeCreateInfo* forUnmarshaling);
+void unmarshal_VkSemaphoreTypeCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSemaphoreTypeCreateInfo* forUnmarshaling);
-void marshal_VkTimelineSemaphoreSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkTimelineSemaphoreSubmitInfo* forMarshaling);
+void marshal_VkTimelineSemaphoreSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkTimelineSemaphoreSubmitInfo* forMarshaling);
-void unmarshal_VkTimelineSemaphoreSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkTimelineSemaphoreSubmitInfo* forUnmarshaling);
+void unmarshal_VkTimelineSemaphoreSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkTimelineSemaphoreSubmitInfo* forUnmarshaling);
-void marshal_VkSemaphoreWaitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreWaitInfo* forMarshaling);
+void marshal_VkSemaphoreWaitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreWaitInfo* forMarshaling);
-void unmarshal_VkSemaphoreWaitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSemaphoreWaitInfo* forUnmarshaling);
+void unmarshal_VkSemaphoreWaitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSemaphoreWaitInfo* forUnmarshaling);
-void marshal_VkSemaphoreSignalInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreSignalInfo* forMarshaling);
+void marshal_VkSemaphoreSignalInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreSignalInfo* forMarshaling);
-void unmarshal_VkSemaphoreSignalInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSemaphoreSignalInfo* forUnmarshaling);
+void unmarshal_VkSemaphoreSignalInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSemaphoreSignalInfo* forUnmarshaling);
#define OP_vkGetSemaphoreCounterValue 267066974
#define OP_vkWaitSemaphores 224777382
#define OP_vkSignalSemaphore 271024127
void marshal_VkPhysicalDeviceBufferDeviceAddressFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceBufferDeviceAddressFeatures* forMarshaling);
void unmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceBufferDeviceAddressFeatures* forUnmarshaling);
-void marshal_VkBufferDeviceAddressInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferDeviceAddressInfo* forMarshaling);
+void marshal_VkBufferDeviceAddressInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferDeviceAddressInfo* forMarshaling);
-void unmarshal_VkBufferDeviceAddressInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferDeviceAddressInfo* forUnmarshaling);
+void unmarshal_VkBufferDeviceAddressInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferDeviceAddressInfo* forUnmarshaling);
void marshal_VkBufferOpaqueCaptureAddressCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkBufferOpaqueCaptureAddressCreateInfo* forMarshaling);
void unmarshal_VkBufferOpaqueCaptureAddressCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkBufferOpaqueCaptureAddressCreateInfo* forUnmarshaling);
void marshal_VkMemoryOpaqueCaptureAddressAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkMemoryOpaqueCaptureAddressAllocateInfo* forMarshaling);
void unmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkMemoryOpaqueCaptureAddressAllocateInfo* forUnmarshaling);
void marshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDeviceMemoryOpaqueCaptureAddressInfo* forMarshaling);
void unmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDeviceMemoryOpaqueCaptureAddressInfo* forUnmarshaling);
#define OP_vkGetBufferDeviceAddress 222632266
@@ -2527,25 +1790,17 @@
#define OP_vkGetDeviceMemoryOpaqueCaptureAddress 260620079
#endif
#ifdef VK_KHR_surface
-void marshal_VkSurfaceCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceCapabilitiesKHR* forMarshaling);
+void marshal_VkSurfaceCapabilitiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceCapabilitiesKHR* forMarshaling);
-void unmarshal_VkSurfaceCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSurfaceCapabilitiesKHR* forUnmarshaling);
+void unmarshal_VkSurfaceCapabilitiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSurfaceCapabilitiesKHR* forUnmarshaling);
-void marshal_VkSurfaceFormatKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceFormatKHR* forMarshaling);
+void marshal_VkSurfaceFormatKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceFormatKHR* forMarshaling);
-void unmarshal_VkSurfaceFormatKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSurfaceFormatKHR* forUnmarshaling);
+void unmarshal_VkSurfaceFormatKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSurfaceFormatKHR* forUnmarshaling);
#define OP_vkDestroySurfaceKHR 20165
#define OP_vkGetPhysicalDeviceSurfaceSupportKHR 20166
@@ -2554,89 +1809,63 @@
#define OP_vkGetPhysicalDeviceSurfacePresentModesKHR 20169
#endif
#ifdef VK_KHR_swapchain
-void marshal_VkSwapchainCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSwapchainCreateInfoKHR* forMarshaling);
+void marshal_VkSwapchainCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSwapchainCreateInfoKHR* forMarshaling);
-void unmarshal_VkSwapchainCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSwapchainCreateInfoKHR* forUnmarshaling);
+void unmarshal_VkSwapchainCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSwapchainCreateInfoKHR* forUnmarshaling);
-void marshal_VkPresentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentInfoKHR* forMarshaling);
+void marshal_VkPresentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentInfoKHR* forMarshaling);
-void unmarshal_VkPresentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPresentInfoKHR* forUnmarshaling);
+void unmarshal_VkPresentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPresentInfoKHR* forUnmarshaling);
#define OP_vkCreateSwapchainKHR 20170
#define OP_vkDestroySwapchainKHR 20171
#define OP_vkGetSwapchainImagesKHR 20172
#define OP_vkAcquireNextImageKHR 20173
#define OP_vkQueuePresentKHR 20174
-void marshal_VkImageSwapchainCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageSwapchainCreateInfoKHR* forMarshaling);
+void marshal_VkImageSwapchainCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSwapchainCreateInfoKHR* forMarshaling);
-void unmarshal_VkImageSwapchainCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageSwapchainCreateInfoKHR* forUnmarshaling);
+void unmarshal_VkImageSwapchainCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageSwapchainCreateInfoKHR* forUnmarshaling);
void marshal_VkBindImageMemorySwapchainInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkBindImageMemorySwapchainInfoKHR* forMarshaling);
void unmarshal_VkBindImageMemorySwapchainInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkBindImageMemorySwapchainInfoKHR* forUnmarshaling);
-void marshal_VkAcquireNextImageInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAcquireNextImageInfoKHR* forMarshaling);
+void marshal_VkAcquireNextImageInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAcquireNextImageInfoKHR* forMarshaling);
-void unmarshal_VkAcquireNextImageInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAcquireNextImageInfoKHR* forUnmarshaling);
+void unmarshal_VkAcquireNextImageInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAcquireNextImageInfoKHR* forUnmarshaling);
void marshal_VkDeviceGroupPresentCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDeviceGroupPresentCapabilitiesKHR* forMarshaling);
void unmarshal_VkDeviceGroupPresentCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDeviceGroupPresentCapabilitiesKHR* forUnmarshaling);
-void marshal_VkDeviceGroupPresentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupPresentInfoKHR* forMarshaling);
+void marshal_VkDeviceGroupPresentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupPresentInfoKHR* forMarshaling);
-void unmarshal_VkDeviceGroupPresentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceGroupPresentInfoKHR* forUnmarshaling);
+void unmarshal_VkDeviceGroupPresentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceGroupPresentInfoKHR* forUnmarshaling);
void marshal_VkDeviceGroupSwapchainCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDeviceGroupSwapchainCreateInfoKHR* forMarshaling);
void unmarshal_VkDeviceGroupSwapchainCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDeviceGroupSwapchainCreateInfoKHR* forUnmarshaling);
#define OP_vkGetDeviceGroupPresentCapabilitiesKHR 20175
@@ -2645,75 +1874,47 @@
#define OP_vkAcquireNextImage2KHR 20178
#endif
#ifdef VK_KHR_display
-void marshal_VkDisplayModeParametersKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayModeParametersKHR* forMarshaling);
+void marshal_VkDisplayModeParametersKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayModeParametersKHR* forMarshaling);
-void unmarshal_VkDisplayModeParametersKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayModeParametersKHR* forUnmarshaling);
+void unmarshal_VkDisplayModeParametersKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayModeParametersKHR* forUnmarshaling);
-void marshal_VkDisplayModeCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayModeCreateInfoKHR* forMarshaling);
+void marshal_VkDisplayModeCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayModeCreateInfoKHR* forMarshaling);
-void unmarshal_VkDisplayModeCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayModeCreateInfoKHR* forUnmarshaling);
+void unmarshal_VkDisplayModeCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayModeCreateInfoKHR* forUnmarshaling);
-void marshal_VkDisplayModePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayModePropertiesKHR* forMarshaling);
+void marshal_VkDisplayModePropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayModePropertiesKHR* forMarshaling);
-void unmarshal_VkDisplayModePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayModePropertiesKHR* forUnmarshaling);
+void unmarshal_VkDisplayModePropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayModePropertiesKHR* forUnmarshaling);
-void marshal_VkDisplayPlaneCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPlaneCapabilitiesKHR* forMarshaling);
+void marshal_VkDisplayPlaneCapabilitiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPlaneCapabilitiesKHR* forMarshaling);
-void unmarshal_VkDisplayPlaneCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayPlaneCapabilitiesKHR* forUnmarshaling);
+void unmarshal_VkDisplayPlaneCapabilitiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayPlaneCapabilitiesKHR* forUnmarshaling);
-void marshal_VkDisplayPlanePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPlanePropertiesKHR* forMarshaling);
+void marshal_VkDisplayPlanePropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPlanePropertiesKHR* forMarshaling);
-void unmarshal_VkDisplayPlanePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayPlanePropertiesKHR* forUnmarshaling);
+void unmarshal_VkDisplayPlanePropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayPlanePropertiesKHR* forUnmarshaling);
-void marshal_VkDisplayPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPropertiesKHR* forMarshaling);
+void marshal_VkDisplayPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPropertiesKHR* forMarshaling);
-void unmarshal_VkDisplayPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayPropertiesKHR* forUnmarshaling);
+void unmarshal_VkDisplayPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayPropertiesKHR* forUnmarshaling);
-void marshal_VkDisplaySurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplaySurfaceCreateInfoKHR* forMarshaling);
+void marshal_VkDisplaySurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplaySurfaceCreateInfoKHR* forMarshaling);
-void unmarshal_VkDisplaySurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplaySurfaceCreateInfoKHR* forUnmarshaling);
+void unmarshal_VkDisplaySurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplaySurfaceCreateInfoKHR* forUnmarshaling);
#define OP_vkGetPhysicalDeviceDisplayPropertiesKHR 20179
#define OP_vkGetPhysicalDeviceDisplayPlanePropertiesKHR 20180
@@ -2724,83 +1925,59 @@
#define OP_vkCreateDisplayPlaneSurfaceKHR 20185
#endif
#ifdef VK_KHR_display_swapchain
-void marshal_VkDisplayPresentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPresentInfoKHR* forMarshaling);
+void marshal_VkDisplayPresentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPresentInfoKHR* forMarshaling);
-void unmarshal_VkDisplayPresentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayPresentInfoKHR* forUnmarshaling);
+void unmarshal_VkDisplayPresentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayPresentInfoKHR* forUnmarshaling);
#define OP_vkCreateSharedSwapchainsKHR 20186
#endif
#ifdef VK_KHR_xlib_surface
-void marshal_VkXlibSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkXlibSurfaceCreateInfoKHR* forMarshaling);
+void marshal_VkXlibSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkXlibSurfaceCreateInfoKHR* forMarshaling);
-void unmarshal_VkXlibSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkXlibSurfaceCreateInfoKHR* forUnmarshaling);
+void unmarshal_VkXlibSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkXlibSurfaceCreateInfoKHR* forUnmarshaling);
#define OP_vkCreateXlibSurfaceKHR 20187
#define OP_vkGetPhysicalDeviceXlibPresentationSupportKHR 20188
#endif
#ifdef VK_KHR_xcb_surface
-void marshal_VkXcbSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkXcbSurfaceCreateInfoKHR* forMarshaling);
+void marshal_VkXcbSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkXcbSurfaceCreateInfoKHR* forMarshaling);
-void unmarshal_VkXcbSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkXcbSurfaceCreateInfoKHR* forUnmarshaling);
+void unmarshal_VkXcbSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkXcbSurfaceCreateInfoKHR* forUnmarshaling);
#define OP_vkCreateXcbSurfaceKHR 20189
#define OP_vkGetPhysicalDeviceXcbPresentationSupportKHR 20190
#endif
#ifdef VK_KHR_wayland_surface
-void marshal_VkWaylandSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWaylandSurfaceCreateInfoKHR* forMarshaling);
+void marshal_VkWaylandSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWaylandSurfaceCreateInfoKHR* forMarshaling);
-void unmarshal_VkWaylandSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkWaylandSurfaceCreateInfoKHR* forUnmarshaling);
+void unmarshal_VkWaylandSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkWaylandSurfaceCreateInfoKHR* forUnmarshaling);
#define OP_vkCreateWaylandSurfaceKHR 20191
#define OP_vkGetPhysicalDeviceWaylandPresentationSupportKHR 20192
#endif
#ifdef VK_KHR_android_surface
-void marshal_VkAndroidSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAndroidSurfaceCreateInfoKHR* forMarshaling);
+void marshal_VkAndroidSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAndroidSurfaceCreateInfoKHR* forMarshaling);
-void unmarshal_VkAndroidSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAndroidSurfaceCreateInfoKHR* forUnmarshaling);
+void unmarshal_VkAndroidSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAndroidSurfaceCreateInfoKHR* forUnmarshaling);
#define OP_vkCreateAndroidSurfaceKHR 20195
#endif
#ifdef VK_KHR_win32_surface
-void marshal_VkWin32SurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWin32SurfaceCreateInfoKHR* forMarshaling);
+void marshal_VkWin32SurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWin32SurfaceCreateInfoKHR* forMarshaling);
-void unmarshal_VkWin32SurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkWin32SurfaceCreateInfoKHR* forUnmarshaling);
+void unmarshal_VkWin32SurfaceCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkWin32SurfaceCreateInfoKHR* forUnmarshaling);
#define OP_vkCreateWin32SurfaceKHR 20196
#define OP_vkGetPhysicalDeviceWin32PresentationSupportKHR 20197
@@ -2809,164 +1986,108 @@
#endif
#ifdef VK_KHR_video_queue
void marshal_VkVideoQueueFamilyProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoQueueFamilyProperties2KHR* forMarshaling);
-void unmarshal_VkVideoQueueFamilyProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoQueueFamilyProperties2KHR* forUnmarshaling);
+void unmarshal_VkVideoQueueFamilyProperties2KHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoQueueFamilyProperties2KHR* forUnmarshaling);
-void marshal_VkVideoProfileKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoProfileKHR* forMarshaling);
+void marshal_VkVideoProfileKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoProfileKHR* forMarshaling);
-void unmarshal_VkVideoProfileKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoProfileKHR* forUnmarshaling);
+void unmarshal_VkVideoProfileKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoProfileKHR* forUnmarshaling);
-void marshal_VkVideoProfilesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoProfilesKHR* forMarshaling);
+void marshal_VkVideoProfilesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoProfilesKHR* forMarshaling);
-void unmarshal_VkVideoProfilesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoProfilesKHR* forUnmarshaling);
+void unmarshal_VkVideoProfilesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoProfilesKHR* forUnmarshaling);
-void marshal_VkVideoCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoCapabilitiesKHR* forMarshaling);
+void marshal_VkVideoCapabilitiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoCapabilitiesKHR* forMarshaling);
-void unmarshal_VkVideoCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoCapabilitiesKHR* forUnmarshaling);
+void unmarshal_VkVideoCapabilitiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoCapabilitiesKHR* forUnmarshaling);
void marshal_VkPhysicalDeviceVideoFormatInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceVideoFormatInfoKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceVideoFormatInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceVideoFormatInfoKHR* forUnmarshaling);
-void marshal_VkVideoFormatPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoFormatPropertiesKHR* forMarshaling);
+void marshal_VkVideoFormatPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoFormatPropertiesKHR* forMarshaling);
-void unmarshal_VkVideoFormatPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoFormatPropertiesKHR* forUnmarshaling);
+void unmarshal_VkVideoFormatPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoFormatPropertiesKHR* forUnmarshaling);
-void marshal_VkVideoPictureResourceKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoPictureResourceKHR* forMarshaling);
+void marshal_VkVideoPictureResourceKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoPictureResourceKHR* forMarshaling);
-void unmarshal_VkVideoPictureResourceKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoPictureResourceKHR* forUnmarshaling);
+void unmarshal_VkVideoPictureResourceKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoPictureResourceKHR* forUnmarshaling);
-void marshal_VkVideoReferenceSlotKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoReferenceSlotKHR* forMarshaling);
+void marshal_VkVideoReferenceSlotKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoReferenceSlotKHR* forMarshaling);
-void unmarshal_VkVideoReferenceSlotKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoReferenceSlotKHR* forUnmarshaling);
+void unmarshal_VkVideoReferenceSlotKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoReferenceSlotKHR* forUnmarshaling);
-void marshal_VkVideoGetMemoryPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoGetMemoryPropertiesKHR* forMarshaling);
+void marshal_VkVideoGetMemoryPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoGetMemoryPropertiesKHR* forMarshaling);
-void unmarshal_VkVideoGetMemoryPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoGetMemoryPropertiesKHR* forUnmarshaling);
+void unmarshal_VkVideoGetMemoryPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoGetMemoryPropertiesKHR* forUnmarshaling);
-void marshal_VkVideoBindMemoryKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoBindMemoryKHR* forMarshaling);
+void marshal_VkVideoBindMemoryKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoBindMemoryKHR* forMarshaling);
-void unmarshal_VkVideoBindMemoryKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoBindMemoryKHR* forUnmarshaling);
+void unmarshal_VkVideoBindMemoryKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoBindMemoryKHR* forUnmarshaling);
-void marshal_VkVideoSessionCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoSessionCreateInfoKHR* forMarshaling);
+void marshal_VkVideoSessionCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoSessionCreateInfoKHR* forMarshaling);
-void unmarshal_VkVideoSessionCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoSessionCreateInfoKHR* forUnmarshaling);
+void unmarshal_VkVideoSessionCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoSessionCreateInfoKHR* forUnmarshaling);
void marshal_VkVideoSessionParametersCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoSessionParametersCreateInfoKHR* forMarshaling);
void unmarshal_VkVideoSessionParametersCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVideoSessionParametersCreateInfoKHR* forUnmarshaling);
void marshal_VkVideoSessionParametersUpdateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoSessionParametersUpdateInfoKHR* forMarshaling);
void unmarshal_VkVideoSessionParametersUpdateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVideoSessionParametersUpdateInfoKHR* forUnmarshaling);
-void marshal_VkVideoBeginCodingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoBeginCodingInfoKHR* forMarshaling);
+void marshal_VkVideoBeginCodingInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoBeginCodingInfoKHR* forMarshaling);
-void unmarshal_VkVideoBeginCodingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoBeginCodingInfoKHR* forUnmarshaling);
+void unmarshal_VkVideoBeginCodingInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoBeginCodingInfoKHR* forUnmarshaling);
-void marshal_VkVideoEndCodingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEndCodingInfoKHR* forMarshaling);
+void marshal_VkVideoEndCodingInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEndCodingInfoKHR* forMarshaling);
-void unmarshal_VkVideoEndCodingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEndCodingInfoKHR* forUnmarshaling);
+void unmarshal_VkVideoEndCodingInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEndCodingInfoKHR* forUnmarshaling);
-void marshal_VkVideoCodingControlInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoCodingControlInfoKHR* forMarshaling);
+void marshal_VkVideoCodingControlInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoCodingControlInfoKHR* forMarshaling);
-void unmarshal_VkVideoCodingControlInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoCodingControlInfoKHR* forUnmarshaling);
+void unmarshal_VkVideoCodingControlInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoCodingControlInfoKHR* forUnmarshaling);
#define OP_vkGetPhysicalDeviceVideoCapabilitiesKHR 248113462
#define OP_vkGetPhysicalDeviceVideoFormatPropertiesKHR 261873967
@@ -2982,128 +2103,107 @@
#define OP_vkCmdControlVideoCodingKHR 252933003
#endif
#ifdef VK_KHR_video_decode_queue
-void marshal_VkVideoDecodeInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeInfoKHR* forMarshaling);
+void marshal_VkVideoDecodeInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeInfoKHR* forMarshaling);
-void unmarshal_VkVideoDecodeInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeInfoKHR* forUnmarshaling);
+void unmarshal_VkVideoDecodeInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoDecodeInfoKHR* forUnmarshaling);
#define OP_vkCmdDecodeVideoKHR 275796951
#endif
#ifdef VK_KHR_dynamic_rendering
-void marshal_VkRenderingAttachmentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderingAttachmentInfoKHR* forMarshaling);
+void marshal_VkRenderingAttachmentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingAttachmentInfoKHR* forMarshaling);
-void unmarshal_VkRenderingAttachmentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRenderingAttachmentInfoKHR* forUnmarshaling);
+void unmarshal_VkRenderingAttachmentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderingAttachmentInfoKHR* forUnmarshaling);
-void marshal_VkRenderingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderingInfoKHR* forMarshaling);
+void marshal_VkRenderingInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingInfoKHR* forMarshaling);
-void unmarshal_VkRenderingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRenderingInfoKHR* forUnmarshaling);
+void unmarshal_VkRenderingInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRenderingInfoKHR* forUnmarshaling);
void marshal_VkPipelineRenderingCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineRenderingCreateInfoKHR* forMarshaling);
-void unmarshal_VkPipelineRenderingCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineRenderingCreateInfoKHR* forUnmarshaling);
+void unmarshal_VkPipelineRenderingCreateInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPipelineRenderingCreateInfoKHR* forUnmarshaling);
void marshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceDynamicRenderingFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceDynamicRenderingFeaturesKHR* forUnmarshaling);
void marshal_VkCommandBufferInheritanceRenderingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkCommandBufferInheritanceRenderingInfoKHR* forMarshaling);
void unmarshal_VkCommandBufferInheritanceRenderingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkCommandBufferInheritanceRenderingInfoKHR* forUnmarshaling);
#define OP_vkCmdBeginRenderingKHR 298092805
#define OP_vkCmdEndRenderingKHR 200651584
void marshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkRenderingFragmentShadingRateAttachmentInfoKHR* forMarshaling);
void unmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkRenderingFragmentShadingRateAttachmentInfoKHR* forUnmarshaling);
void marshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkRenderingFragmentDensityMapAttachmentInfoEXT* forMarshaling);
void unmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkRenderingFragmentDensityMapAttachmentInfoEXT* forUnmarshaling);
-void marshal_VkAttachmentSampleCountInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentSampleCountInfoAMD* forMarshaling);
+void marshal_VkAttachmentSampleCountInfoAMD(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentSampleCountInfoAMD* forMarshaling);
-void unmarshal_VkAttachmentSampleCountInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAttachmentSampleCountInfoAMD* forUnmarshaling);
+void unmarshal_VkAttachmentSampleCountInfoAMD(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAttachmentSampleCountInfoAMD* forUnmarshaling);
DEFINE_ALIAS_FUNCTION(marshal_VkAttachmentSampleCountInfoAMD, marshal_VkAttachmentSampleCountInfoNV)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkAttachmentSampleCountInfoAMD, unmarshal_VkAttachmentSampleCountInfoNV)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkAttachmentSampleCountInfoAMD,
+ unmarshal_VkAttachmentSampleCountInfoNV)
void marshal_VkMultiviewPerViewAttributesInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkMultiviewPerViewAttributesInfoNVX* forMarshaling);
void unmarshal_VkMultiviewPerViewAttributesInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkMultiviewPerViewAttributesInfoNVX* forUnmarshaling);
#endif
#ifdef VK_KHR_multiview
-DEFINE_ALIAS_FUNCTION(marshal_VkRenderPassMultiviewCreateInfo, marshal_VkRenderPassMultiviewCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkRenderPassMultiviewCreateInfo,
+ marshal_VkRenderPassMultiviewCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkRenderPassMultiviewCreateInfo, unmarshal_VkRenderPassMultiviewCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkRenderPassMultiviewCreateInfo,
+ unmarshal_VkRenderPassMultiviewCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceMultiviewFeatures, marshal_VkPhysicalDeviceMultiviewFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceMultiviewFeatures,
+ marshal_VkPhysicalDeviceMultiviewFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceMultiviewFeatures, unmarshal_VkPhysicalDeviceMultiviewFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceMultiviewFeatures,
+ unmarshal_VkPhysicalDeviceMultiviewFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceMultiviewProperties, marshal_VkPhysicalDeviceMultiviewPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceMultiviewProperties,
+ marshal_VkPhysicalDeviceMultiviewPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceMultiviewProperties, unmarshal_VkPhysicalDeviceMultiviewPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceMultiviewProperties,
+ unmarshal_VkPhysicalDeviceMultiviewPropertiesKHR)
#endif
#ifdef VK_KHR_get_physical_device_properties2
@@ -3113,7 +2213,8 @@
DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceProperties2, marshal_VkPhysicalDeviceProperties2KHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceProperties2, unmarshal_VkPhysicalDeviceProperties2KHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceProperties2,
+ unmarshal_VkPhysicalDeviceProperties2KHR)
DEFINE_ALIAS_FUNCTION(marshal_VkFormatProperties2, marshal_VkFormatProperties2KHR)
@@ -3123,25 +2224,33 @@
DEFINE_ALIAS_FUNCTION(unmarshal_VkImageFormatProperties2, unmarshal_VkImageFormatProperties2KHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceImageFormatInfo2, marshal_VkPhysicalDeviceImageFormatInfo2KHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceImageFormatInfo2,
+ marshal_VkPhysicalDeviceImageFormatInfo2KHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceImageFormatInfo2, unmarshal_VkPhysicalDeviceImageFormatInfo2KHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceImageFormatInfo2,
+ unmarshal_VkPhysicalDeviceImageFormatInfo2KHR)
DEFINE_ALIAS_FUNCTION(marshal_VkQueueFamilyProperties2, marshal_VkQueueFamilyProperties2KHR)
DEFINE_ALIAS_FUNCTION(unmarshal_VkQueueFamilyProperties2, unmarshal_VkQueueFamilyProperties2KHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceMemoryProperties2, marshal_VkPhysicalDeviceMemoryProperties2KHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceMemoryProperties2,
+ marshal_VkPhysicalDeviceMemoryProperties2KHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceMemoryProperties2, unmarshal_VkPhysicalDeviceMemoryProperties2KHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceMemoryProperties2,
+ unmarshal_VkPhysicalDeviceMemoryProperties2KHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkSparseImageFormatProperties2, marshal_VkSparseImageFormatProperties2KHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkSparseImageFormatProperties2,
+ marshal_VkSparseImageFormatProperties2KHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkSparseImageFormatProperties2, unmarshal_VkSparseImageFormatProperties2KHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkSparseImageFormatProperties2,
+ unmarshal_VkSparseImageFormatProperties2KHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceSparseImageFormatInfo2, marshal_VkPhysicalDeviceSparseImageFormatInfo2KHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceSparseImageFormatInfo2,
+ marshal_VkPhysicalDeviceSparseImageFormatInfo2KHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceSparseImageFormatInfo2, unmarshal_VkPhysicalDeviceSparseImageFormatInfo2KHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceSparseImageFormatInfo2,
+ unmarshal_VkPhysicalDeviceSparseImageFormatInfo2KHR)
#define OP_vkGetPhysicalDeviceFeatures2KHR 20198
#define OP_vkGetPhysicalDeviceProperties2KHR 20199
@@ -3156,13 +2265,17 @@
DEFINE_ALIAS_FUNCTION(unmarshal_VkMemoryAllocateFlagsInfo, unmarshal_VkMemoryAllocateFlagsInfoKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkDeviceGroupRenderPassBeginInfo, marshal_VkDeviceGroupRenderPassBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkDeviceGroupRenderPassBeginInfo,
+ marshal_VkDeviceGroupRenderPassBeginInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkDeviceGroupRenderPassBeginInfo, unmarshal_VkDeviceGroupRenderPassBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkDeviceGroupRenderPassBeginInfo,
+ unmarshal_VkDeviceGroupRenderPassBeginInfoKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkDeviceGroupCommandBufferBeginInfo, marshal_VkDeviceGroupCommandBufferBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkDeviceGroupCommandBufferBeginInfo,
+ marshal_VkDeviceGroupCommandBufferBeginInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkDeviceGroupCommandBufferBeginInfo, unmarshal_VkDeviceGroupCommandBufferBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkDeviceGroupCommandBufferBeginInfo,
+ unmarshal_VkDeviceGroupCommandBufferBeginInfoKHR)
DEFINE_ALIAS_FUNCTION(marshal_VkDeviceGroupSubmitInfo, marshal_VkDeviceGroupSubmitInfoKHR)
@@ -3170,18 +2283,23 @@
DEFINE_ALIAS_FUNCTION(marshal_VkDeviceGroupBindSparseInfo, marshal_VkDeviceGroupBindSparseInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkDeviceGroupBindSparseInfo, unmarshal_VkDeviceGroupBindSparseInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkDeviceGroupBindSparseInfo,
+ unmarshal_VkDeviceGroupBindSparseInfoKHR)
#define OP_vkGetDeviceGroupPeerMemoryFeaturesKHR 20205
#define OP_vkCmdSetDeviceMaskKHR 20206
#define OP_vkCmdDispatchBaseKHR 20207
-DEFINE_ALIAS_FUNCTION(marshal_VkBindBufferMemoryDeviceGroupInfo, marshal_VkBindBufferMemoryDeviceGroupInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkBindBufferMemoryDeviceGroupInfo,
+ marshal_VkBindBufferMemoryDeviceGroupInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkBindBufferMemoryDeviceGroupInfo, unmarshal_VkBindBufferMemoryDeviceGroupInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkBindBufferMemoryDeviceGroupInfo,
+ unmarshal_VkBindBufferMemoryDeviceGroupInfoKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkBindImageMemoryDeviceGroupInfo, marshal_VkBindImageMemoryDeviceGroupInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkBindImageMemoryDeviceGroupInfo,
+ marshal_VkBindImageMemoryDeviceGroupInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkBindImageMemoryDeviceGroupInfo, unmarshal_VkBindImageMemoryDeviceGroupInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkBindImageMemoryDeviceGroupInfo,
+ unmarshal_VkBindImageMemoryDeviceGroupInfoKHR)
#endif
#ifdef VK_KHR_shader_draw_parameters
@@ -3190,13 +2308,17 @@
#define OP_vkTrimCommandPoolKHR 20208
#endif
#ifdef VK_KHR_device_group_creation
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceGroupProperties, marshal_VkPhysicalDeviceGroupPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceGroupProperties,
+ marshal_VkPhysicalDeviceGroupPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceGroupProperties, unmarshal_VkPhysicalDeviceGroupPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceGroupProperties,
+ unmarshal_VkPhysicalDeviceGroupPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkDeviceGroupDeviceCreateInfo, marshal_VkDeviceGroupDeviceCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkDeviceGroupDeviceCreateInfo,
+ marshal_VkDeviceGroupDeviceCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkDeviceGroupDeviceCreateInfo, unmarshal_VkDeviceGroupDeviceCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkDeviceGroupDeviceCreateInfo,
+ unmarshal_VkDeviceGroupDeviceCreateInfoKHR)
#define OP_vkEnumeratePhysicalDeviceGroupsKHR 20209
#endif
@@ -3205,17 +2327,23 @@
DEFINE_ALIAS_FUNCTION(unmarshal_VkExternalMemoryProperties, unmarshal_VkExternalMemoryPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceExternalImageFormatInfo, marshal_VkPhysicalDeviceExternalImageFormatInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceExternalImageFormatInfo,
+ marshal_VkPhysicalDeviceExternalImageFormatInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceExternalImageFormatInfo, unmarshal_VkPhysicalDeviceExternalImageFormatInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceExternalImageFormatInfo,
+ unmarshal_VkPhysicalDeviceExternalImageFormatInfoKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkExternalImageFormatProperties, marshal_VkExternalImageFormatPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkExternalImageFormatProperties,
+ marshal_VkExternalImageFormatPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkExternalImageFormatProperties, unmarshal_VkExternalImageFormatPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkExternalImageFormatProperties,
+ unmarshal_VkExternalImageFormatPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceExternalBufferInfo, marshal_VkPhysicalDeviceExternalBufferInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceExternalBufferInfo,
+ marshal_VkPhysicalDeviceExternalBufferInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceExternalBufferInfo, unmarshal_VkPhysicalDeviceExternalBufferInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceExternalBufferInfo,
+ unmarshal_VkPhysicalDeviceExternalBufferInfoKHR)
DEFINE_ALIAS_FUNCTION(marshal_VkExternalBufferProperties, marshal_VkExternalBufferPropertiesKHR)
@@ -3223,18 +2351,23 @@
DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceIDProperties, marshal_VkPhysicalDeviceIDPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceIDProperties, unmarshal_VkPhysicalDeviceIDPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceIDProperties,
+ unmarshal_VkPhysicalDeviceIDPropertiesKHR)
#define OP_vkGetPhysicalDeviceExternalBufferPropertiesKHR 20210
#endif
#ifdef VK_KHR_external_memory
-DEFINE_ALIAS_FUNCTION(marshal_VkExternalMemoryImageCreateInfo, marshal_VkExternalMemoryImageCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkExternalMemoryImageCreateInfo,
+ marshal_VkExternalMemoryImageCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkExternalMemoryImageCreateInfo, unmarshal_VkExternalMemoryImageCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkExternalMemoryImageCreateInfo,
+ unmarshal_VkExternalMemoryImageCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkExternalMemoryBufferCreateInfo, marshal_VkExternalMemoryBufferCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkExternalMemoryBufferCreateInfo,
+ marshal_VkExternalMemoryBufferCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkExternalMemoryBufferCreateInfo, unmarshal_VkExternalMemoryBufferCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkExternalMemoryBufferCreateInfo,
+ unmarshal_VkExternalMemoryBufferCreateInfoKHR)
DEFINE_ALIAS_FUNCTION(marshal_VkExportMemoryAllocateInfo, marshal_VkExportMemoryAllocateInfoKHR)
@@ -3243,270 +2376,237 @@
#endif
#ifdef VK_KHR_external_memory_win32
void marshal_VkImportMemoryWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkImportMemoryWin32HandleInfoKHR* forMarshaling);
-void unmarshal_VkImportMemoryWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportMemoryWin32HandleInfoKHR* forUnmarshaling);
+void unmarshal_VkImportMemoryWin32HandleInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkImportMemoryWin32HandleInfoKHR* forUnmarshaling);
void marshal_VkExportMemoryWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkExportMemoryWin32HandleInfoKHR* forMarshaling);
-void unmarshal_VkExportMemoryWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExportMemoryWin32HandleInfoKHR* forUnmarshaling);
+void unmarshal_VkExportMemoryWin32HandleInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkExportMemoryWin32HandleInfoKHR* forUnmarshaling);
void marshal_VkMemoryWin32HandlePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkMemoryWin32HandlePropertiesKHR* forMarshaling);
-void unmarshal_VkMemoryWin32HandlePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryWin32HandlePropertiesKHR* forUnmarshaling);
+void unmarshal_VkMemoryWin32HandlePropertiesKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkMemoryWin32HandlePropertiesKHR* forUnmarshaling);
-void marshal_VkMemoryGetWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryGetWin32HandleInfoKHR* forMarshaling);
+void marshal_VkMemoryGetWin32HandleInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryGetWin32HandleInfoKHR* forMarshaling);
-void unmarshal_VkMemoryGetWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryGetWin32HandleInfoKHR* forUnmarshaling);
+void unmarshal_VkMemoryGetWin32HandleInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryGetWin32HandleInfoKHR* forUnmarshaling);
#define OP_vkGetMemoryWin32HandleKHR 20211
#define OP_vkGetMemoryWin32HandlePropertiesKHR 20212
#endif
#ifdef VK_KHR_external_memory_fd
-void marshal_VkImportMemoryFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportMemoryFdInfoKHR* forMarshaling);
+void marshal_VkImportMemoryFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportMemoryFdInfoKHR* forMarshaling);
-void unmarshal_VkImportMemoryFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportMemoryFdInfoKHR* forUnmarshaling);
+void unmarshal_VkImportMemoryFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImportMemoryFdInfoKHR* forUnmarshaling);
-void marshal_VkMemoryFdPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryFdPropertiesKHR* forMarshaling);
+void marshal_VkMemoryFdPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryFdPropertiesKHR* forMarshaling);
-void unmarshal_VkMemoryFdPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryFdPropertiesKHR* forUnmarshaling);
+void unmarshal_VkMemoryFdPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryFdPropertiesKHR* forUnmarshaling);
-void marshal_VkMemoryGetFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryGetFdInfoKHR* forMarshaling);
+void marshal_VkMemoryGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryGetFdInfoKHR* forMarshaling);
-void unmarshal_VkMemoryGetFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryGetFdInfoKHR* forUnmarshaling);
+void unmarshal_VkMemoryGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryGetFdInfoKHR* forUnmarshaling);
#define OP_vkGetMemoryFdKHR 20213
#define OP_vkGetMemoryFdPropertiesKHR 20214
#endif
#ifdef VK_KHR_win32_keyed_mutex
void marshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkWin32KeyedMutexAcquireReleaseInfoKHR* forMarshaling);
void unmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkWin32KeyedMutexAcquireReleaseInfoKHR* forUnmarshaling);
#endif
#ifdef VK_KHR_external_semaphore_capabilities
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceExternalSemaphoreInfo, marshal_VkPhysicalDeviceExternalSemaphoreInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceExternalSemaphoreInfo,
+ marshal_VkPhysicalDeviceExternalSemaphoreInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceExternalSemaphoreInfo, unmarshal_VkPhysicalDeviceExternalSemaphoreInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceExternalSemaphoreInfo,
+ unmarshal_VkPhysicalDeviceExternalSemaphoreInfoKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkExternalSemaphoreProperties, marshal_VkExternalSemaphorePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkExternalSemaphoreProperties,
+ marshal_VkExternalSemaphorePropertiesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkExternalSemaphoreProperties, unmarshal_VkExternalSemaphorePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkExternalSemaphoreProperties,
+ unmarshal_VkExternalSemaphorePropertiesKHR)
#define OP_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR 20215
#endif
#ifdef VK_KHR_external_semaphore
DEFINE_ALIAS_FUNCTION(marshal_VkExportSemaphoreCreateInfo, marshal_VkExportSemaphoreCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkExportSemaphoreCreateInfo, unmarshal_VkExportSemaphoreCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkExportSemaphoreCreateInfo,
+ unmarshal_VkExportSemaphoreCreateInfoKHR)
#endif
#ifdef VK_KHR_external_semaphore_win32
void marshal_VkImportSemaphoreWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkImportSemaphoreWin32HandleInfoKHR* forMarshaling);
void unmarshal_VkImportSemaphoreWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkImportSemaphoreWin32HandleInfoKHR* forUnmarshaling);
void marshal_VkExportSemaphoreWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkExportSemaphoreWin32HandleInfoKHR* forMarshaling);
void unmarshal_VkExportSemaphoreWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkExportSemaphoreWin32HandleInfoKHR* forUnmarshaling);
-void marshal_VkD3D12FenceSubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkD3D12FenceSubmitInfoKHR* forMarshaling);
+void marshal_VkD3D12FenceSubmitInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkD3D12FenceSubmitInfoKHR* forMarshaling);
-void unmarshal_VkD3D12FenceSubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkD3D12FenceSubmitInfoKHR* forUnmarshaling);
+void unmarshal_VkD3D12FenceSubmitInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkD3D12FenceSubmitInfoKHR* forUnmarshaling);
void marshal_VkSemaphoreGetWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkSemaphoreGetWin32HandleInfoKHR* forMarshaling);
-void unmarshal_VkSemaphoreGetWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSemaphoreGetWin32HandleInfoKHR* forUnmarshaling);
+void unmarshal_VkSemaphoreGetWin32HandleInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkSemaphoreGetWin32HandleInfoKHR* forUnmarshaling);
#define OP_vkImportSemaphoreWin32HandleKHR 20216
#define OP_vkGetSemaphoreWin32HandleKHR 20217
#endif
#ifdef VK_KHR_external_semaphore_fd
-void marshal_VkImportSemaphoreFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportSemaphoreFdInfoKHR* forMarshaling);
+void marshal_VkImportSemaphoreFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportSemaphoreFdInfoKHR* forMarshaling);
-void unmarshal_VkImportSemaphoreFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportSemaphoreFdInfoKHR* forUnmarshaling);
+void unmarshal_VkImportSemaphoreFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImportSemaphoreFdInfoKHR* forUnmarshaling);
-void marshal_VkSemaphoreGetFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreGetFdInfoKHR* forMarshaling);
+void marshal_VkSemaphoreGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreGetFdInfoKHR* forMarshaling);
-void unmarshal_VkSemaphoreGetFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSemaphoreGetFdInfoKHR* forUnmarshaling);
+void unmarshal_VkSemaphoreGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSemaphoreGetFdInfoKHR* forUnmarshaling);
#define OP_vkImportSemaphoreFdKHR 20218
#define OP_vkGetSemaphoreFdKHR 20219
#endif
#ifdef VK_KHR_push_descriptor
void marshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDevicePushDescriptorPropertiesKHR* forMarshaling);
void unmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDevicePushDescriptorPropertiesKHR* forUnmarshaling);
#define OP_vkCmdPushDescriptorSetKHR 20220
#define OP_vkCmdPushDescriptorSetWithTemplateKHR 20221
#endif
#ifdef VK_KHR_shader_float16_int8
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceShaderFloat16Int8Features, marshal_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceShaderFloat16Int8Features,
+ marshal_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceShaderFloat16Int8Features, unmarshal_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceShaderFloat16Int8Features,
+ unmarshal_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceShaderFloat16Int8Features, marshal_VkPhysicalDeviceFloat16Int8FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceShaderFloat16Int8Features,
+ marshal_VkPhysicalDeviceFloat16Int8FeaturesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceShaderFloat16Int8Features, unmarshal_VkPhysicalDeviceFloat16Int8FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceShaderFloat16Int8Features,
+ unmarshal_VkPhysicalDeviceFloat16Int8FeaturesKHR)
#endif
#ifdef VK_KHR_16bit_storage
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDevice16BitStorageFeatures, marshal_VkPhysicalDevice16BitStorageFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDevice16BitStorageFeatures,
+ marshal_VkPhysicalDevice16BitStorageFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDevice16BitStorageFeatures, unmarshal_VkPhysicalDevice16BitStorageFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDevice16BitStorageFeatures,
+ unmarshal_VkPhysicalDevice16BitStorageFeaturesKHR)
#endif
#ifdef VK_KHR_incremental_present
-void marshal_VkRectLayerKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRectLayerKHR* forMarshaling);
+void marshal_VkRectLayerKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRectLayerKHR* forMarshaling);
-void unmarshal_VkRectLayerKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRectLayerKHR* forUnmarshaling);
+void unmarshal_VkRectLayerKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRectLayerKHR* forUnmarshaling);
-void marshal_VkPresentRegionKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentRegionKHR* forMarshaling);
+void marshal_VkPresentRegionKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentRegionKHR* forMarshaling);
-void unmarshal_VkPresentRegionKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPresentRegionKHR* forUnmarshaling);
+void unmarshal_VkPresentRegionKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPresentRegionKHR* forUnmarshaling);
-void marshal_VkPresentRegionsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentRegionsKHR* forMarshaling);
+void marshal_VkPresentRegionsKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentRegionsKHR* forMarshaling);
-void unmarshal_VkPresentRegionsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPresentRegionsKHR* forUnmarshaling);
+void unmarshal_VkPresentRegionsKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPresentRegionsKHR* forUnmarshaling);
#endif
#ifdef VK_KHR_descriptor_update_template
-DEFINE_ALIAS_FUNCTION(marshal_VkDescriptorUpdateTemplateEntry, marshal_VkDescriptorUpdateTemplateEntryKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkDescriptorUpdateTemplateEntry,
+ marshal_VkDescriptorUpdateTemplateEntryKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkDescriptorUpdateTemplateEntry, unmarshal_VkDescriptorUpdateTemplateEntryKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkDescriptorUpdateTemplateEntry,
+ unmarshal_VkDescriptorUpdateTemplateEntryKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkDescriptorUpdateTemplateCreateInfo, marshal_VkDescriptorUpdateTemplateCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkDescriptorUpdateTemplateCreateInfo,
+ marshal_VkDescriptorUpdateTemplateCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkDescriptorUpdateTemplateCreateInfo, unmarshal_VkDescriptorUpdateTemplateCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkDescriptorUpdateTemplateCreateInfo,
+ unmarshal_VkDescriptorUpdateTemplateCreateInfoKHR)
#define OP_vkCreateDescriptorUpdateTemplateKHR 20222
#define OP_vkDestroyDescriptorUpdateTemplateKHR 20223
#define OP_vkUpdateDescriptorSetWithTemplateKHR 20224
#endif
#ifdef VK_KHR_imageless_framebuffer
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceImagelessFramebufferFeatures, marshal_VkPhysicalDeviceImagelessFramebufferFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceImagelessFramebufferFeatures,
+ marshal_VkPhysicalDeviceImagelessFramebufferFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceImagelessFramebufferFeatures, unmarshal_VkPhysicalDeviceImagelessFramebufferFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceImagelessFramebufferFeatures,
+ unmarshal_VkPhysicalDeviceImagelessFramebufferFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkFramebufferAttachmentsCreateInfo, marshal_VkFramebufferAttachmentsCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkFramebufferAttachmentsCreateInfo,
+ marshal_VkFramebufferAttachmentsCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkFramebufferAttachmentsCreateInfo, unmarshal_VkFramebufferAttachmentsCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkFramebufferAttachmentsCreateInfo,
+ unmarshal_VkFramebufferAttachmentsCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkFramebufferAttachmentImageInfo, marshal_VkFramebufferAttachmentImageInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkFramebufferAttachmentImageInfo,
+ marshal_VkFramebufferAttachmentImageInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkFramebufferAttachmentImageInfo, unmarshal_VkFramebufferAttachmentImageInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkFramebufferAttachmentImageInfo,
+ unmarshal_VkFramebufferAttachmentImageInfoKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkRenderPassAttachmentBeginInfo, marshal_VkRenderPassAttachmentBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkRenderPassAttachmentBeginInfo,
+ marshal_VkRenderPassAttachmentBeginInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkRenderPassAttachmentBeginInfo, unmarshal_VkRenderPassAttachmentBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkRenderPassAttachmentBeginInfo,
+ unmarshal_VkRenderPassAttachmentBeginInfoKHR)
#endif
#ifdef VK_KHR_create_renderpass2
@@ -3545,21 +2645,21 @@
#endif
#ifdef VK_KHR_shared_presentable_image
void marshal_VkSharedPresentSurfaceCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkSharedPresentSurfaceCapabilitiesKHR* forMarshaling);
void unmarshal_VkSharedPresentSurfaceCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkSharedPresentSurfaceCapabilitiesKHR* forUnmarshaling);
#define OP_vkGetSwapchainStatusKHR 20229
#endif
#ifdef VK_KHR_external_fence_capabilities
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceExternalFenceInfo, marshal_VkPhysicalDeviceExternalFenceInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceExternalFenceInfo,
+ marshal_VkPhysicalDeviceExternalFenceInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceExternalFenceInfo, unmarshal_VkPhysicalDeviceExternalFenceInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceExternalFenceInfo,
+ unmarshal_VkPhysicalDeviceExternalFenceInfoKHR)
DEFINE_ALIAS_FUNCTION(marshal_VkExternalFenceProperties, marshal_VkExternalFencePropertiesKHR)
@@ -3574,143 +2674,102 @@
#endif
#ifdef VK_KHR_external_fence_win32
-void marshal_VkImportFenceWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportFenceWin32HandleInfoKHR* forMarshaling);
+void marshal_VkImportFenceWin32HandleInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportFenceWin32HandleInfoKHR* forMarshaling);
-void unmarshal_VkImportFenceWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportFenceWin32HandleInfoKHR* forUnmarshaling);
+void unmarshal_VkImportFenceWin32HandleInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkImportFenceWin32HandleInfoKHR* forUnmarshaling);
-void marshal_VkExportFenceWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportFenceWin32HandleInfoKHR* forMarshaling);
+void marshal_VkExportFenceWin32HandleInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportFenceWin32HandleInfoKHR* forMarshaling);
-void unmarshal_VkExportFenceWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExportFenceWin32HandleInfoKHR* forUnmarshaling);
+void unmarshal_VkExportFenceWin32HandleInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkExportFenceWin32HandleInfoKHR* forUnmarshaling);
-void marshal_VkFenceGetWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFenceGetWin32HandleInfoKHR* forMarshaling);
+void marshal_VkFenceGetWin32HandleInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFenceGetWin32HandleInfoKHR* forMarshaling);
-void unmarshal_VkFenceGetWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkFenceGetWin32HandleInfoKHR* forUnmarshaling);
+void unmarshal_VkFenceGetWin32HandleInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkFenceGetWin32HandleInfoKHR* forUnmarshaling);
#define OP_vkImportFenceWin32HandleKHR 20231
#define OP_vkGetFenceWin32HandleKHR 20232
#endif
#ifdef VK_KHR_external_fence_fd
-void marshal_VkImportFenceFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportFenceFdInfoKHR* forMarshaling);
+void marshal_VkImportFenceFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportFenceFdInfoKHR* forMarshaling);
-void unmarshal_VkImportFenceFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportFenceFdInfoKHR* forUnmarshaling);
+void unmarshal_VkImportFenceFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImportFenceFdInfoKHR* forUnmarshaling);
-void marshal_VkFenceGetFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFenceGetFdInfoKHR* forMarshaling);
+void marshal_VkFenceGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFenceGetFdInfoKHR* forMarshaling);
-void unmarshal_VkFenceGetFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkFenceGetFdInfoKHR* forUnmarshaling);
+void unmarshal_VkFenceGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkFenceGetFdInfoKHR* forUnmarshaling);
#define OP_vkImportFenceFdKHR 20233
#define OP_vkGetFenceFdKHR 20234
#endif
#ifdef VK_KHR_performance_query
void marshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDevicePerformanceQueryFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDevicePerformanceQueryFeaturesKHR* forUnmarshaling);
void marshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDevicePerformanceQueryPropertiesKHR* forMarshaling);
void unmarshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDevicePerformanceQueryPropertiesKHR* forUnmarshaling);
-void marshal_VkPerformanceCounterKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceCounterKHR* forMarshaling);
+void marshal_VkPerformanceCounterKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceCounterKHR* forMarshaling);
-void unmarshal_VkPerformanceCounterKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPerformanceCounterKHR* forUnmarshaling);
+void unmarshal_VkPerformanceCounterKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPerformanceCounterKHR* forUnmarshaling);
void marshal_VkPerformanceCounterDescriptionKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPerformanceCounterDescriptionKHR* forMarshaling);
void unmarshal_VkPerformanceCounterDescriptionKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPerformanceCounterDescriptionKHR* forUnmarshaling);
void marshal_VkQueryPoolPerformanceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkQueryPoolPerformanceCreateInfoKHR* forMarshaling);
void unmarshal_VkQueryPoolPerformanceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkQueryPoolPerformanceCreateInfoKHR* forUnmarshaling);
-void marshal_VkPerformanceCounterResultKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceCounterResultKHR* forMarshaling);
+void marshal_VkPerformanceCounterResultKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceCounterResultKHR* forMarshaling);
-void unmarshal_VkPerformanceCounterResultKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPerformanceCounterResultKHR* forUnmarshaling);
+void unmarshal_VkPerformanceCounterResultKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPerformanceCounterResultKHR* forUnmarshaling);
-void marshal_VkAcquireProfilingLockInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAcquireProfilingLockInfoKHR* forMarshaling);
+void marshal_VkAcquireProfilingLockInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAcquireProfilingLockInfoKHR* forMarshaling);
-void unmarshal_VkAcquireProfilingLockInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAcquireProfilingLockInfoKHR* forUnmarshaling);
+void unmarshal_VkAcquireProfilingLockInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAcquireProfilingLockInfoKHR* forUnmarshaling);
-void marshal_VkPerformanceQuerySubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceQuerySubmitInfoKHR* forMarshaling);
+void marshal_VkPerformanceQuerySubmitInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceQuerySubmitInfoKHR* forMarshaling);
-void unmarshal_VkPerformanceQuerySubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPerformanceQuerySubmitInfoKHR* forUnmarshaling);
+void unmarshal_VkPerformanceQuerySubmitInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPerformanceQuerySubmitInfoKHR* forUnmarshaling);
#define OP_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR 299033148
#define OP_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR 282029987
@@ -3718,121 +2777,102 @@
#define OP_vkReleaseProfilingLockKHR 223904011
#endif
#ifdef VK_KHR_maintenance2
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDevicePointClippingProperties, marshal_VkPhysicalDevicePointClippingPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDevicePointClippingProperties,
+ marshal_VkPhysicalDevicePointClippingPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDevicePointClippingProperties, unmarshal_VkPhysicalDevicePointClippingPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDevicePointClippingProperties,
+ unmarshal_VkPhysicalDevicePointClippingPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkRenderPassInputAttachmentAspectCreateInfo, marshal_VkRenderPassInputAttachmentAspectCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkRenderPassInputAttachmentAspectCreateInfo,
+ marshal_VkRenderPassInputAttachmentAspectCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkRenderPassInputAttachmentAspectCreateInfo, unmarshal_VkRenderPassInputAttachmentAspectCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkRenderPassInputAttachmentAspectCreateInfo,
+ unmarshal_VkRenderPassInputAttachmentAspectCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkInputAttachmentAspectReference, marshal_VkInputAttachmentAspectReferenceKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkInputAttachmentAspectReference,
+ marshal_VkInputAttachmentAspectReferenceKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkInputAttachmentAspectReference, unmarshal_VkInputAttachmentAspectReferenceKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkInputAttachmentAspectReference,
+ unmarshal_VkInputAttachmentAspectReferenceKHR)
DEFINE_ALIAS_FUNCTION(marshal_VkImageViewUsageCreateInfo, marshal_VkImageViewUsageCreateInfoKHR)
DEFINE_ALIAS_FUNCTION(unmarshal_VkImageViewUsageCreateInfo, unmarshal_VkImageViewUsageCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkPipelineTessellationDomainOriginStateCreateInfo, marshal_VkPipelineTessellationDomainOriginStateCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPipelineTessellationDomainOriginStateCreateInfo,
+ marshal_VkPipelineTessellationDomainOriginStateCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPipelineTessellationDomainOriginStateCreateInfo, unmarshal_VkPipelineTessellationDomainOriginStateCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPipelineTessellationDomainOriginStateCreateInfo,
+ unmarshal_VkPipelineTessellationDomainOriginStateCreateInfoKHR)
#endif
#ifdef VK_KHR_get_surface_capabilities2
-void marshal_VkPhysicalDeviceSurfaceInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSurfaceInfo2KHR* forMarshaling);
+void marshal_VkPhysicalDeviceSurfaceInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSurfaceInfo2KHR* forMarshaling);
-void unmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceSurfaceInfo2KHR* forUnmarshaling);
+void unmarshal_VkPhysicalDeviceSurfaceInfo2KHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPhysicalDeviceSurfaceInfo2KHR* forUnmarshaling);
-void marshal_VkSurfaceCapabilities2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceCapabilities2KHR* forMarshaling);
+void marshal_VkSurfaceCapabilities2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceCapabilities2KHR* forMarshaling);
-void unmarshal_VkSurfaceCapabilities2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSurfaceCapabilities2KHR* forUnmarshaling);
+void unmarshal_VkSurfaceCapabilities2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSurfaceCapabilities2KHR* forUnmarshaling);
-void marshal_VkSurfaceFormat2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceFormat2KHR* forMarshaling);
+void marshal_VkSurfaceFormat2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceFormat2KHR* forMarshaling);
-void unmarshal_VkSurfaceFormat2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSurfaceFormat2KHR* forUnmarshaling);
+void unmarshal_VkSurfaceFormat2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSurfaceFormat2KHR* forUnmarshaling);
#define OP_vkGetPhysicalDeviceSurfaceCapabilities2KHR 20235
#define OP_vkGetPhysicalDeviceSurfaceFormats2KHR 20236
#endif
#ifdef VK_KHR_variable_pointers
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceVariablePointersFeatures, marshal_VkPhysicalDeviceVariablePointerFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceVariablePointersFeatures,
+ marshal_VkPhysicalDeviceVariablePointerFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceVariablePointersFeatures, unmarshal_VkPhysicalDeviceVariablePointerFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceVariablePointersFeatures,
+ unmarshal_VkPhysicalDeviceVariablePointerFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceVariablePointersFeatures, marshal_VkPhysicalDeviceVariablePointersFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceVariablePointersFeatures,
+ marshal_VkPhysicalDeviceVariablePointersFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceVariablePointersFeatures, unmarshal_VkPhysicalDeviceVariablePointersFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceVariablePointersFeatures,
+ unmarshal_VkPhysicalDeviceVariablePointersFeaturesKHR)
#endif
#ifdef VK_KHR_get_display_properties2
-void marshal_VkDisplayProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayProperties2KHR* forMarshaling);
+void marshal_VkDisplayProperties2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayProperties2KHR* forMarshaling);
-void unmarshal_VkDisplayProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayProperties2KHR* forUnmarshaling);
+void unmarshal_VkDisplayProperties2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayProperties2KHR* forUnmarshaling);
-void marshal_VkDisplayPlaneProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPlaneProperties2KHR* forMarshaling);
+void marshal_VkDisplayPlaneProperties2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPlaneProperties2KHR* forMarshaling);
-void unmarshal_VkDisplayPlaneProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayPlaneProperties2KHR* forUnmarshaling);
+void unmarshal_VkDisplayPlaneProperties2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayPlaneProperties2KHR* forUnmarshaling);
-void marshal_VkDisplayModeProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayModeProperties2KHR* forMarshaling);
+void marshal_VkDisplayModeProperties2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayModeProperties2KHR* forMarshaling);
-void unmarshal_VkDisplayModeProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayModeProperties2KHR* forUnmarshaling);
+void unmarshal_VkDisplayModeProperties2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayModeProperties2KHR* forUnmarshaling);
-void marshal_VkDisplayPlaneInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPlaneInfo2KHR* forMarshaling);
+void marshal_VkDisplayPlaneInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPlaneInfo2KHR* forMarshaling);
-void unmarshal_VkDisplayPlaneInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayPlaneInfo2KHR* forUnmarshaling);
+void unmarshal_VkDisplayPlaneInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayPlaneInfo2KHR* forUnmarshaling);
-void marshal_VkDisplayPlaneCapabilities2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPlaneCapabilities2KHR* forMarshaling);
+void marshal_VkDisplayPlaneCapabilities2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPlaneCapabilities2KHR* forMarshaling);
-void unmarshal_VkDisplayPlaneCapabilities2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayPlaneCapabilities2KHR* forUnmarshaling);
+void unmarshal_VkDisplayPlaneCapabilities2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayPlaneCapabilities2KHR* forUnmarshaling);
#define OP_vkGetPhysicalDeviceDisplayProperties2KHR 20237
#define OP_vkGetPhysicalDeviceDisplayPlaneProperties2KHR 20238
@@ -3840,13 +2880,17 @@
#define OP_vkGetDisplayPlaneCapabilities2KHR 20240
#endif
#ifdef VK_KHR_dedicated_allocation
-DEFINE_ALIAS_FUNCTION(marshal_VkMemoryDedicatedRequirements, marshal_VkMemoryDedicatedRequirementsKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkMemoryDedicatedRequirements,
+ marshal_VkMemoryDedicatedRequirementsKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkMemoryDedicatedRequirements, unmarshal_VkMemoryDedicatedRequirementsKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkMemoryDedicatedRequirements,
+ unmarshal_VkMemoryDedicatedRequirementsKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkMemoryDedicatedAllocateInfo, marshal_VkMemoryDedicatedAllocateInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkMemoryDedicatedAllocateInfo,
+ marshal_VkMemoryDedicatedAllocateInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkMemoryDedicatedAllocateInfo, unmarshal_VkMemoryDedicatedAllocateInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkMemoryDedicatedAllocateInfo,
+ unmarshal_VkMemoryDedicatedAllocateInfoKHR)
#endif
#ifdef VK_KHR_storage_buffer_storage_class
@@ -3854,25 +2898,33 @@
#ifdef VK_KHR_relaxed_block_layout
#endif
#ifdef VK_KHR_get_memory_requirements2
-DEFINE_ALIAS_FUNCTION(marshal_VkBufferMemoryRequirementsInfo2, marshal_VkBufferMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkBufferMemoryRequirementsInfo2,
+ marshal_VkBufferMemoryRequirementsInfo2KHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkBufferMemoryRequirementsInfo2, unmarshal_VkBufferMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkBufferMemoryRequirementsInfo2,
+ unmarshal_VkBufferMemoryRequirementsInfo2KHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkImageMemoryRequirementsInfo2, marshal_VkImageMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkImageMemoryRequirementsInfo2,
+ marshal_VkImageMemoryRequirementsInfo2KHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkImageMemoryRequirementsInfo2, unmarshal_VkImageMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkImageMemoryRequirementsInfo2,
+ unmarshal_VkImageMemoryRequirementsInfo2KHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkImageSparseMemoryRequirementsInfo2, marshal_VkImageSparseMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkImageSparseMemoryRequirementsInfo2,
+ marshal_VkImageSparseMemoryRequirementsInfo2KHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkImageSparseMemoryRequirementsInfo2, unmarshal_VkImageSparseMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkImageSparseMemoryRequirementsInfo2,
+ unmarshal_VkImageSparseMemoryRequirementsInfo2KHR)
DEFINE_ALIAS_FUNCTION(marshal_VkMemoryRequirements2, marshal_VkMemoryRequirements2KHR)
DEFINE_ALIAS_FUNCTION(unmarshal_VkMemoryRequirements2, unmarshal_VkMemoryRequirements2KHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkSparseImageMemoryRequirements2, marshal_VkSparseImageMemoryRequirements2KHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkSparseImageMemoryRequirements2,
+ marshal_VkSparseImageMemoryRequirements2KHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkSparseImageMemoryRequirements2, unmarshal_VkSparseImageMemoryRequirements2KHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkSparseImageMemoryRequirements2,
+ unmarshal_VkSparseImageMemoryRequirements2KHR)
#define OP_vkGetImageMemoryRequirements2KHR 20241
#define OP_vkGetBufferMemoryRequirements2KHR 20242
@@ -3881,33 +2933,43 @@
#ifdef VK_KHR_image_format_list
DEFINE_ALIAS_FUNCTION(marshal_VkImageFormatListCreateInfo, marshal_VkImageFormatListCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkImageFormatListCreateInfo, unmarshal_VkImageFormatListCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkImageFormatListCreateInfo,
+ unmarshal_VkImageFormatListCreateInfoKHR)
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
-DEFINE_ALIAS_FUNCTION(marshal_VkSamplerYcbcrConversionCreateInfo, marshal_VkSamplerYcbcrConversionCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkSamplerYcbcrConversionCreateInfo,
+ marshal_VkSamplerYcbcrConversionCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkSamplerYcbcrConversionCreateInfo, unmarshal_VkSamplerYcbcrConversionCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkSamplerYcbcrConversionCreateInfo,
+ unmarshal_VkSamplerYcbcrConversionCreateInfoKHR)
DEFINE_ALIAS_FUNCTION(marshal_VkSamplerYcbcrConversionInfo, marshal_VkSamplerYcbcrConversionInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkSamplerYcbcrConversionInfo, unmarshal_VkSamplerYcbcrConversionInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkSamplerYcbcrConversionInfo,
+ unmarshal_VkSamplerYcbcrConversionInfoKHR)
DEFINE_ALIAS_FUNCTION(marshal_VkBindImagePlaneMemoryInfo, marshal_VkBindImagePlaneMemoryInfoKHR)
DEFINE_ALIAS_FUNCTION(unmarshal_VkBindImagePlaneMemoryInfo, unmarshal_VkBindImagePlaneMemoryInfoKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkImagePlaneMemoryRequirementsInfo, marshal_VkImagePlaneMemoryRequirementsInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkImagePlaneMemoryRequirementsInfo,
+ marshal_VkImagePlaneMemoryRequirementsInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkImagePlaneMemoryRequirementsInfo, unmarshal_VkImagePlaneMemoryRequirementsInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkImagePlaneMemoryRequirementsInfo,
+ unmarshal_VkImagePlaneMemoryRequirementsInfoKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures, marshal_VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures,
+ marshal_VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures, unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures,
+ unmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkSamplerYcbcrConversionImageFormatProperties, marshal_VkSamplerYcbcrConversionImageFormatPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkSamplerYcbcrConversionImageFormatProperties,
+ marshal_VkSamplerYcbcrConversionImageFormatPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkSamplerYcbcrConversionImageFormatProperties, unmarshal_VkSamplerYcbcrConversionImageFormatPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkSamplerYcbcrConversionImageFormatProperties,
+ unmarshal_VkSamplerYcbcrConversionImageFormatPropertiesKHR)
#define OP_vkCreateSamplerYcbcrConversionKHR 20244
#define OP_vkDestroySamplerYcbcrConversionKHR 20245
@@ -3926,34 +2988,33 @@
#endif
#ifdef VK_KHR_portability_subset
void marshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDevicePortabilitySubsetFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDevicePortabilitySubsetFeaturesKHR* forUnmarshaling);
void marshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDevicePortabilitySubsetPropertiesKHR* forMarshaling);
void unmarshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDevicePortabilitySubsetPropertiesKHR* forUnmarshaling);
#endif
#ifdef VK_KHR_maintenance3
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceMaintenance3Properties, marshal_VkPhysicalDeviceMaintenance3PropertiesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceMaintenance3Properties,
+ marshal_VkPhysicalDeviceMaintenance3PropertiesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceMaintenance3Properties, unmarshal_VkPhysicalDeviceMaintenance3PropertiesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceMaintenance3Properties,
+ unmarshal_VkPhysicalDeviceMaintenance3PropertiesKHR)
DEFINE_ALIAS_FUNCTION(marshal_VkDescriptorSetLayoutSupport, marshal_VkDescriptorSetLayoutSupportKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkDescriptorSetLayoutSupport, unmarshal_VkDescriptorSetLayoutSupportKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkDescriptorSetLayoutSupport,
+ unmarshal_VkDescriptorSetLayoutSupportKHR)
#define OP_vkGetDescriptorSetLayoutSupportKHR 20248
#endif
@@ -3962,32 +3023,36 @@
#define OP_vkCmdDrawIndexedIndirectCountKHR 20250
#endif
#ifdef VK_KHR_shader_subgroup_extended_types
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, marshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures,
+ marshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, unmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures,
+ unmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)
#endif
#ifdef VK_KHR_8bit_storage
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDevice8BitStorageFeatures, marshal_VkPhysicalDevice8BitStorageFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDevice8BitStorageFeatures,
+ marshal_VkPhysicalDevice8BitStorageFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDevice8BitStorageFeatures, unmarshal_VkPhysicalDevice8BitStorageFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDevice8BitStorageFeatures,
+ unmarshal_VkPhysicalDevice8BitStorageFeaturesKHR)
#endif
#ifdef VK_KHR_shader_atomic_int64
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceShaderAtomicInt64Features, marshal_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceShaderAtomicInt64Features,
+ marshal_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceShaderAtomicInt64Features, unmarshal_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceShaderAtomicInt64Features,
+ unmarshal_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR)
#endif
#ifdef VK_KHR_shader_clock
void marshal_VkPhysicalDeviceShaderClockFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderClockFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderClockFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShaderClockFeaturesKHR* forUnmarshaling);
#endif
@@ -3996,45 +3061,59 @@
DEFINE_ALIAS_FUNCTION(unmarshal_VkConformanceVersion, unmarshal_VkConformanceVersionKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceDriverProperties, marshal_VkPhysicalDeviceDriverPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceDriverProperties,
+ marshal_VkPhysicalDeviceDriverPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceDriverProperties, unmarshal_VkPhysicalDeviceDriverPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceDriverProperties,
+ unmarshal_VkPhysicalDeviceDriverPropertiesKHR)
#endif
#ifdef VK_KHR_shader_float_controls
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceFloatControlsProperties, marshal_VkPhysicalDeviceFloatControlsPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceFloatControlsProperties,
+ marshal_VkPhysicalDeviceFloatControlsPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceFloatControlsProperties, unmarshal_VkPhysicalDeviceFloatControlsPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceFloatControlsProperties,
+ unmarshal_VkPhysicalDeviceFloatControlsPropertiesKHR)
#endif
#ifdef VK_KHR_depth_stencil_resolve
-DEFINE_ALIAS_FUNCTION(marshal_VkSubpassDescriptionDepthStencilResolve, marshal_VkSubpassDescriptionDepthStencilResolveKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkSubpassDescriptionDepthStencilResolve,
+ marshal_VkSubpassDescriptionDepthStencilResolveKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkSubpassDescriptionDepthStencilResolve, unmarshal_VkSubpassDescriptionDepthStencilResolveKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkSubpassDescriptionDepthStencilResolve,
+ unmarshal_VkSubpassDescriptionDepthStencilResolveKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceDepthStencilResolveProperties, marshal_VkPhysicalDeviceDepthStencilResolvePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceDepthStencilResolveProperties,
+ marshal_VkPhysicalDeviceDepthStencilResolvePropertiesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceDepthStencilResolveProperties, unmarshal_VkPhysicalDeviceDepthStencilResolvePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceDepthStencilResolveProperties,
+ unmarshal_VkPhysicalDeviceDepthStencilResolvePropertiesKHR)
#endif
#ifdef VK_KHR_swapchain_mutable_format
#endif
#ifdef VK_KHR_timeline_semaphore
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceTimelineSemaphoreFeatures, marshal_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceTimelineSemaphoreFeatures,
+ marshal_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures, unmarshal_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures,
+ unmarshal_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceTimelineSemaphoreProperties, marshal_VkPhysicalDeviceTimelineSemaphorePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceTimelineSemaphoreProperties,
+ marshal_VkPhysicalDeviceTimelineSemaphorePropertiesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceTimelineSemaphoreProperties, unmarshal_VkPhysicalDeviceTimelineSemaphorePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceTimelineSemaphoreProperties,
+ unmarshal_VkPhysicalDeviceTimelineSemaphorePropertiesKHR)
DEFINE_ALIAS_FUNCTION(marshal_VkSemaphoreTypeCreateInfo, marshal_VkSemaphoreTypeCreateInfoKHR)
DEFINE_ALIAS_FUNCTION(unmarshal_VkSemaphoreTypeCreateInfo, unmarshal_VkSemaphoreTypeCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkTimelineSemaphoreSubmitInfo, marshal_VkTimelineSemaphoreSubmitInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkTimelineSemaphoreSubmitInfo,
+ marshal_VkTimelineSemaphoreSubmitInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkTimelineSemaphoreSubmitInfo, unmarshal_VkTimelineSemaphoreSubmitInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkTimelineSemaphoreSubmitInfo,
+ unmarshal_VkTimelineSemaphoreSubmitInfoKHR)
DEFINE_ALIAS_FUNCTION(marshal_VkSemaphoreWaitInfo, marshal_VkSemaphoreWaitInfoKHR)
@@ -4049,72 +3128,62 @@
#define OP_vkSignalSemaphoreKHR 269919108
#endif
#ifdef VK_KHR_vulkan_memory_model
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceVulkanMemoryModelFeatures, marshal_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceVulkanMemoryModelFeatures,
+ marshal_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures, unmarshal_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures,
+ unmarshal_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR)
#endif
#ifdef VK_KHR_shader_terminate_invocation
void marshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forUnmarshaling);
#endif
#ifdef VK_KHR_fragment_shading_rate
void marshal_VkFragmentShadingRateAttachmentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkFragmentShadingRateAttachmentInfoKHR* forMarshaling);
void unmarshal_VkFragmentShadingRateAttachmentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkFragmentShadingRateAttachmentInfoKHR* forUnmarshaling);
void marshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineFragmentShadingRateStateCreateInfoKHR* forMarshaling);
void unmarshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineFragmentShadingRateStateCreateInfoKHR* forUnmarshaling);
void marshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceFragmentShadingRateFeaturesKHR* forUnmarshaling);
void marshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceFragmentShadingRatePropertiesKHR* forUnmarshaling);
void marshal_VkPhysicalDeviceFragmentShadingRateKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceFragmentShadingRateKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceFragmentShadingRateKHR* forUnmarshaling);
#define OP_vkGetPhysicalDeviceFragmentShadingRatesKHR 272978593
@@ -4124,69 +3193,81 @@
#endif
#ifdef VK_KHR_surface_protected_capabilities
void marshal_VkSurfaceProtectedCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkSurfaceProtectedCapabilitiesKHR* forMarshaling);
void unmarshal_VkSurfaceProtectedCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkSurfaceProtectedCapabilitiesKHR* forUnmarshaling);
#endif
#ifdef VK_KHR_separate_depth_stencil_layouts
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, marshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures,
+ marshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, unmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures,
+ unmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkAttachmentReferenceStencilLayout, marshal_VkAttachmentReferenceStencilLayoutKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkAttachmentReferenceStencilLayout,
+ marshal_VkAttachmentReferenceStencilLayoutKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkAttachmentReferenceStencilLayout, unmarshal_VkAttachmentReferenceStencilLayoutKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkAttachmentReferenceStencilLayout,
+ unmarshal_VkAttachmentReferenceStencilLayoutKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkAttachmentDescriptionStencilLayout, marshal_VkAttachmentDescriptionStencilLayoutKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkAttachmentDescriptionStencilLayout,
+ marshal_VkAttachmentDescriptionStencilLayoutKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkAttachmentDescriptionStencilLayout, unmarshal_VkAttachmentDescriptionStencilLayoutKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkAttachmentDescriptionStencilLayout,
+ unmarshal_VkAttachmentDescriptionStencilLayoutKHR)
#endif
#ifdef VK_KHR_present_wait
void marshal_VkPhysicalDevicePresentWaitFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDevicePresentWaitFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDevicePresentWaitFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDevicePresentWaitFeaturesKHR* forUnmarshaling);
#define OP_vkWaitForPresentKHR 263215580
#endif
#ifdef VK_KHR_uniform_buffer_standard_layout
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures, marshal_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures,
+ marshal_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures, unmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures,
+ unmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)
#endif
#ifdef VK_KHR_buffer_device_address
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceBufferDeviceAddressFeatures, marshal_VkPhysicalDeviceBufferDeviceAddressFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceBufferDeviceAddressFeatures,
+ marshal_VkPhysicalDeviceBufferDeviceAddressFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures, unmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures,
+ unmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesKHR)
DEFINE_ALIAS_FUNCTION(marshal_VkBufferDeviceAddressInfo, marshal_VkBufferDeviceAddressInfoKHR)
DEFINE_ALIAS_FUNCTION(unmarshal_VkBufferDeviceAddressInfo, unmarshal_VkBufferDeviceAddressInfoKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkBufferOpaqueCaptureAddressCreateInfo, marshal_VkBufferOpaqueCaptureAddressCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkBufferOpaqueCaptureAddressCreateInfo,
+ marshal_VkBufferOpaqueCaptureAddressCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkBufferOpaqueCaptureAddressCreateInfo, unmarshal_VkBufferOpaqueCaptureAddressCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkBufferOpaqueCaptureAddressCreateInfo,
+ unmarshal_VkBufferOpaqueCaptureAddressCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkMemoryOpaqueCaptureAddressAllocateInfo, marshal_VkMemoryOpaqueCaptureAddressAllocateInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkMemoryOpaqueCaptureAddressAllocateInfo,
+ marshal_VkMemoryOpaqueCaptureAddressAllocateInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo, unmarshal_VkMemoryOpaqueCaptureAddressAllocateInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo,
+ unmarshal_VkMemoryOpaqueCaptureAddressAllocateInfoKHR)
-DEFINE_ALIAS_FUNCTION(marshal_VkDeviceMemoryOpaqueCaptureAddressInfo, marshal_VkDeviceMemoryOpaqueCaptureAddressInfoKHR)
+DEFINE_ALIAS_FUNCTION(marshal_VkDeviceMemoryOpaqueCaptureAddressInfo,
+ marshal_VkDeviceMemoryOpaqueCaptureAddressInfoKHR)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo, unmarshal_VkDeviceMemoryOpaqueCaptureAddressInfoKHR)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo,
+ unmarshal_VkDeviceMemoryOpaqueCaptureAddressInfoKHR)
#define OP_vkGetBufferDeviceAddressKHR 219261480
#define OP_vkGetBufferOpaqueCaptureAddressKHR 285631711
@@ -4201,73 +3282,55 @@
#endif
#ifdef VK_KHR_pipeline_executable_properties
void marshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* forUnmarshaling);
-void marshal_VkPipelineInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineInfoKHR* forMarshaling);
+void marshal_VkPipelineInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineInfoKHR* forMarshaling);
-void unmarshal_VkPipelineInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineInfoKHR* forUnmarshaling);
+void unmarshal_VkPipelineInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineInfoKHR* forUnmarshaling);
void marshal_VkPipelineExecutablePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineExecutablePropertiesKHR* forMarshaling);
void unmarshal_VkPipelineExecutablePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineExecutablePropertiesKHR* forUnmarshaling);
-void marshal_VkPipelineExecutableInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineExecutableInfoKHR* forMarshaling);
+void marshal_VkPipelineExecutableInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineExecutableInfoKHR* forMarshaling);
-void unmarshal_VkPipelineExecutableInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineExecutableInfoKHR* forUnmarshaling);
+void unmarshal_VkPipelineExecutableInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineExecutableInfoKHR* forUnmarshaling);
void marshal_VkPipelineExecutableStatisticValueKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineExecutableStatisticValueKHR* forMarshaling);
void unmarshal_VkPipelineExecutableStatisticValueKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineExecutableStatisticValueKHR* forUnmarshaling);
void marshal_VkPipelineExecutableStatisticKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineExecutableStatisticKHR* forMarshaling);
-void unmarshal_VkPipelineExecutableStatisticKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineExecutableStatisticKHR* forUnmarshaling);
+void unmarshal_VkPipelineExecutableStatisticKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPipelineExecutableStatisticKHR* forUnmarshaling);
void marshal_VkPipelineExecutableInternalRepresentationKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineExecutableInternalRepresentationKHR* forMarshaling);
void unmarshal_VkPipelineExecutableInternalRepresentationKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineExecutableInternalRepresentationKHR* forUnmarshaling);
#define OP_vkGetPipelineExecutablePropertiesKHR 269458798
@@ -4276,164 +3339,113 @@
#endif
#ifdef VK_KHR_shader_integer_dot_product
void marshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* forUnmarshaling);
void marshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* forUnmarshaling);
#endif
#ifdef VK_KHR_pipeline_library
-void marshal_VkPipelineLibraryCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineLibraryCreateInfoKHR* forMarshaling);
+void marshal_VkPipelineLibraryCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineLibraryCreateInfoKHR* forMarshaling);
-void unmarshal_VkPipelineLibraryCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineLibraryCreateInfoKHR* forUnmarshaling);
+void unmarshal_VkPipelineLibraryCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineLibraryCreateInfoKHR* forUnmarshaling);
#endif
#ifdef VK_KHR_shader_non_semantic_info
#endif
#ifdef VK_KHR_present_id
-void marshal_VkPresentIdKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentIdKHR* forMarshaling);
+void marshal_VkPresentIdKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentIdKHR* forMarshaling);
-void unmarshal_VkPresentIdKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPresentIdKHR* forUnmarshaling);
+void unmarshal_VkPresentIdKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPresentIdKHR* forUnmarshaling);
void marshal_VkPhysicalDevicePresentIdFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDevicePresentIdFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDevicePresentIdFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDevicePresentIdFeaturesKHR* forUnmarshaling);
#endif
#ifdef VK_KHR_video_encode_queue
-void marshal_VkVideoEncodeInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeInfoKHR* forMarshaling);
+void marshal_VkVideoEncodeInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeInfoKHR* forMarshaling);
-void unmarshal_VkVideoEncodeInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeInfoKHR* forUnmarshaling);
+void unmarshal_VkVideoEncodeInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEncodeInfoKHR* forUnmarshaling);
-void marshal_VkVideoEncodeRateControlInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeRateControlInfoKHR* forMarshaling);
+void marshal_VkVideoEncodeRateControlInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeRateControlInfoKHR* forMarshaling);
-void unmarshal_VkVideoEncodeRateControlInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeRateControlInfoKHR* forUnmarshaling);
+void unmarshal_VkVideoEncodeRateControlInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoEncodeRateControlInfoKHR* forUnmarshaling);
#define OP_vkCmdEncodeVideoKHR 295869356
#endif
#ifdef VK_KHR_synchronization2
-void marshal_VkMemoryBarrier2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryBarrier2KHR* forMarshaling);
+void marshal_VkMemoryBarrier2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryBarrier2KHR* forMarshaling);
-void unmarshal_VkMemoryBarrier2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryBarrier2KHR* forUnmarshaling);
+void unmarshal_VkMemoryBarrier2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryBarrier2KHR* forUnmarshaling);
-void marshal_VkBufferMemoryBarrier2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferMemoryBarrier2KHR* forMarshaling);
+void marshal_VkBufferMemoryBarrier2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferMemoryBarrier2KHR* forMarshaling);
-void unmarshal_VkBufferMemoryBarrier2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferMemoryBarrier2KHR* forUnmarshaling);
+void unmarshal_VkBufferMemoryBarrier2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferMemoryBarrier2KHR* forUnmarshaling);
-void marshal_VkImageMemoryBarrier2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageMemoryBarrier2KHR* forMarshaling);
+void marshal_VkImageMemoryBarrier2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageMemoryBarrier2KHR* forMarshaling);
-void unmarshal_VkImageMemoryBarrier2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageMemoryBarrier2KHR* forUnmarshaling);
+void unmarshal_VkImageMemoryBarrier2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageMemoryBarrier2KHR* forUnmarshaling);
-void marshal_VkDependencyInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDependencyInfoKHR* forMarshaling);
+void marshal_VkDependencyInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDependencyInfoKHR* forMarshaling);
-void unmarshal_VkDependencyInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDependencyInfoKHR* forUnmarshaling);
+void unmarshal_VkDependencyInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDependencyInfoKHR* forUnmarshaling);
-void marshal_VkSemaphoreSubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreSubmitInfoKHR* forMarshaling);
+void marshal_VkSemaphoreSubmitInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreSubmitInfoKHR* forMarshaling);
-void unmarshal_VkSemaphoreSubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSemaphoreSubmitInfoKHR* forUnmarshaling);
+void unmarshal_VkSemaphoreSubmitInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSemaphoreSubmitInfoKHR* forUnmarshaling);
-void marshal_VkCommandBufferSubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferSubmitInfoKHR* forMarshaling);
+void marshal_VkCommandBufferSubmitInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferSubmitInfoKHR* forMarshaling);
-void unmarshal_VkCommandBufferSubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCommandBufferSubmitInfoKHR* forUnmarshaling);
+void unmarshal_VkCommandBufferSubmitInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCommandBufferSubmitInfoKHR* forUnmarshaling);
-void marshal_VkSubmitInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubmitInfo2KHR* forMarshaling);
+void marshal_VkSubmitInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubmitInfo2KHR* forMarshaling);
-void unmarshal_VkSubmitInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubmitInfo2KHR* forUnmarshaling);
+void unmarshal_VkSubmitInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubmitInfo2KHR* forUnmarshaling);
void marshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceSynchronization2FeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceSynchronization2FeaturesKHR* forUnmarshaling);
#define OP_vkCmdSetEvent2KHR 270411360
@@ -4444,173 +3456,117 @@
#define OP_vkQueueSubmit2KHR 293024240
#define OP_vkCmdWriteBufferMarker2AMD 224701394
void marshal_VkQueueFamilyCheckpointProperties2NV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkQueueFamilyCheckpointProperties2NV* forMarshaling);
void unmarshal_VkQueueFamilyCheckpointProperties2NV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkQueueFamilyCheckpointProperties2NV* forUnmarshaling);
-void marshal_VkCheckpointData2NV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCheckpointData2NV* forMarshaling);
+void marshal_VkCheckpointData2NV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCheckpointData2NV* forMarshaling);
-void unmarshal_VkCheckpointData2NV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCheckpointData2NV* forUnmarshaling);
+void unmarshal_VkCheckpointData2NV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCheckpointData2NV* forUnmarshaling);
#define OP_vkGetQueueCheckpointData2NV 292063036
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
void marshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* forUnmarshaling);
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
void marshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* forUnmarshaling);
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
void marshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* forUnmarshaling);
#endif
#ifdef VK_KHR_copy_commands2
-void marshal_VkBufferCopy2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCopy2KHR* forMarshaling);
+void marshal_VkBufferCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCopy2KHR* forMarshaling);
-void unmarshal_VkBufferCopy2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferCopy2KHR* forUnmarshaling);
+void unmarshal_VkBufferCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferCopy2KHR* forUnmarshaling);
-void marshal_VkCopyBufferInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyBufferInfo2KHR* forMarshaling);
+void marshal_VkCopyBufferInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyBufferInfo2KHR* forMarshaling);
-void unmarshal_VkCopyBufferInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCopyBufferInfo2KHR* forUnmarshaling);
+void unmarshal_VkCopyBufferInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyBufferInfo2KHR* forUnmarshaling);
-void marshal_VkImageCopy2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageCopy2KHR* forMarshaling);
+void marshal_VkImageCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageCopy2KHR* forMarshaling);
-void unmarshal_VkImageCopy2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageCopy2KHR* forUnmarshaling);
+void unmarshal_VkImageCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageCopy2KHR* forUnmarshaling);
-void marshal_VkCopyImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyImageInfo2KHR* forMarshaling);
+void marshal_VkCopyImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyImageInfo2KHR* forMarshaling);
-void unmarshal_VkCopyImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCopyImageInfo2KHR* forUnmarshaling);
+void unmarshal_VkCopyImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyImageInfo2KHR* forUnmarshaling);
-void marshal_VkBufferImageCopy2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferImageCopy2KHR* forMarshaling);
+void marshal_VkBufferImageCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferImageCopy2KHR* forMarshaling);
-void unmarshal_VkBufferImageCopy2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferImageCopy2KHR* forUnmarshaling);
+void unmarshal_VkBufferImageCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferImageCopy2KHR* forUnmarshaling);
-void marshal_VkCopyBufferToImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyBufferToImageInfo2KHR* forMarshaling);
+void marshal_VkCopyBufferToImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyBufferToImageInfo2KHR* forMarshaling);
-void unmarshal_VkCopyBufferToImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCopyBufferToImageInfo2KHR* forUnmarshaling);
+void unmarshal_VkCopyBufferToImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyBufferToImageInfo2KHR* forUnmarshaling);
-void marshal_VkCopyImageToBufferInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyImageToBufferInfo2KHR* forMarshaling);
+void marshal_VkCopyImageToBufferInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyImageToBufferInfo2KHR* forMarshaling);
-void unmarshal_VkCopyImageToBufferInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCopyImageToBufferInfo2KHR* forUnmarshaling);
+void unmarshal_VkCopyImageToBufferInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyImageToBufferInfo2KHR* forUnmarshaling);
-void marshal_VkImageBlit2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageBlit2KHR* forMarshaling);
+void marshal_VkImageBlit2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageBlit2KHR* forMarshaling);
-void unmarshal_VkImageBlit2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageBlit2KHR* forUnmarshaling);
+void unmarshal_VkImageBlit2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageBlit2KHR* forUnmarshaling);
-void marshal_VkBlitImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBlitImageInfo2KHR* forMarshaling);
+void marshal_VkBlitImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBlitImageInfo2KHR* forMarshaling);
-void unmarshal_VkBlitImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBlitImageInfo2KHR* forUnmarshaling);
+void unmarshal_VkBlitImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBlitImageInfo2KHR* forUnmarshaling);
-void marshal_VkImageResolve2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageResolve2KHR* forMarshaling);
+void marshal_VkImageResolve2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageResolve2KHR* forMarshaling);
-void unmarshal_VkImageResolve2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageResolve2KHR* forUnmarshaling);
+void unmarshal_VkImageResolve2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageResolve2KHR* forUnmarshaling);
-void marshal_VkResolveImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkResolveImageInfo2KHR* forMarshaling);
+void marshal_VkResolveImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkResolveImageInfo2KHR* forMarshaling);
-void unmarshal_VkResolveImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkResolveImageInfo2KHR* forUnmarshaling);
+void unmarshal_VkResolveImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkResolveImageInfo2KHR* forUnmarshaling);
#define OP_vkCmdCopyBuffer2KHR 247893766
#define OP_vkCmdCopyImage2KHR 227008250
@@ -4620,56 +3576,44 @@
#define OP_vkCmdResolveImage2KHR 254857232
#endif
#ifdef VK_KHR_format_feature_flags2
-void marshal_VkFormatProperties3KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFormatProperties3KHR* forMarshaling);
+void marshal_VkFormatProperties3KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFormatProperties3KHR* forMarshaling);
-void unmarshal_VkFormatProperties3KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkFormatProperties3KHR* forUnmarshaling);
+void unmarshal_VkFormatProperties3KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkFormatProperties3KHR* forUnmarshaling);
#endif
#ifdef VK_KHR_maintenance4
void marshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceMaintenance4FeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceMaintenance4FeaturesKHR* forUnmarshaling);
void marshal_VkPhysicalDeviceMaintenance4PropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceMaintenance4PropertiesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceMaintenance4PropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceMaintenance4PropertiesKHR* forUnmarshaling);
void marshal_VkDeviceBufferMemoryRequirementsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDeviceBufferMemoryRequirementsKHR* forMarshaling);
void unmarshal_VkDeviceBufferMemoryRequirementsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDeviceBufferMemoryRequirementsKHR* forUnmarshaling);
void marshal_VkDeviceImageMemoryRequirementsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDeviceImageMemoryRequirementsKHR* forMarshaling);
void unmarshal_VkDeviceImageMemoryRequirementsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDeviceImageMemoryRequirementsKHR* forUnmarshaling);
#define OP_vkGetDeviceBufferMemoryRequirementsKHR 201613635
@@ -4677,15 +3621,11 @@
#define OP_vkGetDeviceImageSparseMemoryRequirementsKHR 275585477
#endif
#ifdef VK_ANDROID_native_buffer
-void marshal_VkNativeBufferANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkNativeBufferANDROID* forMarshaling);
+void marshal_VkNativeBufferANDROID(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkNativeBufferANDROID* forMarshaling);
-void unmarshal_VkNativeBufferANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkNativeBufferANDROID* forUnmarshaling);
+void unmarshal_VkNativeBufferANDROID(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkNativeBufferANDROID* forUnmarshaling);
#define OP_vkGetSwapchainGrallocUsageANDROID 20251
#define OP_vkAcquireImageANDROID 20252
@@ -4693,13 +3633,11 @@
#endif
#ifdef VK_EXT_debug_report
void marshal_VkDebugReportCallbackCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDebugReportCallbackCreateInfoEXT* forMarshaling);
void unmarshal_VkDebugReportCallbackCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDebugReportCallbackCreateInfoEXT* forUnmarshaling);
#define OP_vkCreateDebugReportCallbackEXT 20254
@@ -4714,13 +3652,11 @@
#endif
#ifdef VK_AMD_rasterization_order
void marshal_VkPipelineRasterizationStateRasterizationOrderAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineRasterizationStateRasterizationOrderAMD* forMarshaling);
void unmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineRasterizationStateRasterizationOrderAMD* forUnmarshaling);
#endif
@@ -4729,35 +3665,23 @@
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
-void marshal_VkDebugMarkerObjectNameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugMarkerObjectNameInfoEXT* forMarshaling);
+void marshal_VkDebugMarkerObjectNameInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugMarkerObjectNameInfoEXT* forMarshaling);
-void unmarshal_VkDebugMarkerObjectNameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDebugMarkerObjectNameInfoEXT* forUnmarshaling);
+void unmarshal_VkDebugMarkerObjectNameInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDebugMarkerObjectNameInfoEXT* forUnmarshaling);
-void marshal_VkDebugMarkerObjectTagInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugMarkerObjectTagInfoEXT* forMarshaling);
+void marshal_VkDebugMarkerObjectTagInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugMarkerObjectTagInfoEXT* forMarshaling);
-void unmarshal_VkDebugMarkerObjectTagInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDebugMarkerObjectTagInfoEXT* forUnmarshaling);
+void unmarshal_VkDebugMarkerObjectTagInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDebugMarkerObjectTagInfoEXT* forUnmarshaling);
-void marshal_VkDebugMarkerMarkerInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugMarkerMarkerInfoEXT* forMarshaling);
+void marshal_VkDebugMarkerMarkerInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugMarkerMarkerInfoEXT* forMarshaling);
-void unmarshal_VkDebugMarkerMarkerInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDebugMarkerMarkerInfoEXT* forUnmarshaling);
+void unmarshal_VkDebugMarkerMarkerInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDebugMarkerMarkerInfoEXT* forUnmarshaling);
#define OP_vkDebugMarkerSetObjectTagEXT 20257
#define OP_vkDebugMarkerSetObjectNameEXT 20258
@@ -4769,65 +3693,53 @@
#endif
#ifdef VK_NV_dedicated_allocation
void marshal_VkDedicatedAllocationImageCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDedicatedAllocationImageCreateInfoNV* forMarshaling);
void unmarshal_VkDedicatedAllocationImageCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDedicatedAllocationImageCreateInfoNV* forUnmarshaling);
void marshal_VkDedicatedAllocationBufferCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDedicatedAllocationBufferCreateInfoNV* forMarshaling);
void unmarshal_VkDedicatedAllocationBufferCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDedicatedAllocationBufferCreateInfoNV* forUnmarshaling);
void marshal_VkDedicatedAllocationMemoryAllocateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDedicatedAllocationMemoryAllocateInfoNV* forMarshaling);
void unmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDedicatedAllocationMemoryAllocateInfoNV* forUnmarshaling);
#endif
#ifdef VK_EXT_transform_feedback
void marshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceTransformFeedbackFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceTransformFeedbackFeaturesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceTransformFeedbackPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceTransformFeedbackPropertiesEXT* forUnmarshaling);
void marshal_VkPipelineRasterizationStateStreamCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineRasterizationStateStreamCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineRasterizationStateStreamCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineRasterizationStateStreamCreateInfoEXT* forUnmarshaling);
#define OP_vkCmdBindTransformFeedbackBuffersEXT 267779978
@@ -4838,35 +3750,23 @@
#define OP_vkCmdDrawIndirectByteCountEXT 285235943
#endif
#ifdef VK_NVX_binary_import
-void marshal_VkCuModuleCreateInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCuModuleCreateInfoNVX* forMarshaling);
+void marshal_VkCuModuleCreateInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCuModuleCreateInfoNVX* forMarshaling);
-void unmarshal_VkCuModuleCreateInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCuModuleCreateInfoNVX* forUnmarshaling);
+void unmarshal_VkCuModuleCreateInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCuModuleCreateInfoNVX* forUnmarshaling);
-void marshal_VkCuFunctionCreateInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCuFunctionCreateInfoNVX* forMarshaling);
+void marshal_VkCuFunctionCreateInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCuFunctionCreateInfoNVX* forMarshaling);
-void unmarshal_VkCuFunctionCreateInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCuFunctionCreateInfoNVX* forUnmarshaling);
+void unmarshal_VkCuFunctionCreateInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCuFunctionCreateInfoNVX* forUnmarshaling);
-void marshal_VkCuLaunchInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCuLaunchInfoNVX* forMarshaling);
+void marshal_VkCuLaunchInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCuLaunchInfoNVX* forMarshaling);
-void unmarshal_VkCuLaunchInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCuLaunchInfoNVX* forUnmarshaling);
+void unmarshal_VkCuLaunchInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCuLaunchInfoNVX* forUnmarshaling);
#define OP_vkCreateCuModuleNVX 227747396
#define OP_vkCreateCuFunctionNVX 207930440
@@ -4875,25 +3775,18 @@
#define OP_vkCmdCuLaunchKernelNVX 219961351
#endif
#ifdef VK_NVX_image_view_handle
-void marshal_VkImageViewHandleInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageViewHandleInfoNVX* forMarshaling);
+void marshal_VkImageViewHandleInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageViewHandleInfoNVX* forMarshaling);
-void unmarshal_VkImageViewHandleInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageViewHandleInfoNVX* forUnmarshaling);
+void unmarshal_VkImageViewHandleInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageViewHandleInfoNVX* forUnmarshaling);
-void marshal_VkImageViewAddressPropertiesNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageViewAddressPropertiesNVX* forMarshaling);
+void marshal_VkImageViewAddressPropertiesNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageViewAddressPropertiesNVX* forMarshaling);
-void unmarshal_VkImageViewAddressPropertiesNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageViewAddressPropertiesNVX* forUnmarshaling);
+void unmarshal_VkImageViewAddressPropertiesNVX(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkImageViewAddressPropertiesNVX* forUnmarshaling);
#define OP_vkGetImageViewHandleNVX 204379647
#define OP_vkGetImageViewAddressNVX 210668576
@@ -4910,312 +3803,232 @@
#endif
#ifdef VK_EXT_video_encode_h264
void marshal_VkVideoEncodeH264CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoEncodeH264CapabilitiesEXT* forMarshaling);
-void unmarshal_VkVideoEncodeH264CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH264CapabilitiesEXT* forUnmarshaling);
+void unmarshal_VkVideoEncodeH264CapabilitiesEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoEncodeH264CapabilitiesEXT* forUnmarshaling);
void marshal_VkVideoEncodeH264SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoEncodeH264SessionCreateInfoEXT* forMarshaling);
void unmarshal_VkVideoEncodeH264SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVideoEncodeH264SessionCreateInfoEXT* forUnmarshaling);
void marshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoEncodeH264SessionParametersAddInfoEXT* forMarshaling);
void unmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVideoEncodeH264SessionParametersAddInfoEXT* forUnmarshaling);
void marshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoEncodeH264SessionParametersCreateInfoEXT* forMarshaling);
void unmarshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVideoEncodeH264SessionParametersCreateInfoEXT* forUnmarshaling);
-void marshal_VkVideoEncodeH264DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264DpbSlotInfoEXT* forMarshaling);
+void marshal_VkVideoEncodeH264DpbSlotInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264DpbSlotInfoEXT* forMarshaling);
-void unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH264DpbSlotInfoEXT* forUnmarshaling);
+void unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoEncodeH264DpbSlotInfoEXT* forUnmarshaling);
-void marshal_VkVideoEncodeH264NaluSliceEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264NaluSliceEXT* forMarshaling);
+void marshal_VkVideoEncodeH264NaluSliceEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264NaluSliceEXT* forMarshaling);
-void unmarshal_VkVideoEncodeH264NaluSliceEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH264NaluSliceEXT* forUnmarshaling);
+void unmarshal_VkVideoEncodeH264NaluSliceEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEncodeH264NaluSliceEXT* forUnmarshaling);
void marshal_VkVideoEncodeH264VclFrameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoEncodeH264VclFrameInfoEXT* forMarshaling);
-void unmarshal_VkVideoEncodeH264VclFrameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH264VclFrameInfoEXT* forUnmarshaling);
+void unmarshal_VkVideoEncodeH264VclFrameInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoEncodeH264VclFrameInfoEXT* forUnmarshaling);
void marshal_VkVideoEncodeH264EmitPictureParametersEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoEncodeH264EmitPictureParametersEXT* forMarshaling);
void unmarshal_VkVideoEncodeH264EmitPictureParametersEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVideoEncodeH264EmitPictureParametersEXT* forUnmarshaling);
-void marshal_VkVideoEncodeH264ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264ProfileEXT* forMarshaling);
+void marshal_VkVideoEncodeH264ProfileEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264ProfileEXT* forMarshaling);
-void unmarshal_VkVideoEncodeH264ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH264ProfileEXT* forUnmarshaling);
+void unmarshal_VkVideoEncodeH264ProfileEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEncodeH264ProfileEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_video_encode_h265
void marshal_VkVideoEncodeH265CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoEncodeH265CapabilitiesEXT* forMarshaling);
-void unmarshal_VkVideoEncodeH265CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH265CapabilitiesEXT* forUnmarshaling);
+void unmarshal_VkVideoEncodeH265CapabilitiesEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoEncodeH265CapabilitiesEXT* forUnmarshaling);
void marshal_VkVideoEncodeH265SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoEncodeH265SessionCreateInfoEXT* forMarshaling);
void unmarshal_VkVideoEncodeH265SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVideoEncodeH265SessionCreateInfoEXT* forUnmarshaling);
void marshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoEncodeH265SessionParametersAddInfoEXT* forMarshaling);
void unmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVideoEncodeH265SessionParametersAddInfoEXT* forUnmarshaling);
void marshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoEncodeH265SessionParametersCreateInfoEXT* forMarshaling);
void unmarshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVideoEncodeH265SessionParametersCreateInfoEXT* forUnmarshaling);
-void marshal_VkVideoEncodeH265DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265DpbSlotInfoEXT* forMarshaling);
+void marshal_VkVideoEncodeH265DpbSlotInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265DpbSlotInfoEXT* forMarshaling);
-void unmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH265DpbSlotInfoEXT* forUnmarshaling);
+void unmarshal_VkVideoEncodeH265DpbSlotInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoEncodeH265DpbSlotInfoEXT* forUnmarshaling);
void marshal_VkVideoEncodeH265ReferenceListsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoEncodeH265ReferenceListsEXT* forMarshaling);
void unmarshal_VkVideoEncodeH265ReferenceListsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVideoEncodeH265ReferenceListsEXT* forUnmarshaling);
-void marshal_VkVideoEncodeH265NaluSliceEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265NaluSliceEXT* forMarshaling);
+void marshal_VkVideoEncodeH265NaluSliceEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265NaluSliceEXT* forMarshaling);
-void unmarshal_VkVideoEncodeH265NaluSliceEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH265NaluSliceEXT* forUnmarshaling);
+void unmarshal_VkVideoEncodeH265NaluSliceEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEncodeH265NaluSliceEXT* forUnmarshaling);
void marshal_VkVideoEncodeH265VclFrameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoEncodeH265VclFrameInfoEXT* forMarshaling);
-void unmarshal_VkVideoEncodeH265VclFrameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH265VclFrameInfoEXT* forUnmarshaling);
+void unmarshal_VkVideoEncodeH265VclFrameInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoEncodeH265VclFrameInfoEXT* forUnmarshaling);
void marshal_VkVideoEncodeH265EmitPictureParametersEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoEncodeH265EmitPictureParametersEXT* forMarshaling);
void unmarshal_VkVideoEncodeH265EmitPictureParametersEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVideoEncodeH265EmitPictureParametersEXT* forUnmarshaling);
-void marshal_VkVideoEncodeH265ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265ProfileEXT* forMarshaling);
+void marshal_VkVideoEncodeH265ProfileEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265ProfileEXT* forMarshaling);
-void unmarshal_VkVideoEncodeH265ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoEncodeH265ProfileEXT* forUnmarshaling);
+void unmarshal_VkVideoEncodeH265ProfileEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoEncodeH265ProfileEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_video_decode_h264
-void marshal_VkVideoDecodeH264ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264ProfileEXT* forMarshaling);
+void marshal_VkVideoDecodeH264ProfileEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264ProfileEXT* forMarshaling);
-void unmarshal_VkVideoDecodeH264ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH264ProfileEXT* forUnmarshaling);
+void unmarshal_VkVideoDecodeH264ProfileEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoDecodeH264ProfileEXT* forUnmarshaling);
void marshal_VkVideoDecodeH264CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoDecodeH264CapabilitiesEXT* forMarshaling);
-void unmarshal_VkVideoDecodeH264CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH264CapabilitiesEXT* forUnmarshaling);
+void unmarshal_VkVideoDecodeH264CapabilitiesEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoDecodeH264CapabilitiesEXT* forUnmarshaling);
void marshal_VkVideoDecodeH264SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoDecodeH264SessionCreateInfoEXT* forMarshaling);
void unmarshal_VkVideoDecodeH264SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVideoDecodeH264SessionCreateInfoEXT* forUnmarshaling);
void marshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoDecodeH264SessionParametersAddInfoEXT* forMarshaling);
void unmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVideoDecodeH264SessionParametersAddInfoEXT* forUnmarshaling);
void marshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoDecodeH264SessionParametersCreateInfoEXT* forMarshaling);
void unmarshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVideoDecodeH264SessionParametersCreateInfoEXT* forUnmarshaling);
-void marshal_VkVideoDecodeH264PictureInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264PictureInfoEXT* forMarshaling);
+void marshal_VkVideoDecodeH264PictureInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264PictureInfoEXT* forMarshaling);
-void unmarshal_VkVideoDecodeH264PictureInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH264PictureInfoEXT* forUnmarshaling);
+void unmarshal_VkVideoDecodeH264PictureInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoDecodeH264PictureInfoEXT* forUnmarshaling);
-void marshal_VkVideoDecodeH264MvcEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264MvcEXT* forMarshaling);
+void marshal_VkVideoDecodeH264MvcEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264MvcEXT* forMarshaling);
-void unmarshal_VkVideoDecodeH264MvcEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH264MvcEXT* forUnmarshaling);
+void unmarshal_VkVideoDecodeH264MvcEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoDecodeH264MvcEXT* forUnmarshaling);
-void marshal_VkVideoDecodeH264DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264DpbSlotInfoEXT* forMarshaling);
+void marshal_VkVideoDecodeH264DpbSlotInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264DpbSlotInfoEXT* forMarshaling);
-void unmarshal_VkVideoDecodeH264DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH264DpbSlotInfoEXT* forUnmarshaling);
+void unmarshal_VkVideoDecodeH264DpbSlotInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoDecodeH264DpbSlotInfoEXT* forUnmarshaling);
#endif
#ifdef VK_AMD_texture_gather_bias_lod
void marshal_VkTextureLODGatherFormatPropertiesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkTextureLODGatherFormatPropertiesAMD* forMarshaling);
void unmarshal_VkTextureLODGatherFormatPropertiesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkTextureLODGatherFormatPropertiesAMD* forUnmarshaling);
#endif
#ifdef VK_AMD_shader_info
-void marshal_VkShaderResourceUsageAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkShaderResourceUsageAMD* forMarshaling);
+void marshal_VkShaderResourceUsageAMD(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkShaderResourceUsageAMD* forMarshaling);
-void unmarshal_VkShaderResourceUsageAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkShaderResourceUsageAMD* forUnmarshaling);
+void unmarshal_VkShaderResourceUsageAMD(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkShaderResourceUsageAMD* forUnmarshaling);
-void marshal_VkShaderStatisticsInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkShaderStatisticsInfoAMD* forMarshaling);
+void marshal_VkShaderStatisticsInfoAMD(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkShaderStatisticsInfoAMD* forMarshaling);
-void unmarshal_VkShaderStatisticsInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkShaderStatisticsInfoAMD* forUnmarshaling);
+void unmarshal_VkShaderStatisticsInfoAMD(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkShaderStatisticsInfoAMD* forUnmarshaling);
#define OP_vkGetShaderInfoAMD 20264
#endif
@@ -5223,26 +4036,22 @@
#endif
#ifdef VK_GGP_stream_descriptor_surface
void marshal_VkStreamDescriptorSurfaceCreateInfoGGP(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkStreamDescriptorSurfaceCreateInfoGGP* forMarshaling);
void unmarshal_VkStreamDescriptorSurfaceCreateInfoGGP(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkStreamDescriptorSurfaceCreateInfoGGP* forUnmarshaling);
#define OP_vkCreateStreamDescriptorSurfaceGGP 241902685
#endif
#ifdef VK_NV_corner_sampled_image
void marshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceCornerSampledImageFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceCornerSampledImageFeaturesNV* forUnmarshaling);
#endif
@@ -5250,96 +4059,72 @@
#endif
#ifdef VK_NV_external_memory_capabilities
void marshal_VkExternalImageFormatPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkExternalImageFormatPropertiesNV* forMarshaling);
void unmarshal_VkExternalImageFormatPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkExternalImageFormatPropertiesNV* forUnmarshaling);
#define OP_vkGetPhysicalDeviceExternalImageFormatPropertiesNV 20265
#endif
#ifdef VK_NV_external_memory
void marshal_VkExternalMemoryImageCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkExternalMemoryImageCreateInfoNV* forMarshaling);
void unmarshal_VkExternalMemoryImageCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkExternalMemoryImageCreateInfoNV* forUnmarshaling);
-void marshal_VkExportMemoryAllocateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportMemoryAllocateInfoNV* forMarshaling);
+void marshal_VkExportMemoryAllocateInfoNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportMemoryAllocateInfoNV* forMarshaling);
-void unmarshal_VkExportMemoryAllocateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExportMemoryAllocateInfoNV* forUnmarshaling);
+void unmarshal_VkExportMemoryAllocateInfoNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExportMemoryAllocateInfoNV* forUnmarshaling);
#endif
#ifdef VK_NV_external_memory_win32
-void marshal_VkImportMemoryWin32HandleInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportMemoryWin32HandleInfoNV* forMarshaling);
+void marshal_VkImportMemoryWin32HandleInfoNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportMemoryWin32HandleInfoNV* forMarshaling);
-void unmarshal_VkImportMemoryWin32HandleInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportMemoryWin32HandleInfoNV* forUnmarshaling);
+void unmarshal_VkImportMemoryWin32HandleInfoNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkImportMemoryWin32HandleInfoNV* forUnmarshaling);
-void marshal_VkExportMemoryWin32HandleInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportMemoryWin32HandleInfoNV* forMarshaling);
+void marshal_VkExportMemoryWin32HandleInfoNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportMemoryWin32HandleInfoNV* forMarshaling);
-void unmarshal_VkExportMemoryWin32HandleInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExportMemoryWin32HandleInfoNV* forUnmarshaling);
+void unmarshal_VkExportMemoryWin32HandleInfoNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkExportMemoryWin32HandleInfoNV* forUnmarshaling);
#define OP_vkGetMemoryWin32HandleNV 20266
#endif
#ifdef VK_NV_win32_keyed_mutex
void marshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkWin32KeyedMutexAcquireReleaseInfoNV* forMarshaling);
void unmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkWin32KeyedMutexAcquireReleaseInfoNV* forUnmarshaling);
#endif
#ifdef VK_EXT_validation_flags
-void marshal_VkValidationFlagsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkValidationFlagsEXT* forMarshaling);
+void marshal_VkValidationFlagsEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkValidationFlagsEXT* forMarshaling);
-void unmarshal_VkValidationFlagsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkValidationFlagsEXT* forUnmarshaling);
+void unmarshal_VkValidationFlagsEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkValidationFlagsEXT* forUnmarshaling);
#endif
#ifdef VK_NN_vi_surface
-void marshal_VkViSurfaceCreateInfoNN(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkViSurfaceCreateInfoNN* forMarshaling);
+void marshal_VkViSurfaceCreateInfoNN(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkViSurfaceCreateInfoNN* forMarshaling);
-void unmarshal_VkViSurfaceCreateInfoNN(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkViSurfaceCreateInfoNN* forUnmarshaling);
+void unmarshal_VkViSurfaceCreateInfoNN(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkViSurfaceCreateInfoNN* forUnmarshaling);
#define OP_vkCreateViSurfaceNN 20267
#endif
@@ -5349,91 +4134,71 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
void marshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_astc_decode_mode
-void marshal_VkImageViewASTCDecodeModeEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageViewASTCDecodeModeEXT* forMarshaling);
+void marshal_VkImageViewASTCDecodeModeEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageViewASTCDecodeModeEXT* forMarshaling);
-void unmarshal_VkImageViewASTCDecodeModeEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageViewASTCDecodeModeEXT* forUnmarshaling);
+void unmarshal_VkImageViewASTCDecodeModeEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageViewASTCDecodeModeEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceASTCDecodeFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceASTCDecodeFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_conditional_rendering
void marshal_VkConditionalRenderingBeginInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkConditionalRenderingBeginInfoEXT* forMarshaling);
void unmarshal_VkConditionalRenderingBeginInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkConditionalRenderingBeginInfoEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceConditionalRenderingFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceConditionalRenderingFeaturesEXT* forUnmarshaling);
void marshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkCommandBufferInheritanceConditionalRenderingInfoEXT* forMarshaling);
void unmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkCommandBufferInheritanceConditionalRenderingInfoEXT* forUnmarshaling);
#define OP_vkCmdBeginConditionalRenderingEXT 20268
#define OP_vkCmdEndConditionalRenderingEXT 20269
#endif
#ifdef VK_NV_clip_space_w_scaling
-void marshal_VkViewportWScalingNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkViewportWScalingNV* forMarshaling);
+void marshal_VkViewportWScalingNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkViewportWScalingNV* forMarshaling);
-void unmarshal_VkViewportWScalingNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkViewportWScalingNV* forUnmarshaling);
+void unmarshal_VkViewportWScalingNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkViewportWScalingNV* forUnmarshaling);
void marshal_VkPipelineViewportWScalingStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineViewportWScalingStateCreateInfoNV* forMarshaling);
void unmarshal_VkPipelineViewportWScalingStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineViewportWScalingStateCreateInfoNV* forUnmarshaling);
#define OP_vkCmdSetViewportWScalingNV 20279
@@ -5446,58 +4211,39 @@
#define OP_vkGetRandROutputDisplayEXT 20282
#endif
#ifdef VK_EXT_display_surface_counter
-void marshal_VkSurfaceCapabilities2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceCapabilities2EXT* forMarshaling);
+void marshal_VkSurfaceCapabilities2EXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceCapabilities2EXT* forMarshaling);
-void unmarshal_VkSurfaceCapabilities2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSurfaceCapabilities2EXT* forUnmarshaling);
+void unmarshal_VkSurfaceCapabilities2EXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSurfaceCapabilities2EXT* forUnmarshaling);
#define OP_vkGetPhysicalDeviceSurfaceCapabilities2EXT 20283
#endif
#ifdef VK_EXT_display_control
-void marshal_VkDisplayPowerInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPowerInfoEXT* forMarshaling);
+void marshal_VkDisplayPowerInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPowerInfoEXT* forMarshaling);
-void unmarshal_VkDisplayPowerInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayPowerInfoEXT* forUnmarshaling);
+void unmarshal_VkDisplayPowerInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayPowerInfoEXT* forUnmarshaling);
-void marshal_VkDeviceEventInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceEventInfoEXT* forMarshaling);
+void marshal_VkDeviceEventInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceEventInfoEXT* forMarshaling);
-void unmarshal_VkDeviceEventInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceEventInfoEXT* forUnmarshaling);
+void unmarshal_VkDeviceEventInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceEventInfoEXT* forUnmarshaling);
-void marshal_VkDisplayEventInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayEventInfoEXT* forMarshaling);
+void marshal_VkDisplayEventInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayEventInfoEXT* forMarshaling);
-void unmarshal_VkDisplayEventInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDisplayEventInfoEXT* forUnmarshaling);
+void unmarshal_VkDisplayEventInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDisplayEventInfoEXT* forUnmarshaling);
-void marshal_VkSwapchainCounterCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSwapchainCounterCreateInfoEXT* forMarshaling);
+void marshal_VkSwapchainCounterCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSwapchainCounterCreateInfoEXT* forMarshaling);
-void unmarshal_VkSwapchainCounterCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSwapchainCounterCreateInfoEXT* forUnmarshaling);
+void unmarshal_VkSwapchainCounterCreateInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkSwapchainCounterCreateInfoEXT* forUnmarshaling);
#define OP_vkDisplayPowerControlEXT 20284
#define OP_vkRegisterDeviceEventEXT 20285
@@ -5505,45 +4251,29 @@
#define OP_vkGetSwapchainCounterEXT 20287
#endif
#ifdef VK_GOOGLE_display_timing
-void marshal_VkRefreshCycleDurationGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRefreshCycleDurationGOOGLE* forMarshaling);
+void marshal_VkRefreshCycleDurationGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRefreshCycleDurationGOOGLE* forMarshaling);
-void unmarshal_VkRefreshCycleDurationGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRefreshCycleDurationGOOGLE* forUnmarshaling);
+void unmarshal_VkRefreshCycleDurationGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkRefreshCycleDurationGOOGLE* forUnmarshaling);
-void marshal_VkPastPresentationTimingGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPastPresentationTimingGOOGLE* forMarshaling);
+void marshal_VkPastPresentationTimingGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPastPresentationTimingGOOGLE* forMarshaling);
-void unmarshal_VkPastPresentationTimingGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPastPresentationTimingGOOGLE* forUnmarshaling);
+void unmarshal_VkPastPresentationTimingGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPastPresentationTimingGOOGLE* forUnmarshaling);
-void marshal_VkPresentTimeGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentTimeGOOGLE* forMarshaling);
+void marshal_VkPresentTimeGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentTimeGOOGLE* forMarshaling);
-void unmarshal_VkPresentTimeGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPresentTimeGOOGLE* forUnmarshaling);
+void unmarshal_VkPresentTimeGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPresentTimeGOOGLE* forUnmarshaling);
-void marshal_VkPresentTimesInfoGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentTimesInfoGOOGLE* forMarshaling);
+void marshal_VkPresentTimesInfoGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentTimesInfoGOOGLE* forMarshaling);
-void unmarshal_VkPresentTimesInfoGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPresentTimesInfoGOOGLE* forUnmarshaling);
+void unmarshal_VkPresentTimesInfoGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPresentTimesInfoGOOGLE* forUnmarshaling);
#define OP_vkGetRefreshCycleDurationGOOGLE 20288
#define OP_vkGetPastPresentationTimingGOOGLE 20289
@@ -5556,153 +4286,117 @@
#endif
#ifdef VK_NVX_multiview_per_view_attributes
void marshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forMarshaling);
void unmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forUnmarshaling);
#endif
#ifdef VK_NV_viewport_swizzle
-void marshal_VkViewportSwizzleNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkViewportSwizzleNV* forMarshaling);
+void marshal_VkViewportSwizzleNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkViewportSwizzleNV* forMarshaling);
-void unmarshal_VkViewportSwizzleNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkViewportSwizzleNV* forUnmarshaling);
+void unmarshal_VkViewportSwizzleNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkViewportSwizzleNV* forUnmarshaling);
void marshal_VkPipelineViewportSwizzleStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineViewportSwizzleStateCreateInfoNV* forMarshaling);
void unmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineViewportSwizzleStateCreateInfoNV* forUnmarshaling);
#endif
#ifdef VK_EXT_discard_rectangles
void marshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceDiscardRectanglePropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceDiscardRectanglePropertiesEXT* forUnmarshaling);
void marshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineDiscardRectangleStateCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineDiscardRectangleStateCreateInfoEXT* forUnmarshaling);
#define OP_vkCmdSetDiscardRectangleEXT 20290
#endif
#ifdef VK_EXT_conservative_rasterization
void marshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forUnmarshaling);
void marshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineRasterizationConservativeStateCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineRasterizationConservativeStateCreateInfoEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_depth_clip_enable
void marshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceDepthClipEnableFeaturesEXT* forUnmarshaling);
void marshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineRasterizationDepthClipStateCreateInfoEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
-void marshal_VkXYColorEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkXYColorEXT* forMarshaling);
+void marshal_VkXYColorEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkXYColorEXT* forMarshaling);
-void unmarshal_VkXYColorEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkXYColorEXT* forUnmarshaling);
+void unmarshal_VkXYColorEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkXYColorEXT* forUnmarshaling);
-void marshal_VkHdrMetadataEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkHdrMetadataEXT* forMarshaling);
+void marshal_VkHdrMetadataEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkHdrMetadataEXT* forMarshaling);
-void unmarshal_VkHdrMetadataEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkHdrMetadataEXT* forUnmarshaling);
+void unmarshal_VkHdrMetadataEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkHdrMetadataEXT* forUnmarshaling);
#define OP_vkSetHdrMetadataEXT 20291
#endif
#ifdef VK_MVK_ios_surface
-void marshal_VkIOSSurfaceCreateInfoMVK(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkIOSSurfaceCreateInfoMVK* forMarshaling);
+void marshal_VkIOSSurfaceCreateInfoMVK(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkIOSSurfaceCreateInfoMVK* forMarshaling);
-void unmarshal_VkIOSSurfaceCreateInfoMVK(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkIOSSurfaceCreateInfoMVK* forUnmarshaling);
+void unmarshal_VkIOSSurfaceCreateInfoMVK(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkIOSSurfaceCreateInfoMVK* forUnmarshaling);
#define OP_vkCreateIOSSurfaceMVK 20292
#endif
#ifdef VK_MVK_macos_surface
-void marshal_VkMacOSSurfaceCreateInfoMVK(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMacOSSurfaceCreateInfoMVK* forMarshaling);
+void marshal_VkMacOSSurfaceCreateInfoMVK(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMacOSSurfaceCreateInfoMVK* forMarshaling);
-void unmarshal_VkMacOSSurfaceCreateInfoMVK(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMacOSSurfaceCreateInfoMVK* forUnmarshaling);
+void unmarshal_VkMacOSSurfaceCreateInfoMVK(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMacOSSurfaceCreateInfoMVK* forUnmarshaling);
#define OP_vkCreateMacOSSurfaceMVK 20293
#endif
@@ -5719,55 +4413,39 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
-void marshal_VkDebugUtilsLabelEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugUtilsLabelEXT* forMarshaling);
+void marshal_VkDebugUtilsLabelEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugUtilsLabelEXT* forMarshaling);
-void unmarshal_VkDebugUtilsLabelEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDebugUtilsLabelEXT* forUnmarshaling);
+void unmarshal_VkDebugUtilsLabelEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDebugUtilsLabelEXT* forUnmarshaling);
-void marshal_VkDebugUtilsObjectNameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugUtilsObjectNameInfoEXT* forMarshaling);
+void marshal_VkDebugUtilsObjectNameInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugUtilsObjectNameInfoEXT* forMarshaling);
-void unmarshal_VkDebugUtilsObjectNameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDebugUtilsObjectNameInfoEXT* forUnmarshaling);
+void unmarshal_VkDebugUtilsObjectNameInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDebugUtilsObjectNameInfoEXT* forUnmarshaling);
void marshal_VkDebugUtilsMessengerCallbackDataEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDebugUtilsMessengerCallbackDataEXT* forMarshaling);
void unmarshal_VkDebugUtilsMessengerCallbackDataEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDebugUtilsMessengerCallbackDataEXT* forUnmarshaling);
void marshal_VkDebugUtilsMessengerCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDebugUtilsMessengerCreateInfoEXT* forMarshaling);
void unmarshal_VkDebugUtilsMessengerCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDebugUtilsMessengerCreateInfoEXT* forUnmarshaling);
-void marshal_VkDebugUtilsObjectTagInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugUtilsObjectTagInfoEXT* forMarshaling);
+void marshal_VkDebugUtilsObjectTagInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugUtilsObjectTagInfoEXT* forMarshaling);
-void unmarshal_VkDebugUtilsObjectTagInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDebugUtilsObjectTagInfoEXT* forUnmarshaling);
+void unmarshal_VkDebugUtilsObjectTagInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDebugUtilsObjectTagInfoEXT* forUnmarshaling);
#define OP_vkSetDebugUtilsObjectNameEXT 20294
#define OP_vkSetDebugUtilsObjectTagEXT 20295
@@ -5783,86 +4461,74 @@
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
void marshal_VkAndroidHardwareBufferUsageANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAndroidHardwareBufferUsageANDROID* forMarshaling);
void unmarshal_VkAndroidHardwareBufferUsageANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAndroidHardwareBufferUsageANDROID* forUnmarshaling);
void marshal_VkAndroidHardwareBufferPropertiesANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAndroidHardwareBufferPropertiesANDROID* forMarshaling);
void unmarshal_VkAndroidHardwareBufferPropertiesANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAndroidHardwareBufferPropertiesANDROID* forUnmarshaling);
void marshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAndroidHardwareBufferFormatPropertiesANDROID* forMarshaling);
void unmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAndroidHardwareBufferFormatPropertiesANDROID* forUnmarshaling);
void marshal_VkImportAndroidHardwareBufferInfoANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkImportAndroidHardwareBufferInfoANDROID* forMarshaling);
void unmarshal_VkImportAndroidHardwareBufferInfoANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkImportAndroidHardwareBufferInfoANDROID* forUnmarshaling);
void marshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkMemoryGetAndroidHardwareBufferInfoANDROID* forMarshaling);
void unmarshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkMemoryGetAndroidHardwareBufferInfoANDROID* forUnmarshaling);
-void marshal_VkExternalFormatANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalFormatANDROID* forMarshaling);
+void marshal_VkExternalFormatANDROID(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalFormatANDROID* forMarshaling);
-void unmarshal_VkExternalFormatANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkExternalFormatANDROID* forUnmarshaling);
+void unmarshal_VkExternalFormatANDROID(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkExternalFormatANDROID* forUnmarshaling);
#define OP_vkGetAndroidHardwareBufferPropertiesANDROID 20305
#define OP_vkGetMemoryAndroidHardwareBufferANDROID 20306
void marshal_VkAndroidHardwareBufferFormatProperties2ANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAndroidHardwareBufferFormatProperties2ANDROID* forMarshaling);
void unmarshal_VkAndroidHardwareBufferFormatProperties2ANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAndroidHardwareBufferFormatProperties2ANDROID* forUnmarshaling);
#endif
#ifdef VK_EXT_sampler_filter_minmax
-DEFINE_ALIAS_FUNCTION(marshal_VkSamplerReductionModeCreateInfo, marshal_VkSamplerReductionModeCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(marshal_VkSamplerReductionModeCreateInfo,
+ marshal_VkSamplerReductionModeCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkSamplerReductionModeCreateInfo, unmarshal_VkSamplerReductionModeCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkSamplerReductionModeCreateInfo,
+ unmarshal_VkSamplerReductionModeCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceSamplerFilterMinmaxProperties, marshal_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceSamplerFilterMinmaxProperties,
+ marshal_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties, unmarshal_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties,
+ unmarshal_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT)
#endif
#ifdef VK_AMD_gpu_shader_int16
@@ -5873,185 +4539,141 @@
#endif
#ifdef VK_EXT_inline_uniform_block
void marshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forUnmarshaling);
void marshal_VkWriteDescriptorSetInlineUniformBlockEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkWriteDescriptorSetInlineUniformBlockEXT* forMarshaling);
void unmarshal_VkWriteDescriptorSetInlineUniformBlockEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkWriteDescriptorSetInlineUniformBlockEXT* forUnmarshaling);
void marshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forMarshaling);
void unmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
-void marshal_VkSampleLocationEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSampleLocationEXT* forMarshaling);
+void marshal_VkSampleLocationEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSampleLocationEXT* forMarshaling);
-void unmarshal_VkSampleLocationEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSampleLocationEXT* forUnmarshaling);
+void unmarshal_VkSampleLocationEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSampleLocationEXT* forUnmarshaling);
-void marshal_VkSampleLocationsInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSampleLocationsInfoEXT* forMarshaling);
+void marshal_VkSampleLocationsInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSampleLocationsInfoEXT* forMarshaling);
-void unmarshal_VkSampleLocationsInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSampleLocationsInfoEXT* forUnmarshaling);
+void unmarshal_VkSampleLocationsInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSampleLocationsInfoEXT* forUnmarshaling);
-void marshal_VkAttachmentSampleLocationsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentSampleLocationsEXT* forMarshaling);
+void marshal_VkAttachmentSampleLocationsEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentSampleLocationsEXT* forMarshaling);
-void unmarshal_VkAttachmentSampleLocationsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAttachmentSampleLocationsEXT* forUnmarshaling);
+void unmarshal_VkAttachmentSampleLocationsEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAttachmentSampleLocationsEXT* forUnmarshaling);
-void marshal_VkSubpassSampleLocationsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassSampleLocationsEXT* forMarshaling);
+void marshal_VkSubpassSampleLocationsEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassSampleLocationsEXT* forMarshaling);
-void unmarshal_VkSubpassSampleLocationsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSubpassSampleLocationsEXT* forUnmarshaling);
+void unmarshal_VkSubpassSampleLocationsEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSubpassSampleLocationsEXT* forUnmarshaling);
void marshal_VkRenderPassSampleLocationsBeginInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkRenderPassSampleLocationsBeginInfoEXT* forMarshaling);
void unmarshal_VkRenderPassSampleLocationsBeginInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkRenderPassSampleLocationsBeginInfoEXT* forUnmarshaling);
void marshal_VkPipelineSampleLocationsStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineSampleLocationsStateCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineSampleLocationsStateCreateInfoEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceSampleLocationsPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceSampleLocationsPropertiesEXT* forUnmarshaling);
-void marshal_VkMultisamplePropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMultisamplePropertiesEXT* forMarshaling);
+void marshal_VkMultisamplePropertiesEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMultisamplePropertiesEXT* forMarshaling);
-void unmarshal_VkMultisamplePropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMultisamplePropertiesEXT* forUnmarshaling);
+void unmarshal_VkMultisamplePropertiesEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMultisamplePropertiesEXT* forUnmarshaling);
#define OP_vkCmdSetSampleLocationsEXT 20307
#define OP_vkGetPhysicalDeviceMultisamplePropertiesEXT 20308
#endif
#ifdef VK_EXT_blend_operation_advanced
void marshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forUnmarshaling);
void marshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineColorBlendAdvancedStateCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineColorBlendAdvancedStateCreateInfoEXT* forUnmarshaling);
#endif
#ifdef VK_NV_fragment_coverage_to_color
void marshal_VkPipelineCoverageToColorStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineCoverageToColorStateCreateInfoNV* forMarshaling);
void unmarshal_VkPipelineCoverageToColorStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineCoverageToColorStateCreateInfoNV* forUnmarshaling);
#endif
#ifdef VK_NV_framebuffer_mixed_samples
void marshal_VkPipelineCoverageModulationStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineCoverageModulationStateCreateInfoNV* forMarshaling);
void unmarshal_VkPipelineCoverageModulationStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineCoverageModulationStateCreateInfoNV* forUnmarshaling);
#endif
@@ -6059,23 +4681,19 @@
#endif
#ifdef VK_NV_shader_sm_builtins
void marshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* forUnmarshaling);
void marshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* forUnmarshaling);
#endif
@@ -6083,106 +4701,84 @@
#endif
#ifdef VK_EXT_image_drm_format_modifier
void marshal_VkDrmFormatModifierPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDrmFormatModifierPropertiesEXT* forMarshaling);
-void unmarshal_VkDrmFormatModifierPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDrmFormatModifierPropertiesEXT* forUnmarshaling);
+void unmarshal_VkDrmFormatModifierPropertiesEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkDrmFormatModifierPropertiesEXT* forUnmarshaling);
void marshal_VkDrmFormatModifierPropertiesListEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDrmFormatModifierPropertiesListEXT* forMarshaling);
void unmarshal_VkDrmFormatModifierPropertiesListEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDrmFormatModifierPropertiesListEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceImageDrmFormatModifierInfoEXT* forUnmarshaling);
void marshal_VkImageDrmFormatModifierListCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkImageDrmFormatModifierListCreateInfoEXT* forMarshaling);
void unmarshal_VkImageDrmFormatModifierListCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkImageDrmFormatModifierListCreateInfoEXT* forUnmarshaling);
void marshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkImageDrmFormatModifierExplicitCreateInfoEXT* forMarshaling);
void unmarshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkImageDrmFormatModifierExplicitCreateInfoEXT* forUnmarshaling);
void marshal_VkImageDrmFormatModifierPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkImageDrmFormatModifierPropertiesEXT* forMarshaling);
void unmarshal_VkImageDrmFormatModifierPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkImageDrmFormatModifierPropertiesEXT* forUnmarshaling);
#define OP_vkGetImageDrmFormatModifierPropertiesEXT 251301237
void marshal_VkDrmFormatModifierProperties2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDrmFormatModifierProperties2EXT* forMarshaling);
void unmarshal_VkDrmFormatModifierProperties2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDrmFormatModifierProperties2EXT* forUnmarshaling);
void marshal_VkDrmFormatModifierPropertiesList2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDrmFormatModifierPropertiesList2EXT* forMarshaling);
void unmarshal_VkDrmFormatModifierPropertiesList2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDrmFormatModifierPropertiesList2EXT* forUnmarshaling);
#endif
#ifdef VK_EXT_validation_cache
-void marshal_VkValidationCacheCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkValidationCacheCreateInfoEXT* forMarshaling);
+void marshal_VkValidationCacheCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkValidationCacheCreateInfoEXT* forMarshaling);
-void unmarshal_VkValidationCacheCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkValidationCacheCreateInfoEXT* forUnmarshaling);
+void unmarshal_VkValidationCacheCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkValidationCacheCreateInfoEXT* forUnmarshaling);
void marshal_VkShaderModuleValidationCacheCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkShaderModuleValidationCacheCreateInfoEXT* forMarshaling);
void unmarshal_VkShaderModuleValidationCacheCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkShaderModuleValidationCacheCreateInfoEXT* forUnmarshaling);
#define OP_vkCreateValidationCacheEXT 20309
@@ -6191,98 +4787,88 @@
#define OP_vkGetValidationCacheDataEXT 20312
#endif
#ifdef VK_EXT_descriptor_indexing
-DEFINE_ALIAS_FUNCTION(marshal_VkDescriptorSetLayoutBindingFlagsCreateInfo, marshal_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(marshal_VkDescriptorSetLayoutBindingFlagsCreateInfo,
+ marshal_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo, unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo,
+ unmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceDescriptorIndexingFeatures, marshal_VkPhysicalDeviceDescriptorIndexingFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceDescriptorIndexingFeatures,
+ marshal_VkPhysicalDeviceDescriptorIndexingFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceDescriptorIndexingFeatures, unmarshal_VkPhysicalDeviceDescriptorIndexingFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceDescriptorIndexingFeatures,
+ unmarshal_VkPhysicalDeviceDescriptorIndexingFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceDescriptorIndexingProperties, marshal_VkPhysicalDeviceDescriptorIndexingPropertiesEXT)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceDescriptorIndexingProperties,
+ marshal_VkPhysicalDeviceDescriptorIndexingPropertiesEXT)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceDescriptorIndexingProperties, unmarshal_VkPhysicalDeviceDescriptorIndexingPropertiesEXT)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceDescriptorIndexingProperties,
+ unmarshal_VkPhysicalDeviceDescriptorIndexingPropertiesEXT)
-DEFINE_ALIAS_FUNCTION(marshal_VkDescriptorSetVariableDescriptorCountAllocateInfo, marshal_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT)
+DEFINE_ALIAS_FUNCTION(marshal_VkDescriptorSetVariableDescriptorCountAllocateInfo,
+ marshal_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo, unmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo,
+ unmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT)
-DEFINE_ALIAS_FUNCTION(marshal_VkDescriptorSetVariableDescriptorCountLayoutSupport, marshal_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT)
+DEFINE_ALIAS_FUNCTION(marshal_VkDescriptorSetVariableDescriptorCountLayoutSupport,
+ marshal_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport, unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport,
+ unmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT)
#endif
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_NV_shading_rate_image
-void marshal_VkShadingRatePaletteNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkShadingRatePaletteNV* forMarshaling);
+void marshal_VkShadingRatePaletteNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkShadingRatePaletteNV* forMarshaling);
-void unmarshal_VkShadingRatePaletteNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkShadingRatePaletteNV* forUnmarshaling);
+void unmarshal_VkShadingRatePaletteNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkShadingRatePaletteNV* forUnmarshaling);
void marshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineViewportShadingRateImageStateCreateInfoNV* forMarshaling);
void unmarshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineViewportShadingRateImageStateCreateInfoNV* forUnmarshaling);
void marshal_VkPhysicalDeviceShadingRateImageFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShadingRateImageFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceShadingRateImageFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShadingRateImageFeaturesNV* forUnmarshaling);
void marshal_VkPhysicalDeviceShadingRateImagePropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShadingRateImagePropertiesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceShadingRateImagePropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShadingRateImagePropertiesNV* forUnmarshaling);
-void marshal_VkCoarseSampleLocationNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCoarseSampleLocationNV* forMarshaling);
+void marshal_VkCoarseSampleLocationNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCoarseSampleLocationNV* forMarshaling);
-void unmarshal_VkCoarseSampleLocationNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCoarseSampleLocationNV* forUnmarshaling);
+void unmarshal_VkCoarseSampleLocationNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCoarseSampleLocationNV* forUnmarshaling);
-void marshal_VkCoarseSampleOrderCustomNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCoarseSampleOrderCustomNV* forMarshaling);
+void marshal_VkCoarseSampleOrderCustomNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCoarseSampleOrderCustomNV* forMarshaling);
-void unmarshal_VkCoarseSampleOrderCustomNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCoarseSampleOrderCustomNV* forUnmarshaling);
+void unmarshal_VkCoarseSampleOrderCustomNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCoarseSampleOrderCustomNV* forUnmarshaling);
void marshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* forMarshaling);
void unmarshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* forUnmarshaling);
#define OP_vkCmdBindShadingRateImageNV 238618340
@@ -6291,166 +4877,124 @@
#endif
#ifdef VK_NV_ray_tracing
void marshal_VkRayTracingShaderGroupCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkRayTracingShaderGroupCreateInfoNV* forMarshaling);
void unmarshal_VkRayTracingShaderGroupCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkRayTracingShaderGroupCreateInfoNV* forUnmarshaling);
void marshal_VkRayTracingPipelineCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkRayTracingPipelineCreateInfoNV* forMarshaling);
-void unmarshal_VkRayTracingPipelineCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkRayTracingPipelineCreateInfoNV* forUnmarshaling);
+void unmarshal_VkRayTracingPipelineCreateInfoNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkRayTracingPipelineCreateInfoNV* forUnmarshaling);
-void marshal_VkGeometryTrianglesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeometryTrianglesNV* forMarshaling);
+void marshal_VkGeometryTrianglesNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeometryTrianglesNV* forMarshaling);
-void unmarshal_VkGeometryTrianglesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkGeometryTrianglesNV* forUnmarshaling);
+void unmarshal_VkGeometryTrianglesNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkGeometryTrianglesNV* forUnmarshaling);
-void marshal_VkGeometryAABBNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeometryAABBNV* forMarshaling);
+void marshal_VkGeometryAABBNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeometryAABBNV* forMarshaling);
-void unmarshal_VkGeometryAABBNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkGeometryAABBNV* forUnmarshaling);
+void unmarshal_VkGeometryAABBNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkGeometryAABBNV* forUnmarshaling);
-void marshal_VkGeometryDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeometryDataNV* forMarshaling);
+void marshal_VkGeometryDataNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeometryDataNV* forMarshaling);
-void unmarshal_VkGeometryDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkGeometryDataNV* forUnmarshaling);
+void unmarshal_VkGeometryDataNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkGeometryDataNV* forUnmarshaling);
-void marshal_VkGeometryNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeometryNV* forMarshaling);
+void marshal_VkGeometryNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeometryNV* forMarshaling);
-void unmarshal_VkGeometryNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkGeometryNV* forUnmarshaling);
+void unmarshal_VkGeometryNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkGeometryNV* forUnmarshaling);
-void marshal_VkAccelerationStructureInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureInfoNV* forMarshaling);
+void marshal_VkAccelerationStructureInfoNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureInfoNV* forMarshaling);
-void unmarshal_VkAccelerationStructureInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAccelerationStructureInfoNV* forUnmarshaling);
+void unmarshal_VkAccelerationStructureInfoNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAccelerationStructureInfoNV* forUnmarshaling);
void marshal_VkAccelerationStructureCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAccelerationStructureCreateInfoNV* forMarshaling);
void unmarshal_VkAccelerationStructureCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAccelerationStructureCreateInfoNV* forUnmarshaling);
void marshal_VkBindAccelerationStructureMemoryInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkBindAccelerationStructureMemoryInfoNV* forMarshaling);
void unmarshal_VkBindAccelerationStructureMemoryInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkBindAccelerationStructureMemoryInfoNV* forUnmarshaling);
void marshal_VkWriteDescriptorSetAccelerationStructureNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkWriteDescriptorSetAccelerationStructureNV* forMarshaling);
void unmarshal_VkWriteDescriptorSetAccelerationStructureNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkWriteDescriptorSetAccelerationStructureNV* forUnmarshaling);
void marshal_VkAccelerationStructureMemoryRequirementsInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAccelerationStructureMemoryRequirementsInfoNV* forMarshaling);
void unmarshal_VkAccelerationStructureMemoryRequirementsInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAccelerationStructureMemoryRequirementsInfoNV* forUnmarshaling);
void marshal_VkPhysicalDeviceRayTracingPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceRayTracingPropertiesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceRayTracingPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceRayTracingPropertiesNV* forUnmarshaling);
-void marshal_VkTransformMatrixKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkTransformMatrixKHR* forMarshaling);
+void marshal_VkTransformMatrixKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkTransformMatrixKHR* forMarshaling);
-void unmarshal_VkTransformMatrixKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkTransformMatrixKHR* forUnmarshaling);
+void unmarshal_VkTransformMatrixKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkTransformMatrixKHR* forUnmarshaling);
DEFINE_ALIAS_FUNCTION(marshal_VkTransformMatrixKHR, marshal_VkTransformMatrixNV)
DEFINE_ALIAS_FUNCTION(unmarshal_VkTransformMatrixKHR, unmarshal_VkTransformMatrixNV)
-void marshal_VkAabbPositionsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAabbPositionsKHR* forMarshaling);
+void marshal_VkAabbPositionsKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAabbPositionsKHR* forMarshaling);
-void unmarshal_VkAabbPositionsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkAabbPositionsKHR* forUnmarshaling);
+void unmarshal_VkAabbPositionsKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkAabbPositionsKHR* forUnmarshaling);
DEFINE_ALIAS_FUNCTION(marshal_VkAabbPositionsKHR, marshal_VkAabbPositionsNV)
DEFINE_ALIAS_FUNCTION(unmarshal_VkAabbPositionsKHR, unmarshal_VkAabbPositionsNV)
void marshal_VkAccelerationStructureInstanceKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAccelerationStructureInstanceKHR* forMarshaling);
void unmarshal_VkAccelerationStructureInstanceKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAccelerationStructureInstanceKHR* forUnmarshaling);
-DEFINE_ALIAS_FUNCTION(marshal_VkAccelerationStructureInstanceKHR, marshal_VkAccelerationStructureInstanceNV)
+DEFINE_ALIAS_FUNCTION(marshal_VkAccelerationStructureInstanceKHR,
+ marshal_VkAccelerationStructureInstanceNV)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkAccelerationStructureInstanceKHR, unmarshal_VkAccelerationStructureInstanceNV)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkAccelerationStructureInstanceKHR,
+ unmarshal_VkAccelerationStructureInstanceNV)
#define OP_vkCreateAccelerationStructureNV 259713020
#define OP_vkDestroyAccelerationStructureNV 252775746
@@ -6468,45 +5012,37 @@
#endif
#ifdef VK_NV_representative_fragment_test
void marshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* forUnmarshaling);
void marshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* forMarshaling);
void unmarshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineRepresentativeFragmentTestStateCreateInfoNV* forUnmarshaling);
#endif
#ifdef VK_EXT_filter_cubic
void marshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceImageViewImageFormatInfoEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceImageViewImageFormatInfoEXT* forUnmarshaling);
void marshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkFilterCubicImageViewImageFormatPropertiesEXT* forMarshaling);
void unmarshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkFilterCubicImageViewImageFormatPropertiesEXT* forUnmarshaling);
#endif
@@ -6514,45 +5050,37 @@
#endif
#ifdef VK_EXT_global_priority
void marshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDeviceQueueGlobalPriorityCreateInfoEXT* forMarshaling);
void unmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDeviceQueueGlobalPriorityCreateInfoEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_external_memory_host
void marshal_VkImportMemoryHostPointerInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkImportMemoryHostPointerInfoEXT* forMarshaling);
-void unmarshal_VkImportMemoryHostPointerInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportMemoryHostPointerInfoEXT* forUnmarshaling);
+void unmarshal_VkImportMemoryHostPointerInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkImportMemoryHostPointerInfoEXT* forUnmarshaling);
void marshal_VkMemoryHostPointerPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkMemoryHostPointerPropertiesEXT* forMarshaling);
-void unmarshal_VkMemoryHostPointerPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryHostPointerPropertiesEXT* forUnmarshaling);
+void unmarshal_VkMemoryHostPointerPropertiesEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkMemoryHostPointerPropertiesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forUnmarshaling);
#define OP_vkGetMemoryHostPointerPropertiesEXT 20313
@@ -6562,199 +5090,153 @@
#endif
#ifdef VK_AMD_pipeline_compiler_control
void marshal_VkPipelineCompilerControlCreateInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineCompilerControlCreateInfoAMD* forMarshaling);
void unmarshal_VkPipelineCompilerControlCreateInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineCompilerControlCreateInfoAMD* forUnmarshaling);
#endif
#ifdef VK_EXT_calibrated_timestamps
-void marshal_VkCalibratedTimestampInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCalibratedTimestampInfoEXT* forMarshaling);
+void marshal_VkCalibratedTimestampInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCalibratedTimestampInfoEXT* forMarshaling);
-void unmarshal_VkCalibratedTimestampInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCalibratedTimestampInfoEXT* forUnmarshaling);
+void unmarshal_VkCalibratedTimestampInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCalibratedTimestampInfoEXT* forUnmarshaling);
#define OP_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT 295643221
#define OP_vkGetCalibratedTimestampsEXT 203583186
#endif
#ifdef VK_AMD_shader_core_properties
void marshal_VkPhysicalDeviceShaderCorePropertiesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderCorePropertiesAMD* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShaderCorePropertiesAMD* forUnmarshaling);
#endif
#ifdef VK_EXT_video_decode_h265
-void marshal_VkVideoDecodeH265ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265ProfileEXT* forMarshaling);
+void marshal_VkVideoDecodeH265ProfileEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265ProfileEXT* forMarshaling);
-void unmarshal_VkVideoDecodeH265ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH265ProfileEXT* forUnmarshaling);
+void unmarshal_VkVideoDecodeH265ProfileEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkVideoDecodeH265ProfileEXT* forUnmarshaling);
void marshal_VkVideoDecodeH265CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoDecodeH265CapabilitiesEXT* forMarshaling);
-void unmarshal_VkVideoDecodeH265CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH265CapabilitiesEXT* forUnmarshaling);
+void unmarshal_VkVideoDecodeH265CapabilitiesEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoDecodeH265CapabilitiesEXT* forUnmarshaling);
void marshal_VkVideoDecodeH265SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoDecodeH265SessionCreateInfoEXT* forMarshaling);
void unmarshal_VkVideoDecodeH265SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVideoDecodeH265SessionCreateInfoEXT* forUnmarshaling);
void marshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoDecodeH265SessionParametersAddInfoEXT* forMarshaling);
void unmarshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVideoDecodeH265SessionParametersAddInfoEXT* forUnmarshaling);
void marshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVideoDecodeH265SessionParametersCreateInfoEXT* forMarshaling);
void unmarshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVideoDecodeH265SessionParametersCreateInfoEXT* forUnmarshaling);
-void marshal_VkVideoDecodeH265PictureInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265PictureInfoEXT* forMarshaling);
+void marshal_VkVideoDecodeH265PictureInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265PictureInfoEXT* forMarshaling);
-void unmarshal_VkVideoDecodeH265PictureInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH265PictureInfoEXT* forUnmarshaling);
+void unmarshal_VkVideoDecodeH265PictureInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoDecodeH265PictureInfoEXT* forUnmarshaling);
-void marshal_VkVideoDecodeH265DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265DpbSlotInfoEXT* forMarshaling);
+void marshal_VkVideoDecodeH265DpbSlotInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265DpbSlotInfoEXT* forMarshaling);
-void unmarshal_VkVideoDecodeH265DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkVideoDecodeH265DpbSlotInfoEXT* forUnmarshaling);
+void unmarshal_VkVideoDecodeH265DpbSlotInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkVideoDecodeH265DpbSlotInfoEXT* forUnmarshaling);
#endif
#ifdef VK_AMD_memory_overallocation_behavior
void marshal_VkDeviceMemoryOverallocationCreateInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDeviceMemoryOverallocationCreateInfoAMD* forMarshaling);
void unmarshal_VkDeviceMemoryOverallocationCreateInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDeviceMemoryOverallocationCreateInfoAMD* forUnmarshaling);
#endif
#ifdef VK_EXT_vertex_attribute_divisor
void marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forUnmarshaling);
void marshal_VkVertexInputBindingDivisorDescriptionEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVertexInputBindingDivisorDescriptionEXT* forMarshaling);
void unmarshal_VkVertexInputBindingDivisorDescriptionEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVertexInputBindingDivisorDescriptionEXT* forUnmarshaling);
void marshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineVertexInputDivisorStateCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineVertexInputDivisorStateCreateInfoEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_GGP_frame_token
-void marshal_VkPresentFrameTokenGGP(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentFrameTokenGGP* forMarshaling);
+void marshal_VkPresentFrameTokenGGP(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentFrameTokenGGP* forMarshaling);
-void unmarshal_VkPresentFrameTokenGGP(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPresentFrameTokenGGP* forUnmarshaling);
+void unmarshal_VkPresentFrameTokenGGP(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPresentFrameTokenGGP* forUnmarshaling);
#endif
#ifdef VK_EXT_pipeline_creation_feedback
-void marshal_VkPipelineCreationFeedbackEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCreationFeedbackEXT* forMarshaling);
+void marshal_VkPipelineCreationFeedbackEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCreationFeedbackEXT* forMarshaling);
-void unmarshal_VkPipelineCreationFeedbackEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPipelineCreationFeedbackEXT* forUnmarshaling);
+void unmarshal_VkPipelineCreationFeedbackEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPipelineCreationFeedbackEXT* forUnmarshaling);
void marshal_VkPipelineCreationFeedbackCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineCreationFeedbackCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineCreationFeedbackCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineCreationFeedbackCreateInfoEXT* forUnmarshaling);
#endif
@@ -6762,46 +5244,38 @@
#endif
#ifdef VK_NV_compute_shader_derivatives
void marshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* forUnmarshaling);
#endif
#ifdef VK_NV_mesh_shader
void marshal_VkPhysicalDeviceMeshShaderFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceMeshShaderFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceMeshShaderFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceMeshShaderFeaturesNV* forUnmarshaling);
void marshal_VkPhysicalDeviceMeshShaderPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceMeshShaderPropertiesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceMeshShaderPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceMeshShaderPropertiesNV* forUnmarshaling);
void marshal_VkDrawMeshTasksIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDrawMeshTasksIndirectCommandNV* forMarshaling);
-void unmarshal_VkDrawMeshTasksIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDrawMeshTasksIndirectCommandNV* forUnmarshaling);
+void unmarshal_VkDrawMeshTasksIndirectCommandNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkDrawMeshTasksIndirectCommandNV* forUnmarshaling);
#define OP_vkCmdDrawMeshTasksNV 207334931
#define OP_vkCmdDrawMeshTasksIndirectNV 274079208
@@ -6809,170 +5283,132 @@
#endif
#ifdef VK_NV_fragment_shader_barycentric
void marshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forUnmarshaling);
#endif
#ifdef VK_NV_shader_image_footprint
void marshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderImageFootprintFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShaderImageFootprintFeaturesNV* forUnmarshaling);
#endif
#ifdef VK_NV_scissor_exclusive
void marshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineViewportExclusiveScissorStateCreateInfoNV* forMarshaling);
void unmarshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineViewportExclusiveScissorStateCreateInfoNV* forUnmarshaling);
void marshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceExclusiveScissorFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceExclusiveScissorFeaturesNV* forUnmarshaling);
#define OP_vkCmdSetExclusiveScissorNV 225408194
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
void marshal_VkQueueFamilyCheckpointPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkQueueFamilyCheckpointPropertiesNV* forMarshaling);
void unmarshal_VkQueueFamilyCheckpointPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkQueueFamilyCheckpointPropertiesNV* forUnmarshaling);
-void marshal_VkCheckpointDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCheckpointDataNV* forMarshaling);
+void marshal_VkCheckpointDataNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCheckpointDataNV* forMarshaling);
-void unmarshal_VkCheckpointDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCheckpointDataNV* forUnmarshaling);
+void unmarshal_VkCheckpointDataNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCheckpointDataNV* forUnmarshaling);
#define OP_vkCmdSetCheckpointNV 20315
#define OP_vkGetQueueCheckpointDataNV 20316
#endif
#ifdef VK_INTEL_shader_integer_functions2
void marshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* forUnmarshaling);
#endif
#ifdef VK_INTEL_performance_query
-void marshal_VkPerformanceValueDataINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceValueDataINTEL* forMarshaling);
+void marshal_VkPerformanceValueDataINTEL(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceValueDataINTEL* forMarshaling);
-void unmarshal_VkPerformanceValueDataINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPerformanceValueDataINTEL* forUnmarshaling);
+void unmarshal_VkPerformanceValueDataINTEL(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPerformanceValueDataINTEL* forUnmarshaling);
-void marshal_VkPerformanceValueINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceValueINTEL* forMarshaling);
+void marshal_VkPerformanceValueINTEL(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceValueINTEL* forMarshaling);
-void unmarshal_VkPerformanceValueINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPerformanceValueINTEL* forUnmarshaling);
+void unmarshal_VkPerformanceValueINTEL(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPerformanceValueINTEL* forUnmarshaling);
void marshal_VkInitializePerformanceApiInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkInitializePerformanceApiInfoINTEL* forMarshaling);
void unmarshal_VkInitializePerformanceApiInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkInitializePerformanceApiInfoINTEL* forUnmarshaling);
void marshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkQueryPoolPerformanceQueryCreateInfoINTEL* forMarshaling);
void unmarshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkQueryPoolPerformanceQueryCreateInfoINTEL* forUnmarshaling);
-DEFINE_ALIAS_FUNCTION(marshal_VkQueryPoolPerformanceQueryCreateInfoINTEL, marshal_VkQueryPoolCreateInfoINTEL)
+DEFINE_ALIAS_FUNCTION(marshal_VkQueryPoolPerformanceQueryCreateInfoINTEL,
+ marshal_VkQueryPoolCreateInfoINTEL)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkQueryPoolPerformanceQueryCreateInfoINTEL, unmarshal_VkQueryPoolCreateInfoINTEL)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkQueryPoolPerformanceQueryCreateInfoINTEL,
+ unmarshal_VkQueryPoolCreateInfoINTEL)
-void marshal_VkPerformanceMarkerInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceMarkerInfoINTEL* forMarshaling);
+void marshal_VkPerformanceMarkerInfoINTEL(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceMarkerInfoINTEL* forMarshaling);
-void unmarshal_VkPerformanceMarkerInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPerformanceMarkerInfoINTEL* forUnmarshaling);
+void unmarshal_VkPerformanceMarkerInfoINTEL(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPerformanceMarkerInfoINTEL* forUnmarshaling);
void marshal_VkPerformanceStreamMarkerInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPerformanceStreamMarkerInfoINTEL* forMarshaling);
void unmarshal_VkPerformanceStreamMarkerInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPerformanceStreamMarkerInfoINTEL* forUnmarshaling);
-void marshal_VkPerformanceOverrideInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceOverrideInfoINTEL* forMarshaling);
+void marshal_VkPerformanceOverrideInfoINTEL(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceOverrideInfoINTEL* forMarshaling);
-void unmarshal_VkPerformanceOverrideInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPerformanceOverrideInfoINTEL* forUnmarshaling);
+void unmarshal_VkPerformanceOverrideInfoINTEL(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPerformanceOverrideInfoINTEL* forUnmarshaling);
void marshal_VkPerformanceConfigurationAcquireInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPerformanceConfigurationAcquireInfoINTEL* forMarshaling);
void unmarshal_VkPerformanceConfigurationAcquireInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPerformanceConfigurationAcquireInfoINTEL* forUnmarshaling);
#define OP_vkInitializePerformanceApiINTEL 203336121
@@ -6987,101 +5423,85 @@
#endif
#ifdef VK_EXT_pci_bus_info
void marshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDevicePCIBusInfoPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDevicePCIBusInfoPropertiesEXT* forUnmarshaling);
#endif
#ifdef VK_AMD_display_native_hdr
void marshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDisplayNativeHdrSurfaceCapabilitiesAMD* forMarshaling);
void unmarshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDisplayNativeHdrSurfaceCapabilitiesAMD* forUnmarshaling);
void marshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkSwapchainDisplayNativeHdrCreateInfoAMD* forMarshaling);
void unmarshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkSwapchainDisplayNativeHdrCreateInfoAMD* forUnmarshaling);
#define OP_vkSetLocalDimmingAMD 267533472
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
void marshal_VkImagePipeSurfaceCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkImagePipeSurfaceCreateInfoFUCHSIA* forMarshaling);
void unmarshal_VkImagePipeSurfaceCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkImagePipeSurfaceCreateInfoFUCHSIA* forUnmarshaling);
#define OP_vkCreateImagePipeSurfaceFUCHSIA 261626137
#endif
#ifdef VK_EXT_metal_surface
-void marshal_VkMetalSurfaceCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMetalSurfaceCreateInfoEXT* forMarshaling);
+void marshal_VkMetalSurfaceCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMetalSurfaceCreateInfoEXT* forMarshaling);
-void unmarshal_VkMetalSurfaceCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMetalSurfaceCreateInfoEXT* forUnmarshaling);
+void unmarshal_VkMetalSurfaceCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMetalSurfaceCreateInfoEXT* forUnmarshaling);
#define OP_vkCreateMetalSurfaceEXT 254915953
#endif
#ifdef VK_EXT_fragment_density_map
void marshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceFragmentDensityMapFeaturesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceFragmentDensityMapPropertiesEXT* forUnmarshaling);
void marshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkRenderPassFragmentDensityMapCreateInfoEXT* forMarshaling);
void unmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkRenderPassFragmentDensityMapCreateInfoEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_scalar_block_layout
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceScalarBlockLayoutFeatures, marshal_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceScalarBlockLayoutFeatures,
+ marshal_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures, unmarshal_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures,
+ unmarshal_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT)
#endif
#ifdef VK_GOOGLE_hlsl_functionality1
@@ -7090,424 +5510,354 @@
#endif
#ifdef VK_EXT_subgroup_size_control
void marshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forUnmarshaling);
void marshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forUnmarshaling);
#endif
#ifdef VK_AMD_shader_core_properties2
void marshal_VkPhysicalDeviceShaderCoreProperties2AMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderCoreProperties2AMD* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderCoreProperties2AMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShaderCoreProperties2AMD* forUnmarshaling);
#endif
#ifdef VK_AMD_device_coherent_memory
void marshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceCoherentMemoryFeaturesAMD* forMarshaling);
void unmarshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceCoherentMemoryFeaturesAMD* forUnmarshaling);
#endif
#ifdef VK_EXT_shader_image_atomic_int64
void marshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_memory_budget
void marshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceMemoryBudgetPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceMemoryBudgetPropertiesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_memory_priority
void marshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceMemoryPriorityFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceMemoryPriorityFeaturesEXT* forUnmarshaling);
-void marshal_VkMemoryPriorityAllocateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryPriorityAllocateInfoEXT* forMarshaling);
+void marshal_VkMemoryPriorityAllocateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryPriorityAllocateInfoEXT* forMarshaling);
-void unmarshal_VkMemoryPriorityAllocateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryPriorityAllocateInfoEXT* forUnmarshaling);
+void unmarshal_VkMemoryPriorityAllocateInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkMemoryPriorityAllocateInfoEXT* forUnmarshaling);
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
void marshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* forUnmarshaling);
#endif
#ifdef VK_EXT_buffer_device_address
void marshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* forUnmarshaling);
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, marshal_VkPhysicalDeviceBufferAddressFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT,
+ marshal_VkPhysicalDeviceBufferAddressFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, unmarshal_VkPhysicalDeviceBufferAddressFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT,
+ unmarshal_VkPhysicalDeviceBufferAddressFeaturesEXT)
DEFINE_ALIAS_FUNCTION(marshal_VkBufferDeviceAddressInfo, marshal_VkBufferDeviceAddressInfoEXT)
DEFINE_ALIAS_FUNCTION(unmarshal_VkBufferDeviceAddressInfo, unmarshal_VkBufferDeviceAddressInfoEXT)
void marshal_VkBufferDeviceAddressCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkBufferDeviceAddressCreateInfoEXT* forMarshaling);
void unmarshal_VkBufferDeviceAddressCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkBufferDeviceAddressCreateInfoEXT* forUnmarshaling);
#define OP_vkGetBufferDeviceAddressEXT 224361693
#endif
#ifdef VK_EXT_tooling_info
void marshal_VkPhysicalDeviceToolPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceToolPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceToolPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceToolPropertiesEXT* forUnmarshaling);
#define OP_vkGetPhysicalDeviceToolPropertiesEXT 282247593
#endif
#ifdef VK_EXT_separate_stencil_usage
-DEFINE_ALIAS_FUNCTION(marshal_VkImageStencilUsageCreateInfo, marshal_VkImageStencilUsageCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(marshal_VkImageStencilUsageCreateInfo,
+ marshal_VkImageStencilUsageCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkImageStencilUsageCreateInfo, unmarshal_VkImageStencilUsageCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkImageStencilUsageCreateInfo,
+ unmarshal_VkImageStencilUsageCreateInfoEXT)
#endif
#ifdef VK_EXT_validation_features
-void marshal_VkValidationFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkValidationFeaturesEXT* forMarshaling);
+void marshal_VkValidationFeaturesEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkValidationFeaturesEXT* forMarshaling);
-void unmarshal_VkValidationFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkValidationFeaturesEXT* forUnmarshaling);
+void unmarshal_VkValidationFeaturesEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkValidationFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_NV_cooperative_matrix
-void marshal_VkCooperativeMatrixPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCooperativeMatrixPropertiesNV* forMarshaling);
+void marshal_VkCooperativeMatrixPropertiesNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCooperativeMatrixPropertiesNV* forMarshaling);
-void unmarshal_VkCooperativeMatrixPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCooperativeMatrixPropertiesNV* forUnmarshaling);
+void unmarshal_VkCooperativeMatrixPropertiesNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkCooperativeMatrixPropertiesNV* forUnmarshaling);
void marshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceCooperativeMatrixFeaturesNV* forUnmarshaling);
void marshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceCooperativeMatrixPropertiesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceCooperativeMatrixPropertiesNV* forUnmarshaling);
#define OP_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV 287711429
#endif
#ifdef VK_NV_coverage_reduction_mode
void marshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceCoverageReductionModeFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceCoverageReductionModeFeaturesNV* forUnmarshaling);
void marshal_VkPipelineCoverageReductionStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineCoverageReductionStateCreateInfoNV* forMarshaling);
void unmarshal_VkPipelineCoverageReductionStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineCoverageReductionStateCreateInfoNV* forUnmarshaling);
void marshal_VkFramebufferMixedSamplesCombinationNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkFramebufferMixedSamplesCombinationNV* forMarshaling);
void unmarshal_VkFramebufferMixedSamplesCombinationNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkFramebufferMixedSamplesCombinationNV* forUnmarshaling);
#define OP_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV 292032159
#endif
#ifdef VK_EXT_fragment_shader_interlock
void marshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_ycbcr_image_arrays
void marshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_provoking_vertex
void marshal_VkPhysicalDeviceProvokingVertexFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceProvokingVertexFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceProvokingVertexFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceProvokingVertexFeaturesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceProvokingVertexPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceProvokingVertexPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceProvokingVertexPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceProvokingVertexPropertiesEXT* forUnmarshaling);
void marshal_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_full_screen_exclusive
void marshal_VkSurfaceFullScreenExclusiveInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkSurfaceFullScreenExclusiveInfoEXT* forMarshaling);
void unmarshal_VkSurfaceFullScreenExclusiveInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkSurfaceFullScreenExclusiveInfoEXT* forUnmarshaling);
void marshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkSurfaceCapabilitiesFullScreenExclusiveEXT* forMarshaling);
void unmarshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkSurfaceCapabilitiesFullScreenExclusiveEXT* forUnmarshaling);
#define OP_vkGetPhysicalDeviceSurfacePresentModes2EXT 268126279
#define OP_vkAcquireFullScreenExclusiveModeEXT 200946668
#define OP_vkReleaseFullScreenExclusiveModeEXT 257629142
void marshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkSurfaceFullScreenExclusiveWin32InfoEXT* forMarshaling);
void unmarshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkSurfaceFullScreenExclusiveWin32InfoEXT* forUnmarshaling);
#define OP_vkGetDeviceGroupSurfacePresentModes2EXT 206369543
#endif
#ifdef VK_EXT_headless_surface
-void marshal_VkHeadlessSurfaceCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkHeadlessSurfaceCreateInfoEXT* forMarshaling);
+void marshal_VkHeadlessSurfaceCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkHeadlessSurfaceCreateInfoEXT* forMarshaling);
-void unmarshal_VkHeadlessSurfaceCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkHeadlessSurfaceCreateInfoEXT* forUnmarshaling);
+void unmarshal_VkHeadlessSurfaceCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkHeadlessSurfaceCreateInfoEXT* forUnmarshaling);
#define OP_vkCreateHeadlessSurfaceEXT 298411290
#endif
#ifdef VK_EXT_line_rasterization
void marshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceLineRasterizationFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceLineRasterizationFeaturesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceLineRasterizationPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceLineRasterizationPropertiesEXT* forUnmarshaling);
void marshal_VkPipelineRasterizationLineStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineRasterizationLineStateCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineRasterizationLineStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineRasterizationLineStateCreateInfoEXT* forUnmarshaling);
#define OP_vkCmdSetLineStippleEXT 263855692
#endif
#ifdef VK_EXT_shader_atomic_float
void marshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_host_query_reset
-DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceHostQueryResetFeatures, marshal_VkPhysicalDeviceHostQueryResetFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceHostQueryResetFeatures,
+ marshal_VkPhysicalDeviceHostQueryResetFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceHostQueryResetFeatures, unmarshal_VkPhysicalDeviceHostQueryResetFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceHostQueryResetFeatures,
+ unmarshal_VkPhysicalDeviceHostQueryResetFeaturesEXT)
#define OP_vkResetQueryPoolEXT 242995959
#endif
#ifdef VK_EXT_index_type_uint8
void marshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceIndexTypeUint8FeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_extended_dynamic_state
void marshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* forUnmarshaling);
#define OP_vkCmdSetCullModeEXT 266285895
@@ -7525,157 +5875,122 @@
#endif
#ifdef VK_EXT_shader_atomic_float2
void marshal_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
void marshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_NV_device_generated_commands
void marshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* forUnmarshaling);
void marshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* forUnmarshaling);
void marshal_VkGraphicsShaderGroupCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkGraphicsShaderGroupCreateInfoNV* forMarshaling);
void unmarshal_VkGraphicsShaderGroupCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkGraphicsShaderGroupCreateInfoNV* forUnmarshaling);
void marshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkGraphicsPipelineShaderGroupsCreateInfoNV* forMarshaling);
void unmarshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkGraphicsPipelineShaderGroupsCreateInfoNV* forUnmarshaling);
void marshal_VkBindShaderGroupIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkBindShaderGroupIndirectCommandNV* forMarshaling);
void unmarshal_VkBindShaderGroupIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkBindShaderGroupIndirectCommandNV* forUnmarshaling);
void marshal_VkBindIndexBufferIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkBindIndexBufferIndirectCommandNV* forMarshaling);
void unmarshal_VkBindIndexBufferIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkBindIndexBufferIndirectCommandNV* forUnmarshaling);
void marshal_VkBindVertexBufferIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkBindVertexBufferIndirectCommandNV* forMarshaling);
void unmarshal_VkBindVertexBufferIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkBindVertexBufferIndirectCommandNV* forUnmarshaling);
void marshal_VkSetStateFlagsIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkSetStateFlagsIndirectCommandNV* forMarshaling);
-void unmarshal_VkSetStateFlagsIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSetStateFlagsIndirectCommandNV* forUnmarshaling);
+void unmarshal_VkSetStateFlagsIndirectCommandNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkSetStateFlagsIndirectCommandNV* forUnmarshaling);
-void marshal_VkIndirectCommandsStreamNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkIndirectCommandsStreamNV* forMarshaling);
+void marshal_VkIndirectCommandsStreamNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkIndirectCommandsStreamNV* forMarshaling);
-void unmarshal_VkIndirectCommandsStreamNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkIndirectCommandsStreamNV* forUnmarshaling);
+void unmarshal_VkIndirectCommandsStreamNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkIndirectCommandsStreamNV* forUnmarshaling);
-void marshal_VkIndirectCommandsLayoutTokenNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkIndirectCommandsLayoutTokenNV* forMarshaling);
+void marshal_VkIndirectCommandsLayoutTokenNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkIndirectCommandsLayoutTokenNV* forMarshaling);
-void unmarshal_VkIndirectCommandsLayoutTokenNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkIndirectCommandsLayoutTokenNV* forUnmarshaling);
+void unmarshal_VkIndirectCommandsLayoutTokenNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkIndirectCommandsLayoutTokenNV* forUnmarshaling);
void marshal_VkIndirectCommandsLayoutCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkIndirectCommandsLayoutCreateInfoNV* forMarshaling);
void unmarshal_VkIndirectCommandsLayoutCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkIndirectCommandsLayoutCreateInfoNV* forUnmarshaling);
-void marshal_VkGeneratedCommandsInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeneratedCommandsInfoNV* forMarshaling);
+void marshal_VkGeneratedCommandsInfoNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeneratedCommandsInfoNV* forMarshaling);
-void unmarshal_VkGeneratedCommandsInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkGeneratedCommandsInfoNV* forUnmarshaling);
+void unmarshal_VkGeneratedCommandsInfoNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkGeneratedCommandsInfoNV* forUnmarshaling);
void marshal_VkGeneratedCommandsMemoryRequirementsInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkGeneratedCommandsMemoryRequirementsInfoNV* forMarshaling);
void unmarshal_VkGeneratedCommandsMemoryRequirementsInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkGeneratedCommandsMemoryRequirementsInfoNV* forUnmarshaling);
#define OP_vkGetGeneratedCommandsMemoryRequirementsNV 249047049
@@ -7687,99 +6002,81 @@
#endif
#ifdef VK_NV_inherited_viewport_scissor
void marshal_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceInheritedViewportScissorFeaturesNV* forUnmarshaling);
void marshal_VkCommandBufferInheritanceViewportScissorInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkCommandBufferInheritanceViewportScissorInfoNV* forMarshaling);
void unmarshal_VkCommandBufferInheritanceViewportScissorInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkCommandBufferInheritanceViewportScissorInfoNV* forUnmarshaling);
#endif
#ifdef VK_EXT_texel_buffer_alignment
void marshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forUnmarshaling);
#endif
#ifdef VK_QCOM_render_pass_transform
void marshal_VkRenderPassTransformBeginInfoQCOM(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkRenderPassTransformBeginInfoQCOM* forMarshaling);
void unmarshal_VkRenderPassTransformBeginInfoQCOM(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkRenderPassTransformBeginInfoQCOM* forUnmarshaling);
void marshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* forMarshaling);
void unmarshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkCommandBufferInheritanceRenderPassTransformInfoQCOM* forUnmarshaling);
#endif
#ifdef VK_EXT_device_memory_report
void marshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* forUnmarshaling);
void marshal_VkDeviceMemoryReportCallbackDataEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDeviceMemoryReportCallbackDataEXT* forMarshaling);
void unmarshal_VkDeviceMemoryReportCallbackDataEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDeviceMemoryReportCallbackDataEXT* forUnmarshaling);
void marshal_VkDeviceDeviceMemoryReportCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDeviceDeviceMemoryReportCreateInfoEXT* forMarshaling);
void unmarshal_VkDeviceDeviceMemoryReportCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDeviceDeviceMemoryReportCreateInfoEXT* forUnmarshaling);
#endif
@@ -7789,55 +6086,45 @@
#endif
#ifdef VK_EXT_robustness2
void marshal_VkPhysicalDeviceRobustness2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceRobustness2FeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceRobustness2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceRobustness2FeaturesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceRobustness2PropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceRobustness2PropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceRobustness2PropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceRobustness2PropertiesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_custom_border_color
void marshal_VkSamplerCustomBorderColorCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkSamplerCustomBorderColorCreateInfoEXT* forMarshaling);
void unmarshal_VkSamplerCustomBorderColorCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkSamplerCustomBorderColorCreateInfoEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceCustomBorderColorPropertiesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceCustomBorderColorFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceCustomBorderColorFeaturesEXT* forUnmarshaling);
#endif
@@ -7845,34 +6132,26 @@
#endif
#ifdef VK_EXT_private_data
void marshal_VkPhysicalDevicePrivateDataFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDevicePrivateDataFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDevicePrivateDataFeaturesEXT* forUnmarshaling);
void marshal_VkDevicePrivateDataCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDevicePrivateDataCreateInfoEXT* forMarshaling);
-void unmarshal_VkDevicePrivateDataCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDevicePrivateDataCreateInfoEXT* forUnmarshaling);
+void unmarshal_VkDevicePrivateDataCreateInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkDevicePrivateDataCreateInfoEXT* forUnmarshaling);
-void marshal_VkPrivateDataSlotCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPrivateDataSlotCreateInfoEXT* forMarshaling);
+void marshal_VkPrivateDataSlotCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPrivateDataSlotCreateInfoEXT* forMarshaling);
-void unmarshal_VkPrivateDataSlotCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPrivateDataSlotCreateInfoEXT* forUnmarshaling);
+void unmarshal_VkPrivateDataSlotCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkPrivateDataSlotCreateInfoEXT* forUnmarshaling);
#define OP_vkCreatePrivateDataSlotEXT 236374049
#define OP_vkDestroyPrivateDataSlotEXT 208891309
@@ -7881,35 +6160,29 @@
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
void marshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_NV_device_diagnostics_config
void marshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forUnmarshaling);
void marshal_VkDeviceDiagnosticsConfigCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkDeviceDiagnosticsConfigCreateInfoNV* forMarshaling);
void unmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkDeviceDiagnosticsConfigCreateInfoNV* forUnmarshaling);
#endif
@@ -7917,208 +6190,164 @@
#endif
#ifdef VK_NV_fragment_shading_rate_enums
void marshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* forUnmarshaling);
void marshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* forUnmarshaling);
void marshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* forMarshaling);
void unmarshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineFragmentShadingRateEnumStateCreateInfoNV* forUnmarshaling);
#define OP_vkCmdSetFragmentShadingRateEnumNV 264649847
#endif
#ifdef VK_NV_ray_tracing_motion_blur
-void marshal_VkDeviceOrHostAddressConstKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceOrHostAddressConstKHR* forMarshaling);
+void marshal_VkDeviceOrHostAddressConstKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceOrHostAddressConstKHR* forMarshaling);
-void unmarshal_VkDeviceOrHostAddressConstKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceOrHostAddressConstKHR* forUnmarshaling);
+void unmarshal_VkDeviceOrHostAddressConstKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceOrHostAddressConstKHR* forUnmarshaling);
void marshal_VkAccelerationStructureGeometryMotionTrianglesDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAccelerationStructureGeometryMotionTrianglesDataNV* forMarshaling);
void unmarshal_VkAccelerationStructureGeometryMotionTrianglesDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAccelerationStructureGeometryMotionTrianglesDataNV* forUnmarshaling);
void marshal_VkAccelerationStructureMotionInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAccelerationStructureMotionInfoNV* forMarshaling);
void unmarshal_VkAccelerationStructureMotionInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAccelerationStructureMotionInfoNV* forUnmarshaling);
void marshal_VkAccelerationStructureMatrixMotionInstanceNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAccelerationStructureMatrixMotionInstanceNV* forMarshaling);
void unmarshal_VkAccelerationStructureMatrixMotionInstanceNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAccelerationStructureMatrixMotionInstanceNV* forUnmarshaling);
-void marshal_VkSRTDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSRTDataNV* forMarshaling);
+void marshal_VkSRTDataNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSRTDataNV* forMarshaling);
-void unmarshal_VkSRTDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSRTDataNV* forUnmarshaling);
+void unmarshal_VkSRTDataNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSRTDataNV* forUnmarshaling);
void marshal_VkAccelerationStructureSRTMotionInstanceNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAccelerationStructureSRTMotionInstanceNV* forMarshaling);
void unmarshal_VkAccelerationStructureSRTMotionInstanceNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAccelerationStructureSRTMotionInstanceNV* forUnmarshaling);
void marshal_VkAccelerationStructureMotionInstanceDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAccelerationStructureMotionInstanceDataNV* forMarshaling);
void unmarshal_VkAccelerationStructureMotionInstanceDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAccelerationStructureMotionInstanceDataNV* forUnmarshaling);
void marshal_VkAccelerationStructureMotionInstanceNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAccelerationStructureMotionInstanceNV* forMarshaling);
void unmarshal_VkAccelerationStructureMotionInstanceNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAccelerationStructureMotionInstanceNV* forUnmarshaling);
void marshal_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* forUnmarshaling);
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
void marshal_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_fragment_density_map2
void marshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* forUnmarshaling);
#endif
#ifdef VK_QCOM_rotated_copy_commands
-void marshal_VkCopyCommandTransformInfoQCOM(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyCommandTransformInfoQCOM* forMarshaling);
+void marshal_VkCopyCommandTransformInfoQCOM(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyCommandTransformInfoQCOM* forMarshaling);
-void unmarshal_VkCopyCommandTransformInfoQCOM(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkCopyCommandTransformInfoQCOM* forUnmarshaling);
+void unmarshal_VkCopyCommandTransformInfoQCOM(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkCopyCommandTransformInfoQCOM* forUnmarshaling);
#endif
#ifdef VK_EXT_image_robustness
void marshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceImageRobustnessFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceImageRobustnessFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_4444_formats
void marshal_VkPhysicalDevice4444FormatsFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDevice4444FormatsFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDevice4444FormatsFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDevice4444FormatsFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_rgba10x6_formats
void marshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* forUnmarshaling);
#endif
@@ -8127,137 +6356,111 @@
#define OP_vkGetWinrtDisplayNV 294381219
#endif
#ifdef VK_EXT_directfb_surface
-void marshal_VkDirectFBSurfaceCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDirectFBSurfaceCreateInfoEXT* forMarshaling);
+void marshal_VkDirectFBSurfaceCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDirectFBSurfaceCreateInfoEXT* forMarshaling);
-void unmarshal_VkDirectFBSurfaceCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDirectFBSurfaceCreateInfoEXT* forUnmarshaling);
+void unmarshal_VkDirectFBSurfaceCreateInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDirectFBSurfaceCreateInfoEXT* forUnmarshaling);
#define OP_vkCreateDirectFBSurfaceEXT 220792403
#define OP_vkGetPhysicalDeviceDirectFBPresentationSupportEXT 285441990
#endif
#ifdef VK_VALVE_mutable_descriptor_type
void marshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* forMarshaling);
void unmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* forUnmarshaling);
void marshal_VkMutableDescriptorTypeListVALVE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkMutableDescriptorTypeListVALVE* forMarshaling);
-void unmarshal_VkMutableDescriptorTypeListVALVE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMutableDescriptorTypeListVALVE* forUnmarshaling);
+void unmarshal_VkMutableDescriptorTypeListVALVE(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkMutableDescriptorTypeListVALVE* forUnmarshaling);
void marshal_VkMutableDescriptorTypeCreateInfoVALVE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkMutableDescriptorTypeCreateInfoVALVE* forMarshaling);
void unmarshal_VkMutableDescriptorTypeCreateInfoVALVE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkMutableDescriptorTypeCreateInfoVALVE* forUnmarshaling);
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
void marshal_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* forUnmarshaling);
void marshal_VkVertexInputBindingDescription2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVertexInputBindingDescription2EXT* forMarshaling);
void unmarshal_VkVertexInputBindingDescription2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVertexInputBindingDescription2EXT* forUnmarshaling);
void marshal_VkVertexInputAttributeDescription2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkVertexInputAttributeDescription2EXT* forMarshaling);
void unmarshal_VkVertexInputAttributeDescription2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkVertexInputAttributeDescription2EXT* forUnmarshaling);
#define OP_vkCmdSetVertexInputEXT 211522810
#endif
#ifdef VK_EXT_physical_device_drm
void marshal_VkPhysicalDeviceDrmPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceDrmPropertiesEXT* forMarshaling);
-void unmarshal_VkPhysicalDeviceDrmPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkPhysicalDeviceDrmPropertiesEXT* forUnmarshaling);
+void unmarshal_VkPhysicalDeviceDrmPropertiesEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkPhysicalDeviceDrmPropertiesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_primitive_topology_list_restart
void marshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* forUnmarshaling);
#endif
#ifdef VK_FUCHSIA_external_memory
void marshal_VkImportMemoryZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkImportMemoryZirconHandleInfoFUCHSIA* forMarshaling);
void unmarshal_VkImportMemoryZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkImportMemoryZirconHandleInfoFUCHSIA* forUnmarshaling);
void marshal_VkMemoryZirconHandlePropertiesFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkMemoryZirconHandlePropertiesFUCHSIA* forMarshaling);
void unmarshal_VkMemoryZirconHandlePropertiesFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkMemoryZirconHandlePropertiesFUCHSIA* forUnmarshaling);
void marshal_VkMemoryGetZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkMemoryGetZirconHandleInfoFUCHSIA* forMarshaling);
void unmarshal_VkMemoryGetZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkMemoryGetZirconHandleInfoFUCHSIA* forUnmarshaling);
#define OP_vkGetMemoryZirconHandleFUCHSIA 215089868
@@ -8265,23 +6468,19 @@
#endif
#ifdef VK_FUCHSIA_external_semaphore
void marshal_VkImportSemaphoreZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkImportSemaphoreZirconHandleInfoFUCHSIA* forMarshaling);
void unmarshal_VkImportSemaphoreZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkImportSemaphoreZirconHandleInfoFUCHSIA* forUnmarshaling);
void marshal_VkSemaphoreGetZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkSemaphoreGetZirconHandleInfoFUCHSIA* forMarshaling);
void unmarshal_VkSemaphoreGetZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkSemaphoreGetZirconHandleInfoFUCHSIA* forUnmarshaling);
#define OP_vkImportSemaphoreZirconHandleFUCHSIA 299314530
@@ -8289,104 +6488,78 @@
#endif
#ifdef VK_FUCHSIA_buffer_collection
void marshal_VkBufferCollectionCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkBufferCollectionCreateInfoFUCHSIA* forMarshaling);
void unmarshal_VkBufferCollectionCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkBufferCollectionCreateInfoFUCHSIA* forUnmarshaling);
void marshal_VkImportMemoryBufferCollectionFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkImportMemoryBufferCollectionFUCHSIA* forMarshaling);
void unmarshal_VkImportMemoryBufferCollectionFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkImportMemoryBufferCollectionFUCHSIA* forUnmarshaling);
void marshal_VkBufferCollectionImageCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkBufferCollectionImageCreateInfoFUCHSIA* forMarshaling);
void unmarshal_VkBufferCollectionImageCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkBufferCollectionImageCreateInfoFUCHSIA* forUnmarshaling);
void marshal_VkBufferCollectionConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkBufferCollectionConstraintsInfoFUCHSIA* forMarshaling);
void unmarshal_VkBufferCollectionConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkBufferCollectionConstraintsInfoFUCHSIA* forUnmarshaling);
-void marshal_VkBufferConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferConstraintsInfoFUCHSIA* forMarshaling);
+void marshal_VkBufferConstraintsInfoFUCHSIA(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferConstraintsInfoFUCHSIA* forMarshaling);
-void unmarshal_VkBufferConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkBufferConstraintsInfoFUCHSIA* forUnmarshaling);
+void unmarshal_VkBufferConstraintsInfoFUCHSIA(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkBufferConstraintsInfoFUCHSIA* forUnmarshaling);
void marshal_VkBufferCollectionBufferCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkBufferCollectionBufferCreateInfoFUCHSIA* forMarshaling);
void unmarshal_VkBufferCollectionBufferCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkBufferCollectionBufferCreateInfoFUCHSIA* forUnmarshaling);
-void marshal_VkSysmemColorSpaceFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSysmemColorSpaceFUCHSIA* forMarshaling);
+void marshal_VkSysmemColorSpaceFUCHSIA(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSysmemColorSpaceFUCHSIA* forMarshaling);
-void unmarshal_VkSysmemColorSpaceFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkSysmemColorSpaceFUCHSIA* forUnmarshaling);
+void unmarshal_VkSysmemColorSpaceFUCHSIA(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkSysmemColorSpaceFUCHSIA* forUnmarshaling);
void marshal_VkBufferCollectionPropertiesFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkBufferCollectionPropertiesFUCHSIA* forMarshaling);
void unmarshal_VkBufferCollectionPropertiesFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkBufferCollectionPropertiesFUCHSIA* forUnmarshaling);
void marshal_VkImageFormatConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkImageFormatConstraintsInfoFUCHSIA* forMarshaling);
void unmarshal_VkImageFormatConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkImageFormatConstraintsInfoFUCHSIA* forUnmarshaling);
-void marshal_VkImageConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageConstraintsInfoFUCHSIA* forMarshaling);
+void marshal_VkImageConstraintsInfoFUCHSIA(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageConstraintsInfoFUCHSIA* forMarshaling);
-void unmarshal_VkImageConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImageConstraintsInfoFUCHSIA* forUnmarshaling);
+void unmarshal_VkImageConstraintsInfoFUCHSIA(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImageConstraintsInfoFUCHSIA* forUnmarshaling);
#define OP_vkCreateBufferCollectionFUCHSIA 277502099
#define OP_vkSetBufferCollectionImageConstraintsFUCHSIA 274938613
@@ -8396,33 +6569,27 @@
#endif
#ifdef VK_HUAWEI_subpass_shading
void marshal_VkSubpassShadingPipelineCreateInfoHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkSubpassShadingPipelineCreateInfoHUAWEI* forMarshaling);
void unmarshal_VkSubpassShadingPipelineCreateInfoHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkSubpassShadingPipelineCreateInfoHUAWEI* forUnmarshaling);
void marshal_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* forMarshaling);
void unmarshal_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* forUnmarshaling);
void marshal_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* forMarshaling);
void unmarshal_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* forUnmarshaling);
#define OP_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI 225288634
@@ -8430,49 +6597,39 @@
#endif
#ifdef VK_HUAWEI_invocation_mask
void marshal_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* forMarshaling);
void unmarshal_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* forUnmarshaling);
#define OP_vkCmdBindInvocationMaskHUAWEI 299305130
#endif
#ifdef VK_NV_external_memory_rdma
-void marshal_VkMemoryGetRemoteAddressInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryGetRemoteAddressInfoNV* forMarshaling);
+void marshal_VkMemoryGetRemoteAddressInfoNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryGetRemoteAddressInfoNV* forMarshaling);
-void unmarshal_VkMemoryGetRemoteAddressInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMemoryGetRemoteAddressInfoNV* forUnmarshaling);
+void unmarshal_VkMemoryGetRemoteAddressInfoNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMemoryGetRemoteAddressInfoNV* forUnmarshaling);
void marshal_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* forMarshaling);
void unmarshal_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* forUnmarshaling);
#define OP_vkGetMemoryRemoteAddressNV 256917597
#endif
#ifdef VK_EXT_extended_dynamic_state2
void marshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* forUnmarshaling);
#define OP_vkCmdSetPatchControlPointsEXT 208680354
@@ -8482,72 +6639,52 @@
#define OP_vkCmdSetPrimitiveRestartEnableEXT 299567883
#endif
#ifdef VK_QNX_screen_surface
-void marshal_VkScreenSurfaceCreateInfoQNX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkScreenSurfaceCreateInfoQNX* forMarshaling);
+void marshal_VkScreenSurfaceCreateInfoQNX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkScreenSurfaceCreateInfoQNX* forMarshaling);
-void unmarshal_VkScreenSurfaceCreateInfoQNX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkScreenSurfaceCreateInfoQNX* forUnmarshaling);
+void unmarshal_VkScreenSurfaceCreateInfoQNX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkScreenSurfaceCreateInfoQNX* forUnmarshaling);
#define OP_vkCreateScreenSurfaceQNX 224377168
#define OP_vkGetPhysicalDeviceScreenPresentationSupportQNX 258528902
#endif
#ifdef VK_EXT_color_write_enable
void marshal_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceColorWriteEnableFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceColorWriteEnableFeaturesEXT* forUnmarshaling);
void marshal_VkPipelineColorWriteCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPipelineColorWriteCreateInfoEXT* forMarshaling);
void unmarshal_VkPipelineColorWriteCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPipelineColorWriteCreateInfoEXT* forUnmarshaling);
#define OP_vkCmdSetColorWriteEnableEXT 202223297
#endif
#ifdef VK_GOOGLE_gfxstream
-void marshal_VkImportColorBufferGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportColorBufferGOOGLE* forMarshaling);
+void marshal_VkImportColorBufferGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportColorBufferGOOGLE* forMarshaling);
-void unmarshal_VkImportColorBufferGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportColorBufferGOOGLE* forUnmarshaling);
+void unmarshal_VkImportColorBufferGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImportColorBufferGOOGLE* forUnmarshaling);
-void marshal_VkImportBufferGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportBufferGOOGLE* forMarshaling);
+void marshal_VkImportBufferGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportBufferGOOGLE* forMarshaling);
-void unmarshal_VkImportBufferGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportBufferGOOGLE* forUnmarshaling);
+void unmarshal_VkImportBufferGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImportBufferGOOGLE* forUnmarshaling);
-void marshal_VkImportPhysicalAddressGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportPhysicalAddressGOOGLE* forMarshaling);
+void marshal_VkImportPhysicalAddressGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportPhysicalAddressGOOGLE* forMarshaling);
-void unmarshal_VkImportPhysicalAddressGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkImportPhysicalAddressGOOGLE* forUnmarshaling);
+void unmarshal_VkImportPhysicalAddressGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkImportPhysicalAddressGOOGLE* forUnmarshaling);
#define OP_vkRegisterImageColorBufferGOOGLE 20318
#define OP_vkRegisterBufferColorBufferGOOGLE 20319
@@ -8574,66 +6711,50 @@
#endif
#ifdef VK_EXT_global_priority_query
void marshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* forUnmarshaling);
void marshal_VkQueueFamilyGlobalPriorityPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkQueueFamilyGlobalPriorityPropertiesEXT* forMarshaling);
void unmarshal_VkQueueFamilyGlobalPriorityPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkQueueFamilyGlobalPriorityPropertiesEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_multi_draw
void marshal_VkPhysicalDeviceMultiDrawFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceMultiDrawFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceMultiDrawFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceMultiDrawFeaturesEXT* forUnmarshaling);
void marshal_VkPhysicalDeviceMultiDrawPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceMultiDrawPropertiesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceMultiDrawPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceMultiDrawPropertiesEXT* forUnmarshaling);
-void marshal_VkMultiDrawInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMultiDrawInfoEXT* forMarshaling);
+void marshal_VkMultiDrawInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMultiDrawInfoEXT* forMarshaling);
-void unmarshal_VkMultiDrawInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMultiDrawInfoEXT* forUnmarshaling);
+void unmarshal_VkMultiDrawInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMultiDrawInfoEXT* forUnmarshaling);
-void marshal_VkMultiDrawIndexedInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMultiDrawIndexedInfoEXT* forMarshaling);
+void marshal_VkMultiDrawIndexedInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMultiDrawIndexedInfoEXT* forMarshaling);
-void unmarshal_VkMultiDrawIndexedInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkMultiDrawIndexedInfoEXT* forUnmarshaling);
+void unmarshal_VkMultiDrawIndexedInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkMultiDrawIndexedInfoEXT* forUnmarshaling);
#define OP_vkCmdDrawMultiEXT 263629455
#define OP_vkCmdDrawMultiIndexedEXT 284764463
@@ -8642,218 +6763,174 @@
#endif
#ifdef VK_EXT_border_color_swizzle
void marshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* forUnmarshaling);
void marshal_VkSamplerBorderColorComponentMappingCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkSamplerBorderColorComponentMappingCreateInfoEXT* forMarshaling);
void unmarshal_VkSamplerBorderColorComponentMappingCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkSamplerBorderColorComponentMappingCreateInfoEXT* forUnmarshaling);
#endif
#ifdef VK_EXT_pageable_device_local_memory
void marshal_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* forMarshaling);
void unmarshal_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* forUnmarshaling);
#define OP_vkSetDeviceMemoryPriorityEXT 223991870
#endif
#ifdef VK_KHR_acceleration_structure
-void marshal_VkDeviceOrHostAddressKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceOrHostAddressKHR* forMarshaling);
+void marshal_VkDeviceOrHostAddressKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceOrHostAddressKHR* forMarshaling);
-void unmarshal_VkDeviceOrHostAddressKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkDeviceOrHostAddressKHR* forUnmarshaling);
+void unmarshal_VkDeviceOrHostAddressKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkDeviceOrHostAddressKHR* forUnmarshaling);
void marshal_VkAccelerationStructureBuildRangeInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAccelerationStructureBuildRangeInfoKHR* forMarshaling);
void unmarshal_VkAccelerationStructureBuildRangeInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAccelerationStructureBuildRangeInfoKHR* forUnmarshaling);
void marshal_VkAccelerationStructureGeometryTrianglesDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAccelerationStructureGeometryTrianglesDataKHR* forMarshaling);
void unmarshal_VkAccelerationStructureGeometryTrianglesDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAccelerationStructureGeometryTrianglesDataKHR* forUnmarshaling);
void marshal_VkAccelerationStructureGeometryAabbsDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAccelerationStructureGeometryAabbsDataKHR* forMarshaling);
void unmarshal_VkAccelerationStructureGeometryAabbsDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAccelerationStructureGeometryAabbsDataKHR* forUnmarshaling);
void marshal_VkAccelerationStructureGeometryInstancesDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAccelerationStructureGeometryInstancesDataKHR* forMarshaling);
void unmarshal_VkAccelerationStructureGeometryInstancesDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAccelerationStructureGeometryInstancesDataKHR* forUnmarshaling);
void marshal_VkAccelerationStructureGeometryDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAccelerationStructureGeometryDataKHR* forMarshaling);
void unmarshal_VkAccelerationStructureGeometryDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAccelerationStructureGeometryDataKHR* forUnmarshaling);
void marshal_VkAccelerationStructureGeometryKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAccelerationStructureGeometryKHR* forMarshaling);
void unmarshal_VkAccelerationStructureGeometryKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAccelerationStructureGeometryKHR* forUnmarshaling);
void marshal_VkAccelerationStructureBuildGeometryInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAccelerationStructureBuildGeometryInfoKHR* forMarshaling);
void unmarshal_VkAccelerationStructureBuildGeometryInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAccelerationStructureBuildGeometryInfoKHR* forUnmarshaling);
void marshal_VkAccelerationStructureCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAccelerationStructureCreateInfoKHR* forMarshaling);
void unmarshal_VkAccelerationStructureCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAccelerationStructureCreateInfoKHR* forUnmarshaling);
void marshal_VkWriteDescriptorSetAccelerationStructureKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkWriteDescriptorSetAccelerationStructureKHR* forMarshaling);
void unmarshal_VkWriteDescriptorSetAccelerationStructureKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkWriteDescriptorSetAccelerationStructureKHR* forUnmarshaling);
void marshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceAccelerationStructureFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceAccelerationStructureFeaturesKHR* forUnmarshaling);
void marshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceAccelerationStructurePropertiesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceAccelerationStructurePropertiesKHR* forUnmarshaling);
void marshal_VkAccelerationStructureDeviceAddressInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAccelerationStructureDeviceAddressInfoKHR* forMarshaling);
void unmarshal_VkAccelerationStructureDeviceAddressInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAccelerationStructureDeviceAddressInfoKHR* forUnmarshaling);
void marshal_VkAccelerationStructureVersionInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAccelerationStructureVersionInfoKHR* forMarshaling);
void unmarshal_VkAccelerationStructureVersionInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAccelerationStructureVersionInfoKHR* forUnmarshaling);
void marshal_VkCopyAccelerationStructureToMemoryInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkCopyAccelerationStructureToMemoryInfoKHR* forMarshaling);
void unmarshal_VkCopyAccelerationStructureToMemoryInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkCopyAccelerationStructureToMemoryInfoKHR* forUnmarshaling);
void marshal_VkCopyMemoryToAccelerationStructureInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkCopyMemoryToAccelerationStructureInfoKHR* forMarshaling);
void unmarshal_VkCopyMemoryToAccelerationStructureInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkCopyMemoryToAccelerationStructureInfoKHR* forUnmarshaling);
void marshal_VkCopyAccelerationStructureInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkCopyAccelerationStructureInfoKHR* forMarshaling);
void unmarshal_VkCopyAccelerationStructureInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkCopyAccelerationStructureInfoKHR* forUnmarshaling);
void marshal_VkAccelerationStructureBuildSizesInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkAccelerationStructureBuildSizesInfoKHR* forMarshaling);
void unmarshal_VkAccelerationStructureBuildSizesInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkAccelerationStructureBuildSizesInfoKHR* forUnmarshaling);
#define OP_vkCreateAccelerationStructureKHR 259403971
@@ -8875,74 +6952,57 @@
#endif
#ifdef VK_KHR_ray_tracing_pipeline
void marshal_VkRayTracingShaderGroupCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkRayTracingShaderGroupCreateInfoKHR* forMarshaling);
void unmarshal_VkRayTracingShaderGroupCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkRayTracingShaderGroupCreateInfoKHR* forUnmarshaling);
void marshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkRayTracingPipelineInterfaceCreateInfoKHR* forMarshaling);
void unmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkRayTracingPipelineInterfaceCreateInfoKHR* forUnmarshaling);
void marshal_VkRayTracingPipelineCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkRayTracingPipelineCreateInfoKHR* forMarshaling);
void unmarshal_VkRayTracingPipelineCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkRayTracingPipelineCreateInfoKHR* forUnmarshaling);
void marshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forUnmarshaling);
void marshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forUnmarshaling);
-void marshal_VkStridedDeviceAddressRegionKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkStridedDeviceAddressRegionKHR* forMarshaling);
+void marshal_VkStridedDeviceAddressRegionKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkStridedDeviceAddressRegionKHR* forMarshaling);
-void unmarshal_VkStridedDeviceAddressRegionKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkStridedDeviceAddressRegionKHR* forUnmarshaling);
+void unmarshal_VkStridedDeviceAddressRegionKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ VkStridedDeviceAddressRegionKHR* forUnmarshaling);
-void marshal_VkTraceRaysIndirectCommandKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkTraceRaysIndirectCommandKHR* forMarshaling);
+void marshal_VkTraceRaysIndirectCommandKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkTraceRaysIndirectCommandKHR* forMarshaling);
-void unmarshal_VkTraceRaysIndirectCommandKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- VkTraceRaysIndirectCommandKHR* forUnmarshaling);
+void unmarshal_VkTraceRaysIndirectCommandKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ VkTraceRaysIndirectCommandKHR* forUnmarshaling);
#define OP_vkCmdTraceRaysKHR 213680716
#define OP_vkCreateRayTracingPipelinesKHR 247628685
@@ -8953,22 +7013,19 @@
#endif
#ifdef VK_KHR_ray_query
void marshal_VkPhysicalDeviceRayQueryFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceRayQueryFeaturesKHR* forMarshaling);
void unmarshal_VkPhysicalDeviceRayQueryFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
VkPhysicalDeviceRayQueryFeaturesKHR* forUnmarshaling);
#endif
-const char* api_opcode_to_string(
- const uint32_t opcode);
+const char* api_opcode_to_string(const uint32_t opcode);
#define OP_vkFirst_old 20000
#define OP_vkLast_old 30000
#define OP_vkFirst 200000000
#define OP_vkLast 300000000
-} // namespace goldfish_vk
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_private_defs.h b/system/vulkan_enc/goldfish_vk_private_defs.h
index e591608..0867320 100644
--- a/system/vulkan_enc/goldfish_vk_private_defs.h
+++ b/system/vulkan_enc/goldfish_vk_private_defs.h
@@ -1,10 +1,3 @@
-// Copyright (C) 2018 The Android Open Source Project
-// Copyright (C) 2018 Google 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
@@ -18,348 +11,8 @@
#ifdef __cplusplus
#include <algorithm>
-extern "C" {
#endif
-#define VK_ANDROID_native_buffer 1
-#define VK_ANDROID_NATIVE_BUFFER_EXTENSION_NUMBER 11
-
-/* NOTE ON VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION 6
- *
- * This version of the extension transitions from gralloc0 to gralloc1 usage
- * flags (int -> 2x uint64_t). The WSI implementation will temporarily continue
- * to fill out deprecated fields in VkNativeBufferANDROID, and will call the
- * deprecated vkGetSwapchainGrallocUsageANDROID if the new
- * vkGetSwapchainGrallocUsage2ANDROID is not supported. This transitionary
- * backwards-compatibility support is temporary, and will likely be removed in
- * (along with all gralloc0 support) in a future release.
- */
-#define VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION 7
-#define VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME "VK_ANDROID_native_buffer"
-
-#define VK_ANDROID_NATIVE_BUFFER_ENUM(type,id) ((type)(1000000000 + (1000 * (VK_ANDROID_NATIVE_BUFFER_EXTENSION_NUMBER - 1)) + (id)))
-#define VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 0)
-#define VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 1)
-#define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 2)
-
-typedef enum VkSwapchainImageUsageFlagBitsANDROID {
- VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID = 0x00000001,
- VK_SWAPCHAIN_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkSwapchainImageUsageFlagBitsANDROID;
-typedef VkFlags VkSwapchainImageUsageFlagsANDROID;
-
-typedef struct {
- VkStructureType sType; // must be VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID
- const void* pNext;
-
- // Buffer handle and stride returned from gralloc alloc()
- const uint32_t* handle;
- int stride;
-
- // Gralloc format and usage requested when the buffer was allocated.
- int format;
- int usage; // DEPRECATED in SPEC_VERSION 6
- // -- Added in SPEC_VERSION 6 --
- uint64_t consumer;
- uint64_t producer;
-} VkNativeBufferANDROID;
-
-typedef struct {
- VkStructureType sType; // must be VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID
- const void* pNext;
-
- VkSwapchainImageUsageFlagsANDROID usage;
-} VkSwapchainImageCreateInfoANDROID;
-
-typedef struct {
- VkStructureType sType; // must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID
- const void* pNext;
-
- VkBool32 sharedImage;
-} VkPhysicalDevicePresentationPropertiesANDROID;
-
-// -- DEPRECATED in SPEC_VERSION 6 --
-typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainGrallocUsageANDROID)(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage);
-// -- ADDED in SPEC_VERSION 6 --
-typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainGrallocUsage2ANDROID)(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage, uint64_t* grallocProducerUsage);
-typedef VkResult (VKAPI_PTR *PFN_vkAcquireImageANDROID)(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence);
-typedef VkResult (VKAPI_PTR *PFN_vkQueueSignalReleaseImageANDROID)(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int* pNativeFenceFd);
-
-typedef VkResult (VKAPI_PTR *PFN_vkMapMemoryIntoAddressSpaceGOOGLE)(VkDevice device, VkDeviceMemory memory, uint64_t* pAddress);
-
-#define VK_GOOGLE_gfxstream 1
-#define VK_GOOGLE_GFXSTREAM_EXTENSION_NUMBER 386
-
-#define VK_GOOGLE_GFXSTREAM_ENUM(type,id) ((type)(1000000000 + (1000 * (VK_GOOGLE_GFXSTREAM_EXTENSION_NUMBER - 1)) + (id)))
-#define VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE VK_GOOGLE_GFXSTREAM_ENUM(VkStructureType, 0)
-#define VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE VK_GOOGLE_GFXSTREAM_ENUM(VkStructureType, 1)
-#define VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE VK_GOOGLE_GFXSTREAM_ENUM(VkStructureType, 2)
-
-typedef struct {
- VkStructureType sType; // must be VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE
- const void* pNext;
- uint32_t colorBuffer;
-} VkImportColorBufferGOOGLE;
-
-typedef struct {
- VkStructureType sType; // must be VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE
- const void* pNext;
- uint64_t physicalAddress;
- VkDeviceSize size;
- VkFormat format;
- VkImageTiling tiling;
- uint32_t tilingParameter;
-} VkImportPhysicalAddressGOOGLE;
-
-typedef struct {
- VkStructureType sType; // must be VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE
- const void* pNext;
- uint32_t buffer;
-} VkImportBufferGOOGLE;
-
-typedef VkResult (VKAPI_PTR *PFN_vkRegisterImageColorBufferGOOGLE)(VkDevice device, VkImage image, uint32_t colorBuffer);
-typedef VkResult (VKAPI_PTR *PFN_vkRegisterBufferColorBufferGOOGLE)(VkDevice device, VkBuffer image, uint32_t colorBuffer);
-
-typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostAddressInfoGOOGLE)(VkDevice device, VkDeviceMemory memory, uint64_t* pAddress, uint64_t* pSize);
-
-typedef VkResult (VKAPI_PTR *PFN_vkFreeMemorySyncGOOGLE)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocationCallbacks);
-
-#define VK_ANDROID_external_memory_android_hardware_buffer 1
-struct AHardwareBuffer;
-struct VkAndroidHardwareBufferPropertiesANDROID;
-struct VkMemoryGetAndroidHardwareBufferInfoANDROID;
-
-#ifndef VK_USE_PLATFORM_ANDROID_KHR
-
-typedef struct VkAndroidHardwareBufferUsageANDROID {
- VkStructureType sType;
- void* pNext;
- uint64_t androidHardwareBufferUsage;
-} VkAndroidHardwareBufferUsageANDROID;
-
-typedef struct VkAndroidHardwareBufferPropertiesANDROID {
- VkStructureType sType;
- void* pNext;
- VkDeviceSize allocationSize;
- uint32_t memoryTypeBits;
-} VkAndroidHardwareBufferPropertiesANDROID;
-
-typedef struct VkAndroidHardwareBufferFormatPropertiesANDROID {
- VkStructureType sType;
- void* pNext;
- VkFormat format;
- uint64_t externalFormat;
- VkFormatFeatureFlags formatFeatures;
- VkComponentMapping samplerYcbcrConversionComponents;
- VkSamplerYcbcrModelConversion suggestedYcbcrModel;
- VkSamplerYcbcrRange suggestedYcbcrRange;
- VkChromaLocation suggestedXChromaOffset;
- VkChromaLocation suggestedYChromaOffset;
-} VkAndroidHardwareBufferFormatPropertiesANDROID;
-
-typedef struct VkImportAndroidHardwareBufferInfoANDROID {
- VkStructureType sType;
- const void* pNext;
- struct AHardwareBuffer* buffer;
-} VkImportAndroidHardwareBufferInfoANDROID;
-
-typedef struct VkMemoryGetAndroidHardwareBufferInfoANDROID {
- VkStructureType sType;
- const void* pNext;
- VkDeviceMemory memory;
-} VkMemoryGetAndroidHardwareBufferInfoANDROID;
-
-typedef struct VkExternalFormatANDROID {
- VkStructureType sType;
- void* pNext;
- uint64_t externalFormat;
-} VkExternalFormatANDROID;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties);
-typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID(
- VkDevice device,
- const struct AHardwareBuffer* buffer,
- VkAndroidHardwareBufferPropertiesANDROID* pProperties);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(
- VkDevice device,
- const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
- struct AHardwareBuffer** pBuffer);
-#endif
-
-#endif // __Fuchsia__
-
-#define VK_GOOGLE_sized_descriptor_update_template 1
-
-typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateSizedGOOGLE)(
- VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- uint32_t imageInfoCount,
- uint32_t bufferInfoCount,
- uint32_t bufferViewCount,
- const uint32_t* pImageInfoEntryIndices,
- const uint32_t* pBufferInfoEntryIndices,
- const uint32_t* pBufferViewEntryIndices,
- const VkDescriptorImageInfo* pImageInfos,
- const VkDescriptorBufferInfo* pBufferInfos,
- const VkBufferView* pBufferViews);
-
-#define VK_GOOGLE_async_command_buffers 1
-
-typedef void (VKAPI_PTR *PFN_vkBeginCommandBufferAsyncGOOGLE)(
- VkCommandBuffer commandBuffer,
- const VkCommandBufferBeginInfo* pBeginInfo);
-typedef void (VKAPI_PTR *PFN_vkEndCommandBufferAsyncGOOGLE)(
- VkCommandBuffer commandBuffer);
-typedef void (VKAPI_PTR *PFN_vkResetCommandBufferAsyncGOOGLE)(
- VkCommandBuffer commandBuffer,
- VkCommandBufferResetFlags flags);
-typedef void (VKAPI_PTR *PFN_vkCommandBufferHostSyncGOOGLE)(
- VkCommandBuffer commandBuffer,
- uint32_t needHostSync,
- uint32_t sequenceNumber);
-
-typedef void (VKAPI_PTR *PFN_vkCreateImageWithRequirementsGOOGLE)(
- VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage, VkMemoryRequirements* pMemoryRequirements);
-
-#ifdef VK_USE_PLATFORM_FUCHSIA
-
-#ifndef VK_FUCHSIA_buffer_collection_x
-
-#define VK_FUCHSIA_buffer_collection_x 1
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferCollectionFUCHSIAX)
-#define VK_FUCHSIA_BUFFER_COLLECTION_X_SPEC_VERSION 1
-#define VK_FUCHSIA_BUFFER_COLLECTION_X_EXTENSION_NAME \
- "VK_FUCHSIA_buffer_collection_x"
-
-typedef enum VkImageFormatConstraintsFlagBitsFUCHSIAX {
- VK_IMAGE_FORMAT_CONSTRAINTS_FLAG_BITS_MAX_ENUM_FUCHSIAX = 0x7FFFFFFF
-} VkImageFormatConstraintsFlagBitsFUCHSIAX;
-typedef VkFlags VkImageFormatConstraintsFlagsFUCHSIAX;
-
-typedef enum VkImageConstraintsInfoFlagBitsFUCHSIAX {
- VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIAX = 0x00000001,
- VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIAX = 0x00000002,
- VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIAX = 0x00000004,
- VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIAX = 0x00000008,
- VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIAX = 0x00000010,
- VK_IMAGE_CONSTRAINTS_INFO_FLAG_BITS_MAX_ENUM_FUCHSIAX = 0x7FFFFFFF
-} VkImageConstraintsInfoFlagBitsFUCHSIAX;
-typedef VkFlags VkImageConstraintsInfoFlagsFUCHSIAX;
-typedef struct VkBufferCollectionCreateInfoFUCHSIAX {
- VkStructureType sType;
- const void* pNext;
- uint32_t collectionToken;
-} VkBufferCollectionCreateInfoFUCHSIAX;
-
-typedef struct VkImportMemoryBufferCollectionFUCHSIAX {
- VkStructureType sType;
- const void* pNext;
- VkBufferCollectionFUCHSIAX collection;
- uint32_t index;
-} VkImportMemoryBufferCollectionFUCHSIAX;
-
-typedef struct VkBufferCollectionImageCreateInfoFUCHSIAX {
- VkStructureType sType;
- const void* pNext;
- VkBufferCollectionFUCHSIAX collection;
- uint32_t index;
-} VkBufferCollectionImageCreateInfoFUCHSIAX;
-
-typedef struct VkBufferConstraintsInfoFUCHSIAX {
- VkStructureType sType;
- const void* pNext;
- const VkBufferCreateInfo* pBufferCreateInfo;
- VkFormatFeatureFlags requiredFormatFeatures;
- uint32_t minCount;
-} VkBufferConstraintsInfoFUCHSIAX;
-
-typedef struct VkBufferCollectionBufferCreateInfoFUCHSIAX {
- VkStructureType sType;
- const void* pNext;
- VkBufferCollectionFUCHSIAX collection;
- uint32_t index;
-} VkBufferCollectionBufferCreateInfoFUCHSIAX;
-
-typedef struct VkBufferCollectionPropertiesFUCHSIAX {
- VkStructureType sType;
- void* pNext;
- uint32_t memoryTypeBits;
- uint32_t count;
-} VkBufferCollectionPropertiesFUCHSIAX;
-
-typedef struct VkSysmemColorSpaceFUCHSIAX {
- VkStructureType sType;
- const void* pNext;
- uint32_t colorSpace;
-} VkSysmemColorSpaceFUCHSIAX;
-
-typedef struct VkBufferCollectionProperties2FUCHSIAX {
- VkStructureType sType;
- void* pNext;
- uint32_t memoryTypeBits;
- uint32_t bufferCount;
- uint32_t createInfoIndex;
- uint64_t sysmemFormat;
- VkFormatFeatureFlags formatFeatures;
- VkSysmemColorSpaceFUCHSIAX colorSpace;
- VkComponentMapping samplerYcbcrConversionComponents;
- VkSamplerYcbcrModelConversion suggestedYcbcrModel;
- VkSamplerYcbcrRange suggestedYcbcrRange;
- VkChromaLocation suggestedXChromaOffset;
- VkChromaLocation suggestedYChromaOffset;
-} VkBufferCollectionProperties2FUCHSIAX;
-
-typedef struct VkImageFormatConstraintsInfoFUCHSIAX {
- VkStructureType sType;
- const void* pNext;
- VkFormatFeatureFlags requiredFormatFeatures;
- VkImageFormatConstraintsFlagsFUCHSIAX flags;
- uint64_t sysmemFormat;
- uint32_t colorSpaceCount;
- const VkSysmemColorSpaceFUCHSIAX* pColorSpaces;
-} VkImageFormatConstraintsInfoFUCHSIAX;
-
-typedef struct VkImageConstraintsInfoFUCHSIAX {
- VkStructureType sType;
- const void* pNext;
- uint32_t createInfoCount;
- const VkImageCreateInfo* pCreateInfos;
- const VkImageFormatConstraintsInfoFUCHSIAX* pFormatConstraints;
- uint32_t minBufferCount;
- uint32_t maxBufferCount;
- uint32_t minBufferCountForCamping;
- uint32_t minBufferCountForDedicatedSlack;
- uint32_t minBufferCountForSharedSlack;
- VkImageConstraintsInfoFlagsFUCHSIAX flags;
-} VkImageConstraintsInfoFUCHSIAX;
-
-#define VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIAX \
- ((VkStructureType)1000367000)
-#define VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIAX \
- ((VkStructureType)1000367004)
-#define VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIAX \
- ((VkStructureType)1000367005)
-#define VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIAX \
- ((VkStructureType)1000367006)
-#define VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIAX \
- ((VkStructureType)1000367007)
-#define VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIAX \
- ((VkStructureType)1000367008)
-#define VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIAX \
- ((VkStructureType)1000367009)
-#define VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIAX \
- ((VkStructureType)1000367010)
-#define VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES2_FUCHSIAX \
- ((VkStructureType)1000367011)
-
-#endif // VK_FUCHSIA_buffer_collection_x
-
-#endif // VK_USE_PLATFORM_FUCHSIA
-
// VulkanStream features
#define VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT (1 << 0)
#define VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT (1 << 1)
@@ -368,131 +21,6 @@
#define VK_YCBCR_CONVERSION_DO_NOTHING ((VkSamplerYcbcrConversion)0x1111111111111111)
-// Stuff we advertised but didn't define the structs for it yet because
-// we also needed to update our vulkan headers and xml
-
-#ifndef VK_VERSION_1_2
-
-typedef struct VkPhysicalDeviceShaderFloat16Int8Features {
- VkStructureType sType;
- void* pNext;
- VkBool32 shaderFloat16;
- VkBool32 shaderInt8;
-} VkPhysicalDeviceShaderFloat16Int8Features;
-
-
-#define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES \
- ((VkStructureType)1000082000)
-
-#endif
-
-#define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR \
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES
-
-#define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR \
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES
-
-#ifndef VK_KHR_shader_float16_int8
-
-#define VK_KHR_shader_float16_int8 1
-#define VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION 1
-#define VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME "VK_KHR_shader_float16_int8"
-typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShaderFloat16Int8FeaturesKHR;
-typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceFloat16Int8FeaturesKHR;
-
-#endif
-
-#define VK_GOOGLE_gfxstream 1
-
-typedef void (VKAPI_PTR *PFN_vkQueueHostSyncGOOGLE)(
- VkQueue queue, uint32_t needHostSync, uint32_t sequenceNumber);
-typedef void (VKAPI_PTR *PFN_vkQueueSubmitAsyncGOOGLE)(
- VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
-typedef void (VKAPI_PTR *PFN_vkQueueWaitIdleAsyncGOOGLE)(VkQueue queue);
-typedef void (VKAPI_PTR *PFN_vkQueueBindSparseAsyncGOOGLE)(
- VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
-
-typedef VkResult (VKAPI_PTR *PFN_vkGetLinearImageLayoutGOOGLE)(VkDevice device, VkFormat format, VkDeviceSize* pOffset, VkDeviceSize* pRowPitchAlignment);
-typedef VkResult (VKAPI_PTR *PFN_vkGetLinearImageLayout2GOOGLE)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkDeviceSize* pOffset, VkDeviceSize* pRowPitchAlignment);
-
-typedef void (VKAPI_PTR *PFN_vkQueueFlushCommandsGOOGLE)(VkQueue queue, VkDeviceSize dataSize, const void* pData);
-typedef void (VKAPI_PTR *PFN_vkQueueCommitDescriptorSetUpdatesGOOGLE)(VkQueue queue, uint32_t descriptorPoolCount, const VkDescriptorPool* pDescriptorPools, uint32_t descriptorSetCount, const VkDescriptorSetLayout* pDescriptorSetLayouts, const uint64_t* pDescriptorSetPoolIds, const uint32_t* pDescriptorSetWhichPool, const uint32_t* pDescriptorSetPendingAllocation, const uint32_t* pDescriptorWriteStartingIndices, uint32_t pendingDescriptorWriteCount, const VkWriteDescriptorSet* pPendingDescriptorWrites);
-typedef void (VKAPI_PTR *PFN_vkCollectDescriptorPoolIdsGOOGLE)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t* pPoolIdCount, uint64_t* pPoolIds);
-typedef void (VKAPI_PTR *PFN_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE)(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image);
-
-// TODO(liyl): Remove once Android vulkan-headers is updated
-// to 1.2.184 or higher.
-
-#if VK_HEADER_VERSION < 184
-
-typedef struct VkPipelineCacheHeaderVersionOne {
- uint32_t headerSize;
- VkPipelineCacheHeaderVersion headerVersion;
- uint32_t vendorID;
- uint32_t deviceID;
- uint8_t pipelineCacheUUID[VK_UUID_SIZE];
-} VkPipelineCacheHeaderVersionOne;
-
-#endif // VK_HEADER_VERSION < 184
-
-// TODO(liyl): Remove once Android vulkan-headers is updated
-// to 1.2.195 or higher.
-
-#ifdef VK_EXT_image_drm_format_modifier
-
-#if VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION < 2
-
-#ifndef VK_KHR_format_feature_flags2
-typedef uint64_t VkFormatFeatureFlags2KHR;
-#endif // VK_KHR_format_feature_flags2
-
-#define VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT ((VkStructureType)1000158006)
-typedef struct VkDrmFormatModifierProperties2EXT {
- uint64_t drmFormatModifier;
- uint32_t drmFormatModifierPlaneCount;
- VkFormatFeatureFlags2KHR drmFormatModifierTilingFeatures;
-} VkDrmFormatModifierProperties2EXT;
-
-typedef struct VkDrmFormatModifierPropertiesList2EXT {
- VkStructureType sType;
- void* pNext;
- uint32_t drmFormatModifierCount;
- VkDrmFormatModifierProperties2EXT* pDrmFormatModifierProperties;
-} VkDrmFormatModifierPropertiesList2EXT;
-
-#endif // VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION < 2
-
-#endif // VK_EXT_image_drm_format_modifier
-
-// TODO(liyl): Remove once Android vulkan-headers is updated
-// to 1.2.195 or higher.
-
-#ifdef VK_ANDROID_external_memory_android_hardware_buffer
-
-#if VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION < 4
-
-#define VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID ((VkStructureType)1000129006)
-typedef struct VkAndroidHardwareBufferFormatProperties2ANDROID {
- VkStructureType sType;
- void* pNext;
- VkFormat format;
- uint64_t externalFormat;
- VkFormatFeatureFlags2KHR formatFeatures;
- VkComponentMapping samplerYcbcrConversionComponents;
- VkSamplerYcbcrModelConversion suggestedYcbcrModel;
- VkSamplerYcbcrRange suggestedYcbcrRange;
- VkChromaLocation suggestedXChromaOffset;
- VkChromaLocation suggestedYChromaOffset;
-} VkAndroidHardwareBufferFormatProperties2ANDROID;
-
-#endif // VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION < 4
-
-#endif // VK_ANDROID_external_memory_android_hardware_buffer
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
#ifdef __cplusplus
template<class T, typename F>
diff --git a/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp b/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp
index 3b9e0e4..6960311 100644
--- a/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp
@@ -14,47 +14,40 @@
// limitations under the License.
// Autogenerated module goldfish_vk_reserved_marshaling_guest
-// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal -o ../qemu/android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+//
+// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
+// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
-// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+//
+// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
+// $CEREAL_OUTPUT_DIR
+//
#include "goldfish_vk_reserved_marshaling_guest.h"
-
-#include "goldfish_vk_extension_structs_guest.h"
-#include "goldfish_vk_private_defs.h"
-
#include <cstring>
#include "Resources.h"
-
+#include "goldfish_vk_extension_structs_guest.h"
+#include "goldfish_vk_private_defs.h"
namespace goldfish_vk {
-void reservedmarshal_extension_struct(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const void* structExtension,
- uint8_t** ptr);
+void reservedmarshal_extension_struct(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const void* structExtension, uint8_t** ptr);
-void reservedunmarshal_extension_struct(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- void* structExtension_out,
- uint8_t** ptr);
+void reservedunmarshal_extension_struct(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ void* structExtension_out, uint8_t** ptr);
#ifdef VK_VERSION_1_0
-void reservedmarshal_VkExtent2D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExtent2D* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkExtent2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExtent2D* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->width, sizeof(uint32_t));
@@ -63,12 +56,8 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkExtent3D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExtent3D* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkExtent3D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExtent3D* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->width, sizeof(uint32_t));
@@ -79,12 +68,8 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkOffset2D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkOffset2D* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkOffset2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkOffset2D* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (int32_t*)&forMarshaling->x, sizeof(int32_t));
@@ -93,12 +78,8 @@
*ptr += sizeof(int32_t);
}
-void reservedmarshal_VkOffset3D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkOffset3D* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkOffset3D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkOffset3D* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (int32_t*)&forMarshaling->x, sizeof(int32_t));
@@ -109,64 +90,46 @@
*ptr += sizeof(int32_t);
}
-void reservedmarshal_VkRect2D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRect2D* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkRect2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRect2D* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
reservedmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->offset), ptr);
reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->extent), ptr);
}
-void reservedmarshal_VkBaseInStructure(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBaseInStructure* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkBaseInStructure(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBaseInStructure* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
}
-void reservedmarshal_VkBaseOutStructure(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBaseOutStructure* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkBaseOutStructure(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBaseOutStructure* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
}
-void reservedmarshal_VkBufferMemoryBarrier(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferMemoryBarrier* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkBufferMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferMemoryBarrier* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -188,12 +151,10 @@
*ptr += sizeof(VkDeviceSize);
}
-void reservedmarshal_VkDispatchIndirectCommand(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDispatchIndirectCommand* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDispatchIndirectCommand(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDispatchIndirectCommand* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->x, sizeof(uint32_t));
@@ -204,12 +165,10 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkDrawIndexedIndirectCommand(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrawIndexedIndirectCommand* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDrawIndexedIndirectCommand(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDrawIndexedIndirectCommand* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->indexCount, sizeof(uint32_t));
@@ -224,12 +183,9 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkDrawIndirectCommand(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrawIndirectCommand* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDrawIndirectCommand(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrawIndirectCommand* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->vertexCount, sizeof(uint32_t));
@@ -242,12 +198,9 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkImageSubresourceRange(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageSubresourceRange* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImageSubresourceRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSubresourceRange* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
@@ -262,18 +215,14 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkImageMemoryBarrier(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageMemoryBarrier* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImageMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageMemoryBarrier* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -293,21 +242,17 @@
*&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->image));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
- reservedmarshal_VkImageSubresourceRange(vkStream, rootType, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange), ptr);
+ reservedmarshal_VkImageSubresourceRange(
+ vkStream, rootType, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange), ptr);
}
-void reservedmarshal_VkMemoryBarrier(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryBarrier* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryBarrier* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -318,16 +263,14 @@
}
void reservedmarshal_VkPipelineCacheHeaderVersionOne(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCacheHeaderVersionOne* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCacheHeaderVersionOne* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->headerSize, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkPipelineCacheHeaderVersion*)&forMarshaling->headerVersion, sizeof(VkPipelineCacheHeaderVersion));
+ memcpy(*ptr, (VkPipelineCacheHeaderVersion*)&forMarshaling->headerVersion,
+ sizeof(VkPipelineCacheHeaderVersion));
*ptr += sizeof(VkPipelineCacheHeaderVersion);
memcpy(*ptr, (uint32_t*)&forMarshaling->vendorID, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -337,12 +280,9 @@
*ptr += VK_UUID_SIZE * sizeof(uint8_t);
}
-void reservedmarshal_VkAllocationCallbacks(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAllocationCallbacks* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkAllocationCallbacks(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAllocationCallbacks* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
// WARNING PTR CHECK
@@ -350,8 +290,7 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pUserData)
- {
+ if (forMarshaling->pUserData) {
memcpy(*ptr, (void*)forMarshaling->pUserData, sizeof(uint8_t));
*ptr += sizeof(uint8_t);
}
@@ -377,32 +316,26 @@
*ptr += 8;
}
-void reservedmarshal_VkApplicationInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkApplicationInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkApplicationInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkApplicationInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
- {
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pApplicationName;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pApplicationName)
- {
+ if (forMarshaling->pApplicationName) {
{
- uint32_t l = forMarshaling->pApplicationName ? strlen(forMarshaling->pApplicationName): 0;
+ uint32_t l =
+ forMarshaling->pApplicationName ? strlen(forMarshaling->pApplicationName) : 0;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
@@ -410,11 +343,10 @@
*ptr += l;
}
}
- }
- else
- {
+ } else {
{
- uint32_t l = forMarshaling->pApplicationName ? strlen(forMarshaling->pApplicationName): 0;
+ uint32_t l =
+ forMarshaling->pApplicationName ? strlen(forMarshaling->pApplicationName) : 0;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
@@ -424,17 +356,15 @@
}
memcpy(*ptr, (uint32_t*)&forMarshaling->applicationVersion, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
- {
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pEngineName;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pEngineName)
- {
+ if (forMarshaling->pEngineName) {
{
- uint32_t l = forMarshaling->pEngineName ? strlen(forMarshaling->pEngineName): 0;
+ uint32_t l = forMarshaling->pEngineName ? strlen(forMarshaling->pEngineName) : 0;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
@@ -442,11 +372,9 @@
*ptr += l;
}
}
- }
- else
- {
+ } else {
{
- uint32_t l = forMarshaling->pEngineName ? strlen(forMarshaling->pEngineName): 0;
+ uint32_t l = forMarshaling->pEngineName ? strlen(forMarshaling->pEngineName) : 0;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
@@ -460,28 +388,24 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFormatProperties* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkFormatProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFormatProperties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->linearTilingFeatures, sizeof(VkFormatFeatureFlags));
+ memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->linearTilingFeatures,
+ sizeof(VkFormatFeatureFlags));
*ptr += sizeof(VkFormatFeatureFlags);
- memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->optimalTilingFeatures, sizeof(VkFormatFeatureFlags));
+ memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->optimalTilingFeatures,
+ sizeof(VkFormatFeatureFlags));
*ptr += sizeof(VkFormatFeatureFlags);
- memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->bufferFeatures, sizeof(VkFormatFeatureFlags));
+ memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->bufferFeatures,
+ sizeof(VkFormatFeatureFlags));
*ptr += sizeof(VkFormatFeatureFlags);
}
-void reservedmarshal_VkImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageFormatProperties* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImageFormatProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageFormatProperties* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->maxExtent), ptr);
@@ -495,18 +419,14 @@
*ptr += sizeof(VkDeviceSize);
}
-void reservedmarshal_VkInstanceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkInstanceCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkInstanceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkInstanceCreateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -517,29 +437,28 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pApplicationInfo)
- {
- reservedmarshal_VkApplicationInfo(vkStream, rootType, (const VkApplicationInfo*)(forMarshaling->pApplicationInfo), ptr);
+ if (forMarshaling->pApplicationInfo) {
+ reservedmarshal_VkApplicationInfo(
+ vkStream, rootType, (const VkApplicationInfo*)(forMarshaling->pApplicationInfo), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->enabledLayerCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
{
uint32_t c = 0;
- if (forMarshaling)
- {
+ if (forMarshaling) {
c = forMarshaling->enabledLayerCount;
}
memcpy(*ptr, (uint32_t*)&c, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < c; ++i)
- {
- uint32_t l = forMarshaling->ppEnabledLayerNames ? strlen(forMarshaling->ppEnabledLayerNames[i]): 0;
+ for (uint32_t i = 0; i < c; ++i) {
+ uint32_t l = forMarshaling->ppEnabledLayerNames
+ ? strlen(forMarshaling->ppEnabledLayerNames[i])
+ : 0;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
- if (l)
- {
+ if (l) {
memcpy(*ptr, (char*)(forMarshaling->ppEnabledLayerNames[i]), l);
*ptr += l;
}
@@ -549,21 +468,20 @@
*ptr += sizeof(uint32_t);
{
uint32_t c = 0;
- if (forMarshaling)
- {
+ if (forMarshaling) {
c = forMarshaling->enabledExtensionCount;
}
memcpy(*ptr, (uint32_t*)&c, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < c; ++i)
- {
- uint32_t l = forMarshaling->ppEnabledExtensionNames ? strlen(forMarshaling->ppEnabledExtensionNames[i]): 0;
+ for (uint32_t i = 0; i < c; ++i) {
+ uint32_t l = forMarshaling->ppEnabledExtensionNames
+ ? strlen(forMarshaling->ppEnabledExtensionNames[i])
+ : 0;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
- if (l)
- {
+ if (l) {
memcpy(*ptr, (char*)(forMarshaling->ppEnabledExtensionNames[i]), l);
*ptr += l;
}
@@ -571,12 +489,8 @@
}
}
-void reservedmarshal_VkMemoryHeap(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryHeap* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkMemoryHeap(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryHeap* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
@@ -585,26 +499,20 @@
*ptr += sizeof(VkMemoryHeapFlags);
}
-void reservedmarshal_VkMemoryType(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryType* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkMemoryType(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryType* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- memcpy(*ptr, (VkMemoryPropertyFlags*)&forMarshaling->propertyFlags, sizeof(VkMemoryPropertyFlags));
+ memcpy(*ptr, (VkMemoryPropertyFlags*)&forMarshaling->propertyFlags,
+ sizeof(VkMemoryPropertyFlags));
*ptr += sizeof(VkMemoryPropertyFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->heapIndex, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkPhysicalDeviceFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFeatures* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPhysicalDeviceFeatures(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFeatures* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkBool32*)&forMarshaling->robustBufferAccess, sizeof(VkBool32));
@@ -661,7 +569,8 @@
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentStoresAndAtomics, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderTessellationAndGeometryPointSize, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderTessellationAndGeometryPointSize,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderImageGatherExtended, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -673,13 +582,17 @@
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageImageWriteWithoutFormat, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderUniformBufferArrayDynamicIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderUniformBufferArrayDynamicIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSampledImageArrayDynamicIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSampledImageArrayDynamicIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageBufferArrayDynamicIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageBufferArrayDynamicIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageImageArrayDynamicIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageImageArrayDynamicIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderClipDistance, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -719,12 +632,9 @@
*ptr += sizeof(VkBool32);
}
-void reservedmarshal_VkPhysicalDeviceLimits(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceLimits* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPhysicalDeviceLimits(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceLimits* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->maxImageDimension1D, sizeof(uint32_t));
@@ -765,7 +675,8 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorStorageImages, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorInputAttachments, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorInputAttachments,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageResources, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -773,11 +684,13 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUniformBuffers, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUniformBuffersDynamic, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUniformBuffersDynamic,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetStorageBuffers, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetStorageBuffersDynamic, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetStorageBuffersDynamic,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetSampledImages, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -799,17 +712,23 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxTessellationPatchSize, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxTessellationControlPerVertexInputComponents, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxTessellationControlPerVertexInputComponents,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxTessellationControlPerVertexOutputComponents, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxTessellationControlPerVertexOutputComponents,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxTessellationControlPerPatchOutputComponents, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxTessellationControlPerPatchOutputComponents,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxTessellationControlTotalOutputComponents, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxTessellationControlTotalOutputComponents,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxTessellationEvaluationInputComponents, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxTessellationEvaluationInputComponents,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxTessellationEvaluationOutputComponents, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxTessellationEvaluationOutputComponents,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxGeometryShaderInvocations, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -863,11 +782,14 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- memcpy(*ptr, (VkDeviceSize*)&forMarshaling->minTexelBufferOffsetAlignment, sizeof(VkDeviceSize));
+ memcpy(*ptr, (VkDeviceSize*)&forMarshaling->minTexelBufferOffsetAlignment,
+ sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
- memcpy(*ptr, (VkDeviceSize*)&forMarshaling->minUniformBufferOffsetAlignment, sizeof(VkDeviceSize));
+ memcpy(*ptr, (VkDeviceSize*)&forMarshaling->minUniformBufferOffsetAlignment,
+ sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
- memcpy(*ptr, (VkDeviceSize*)&forMarshaling->minStorageBufferOffsetAlignment, sizeof(VkDeviceSize));
+ memcpy(*ptr, (VkDeviceSize*)&forMarshaling->minStorageBufferOffsetAlignment,
+ sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (int32_t*)&forMarshaling->minTexelOffset, sizeof(int32_t));
*ptr += sizeof(int32_t);
@@ -889,25 +811,34 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxFramebufferLayers, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->framebufferColorSampleCounts, sizeof(VkSampleCountFlags));
+ memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->framebufferColorSampleCounts,
+ sizeof(VkSampleCountFlags));
*ptr += sizeof(VkSampleCountFlags);
- memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->framebufferDepthSampleCounts, sizeof(VkSampleCountFlags));
+ memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->framebufferDepthSampleCounts,
+ sizeof(VkSampleCountFlags));
*ptr += sizeof(VkSampleCountFlags);
- memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->framebufferStencilSampleCounts, sizeof(VkSampleCountFlags));
+ memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->framebufferStencilSampleCounts,
+ sizeof(VkSampleCountFlags));
*ptr += sizeof(VkSampleCountFlags);
- memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->framebufferNoAttachmentsSampleCounts, sizeof(VkSampleCountFlags));
+ memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->framebufferNoAttachmentsSampleCounts,
+ sizeof(VkSampleCountFlags));
*ptr += sizeof(VkSampleCountFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxColorAttachments, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->sampledImageColorSampleCounts, sizeof(VkSampleCountFlags));
+ memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->sampledImageColorSampleCounts,
+ sizeof(VkSampleCountFlags));
*ptr += sizeof(VkSampleCountFlags);
- memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->sampledImageIntegerSampleCounts, sizeof(VkSampleCountFlags));
+ memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->sampledImageIntegerSampleCounts,
+ sizeof(VkSampleCountFlags));
*ptr += sizeof(VkSampleCountFlags);
- memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->sampledImageDepthSampleCounts, sizeof(VkSampleCountFlags));
+ memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->sampledImageDepthSampleCounts,
+ sizeof(VkSampleCountFlags));
*ptr += sizeof(VkSampleCountFlags);
- memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->sampledImageStencilSampleCounts, sizeof(VkSampleCountFlags));
+ memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->sampledImageStencilSampleCounts,
+ sizeof(VkSampleCountFlags));
*ptr += sizeof(VkSampleCountFlags);
- memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->storageImageSampleCounts, sizeof(VkSampleCountFlags));
+ memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->storageImageSampleCounts,
+ sizeof(VkSampleCountFlags));
*ptr += sizeof(VkSampleCountFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxSampleMaskWords, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -935,47 +866,44 @@
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->standardSampleLocations, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkDeviceSize*)&forMarshaling->optimalBufferCopyOffsetAlignment, sizeof(VkDeviceSize));
+ memcpy(*ptr, (VkDeviceSize*)&forMarshaling->optimalBufferCopyOffsetAlignment,
+ sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
- memcpy(*ptr, (VkDeviceSize*)&forMarshaling->optimalBufferCopyRowPitchAlignment, sizeof(VkDeviceSize));
+ memcpy(*ptr, (VkDeviceSize*)&forMarshaling->optimalBufferCopyRowPitchAlignment,
+ sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->nonCoherentAtomSize, sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
}
void reservedmarshal_VkPhysicalDeviceMemoryProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryProperties* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryProperties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->memoryTypeCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i)
- {
- reservedmarshal_VkMemoryType(vkStream, rootType, (VkMemoryType*)(forMarshaling->memoryTypes + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i) {
+ reservedmarshal_VkMemoryType(vkStream, rootType,
+ (VkMemoryType*)(forMarshaling->memoryTypes + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->memoryHeapCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i)
- {
- reservedmarshal_VkMemoryHeap(vkStream, rootType, (VkMemoryHeap*)(forMarshaling->memoryHeaps + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i) {
+ reservedmarshal_VkMemoryHeap(vkStream, rootType,
+ (VkMemoryHeap*)(forMarshaling->memoryHeaps + i), ptr);
}
}
void reservedmarshal_VkPhysicalDeviceSparseProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSparseProperties* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSparseProperties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkBool32*)&forMarshaling->residencyStandard2DBlockShape, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->residencyStandard2DMultisampleBlockShape, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->residencyStandard2DMultisampleBlockShape,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->residencyStandard3DBlockShape, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -985,12 +913,10 @@
*ptr += sizeof(VkBool32);
}
-void reservedmarshal_VkPhysicalDeviceProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceProperties* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPhysicalDeviceProperties(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkPhysicalDeviceProperties* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->apiVersion, sizeof(uint32_t));
@@ -1007,16 +933,16 @@
*ptr += VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char);
memcpy(*ptr, (uint8_t*)forMarshaling->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
*ptr += VK_UUID_SIZE * sizeof(uint8_t);
- reservedmarshal_VkPhysicalDeviceLimits(vkStream, rootType, (VkPhysicalDeviceLimits*)(&forMarshaling->limits), ptr);
- reservedmarshal_VkPhysicalDeviceSparseProperties(vkStream, rootType, (VkPhysicalDeviceSparseProperties*)(&forMarshaling->sparseProperties), ptr);
+ reservedmarshal_VkPhysicalDeviceLimits(vkStream, rootType,
+ (VkPhysicalDeviceLimits*)(&forMarshaling->limits), ptr);
+ reservedmarshal_VkPhysicalDeviceSparseProperties(
+ vkStream, rootType, (VkPhysicalDeviceSparseProperties*)(&forMarshaling->sparseProperties),
+ ptr);
}
-void reservedmarshal_VkQueueFamilyProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueueFamilyProperties* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkQueueFamilyProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyProperties* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkQueueFlags*)&forMarshaling->queueFlags, sizeof(VkQueueFlags));
@@ -1025,46 +951,40 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->timestampValidBits, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->minImageTransferGranularity), ptr);
+ reservedmarshal_VkExtent3D(vkStream, rootType,
+ (VkExtent3D*)(&forMarshaling->minImageTransferGranularity), ptr);
}
-void reservedmarshal_VkDeviceQueueCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceQueueCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDeviceQueueCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceQueueCreateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDeviceQueueCreateFlags*)&forMarshaling->flags, sizeof(VkDeviceQueueCreateFlags));
+ memcpy(*ptr, (VkDeviceQueueCreateFlags*)&forMarshaling->flags,
+ sizeof(VkDeviceQueueCreateFlags));
*ptr += sizeof(VkDeviceQueueCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->queueCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const float*)forMarshaling->pQueuePriorities, forMarshaling->queueCount * sizeof(const float));
+ memcpy(*ptr, (const float*)forMarshaling->pQueuePriorities,
+ forMarshaling->queueCount * sizeof(const float));
*ptr += forMarshaling->queueCount * sizeof(const float);
}
-void reservedmarshal_VkDeviceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDeviceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -1072,29 +992,29 @@
*ptr += sizeof(VkDeviceCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->queueCreateInfoCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueCreateInfoCount; ++i)
- {
- reservedmarshal_VkDeviceQueueCreateInfo(vkStream, rootType, (const VkDeviceQueueCreateInfo*)(forMarshaling->pQueueCreateInfos + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueCreateInfoCount; ++i) {
+ reservedmarshal_VkDeviceQueueCreateInfo(
+ vkStream, rootType,
+ (const VkDeviceQueueCreateInfo*)(forMarshaling->pQueueCreateInfos + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->enabledLayerCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
{
uint32_t c = 0;
- if (forMarshaling)
- {
+ if (forMarshaling) {
c = forMarshaling->enabledLayerCount;
}
memcpy(*ptr, (uint32_t*)&c, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < c; ++i)
- {
- uint32_t l = forMarshaling->ppEnabledLayerNames ? strlen(forMarshaling->ppEnabledLayerNames[i]): 0;
+ for (uint32_t i = 0; i < c; ++i) {
+ uint32_t l = forMarshaling->ppEnabledLayerNames
+ ? strlen(forMarshaling->ppEnabledLayerNames[i])
+ : 0;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
- if (l)
- {
+ if (l) {
memcpy(*ptr, (char*)(forMarshaling->ppEnabledLayerNames[i]), l);
*ptr += l;
}
@@ -1104,21 +1024,20 @@
*ptr += sizeof(uint32_t);
{
uint32_t c = 0;
- if (forMarshaling)
- {
+ if (forMarshaling) {
c = forMarshaling->enabledExtensionCount;
}
memcpy(*ptr, (uint32_t*)&c, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < c; ++i)
- {
- uint32_t l = forMarshaling->ppEnabledExtensionNames ? strlen(forMarshaling->ppEnabledExtensionNames[i]): 0;
+ for (uint32_t i = 0; i < c; ++i) {
+ uint32_t l = forMarshaling->ppEnabledExtensionNames
+ ? strlen(forMarshaling->ppEnabledExtensionNames[i])
+ : 0;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
- if (l)
- {
+ if (l) {
memcpy(*ptr, (char*)(forMarshaling->ppEnabledExtensionNames[i]), l);
*ptr += l;
}
@@ -1129,18 +1048,16 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pEnabledFeatures)
- {
- reservedmarshal_VkPhysicalDeviceFeatures(vkStream, rootType, (const VkPhysicalDeviceFeatures*)(forMarshaling->pEnabledFeatures), ptr);
+ if (forMarshaling->pEnabledFeatures) {
+ reservedmarshal_VkPhysicalDeviceFeatures(
+ vkStream, rootType, (const VkPhysicalDeviceFeatures*)(forMarshaling->pEnabledFeatures),
+ ptr);
}
}
-void reservedmarshal_VkExtensionProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExtensionProperties* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkExtensionProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExtensionProperties* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (char*)forMarshaling->extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
@@ -1149,12 +1066,8 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkLayerProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkLayerProperties* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkLayerProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkLayerProperties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (char*)forMarshaling->layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
@@ -1167,47 +1080,37 @@
*ptr += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
}
-void reservedmarshal_VkSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubmitInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubmitInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- if (forMarshaling->waitSemaphoreCount)
- {
+ if (forMarshaling->waitSemaphoreCount) {
uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->waitSemaphoreCount; ++k)
- {
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->waitSemaphoreCount; ++k) {
uint64_t tmpval = get_host_u64_VkSemaphore(forMarshaling->pWaitSemaphores[k]);
memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
}
*ptr += 8 * forMarshaling->waitSemaphoreCount;
}
- memcpy(*ptr, (const VkPipelineStageFlags*)forMarshaling->pWaitDstStageMask, forMarshaling->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
+ memcpy(*ptr, (const VkPipelineStageFlags*)forMarshaling->pWaitDstStageMask,
+ forMarshaling->waitSemaphoreCount * sizeof(const VkPipelineStageFlags));
*ptr += forMarshaling->waitSemaphoreCount * sizeof(const VkPipelineStageFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- if (forMarshaling->commandBufferCount)
- {
+ if (forMarshaling->commandBufferCount) {
uint8_t* cgen_var_1_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->commandBufferCount; ++k)
- {
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->commandBufferCount; ++k) {
uint64_t tmpval = get_host_u64_VkCommandBuffer(forMarshaling->pCommandBuffers[k]);
memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -1216,13 +1119,10 @@
}
memcpy(*ptr, (uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- if (forMarshaling->signalSemaphoreCount)
- {
+ if (forMarshaling->signalSemaphoreCount) {
uint8_t* cgen_var_2_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->signalSemaphoreCount; ++k)
- {
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->signalSemaphoreCount; ++k) {
uint64_t tmpval = get_host_u64_VkSemaphore(forMarshaling->pSignalSemaphores[k]);
memcpy(cgen_var_2_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -1231,18 +1131,13 @@
}
}
-void reservedmarshal_VkMappedMemoryRange(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMappedMemoryRange* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkMappedMemoryRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMappedMemoryRange* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -1256,18 +1151,14 @@
*ptr += sizeof(VkDeviceSize);
}
-void reservedmarshal_VkMemoryAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryAllocateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkMemoryAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryAllocateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -1277,12 +1168,9 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkMemoryRequirements(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryRequirements* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkMemoryRequirements(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryRequirements* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
@@ -1293,12 +1181,8 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkSparseMemoryBind(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseMemoryBind* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSparseMemoryBind(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseMemoryBind* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->resourceOffset, sizeof(VkDeviceSize));
@@ -1315,12 +1199,10 @@
*ptr += sizeof(VkSparseMemoryBindFlags);
}
-void reservedmarshal_VkSparseBufferMemoryBindInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseBufferMemoryBindInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSparseBufferMemoryBindInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkSparseBufferMemoryBindInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
uint64_t cgen_var_0;
@@ -1329,18 +1211,15 @@
*ptr += 1 * 8;
memcpy(*ptr, (uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
- {
- reservedmarshal_VkSparseMemoryBind(vkStream, rootType, (const VkSparseMemoryBind*)(forMarshaling->pBinds + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i) {
+ reservedmarshal_VkSparseMemoryBind(
+ vkStream, rootType, (const VkSparseMemoryBind*)(forMarshaling->pBinds + i), ptr);
}
}
void reservedmarshal_VkSparseImageOpaqueMemoryBindInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageOpaqueMemoryBindInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageOpaqueMemoryBindInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
uint64_t cgen_var_0;
@@ -1349,18 +1228,14 @@
*ptr += 1 * 8;
memcpy(*ptr, (uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
- {
- reservedmarshal_VkSparseMemoryBind(vkStream, rootType, (const VkSparseMemoryBind*)(forMarshaling->pBinds + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i) {
+ reservedmarshal_VkSparseMemoryBind(
+ vkStream, rootType, (const VkSparseMemoryBind*)(forMarshaling->pBinds + i), ptr);
}
}
-void reservedmarshal_VkImageSubresource(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageSubresource* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImageSubresource(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSubresource* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
@@ -1371,15 +1246,13 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkSparseImageMemoryBind(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageMemoryBind* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSparseImageMemoryBind(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageMemoryBind* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- reservedmarshal_VkImageSubresource(vkStream, rootType, (VkImageSubresource*)(&forMarshaling->subresource), ptr);
+ reservedmarshal_VkImageSubresource(vkStream, rootType,
+ (VkImageSubresource*)(&forMarshaling->subresource), ptr);
reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->offset), ptr);
reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent), ptr);
uint64_t cgen_var_0;
@@ -1392,12 +1265,10 @@
*ptr += sizeof(VkSparseMemoryBindFlags);
}
-void reservedmarshal_VkSparseImageMemoryBindInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageMemoryBindInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSparseImageMemoryBindInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkSparseImageMemoryBindInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
uint64_t cgen_var_0;
@@ -1406,36 +1277,28 @@
*ptr += 1 * 8;
memcpy(*ptr, (uint32_t*)&forMarshaling->bindCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i)
- {
- reservedmarshal_VkSparseImageMemoryBind(vkStream, rootType, (const VkSparseImageMemoryBind*)(forMarshaling->pBinds + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindCount; ++i) {
+ reservedmarshal_VkSparseImageMemoryBind(
+ vkStream, rootType, (const VkSparseImageMemoryBind*)(forMarshaling->pBinds + i), ptr);
}
}
-void reservedmarshal_VkBindSparseInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindSparseInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkBindSparseInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindSparseInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- if (forMarshaling->waitSemaphoreCount)
- {
+ if (forMarshaling->waitSemaphoreCount) {
uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->waitSemaphoreCount; ++k)
- {
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->waitSemaphoreCount; ++k) {
uint64_t tmpval = get_host_u64_VkSemaphore(forMarshaling->pWaitSemaphores[k]);
memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -1444,31 +1307,31 @@
}
memcpy(*ptr, (uint32_t*)&forMarshaling->bufferBindCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->bufferBindCount; ++i)
- {
- reservedmarshal_VkSparseBufferMemoryBindInfo(vkStream, rootType, (const VkSparseBufferMemoryBindInfo*)(forMarshaling->pBufferBinds + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->bufferBindCount; ++i) {
+ reservedmarshal_VkSparseBufferMemoryBindInfo(
+ vkStream, rootType,
+ (const VkSparseBufferMemoryBindInfo*)(forMarshaling->pBufferBinds + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->imageOpaqueBindCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageOpaqueBindCount; ++i)
- {
- reservedmarshal_VkSparseImageOpaqueMemoryBindInfo(vkStream, rootType, (const VkSparseImageOpaqueMemoryBindInfo*)(forMarshaling->pImageOpaqueBinds + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageOpaqueBindCount; ++i) {
+ reservedmarshal_VkSparseImageOpaqueMemoryBindInfo(
+ vkStream, rootType,
+ (const VkSparseImageOpaqueMemoryBindInfo*)(forMarshaling->pImageOpaqueBinds + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->imageBindCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageBindCount; ++i)
- {
- reservedmarshal_VkSparseImageMemoryBindInfo(vkStream, rootType, (const VkSparseImageMemoryBindInfo*)(forMarshaling->pImageBinds + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageBindCount; ++i) {
+ reservedmarshal_VkSparseImageMemoryBindInfo(
+ vkStream, rootType,
+ (const VkSparseImageMemoryBindInfo*)(forMarshaling->pImageBinds + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- if (forMarshaling->signalSemaphoreCount)
- {
+ if (forMarshaling->signalSemaphoreCount) {
uint8_t* cgen_var_1_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->signalSemaphoreCount; ++k)
- {
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->signalSemaphoreCount; ++k) {
uint64_t tmpval = get_host_u64_VkSemaphore(forMarshaling->pSignalSemaphores[k]);
memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -1478,29 +1341,27 @@
}
void reservedmarshal_VkSparseImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageFormatProperties* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageFormatProperties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
*ptr += sizeof(VkImageAspectFlags);
- reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageGranularity), ptr);
- memcpy(*ptr, (VkSparseImageFormatFlags*)&forMarshaling->flags, sizeof(VkSparseImageFormatFlags));
+ reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageGranularity),
+ ptr);
+ memcpy(*ptr, (VkSparseImageFormatFlags*)&forMarshaling->flags,
+ sizeof(VkSparseImageFormatFlags));
*ptr += sizeof(VkSparseImageFormatFlags);
}
void reservedmarshal_VkSparseImageMemoryRequirements(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageMemoryRequirements* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageMemoryRequirements* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- reservedmarshal_VkSparseImageFormatProperties(vkStream, rootType, (VkSparseImageFormatProperties*)(&forMarshaling->formatProperties), ptr);
+ reservedmarshal_VkSparseImageFormatProperties(
+ vkStream, rootType, (VkSparseImageFormatProperties*)(&forMarshaling->formatProperties),
+ ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->imageMipTailFirstLod, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->imageMipTailSize, sizeof(VkDeviceSize));
@@ -1511,18 +1372,13 @@
*ptr += sizeof(VkDeviceSize);
}
-void reservedmarshal_VkFenceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFenceCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkFenceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFenceCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -1530,18 +1386,14 @@
*ptr += sizeof(VkFenceCreateFlags);
}
-void reservedmarshal_VkSemaphoreCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSemaphoreCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreCreateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -1549,18 +1401,13 @@
*ptr += sizeof(VkSemaphoreCreateFlags);
}
-void reservedmarshal_VkEventCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkEventCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkEventCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkEventCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -1568,18 +1415,14 @@
*ptr += sizeof(VkEventCreateFlags);
}
-void reservedmarshal_VkQueryPoolCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueryPoolCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkQueryPoolCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueryPoolCreateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -1589,22 +1432,18 @@
*ptr += sizeof(VkQueryType);
memcpy(*ptr, (uint32_t*)&forMarshaling->queryCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkQueryPipelineStatisticFlags*)&forMarshaling->pipelineStatistics, sizeof(VkQueryPipelineStatisticFlags));
+ memcpy(*ptr, (VkQueryPipelineStatisticFlags*)&forMarshaling->pipelineStatistics,
+ sizeof(VkQueryPipelineStatisticFlags));
*ptr += sizeof(VkQueryPipelineStatisticFlags);
}
-void reservedmarshal_VkBufferCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkBufferCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -1623,25 +1462,21 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pQueueFamilyIndices)
- {
- memcpy(*ptr, (const uint32_t*)forMarshaling->pQueueFamilyIndices, forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ if (forMarshaling->pQueueFamilyIndices) {
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pQueueFamilyIndices,
+ forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
*ptr += forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t);
}
}
-void reservedmarshal_VkBufferViewCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferViewCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkBufferViewCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferViewCreateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -1659,18 +1494,13 @@
*ptr += sizeof(VkDeviceSize);
}
-void reservedmarshal_VkImageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImageCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -1700,21 +1530,17 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pQueueFamilyIndices)
- {
- memcpy(*ptr, (const uint32_t*)forMarshaling->pQueueFamilyIndices, forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ if (forMarshaling->pQueueFamilyIndices) {
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pQueueFamilyIndices,
+ forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
*ptr += forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t);
}
memcpy(*ptr, (VkImageLayout*)&forMarshaling->initialLayout, sizeof(VkImageLayout));
*ptr += sizeof(VkImageLayout);
}
-void reservedmarshal_VkSubresourceLayout(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubresourceLayout* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSubresourceLayout(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubresourceLayout* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
@@ -1729,12 +1555,8 @@
*ptr += sizeof(VkDeviceSize);
}
-void reservedmarshal_VkComponentMapping(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkComponentMapping* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkComponentMapping(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkComponentMapping* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkComponentSwizzle*)&forMarshaling->r, sizeof(VkComponentSwizzle));
@@ -1747,18 +1569,14 @@
*ptr += sizeof(VkComponentSwizzle);
}
-void reservedmarshal_VkImageViewCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageViewCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImageViewCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageViewCreateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -1772,66 +1590,62 @@
*ptr += sizeof(VkImageViewType);
memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
*ptr += sizeof(VkFormat);
- reservedmarshal_VkComponentMapping(vkStream, rootType, (VkComponentMapping*)(&forMarshaling->components), ptr);
- reservedmarshal_VkImageSubresourceRange(vkStream, rootType, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange), ptr);
+ reservedmarshal_VkComponentMapping(vkStream, rootType,
+ (VkComponentMapping*)(&forMarshaling->components), ptr);
+ reservedmarshal_VkImageSubresourceRange(
+ vkStream, rootType, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange), ptr);
}
-void reservedmarshal_VkShaderModuleCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkShaderModuleCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkShaderModuleCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkShaderModuleCreateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkShaderModuleCreateFlags*)&forMarshaling->flags, sizeof(VkShaderModuleCreateFlags));
+ memcpy(*ptr, (VkShaderModuleCreateFlags*)&forMarshaling->flags,
+ sizeof(VkShaderModuleCreateFlags));
*ptr += sizeof(VkShaderModuleCreateFlags);
uint64_t cgen_var_0 = (uint64_t)forMarshaling->codeSize;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- memcpy(*ptr, (const uint32_t*)forMarshaling->pCode, (forMarshaling->codeSize / 4) * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pCode,
+ (forMarshaling->codeSize / 4) * sizeof(const uint32_t));
*ptr += (forMarshaling->codeSize / 4) * sizeof(const uint32_t);
}
-void reservedmarshal_VkPipelineCacheCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCacheCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPipelineCacheCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkPipelineCacheCreateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineCacheCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCacheCreateFlags));
+ memcpy(*ptr, (VkPipelineCacheCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineCacheCreateFlags));
*ptr += sizeof(VkPipelineCacheCreateFlags);
uint64_t cgen_var_0 = (uint64_t)forMarshaling->initialDataSize;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- memcpy(*ptr, (const void*)forMarshaling->pInitialData, forMarshaling->initialDataSize * sizeof(const uint8_t));
+ memcpy(*ptr, (const void*)forMarshaling->pInitialData,
+ forMarshaling->initialDataSize * sizeof(const uint8_t));
*ptr += forMarshaling->initialDataSize * sizeof(const uint8_t);
}
-void reservedmarshal_VkSpecializationMapEntry(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSpecializationMapEntry* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSpecializationMapEntry(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSpecializationMapEntry* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->constantID, sizeof(uint32_t));
@@ -1844,44 +1658,40 @@
*ptr += 8;
}
-void reservedmarshal_VkSpecializationInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSpecializationInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSpecializationInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSpecializationInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->mapEntryCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->mapEntryCount; ++i)
- {
- reservedmarshal_VkSpecializationMapEntry(vkStream, rootType, (const VkSpecializationMapEntry*)(forMarshaling->pMapEntries + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->mapEntryCount; ++i) {
+ reservedmarshal_VkSpecializationMapEntry(
+ vkStream, rootType, (const VkSpecializationMapEntry*)(forMarshaling->pMapEntries + i),
+ ptr);
}
uint64_t cgen_var_0 = (uint64_t)forMarshaling->dataSize;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- memcpy(*ptr, (const void*)forMarshaling->pData, forMarshaling->dataSize * sizeof(const uint8_t));
+ memcpy(*ptr, (const void*)forMarshaling->pData,
+ forMarshaling->dataSize * sizeof(const uint8_t));
*ptr += forMarshaling->dataSize * sizeof(const uint8_t);
}
void reservedmarshal_VkPipelineShaderStageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineShaderStageCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineShaderStageCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineShaderStageCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineShaderStageCreateFlags));
+ memcpy(*ptr, (VkPipelineShaderStageCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineShaderStageCreateFlags));
*ptr += sizeof(VkPipelineShaderStageCreateFlags);
memcpy(*ptr, (VkShaderStageFlagBits*)&forMarshaling->stage, sizeof(VkShaderStageFlagBits));
*ptr += sizeof(VkShaderStageFlagBits);
@@ -1890,7 +1700,7 @@
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
{
- uint32_t l = forMarshaling->pName ? strlen(forMarshaling->pName): 0;
+ uint32_t l = forMarshaling->pName ? strlen(forMarshaling->pName) : 0;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
@@ -1902,30 +1712,29 @@
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pSpecializationInfo)
- {
- reservedmarshal_VkSpecializationInfo(vkStream, rootType, (const VkSpecializationInfo*)(forMarshaling->pSpecializationInfo), ptr);
+ if (forMarshaling->pSpecializationInfo) {
+ reservedmarshal_VkSpecializationInfo(
+ vkStream, rootType, (const VkSpecializationInfo*)(forMarshaling->pSpecializationInfo),
+ ptr);
}
}
-void reservedmarshal_VkComputePipelineCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkComputePipelineCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkComputePipelineCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkComputePipelineCreateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkPipelineCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags));
*ptr += sizeof(VkPipelineCreateFlags);
- reservedmarshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (VkPipelineShaderStageCreateInfo*)(&forMarshaling->stage), ptr);
+ reservedmarshal_VkPipelineShaderStageCreateInfo(
+ vkStream, rootType, (VkPipelineShaderStageCreateInfo*)(&forMarshaling->stage), ptr);
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPipelineLayout((*&forMarshaling->layout));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
@@ -1939,11 +1748,8 @@
}
void reservedmarshal_VkVertexInputBindingDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVertexInputBindingDescription* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVertexInputBindingDescription* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
@@ -1955,11 +1761,8 @@
}
void reservedmarshal_VkVertexInputAttributeDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVertexInputAttributeDescription* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVertexInputAttributeDescription* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->location, sizeof(uint32_t));
@@ -1973,52 +1776,51 @@
}
void reservedmarshal_VkPipelineVertexInputStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineVertexInputStateCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineVertexInputStateCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineVertexInputStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineVertexInputStateCreateFlags));
+ memcpy(*ptr, (VkPipelineVertexInputStateCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineVertexInputStateCreateFlags));
*ptr += sizeof(VkPipelineVertexInputStateCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->vertexBindingDescriptionCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexBindingDescriptionCount; ++i)
- {
- reservedmarshal_VkVertexInputBindingDescription(vkStream, rootType, (const VkVertexInputBindingDescription*)(forMarshaling->pVertexBindingDescriptions + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexBindingDescriptionCount; ++i) {
+ reservedmarshal_VkVertexInputBindingDescription(
+ vkStream, rootType,
+ (const VkVertexInputBindingDescription*)(forMarshaling->pVertexBindingDescriptions + i),
+ ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->vertexAttributeDescriptionCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexAttributeDescriptionCount; ++i)
- {
- reservedmarshal_VkVertexInputAttributeDescription(vkStream, rootType, (const VkVertexInputAttributeDescription*)(forMarshaling->pVertexAttributeDescriptions + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexAttributeDescriptionCount; ++i) {
+ reservedmarshal_VkVertexInputAttributeDescription(
+ vkStream, rootType,
+ (const VkVertexInputAttributeDescription*)(forMarshaling->pVertexAttributeDescriptions +
+ i),
+ ptr);
}
}
void reservedmarshal_VkPipelineInputAssemblyStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineInputAssemblyStateCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineInputAssemblyStateCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineInputAssemblyStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineInputAssemblyStateCreateFlags));
+ memcpy(*ptr, (VkPipelineInputAssemblyStateCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineInputAssemblyStateCreateFlags));
*ptr += sizeof(VkPipelineInputAssemblyStateCreateFlags);
memcpy(*ptr, (VkPrimitiveTopology*)&forMarshaling->topology, sizeof(VkPrimitiveTopology));
*ptr += sizeof(VkPrimitiveTopology);
@@ -2027,32 +1829,25 @@
}
void reservedmarshal_VkPipelineTessellationStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineTessellationStateCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineTessellationStateCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineTessellationStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineTessellationStateCreateFlags));
+ memcpy(*ptr, (VkPipelineTessellationStateCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineTessellationStateCreateFlags));
*ptr += sizeof(VkPipelineTessellationStateCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->patchControlPoints, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkViewport(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkViewport* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkViewport(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkViewport* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (float*)&forMarshaling->x, sizeof(float));
@@ -2070,21 +1865,18 @@
}
void reservedmarshal_VkPipelineViewportStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineViewportStateCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineViewportStateCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineViewportStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineViewportStateCreateFlags));
+ memcpy(*ptr, (VkPipelineViewportStateCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineViewportStateCreateFlags));
*ptr += sizeof(VkPipelineViewportStateCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -2093,11 +1885,10 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pViewports)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
- {
- reservedmarshal_VkViewport(vkStream, rootType, (const VkViewport*)(forMarshaling->pViewports + i), ptr);
+ if (forMarshaling->pViewports) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i) {
+ reservedmarshal_VkViewport(vkStream, rootType,
+ (const VkViewport*)(forMarshaling->pViewports + i), ptr);
}
}
memcpy(*ptr, (uint32_t*)&forMarshaling->scissorCount, sizeof(uint32_t));
@@ -2107,31 +1898,27 @@
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pScissors)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->scissorCount; ++i)
- {
- reservedmarshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pScissors + i), ptr);
+ if (forMarshaling->pScissors) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->scissorCount; ++i) {
+ reservedmarshal_VkRect2D(vkStream, rootType,
+ (const VkRect2D*)(forMarshaling->pScissors + i), ptr);
}
}
}
void reservedmarshal_VkPipelineRasterizationStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationStateCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationStateCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineRasterizationStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineRasterizationStateCreateFlags));
+ memcpy(*ptr, (VkPipelineRasterizationStateCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineRasterizationStateCreateFlags));
*ptr += sizeof(VkPipelineRasterizationStateCreateFlags);
memcpy(*ptr, (VkBool32*)&forMarshaling->depthClampEnable, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -2156,23 +1943,21 @@
}
void reservedmarshal_VkPipelineMultisampleStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineMultisampleStateCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineMultisampleStateCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineMultisampleStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineMultisampleStateCreateFlags));
+ memcpy(*ptr, (VkPipelineMultisampleStateCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineMultisampleStateCreateFlags));
*ptr += sizeof(VkPipelineMultisampleStateCreateFlags);
- memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples, sizeof(VkSampleCountFlagBits));
+ memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples,
+ sizeof(VkSampleCountFlagBits));
*ptr += sizeof(VkSampleCountFlagBits);
memcpy(*ptr, (VkBool32*)&forMarshaling->sampleShadingEnable, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -2183,9 +1968,9 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pSampleMask)
- {
- memcpy(*ptr, (const VkSampleMask*)forMarshaling->pSampleMask, (((forMarshaling->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
+ if (forMarshaling->pSampleMask) {
+ memcpy(*ptr, (const VkSampleMask*)forMarshaling->pSampleMask,
+ (((forMarshaling->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask));
*ptr += (((forMarshaling->rasterizationSamples) + 31) / 32) * sizeof(const VkSampleMask);
}
memcpy(*ptr, (VkBool32*)&forMarshaling->alphaToCoverageEnable, sizeof(VkBool32));
@@ -2194,12 +1979,8 @@
*ptr += sizeof(VkBool32);
}
-void reservedmarshal_VkStencilOpState(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkStencilOpState* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkStencilOpState(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkStencilOpState* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStencilOp*)&forMarshaling->failOp, sizeof(VkStencilOp));
@@ -2219,21 +2000,18 @@
}
void reservedmarshal_VkPipelineDepthStencilStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineDepthStencilStateCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineDepthStencilStateCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineDepthStencilStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineDepthStencilStateCreateFlags));
+ memcpy(*ptr, (VkPipelineDepthStencilStateCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineDepthStencilStateCreateFlags));
*ptr += sizeof(VkPipelineDepthStencilStateCreateFlags);
memcpy(*ptr, (VkBool32*)&forMarshaling->depthTestEnable, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -2245,8 +2023,10 @@
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->stencilTestEnable, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- reservedmarshal_VkStencilOpState(vkStream, rootType, (VkStencilOpState*)(&forMarshaling->front), ptr);
- reservedmarshal_VkStencilOpState(vkStream, rootType, (VkStencilOpState*)(&forMarshaling->back), ptr);
+ reservedmarshal_VkStencilOpState(vkStream, rootType, (VkStencilOpState*)(&forMarshaling->front),
+ ptr);
+ reservedmarshal_VkStencilOpState(vkStream, rootType, (VkStencilOpState*)(&forMarshaling->back),
+ ptr);
memcpy(*ptr, (float*)&forMarshaling->minDepthBounds, sizeof(float));
*ptr += sizeof(float);
memcpy(*ptr, (float*)&forMarshaling->maxDepthBounds, sizeof(float));
@@ -2254,11 +2034,8 @@
}
void reservedmarshal_VkPipelineColorBlendAttachmentState(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineColorBlendAttachmentState* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineColorBlendAttachmentState* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkBool32*)&forMarshaling->blendEnable, sizeof(VkBool32));
@@ -2275,26 +2052,24 @@
*ptr += sizeof(VkBlendFactor);
memcpy(*ptr, (VkBlendOp*)&forMarshaling->alphaBlendOp, sizeof(VkBlendOp));
*ptr += sizeof(VkBlendOp);
- memcpy(*ptr, (VkColorComponentFlags*)&forMarshaling->colorWriteMask, sizeof(VkColorComponentFlags));
+ memcpy(*ptr, (VkColorComponentFlags*)&forMarshaling->colorWriteMask,
+ sizeof(VkColorComponentFlags));
*ptr += sizeof(VkColorComponentFlags);
}
void reservedmarshal_VkPipelineColorBlendStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineColorBlendStateCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineColorBlendStateCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineColorBlendStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineColorBlendStateCreateFlags));
+ memcpy(*ptr, (VkPipelineColorBlendStateCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineColorBlendStateCreateFlags));
*ptr += sizeof(VkPipelineColorBlendStateCreateFlags);
memcpy(*ptr, (VkBool32*)&forMarshaling->logicOpEnable, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -2302,58 +2077,61 @@
*ptr += sizeof(VkLogicOp);
memcpy(*ptr, (uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i)
- {
- reservedmarshal_VkPipelineColorBlendAttachmentState(vkStream, rootType, (const VkPipelineColorBlendAttachmentState*)(forMarshaling->pAttachments + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i) {
+ reservedmarshal_VkPipelineColorBlendAttachmentState(
+ vkStream, rootType,
+ (const VkPipelineColorBlendAttachmentState*)(forMarshaling->pAttachments + i), ptr);
}
memcpy(*ptr, (float*)forMarshaling->blendConstants, 4 * sizeof(float));
*ptr += 4 * sizeof(float);
}
void reservedmarshal_VkPipelineDynamicStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineDynamicStateCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineDynamicStateCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineDynamicStateCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineDynamicStateCreateFlags));
+ memcpy(*ptr, (VkPipelineDynamicStateCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineDynamicStateCreateFlags));
*ptr += sizeof(VkPipelineDynamicStateCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->dynamicStateCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const VkDynamicState*)forMarshaling->pDynamicStates, forMarshaling->dynamicStateCount * sizeof(const VkDynamicState));
+ memcpy(*ptr, (const VkDynamicState*)forMarshaling->pDynamicStates,
+ forMarshaling->dynamicStateCount * sizeof(const VkDynamicState));
*ptr += forMarshaling->dynamicStateCount * sizeof(const VkDynamicState);
}
-void reservedmarshal_VkGraphicsPipelineCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGraphicsPipelineCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkGraphicsPipelineCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkGraphicsPipelineCreateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
uint32_t hasRasterization = 1;
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
- {
- hasRasterization = (((0 == forMarshaling->pRasterizationState)) ? (0) : (!((*(forMarshaling->pRasterizationState)).rasterizerDiscardEnable)));
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
+ hasRasterization =
+ (((0 == forMarshaling->pRasterizationState))
+ ? (0)
+ : (!((*(forMarshaling->pRasterizationState)).rasterizerDiscardEnable)));
uint32_t cgen_var_0 = (uint32_t)hasRasterization;
memcpy((*ptr), &cgen_var_0, 4);
android::base::Stream::toBe32((uint8_t*)(*ptr));
*ptr += 4;
}
uint32_t hasTessellation = 1;
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
- {
- hasTessellation = arrayany(forMarshaling->pStages, 0, forMarshaling->stageCount, [](VkPipelineShaderStageCreateInfo s) { return ((s.stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) || (s.stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)); });
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
+ hasTessellation =
+ arrayany(forMarshaling->pStages, 0, forMarshaling->stageCount,
+ [](VkPipelineShaderStageCreateInfo s) {
+ return ((s.stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) ||
+ (s.stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT));
+ });
uint32_t cgen_var_0 = (uint32_t)hasTessellation;
memcpy((*ptr), &cgen_var_0, 4);
android::base::Stream::toBe32((uint8_t*)(*ptr));
@@ -2361,8 +2139,7 @@
}
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -2370,44 +2147,49 @@
*ptr += sizeof(VkPipelineCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->stageCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i)
- {
- reservedmarshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i) {
+ reservedmarshal_VkPipelineShaderStageCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i), ptr);
}
// WARNING PTR CHECK
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
- {
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pVertexInputState;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
}
- if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forMarshaling->pVertexInputState))
- {
- reservedmarshal_VkPipelineVertexInputStateCreateInfo(vkStream, rootType, (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState), ptr);
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ forMarshaling->pVertexInputState)) {
+ reservedmarshal_VkPipelineVertexInputStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState), ptr);
}
// WARNING PTR CHECK
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
- {
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pInputAssemblyState;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
}
- if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forMarshaling->pInputAssemblyState))
- {
- reservedmarshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, rootType, (const VkPipelineInputAssemblyStateCreateInfo*)(forMarshaling->pInputAssemblyState), ptr);
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ forMarshaling->pInputAssemblyState)) {
+ reservedmarshal_VkPipelineInputAssemblyStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineInputAssemblyStateCreateInfo*)(forMarshaling->pInputAssemblyState),
+ ptr);
}
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pTessellationState;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pTessellationState)
- {
- if (hasTessellation)
- {
- reservedmarshal_VkPipelineTessellationStateCreateInfo(vkStream, rootType, (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState), ptr);
+ if (forMarshaling->pTessellationState) {
+ if (hasTessellation) {
+ reservedmarshal_VkPipelineTessellationStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState),
+ ptr);
}
}
// WARNING PTR CHECK
@@ -2415,35 +2197,38 @@
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pViewportState)
- {
- if (hasRasterization)
- {
- reservedmarshal_VkPipelineViewportStateCreateInfo(vkStream, rootType, (const VkPipelineViewportStateCreateInfo*)(forMarshaling->pViewportState), ptr);
+ if (forMarshaling->pViewportState) {
+ if (hasRasterization) {
+ reservedmarshal_VkPipelineViewportStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineViewportStateCreateInfo*)(forMarshaling->pViewportState), ptr);
}
}
// WARNING PTR CHECK
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
- {
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) {
uint64_t cgen_var_1_0 = (uint64_t)(uintptr_t)forMarshaling->pRasterizationState;
memcpy((*ptr), &cgen_var_1_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
}
- if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forMarshaling->pRasterizationState))
- {
- reservedmarshal_VkPipelineRasterizationStateCreateInfo(vkStream, rootType, (const VkPipelineRasterizationStateCreateInfo*)(forMarshaling->pRasterizationState), ptr);
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ forMarshaling->pRasterizationState)) {
+ reservedmarshal_VkPipelineRasterizationStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineRasterizationStateCreateInfo*)(forMarshaling->pRasterizationState),
+ ptr);
}
// WARNING PTR CHECK
uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pMultisampleState;
memcpy((*ptr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pMultisampleState)
- {
- if (hasRasterization)
- {
- reservedmarshal_VkPipelineMultisampleStateCreateInfo(vkStream, rootType, (const VkPipelineMultisampleStateCreateInfo*)(forMarshaling->pMultisampleState), ptr);
+ if (forMarshaling->pMultisampleState) {
+ if (hasRasterization) {
+ reservedmarshal_VkPipelineMultisampleStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineMultisampleStateCreateInfo*)(forMarshaling->pMultisampleState),
+ ptr);
}
}
// WARNING PTR CHECK
@@ -2451,11 +2236,12 @@
memcpy((*ptr), &cgen_var_3, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pDepthStencilState)
- {
- if (hasRasterization)
- {
- reservedmarshal_VkPipelineDepthStencilStateCreateInfo(vkStream, rootType, (const VkPipelineDepthStencilStateCreateInfo*)(forMarshaling->pDepthStencilState), ptr);
+ if (forMarshaling->pDepthStencilState) {
+ if (hasRasterization) {
+ reservedmarshal_VkPipelineDepthStencilStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineDepthStencilStateCreateInfo*)(forMarshaling->pDepthStencilState),
+ ptr);
}
}
// WARNING PTR CHECK
@@ -2463,11 +2249,11 @@
memcpy((*ptr), &cgen_var_4, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pColorBlendState)
- {
- if (hasRasterization)
- {
- reservedmarshal_VkPipelineColorBlendStateCreateInfo(vkStream, rootType, (const VkPipelineColorBlendStateCreateInfo*)(forMarshaling->pColorBlendState), ptr);
+ if (forMarshaling->pColorBlendState) {
+ if (hasRasterization) {
+ reservedmarshal_VkPipelineColorBlendStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineColorBlendStateCreateInfo*)(forMarshaling->pColorBlendState), ptr);
}
}
// WARNING PTR CHECK
@@ -2475,9 +2261,10 @@
memcpy((*ptr), &cgen_var_5, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pDynamicState)
- {
- reservedmarshal_VkPipelineDynamicStateCreateInfo(vkStream, rootType, (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState), ptr);
+ if (forMarshaling->pDynamicState) {
+ reservedmarshal_VkPipelineDynamicStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState), ptr);
}
uint64_t cgen_var_6;
*&cgen_var_6 = get_host_u64_VkPipelineLayout((*&forMarshaling->layout));
@@ -2497,12 +2284,8 @@
*ptr += sizeof(int32_t);
}
-void reservedmarshal_VkPushConstantRange(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPushConstantRange* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPushConstantRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPushConstantRange* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
@@ -2513,32 +2296,27 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkPipelineLayoutCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineLayoutCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPipelineLayoutCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkPipelineLayoutCreateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineLayoutCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineLayoutCreateFlags));
+ memcpy(*ptr, (VkPipelineLayoutCreateFlags*)&forMarshaling->flags,
+ sizeof(VkPipelineLayoutCreateFlags));
*ptr += sizeof(VkPipelineLayoutCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->setLayoutCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- if (forMarshaling->setLayoutCount)
- {
+ if (forMarshaling->setLayoutCount) {
uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->setLayoutCount; ++k)
- {
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->setLayoutCount; ++k) {
uint64_t tmpval = get_host_u64_VkDescriptorSetLayout(forMarshaling->pSetLayouts[k]);
memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -2547,24 +2325,20 @@
}
memcpy(*ptr, (uint32_t*)&forMarshaling->pushConstantRangeCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->pushConstantRangeCount; ++i)
- {
- reservedmarshal_VkPushConstantRange(vkStream, rootType, (const VkPushConstantRange*)(forMarshaling->pPushConstantRanges + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->pushConstantRangeCount; ++i) {
+ reservedmarshal_VkPushConstantRange(
+ vkStream, rootType,
+ (const VkPushConstantRange*)(forMarshaling->pPushConstantRanges + i), ptr);
}
}
-void reservedmarshal_VkSamplerCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSamplerCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -2602,18 +2376,13 @@
*ptr += sizeof(VkBool32);
}
-void reservedmarshal_VkCopyDescriptorSet(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyDescriptorSet* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkCopyDescriptorSet(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyDescriptorSet* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -2637,12 +2406,9 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkDescriptorBufferInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorBufferInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDescriptorBufferInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorBufferInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
uint64_t cgen_var_0;
@@ -2655,12 +2421,9 @@
*ptr += sizeof(VkDeviceSize);
}
-void reservedmarshal_VkDescriptorImageInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorImageInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDescriptorImageInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorImageInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
uint64_t cgen_var_0;
@@ -2675,12 +2438,9 @@
*ptr += sizeof(VkImageLayout);
}
-void reservedmarshal_VkDescriptorPoolSize(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorPoolSize* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDescriptorPoolSize(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorPoolSize* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkDescriptorType*)&forMarshaling->type, sizeof(VkDescriptorType));
@@ -2689,45 +2449,40 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkDescriptorPoolCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorPoolCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDescriptorPoolCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDescriptorPoolCreateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDescriptorPoolCreateFlags*)&forMarshaling->flags, sizeof(VkDescriptorPoolCreateFlags));
+ memcpy(*ptr, (VkDescriptorPoolCreateFlags*)&forMarshaling->flags,
+ sizeof(VkDescriptorPoolCreateFlags));
*ptr += sizeof(VkDescriptorPoolCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxSets, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->poolSizeCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->poolSizeCount; ++i)
- {
- reservedmarshal_VkDescriptorPoolSize(vkStream, rootType, (const VkDescriptorPoolSize*)(forMarshaling->pPoolSizes + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->poolSizeCount; ++i) {
+ reservedmarshal_VkDescriptorPoolSize(
+ vkStream, rootType, (const VkDescriptorPoolSize*)(forMarshaling->pPoolSizes + i), ptr);
}
}
-void reservedmarshal_VkDescriptorSetAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetAllocateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDescriptorSetAllocateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDescriptorSetAllocateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -2737,13 +2492,10 @@
*ptr += 1 * 8;
memcpy(*ptr, (uint32_t*)&forMarshaling->descriptorSetCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- if (forMarshaling->descriptorSetCount)
- {
+ if (forMarshaling->descriptorSetCount) {
uint8_t* cgen_var_1_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->descriptorSetCount; ++k)
- {
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->descriptorSetCount; ++k) {
uint64_t tmpval = get_host_u64_VkDescriptorSetLayout(forMarshaling->pSetLayouts[k]);
memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -2752,12 +2504,10 @@
}
}
-void reservedmarshal_VkDescriptorSetLayoutBinding(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetLayoutBinding* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDescriptorSetLayoutBinding(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDescriptorSetLayoutBinding* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
@@ -2773,15 +2523,11 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pImmutableSamplers)
- {
- if (forMarshaling->descriptorCount)
- {
+ if (forMarshaling->pImmutableSamplers) {
+ if (forMarshaling->descriptorCount) {
uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->descriptorCount; ++k)
- {
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->descriptorCount; ++k) {
uint64_t tmpval = get_host_u64_VkSampler(forMarshaling->pImmutableSamplers[k]);
memcpy(cgen_var_0_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -2792,42 +2538,36 @@
}
void reservedmarshal_VkDescriptorSetLayoutCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetLayoutCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorSetLayoutCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDescriptorSetLayoutCreateFlags*)&forMarshaling->flags, sizeof(VkDescriptorSetLayoutCreateFlags));
+ memcpy(*ptr, (VkDescriptorSetLayoutCreateFlags*)&forMarshaling->flags,
+ sizeof(VkDescriptorSetLayoutCreateFlags));
*ptr += sizeof(VkDescriptorSetLayoutCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->bindingCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindingCount; ++i)
- {
- reservedmarshal_VkDescriptorSetLayoutBinding(vkStream, rootType, (const VkDescriptorSetLayoutBinding*)(forMarshaling->pBindings + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->bindingCount; ++i) {
+ reservedmarshal_VkDescriptorSetLayoutBinding(
+ vkStream, rootType, (const VkDescriptorSetLayoutBinding*)(forMarshaling->pBindings + i),
+ ptr);
}
}
-void reservedmarshal_VkWriteDescriptorSet(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWriteDescriptorSet* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkWriteDescriptorSet(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWriteDescriptorSet* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -2848,13 +2588,17 @@
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pImageInfo)
- {
- if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_SAMPLER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT == forMarshaling->descriptorType))))
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i)
- {
- reservedmarshal_VkDescriptorImageInfo(vkStream, rootType, (const VkDescriptorImageInfo*)(forMarshaling->pImageInfo + i), ptr);
+ if (forMarshaling->pImageInfo) {
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ ((VK_DESCRIPTOR_TYPE_SAMPLER == forMarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER == forMarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE == forMarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE == forMarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT == forMarshaling->descriptorType)))) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i) {
+ reservedmarshal_VkDescriptorImageInfo(
+ vkStream, rootType,
+ (const VkDescriptorImageInfo*)(forMarshaling->pImageInfo + i), ptr);
}
}
}
@@ -2863,13 +2607,16 @@
memcpy((*ptr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pBufferInfo)
- {
- if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == forMarshaling->descriptorType))))
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i)
- {
- reservedmarshal_VkDescriptorBufferInfo(vkStream, rootType, (const VkDescriptorBufferInfo*)(forMarshaling->pBufferInfo + i), ptr);
+ if (forMarshaling->pBufferInfo) {
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ ((VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER == forMarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == forMarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == forMarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == forMarshaling->descriptorType)))) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i) {
+ reservedmarshal_VkDescriptorBufferInfo(
+ vkStream, rootType,
+ (const VkDescriptorBufferInfo*)(forMarshaling->pBufferInfo + i), ptr);
}
}
}
@@ -2878,18 +2625,16 @@
memcpy((*ptr), &cgen_var_3, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pTexelBufferView)
- {
- if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER == forMarshaling->descriptorType))))
- {
- if (forMarshaling->descriptorCount)
- {
+ if (forMarshaling->pTexelBufferView) {
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ ((VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER == forMarshaling->descriptorType) ||
+ (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER == forMarshaling->descriptorType)))) {
+ if (forMarshaling->descriptorCount) {
uint8_t* cgen_var_3_0_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->descriptorCount; ++k)
- {
- uint64_t tmpval = get_host_u64_VkBufferView(forMarshaling->pTexelBufferView[k]);
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->descriptorCount; ++k) {
+ uint64_t tmpval =
+ get_host_u64_VkBufferView(forMarshaling->pTexelBufferView[k]);
memcpy(cgen_var_3_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
}
@@ -2899,15 +2644,13 @@
}
}
-void reservedmarshal_VkAttachmentDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentDescription* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkAttachmentDescription(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentDescription* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- memcpy(*ptr, (VkAttachmentDescriptionFlags*)&forMarshaling->flags, sizeof(VkAttachmentDescriptionFlags));
+ memcpy(*ptr, (VkAttachmentDescriptionFlags*)&forMarshaling->flags,
+ sizeof(VkAttachmentDescriptionFlags));
*ptr += sizeof(VkAttachmentDescriptionFlags);
memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
*ptr += sizeof(VkFormat);
@@ -2927,12 +2670,9 @@
*ptr += sizeof(VkImageLayout);
}
-void reservedmarshal_VkAttachmentReference(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentReference* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkAttachmentReference(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentReference* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->attachment, sizeof(uint32_t));
@@ -2941,22 +2681,19 @@
*ptr += sizeof(VkImageLayout);
}
-void reservedmarshal_VkFramebufferCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFramebufferCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkFramebufferCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFramebufferCreateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkFramebufferCreateFlags*)&forMarshaling->flags, sizeof(VkFramebufferCreateFlags));
+ memcpy(*ptr, (VkFramebufferCreateFlags*)&forMarshaling->flags,
+ sizeof(VkFramebufferCreateFlags));
*ptr += sizeof(VkFramebufferCreateFlags);
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkRenderPass((*&forMarshaling->renderPass));
@@ -2964,18 +2701,18 @@
*ptr += 1 * 8;
memcpy(*ptr, (uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- if (forMarshaling->attachmentCount)
- {
- uint8_t* cgen_var_1_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->attachmentCount; ++k)
- {
- uint64_t tmpval = get_host_u64_VkImageView(forMarshaling->pAttachments[k]);
- memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
+ if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) ||
+ (((forMarshaling->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT) == 0)))) {
+ if (forMarshaling->attachmentCount) {
+ uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*ptr);
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->attachmentCount; ++k) {
+ uint64_t tmpval = get_host_u64_VkImageView(forMarshaling->pAttachments[k]);
+ memcpy(cgen_var_0_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
+ }
}
+ *ptr += 8 * forMarshaling->attachmentCount;
}
- *ptr += 8 * forMarshaling->attachmentCount;
}
memcpy(*ptr, (uint32_t*)&forMarshaling->width, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -2985,40 +2722,41 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkSubpassDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassDescription* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSubpassDescription(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassDescription* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- memcpy(*ptr, (VkSubpassDescriptionFlags*)&forMarshaling->flags, sizeof(VkSubpassDescriptionFlags));
+ memcpy(*ptr, (VkSubpassDescriptionFlags*)&forMarshaling->flags,
+ sizeof(VkSubpassDescriptionFlags));
*ptr += sizeof(VkSubpassDescriptionFlags);
- memcpy(*ptr, (VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ memcpy(*ptr, (VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
*ptr += sizeof(VkPipelineBindPoint);
memcpy(*ptr, (uint32_t*)&forMarshaling->inputAttachmentCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->inputAttachmentCount; ++i)
- {
- reservedmarshal_VkAttachmentReference(vkStream, rootType, (const VkAttachmentReference*)(forMarshaling->pInputAttachments + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->inputAttachmentCount; ++i) {
+ reservedmarshal_VkAttachmentReference(
+ vkStream, rootType,
+ (const VkAttachmentReference*)(forMarshaling->pInputAttachments + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
- {
- reservedmarshal_VkAttachmentReference(vkStream, rootType, (const VkAttachmentReference*)(forMarshaling->pColorAttachments + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
+ reservedmarshal_VkAttachmentReference(
+ vkStream, rootType,
+ (const VkAttachmentReference*)(forMarshaling->pColorAttachments + i), ptr);
}
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pResolveAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
- {
- reservedmarshal_VkAttachmentReference(vkStream, rootType, (const VkAttachmentReference*)(forMarshaling->pResolveAttachments + i), ptr);
+ if (forMarshaling->pResolveAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
+ reservedmarshal_VkAttachmentReference(
+ vkStream, rootType,
+ (const VkAttachmentReference*)(forMarshaling->pResolveAttachments + i), ptr);
}
}
// WARNING PTR CHECK
@@ -3026,22 +2764,20 @@
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pDepthStencilAttachment)
- {
- reservedmarshal_VkAttachmentReference(vkStream, rootType, (const VkAttachmentReference*)(forMarshaling->pDepthStencilAttachment), ptr);
+ if (forMarshaling->pDepthStencilAttachment) {
+ reservedmarshal_VkAttachmentReference(
+ vkStream, rootType,
+ (const VkAttachmentReference*)(forMarshaling->pDepthStencilAttachment), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->preserveAttachmentCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const uint32_t*)forMarshaling->pPreserveAttachments, forMarshaling->preserveAttachmentCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pPreserveAttachments,
+ forMarshaling->preserveAttachmentCount * sizeof(const uint32_t));
*ptr += forMarshaling->preserveAttachmentCount * sizeof(const uint32_t);
}
-void reservedmarshal_VkSubpassDependency(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassDependency* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSubpassDependency(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassDependency* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->srcSubpass, sizeof(uint32_t));
@@ -3060,18 +2796,14 @@
*ptr += sizeof(VkDependencyFlags);
}
-void reservedmarshal_VkRenderPassCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkRenderPassCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassCreateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -3079,57 +2811,53 @@
*ptr += sizeof(VkRenderPassCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i)
- {
- reservedmarshal_VkAttachmentDescription(vkStream, rootType, (const VkAttachmentDescription*)(forMarshaling->pAttachments + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i) {
+ reservedmarshal_VkAttachmentDescription(
+ vkStream, rootType, (const VkAttachmentDescription*)(forMarshaling->pAttachments + i),
+ ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->subpassCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->subpassCount; ++i)
- {
- reservedmarshal_VkSubpassDescription(vkStream, rootType, (const VkSubpassDescription*)(forMarshaling->pSubpasses + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->subpassCount; ++i) {
+ reservedmarshal_VkSubpassDescription(
+ vkStream, rootType, (const VkSubpassDescription*)(forMarshaling->pSubpasses + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->dependencyCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->dependencyCount; ++i)
- {
- reservedmarshal_VkSubpassDependency(vkStream, rootType, (const VkSubpassDependency*)(forMarshaling->pDependencies + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->dependencyCount; ++i) {
+ reservedmarshal_VkSubpassDependency(
+ vkStream, rootType, (const VkSubpassDependency*)(forMarshaling->pDependencies + i),
+ ptr);
}
}
-void reservedmarshal_VkCommandPoolCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandPoolCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkCommandPoolCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandPoolCreateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkCommandPoolCreateFlags*)&forMarshaling->flags, sizeof(VkCommandPoolCreateFlags));
+ memcpy(*ptr, (VkCommandPoolCreateFlags*)&forMarshaling->flags,
+ sizeof(VkCommandPoolCreateFlags));
*ptr += sizeof(VkCommandPoolCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkCommandBufferAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferAllocateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkCommandBufferAllocateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkCommandBufferAllocateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -3144,17 +2872,13 @@
}
void reservedmarshal_VkCommandBufferInheritanceInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferInheritanceInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferInheritanceInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -3172,44 +2896,39 @@
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkQueryControlFlags*)&forMarshaling->queryFlags, sizeof(VkQueryControlFlags));
*ptr += sizeof(VkQueryControlFlags);
- memcpy(*ptr, (VkQueryPipelineStatisticFlags*)&forMarshaling->pipelineStatistics, sizeof(VkQueryPipelineStatisticFlags));
+ memcpy(*ptr, (VkQueryPipelineStatisticFlags*)&forMarshaling->pipelineStatistics,
+ sizeof(VkQueryPipelineStatisticFlags));
*ptr += sizeof(VkQueryPipelineStatisticFlags);
}
-void reservedmarshal_VkCommandBufferBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferBeginInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkCommandBufferBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferBeginInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkCommandBufferUsageFlags*)&forMarshaling->flags, sizeof(VkCommandBufferUsageFlags));
+ memcpy(*ptr, (VkCommandBufferUsageFlags*)&forMarshaling->flags,
+ sizeof(VkCommandBufferUsageFlags));
*ptr += sizeof(VkCommandBufferUsageFlags);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pInheritanceInfo;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pInheritanceInfo)
- {
- reservedmarshal_VkCommandBufferInheritanceInfo(vkStream, rootType, (const VkCommandBufferInheritanceInfo*)(forMarshaling->pInheritanceInfo), ptr);
+ if (forMarshaling->pInheritanceInfo) {
+ reservedmarshal_VkCommandBufferInheritanceInfo(
+ vkStream, rootType,
+ (const VkCommandBufferInheritanceInfo*)(forMarshaling->pInheritanceInfo), ptr);
}
}
-void reservedmarshal_VkBufferCopy(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCopy* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkBufferCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCopy* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->srcOffset, sizeof(VkDeviceSize));
@@ -3220,12 +2939,9 @@
*ptr += sizeof(VkDeviceSize);
}
-void reservedmarshal_VkImageSubresourceLayers(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageSubresourceLayers* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImageSubresourceLayers(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSubresourceLayers* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
@@ -3238,12 +2954,8 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkBufferImageCopy(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferImageCopy* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkBufferImageCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferImageCopy* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->bufferOffset, sizeof(VkDeviceSize));
@@ -3252,29 +2964,23 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->bufferImageHeight, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- reservedmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource), ptr);
+ reservedmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource), ptr);
reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset), ptr);
reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent), ptr);
}
-void reservedmarshal_VkClearColorValue(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkClearColorValue* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkClearColorValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkClearColorValue* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (float*)forMarshaling->float32, 4 * sizeof(float));
*ptr += 4 * sizeof(float);
}
-void reservedmarshal_VkClearDepthStencilValue(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkClearDepthStencilValue* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkClearDepthStencilValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkClearDepthStencilValue* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (float*)&forMarshaling->depth, sizeof(float));
@@ -3283,38 +2989,28 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkClearValue(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkClearValue* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkClearValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkClearValue* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- reservedmarshal_VkClearColorValue(vkStream, rootType, (VkClearColorValue*)(&forMarshaling->color), ptr);
+ reservedmarshal_VkClearColorValue(vkStream, rootType,
+ (VkClearColorValue*)(&forMarshaling->color), ptr);
}
-void reservedmarshal_VkClearAttachment(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkClearAttachment* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkClearAttachment(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkClearAttachment* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkImageAspectFlags*)&forMarshaling->aspectMask, sizeof(VkImageAspectFlags));
*ptr += sizeof(VkImageAspectFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->colorAttachment, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- reservedmarshal_VkClearValue(vkStream, rootType, (VkClearValue*)(&forMarshaling->clearValue), ptr);
+ reservedmarshal_VkClearValue(vkStream, rootType, (VkClearValue*)(&forMarshaling->clearValue),
+ ptr);
}
-void reservedmarshal_VkClearRect(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkClearRect* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkClearRect(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkClearRect* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
reservedmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->rect), ptr);
@@ -3324,68 +3020,58 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkImageBlit(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageBlit* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImageBlit(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageBlit* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- reservedmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
- reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->srcOffsets + i), ptr);
+ reservedmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+ reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->srcOffsets + i),
+ ptr);
}
- reservedmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
- reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->dstOffsets + i), ptr);
+ reservedmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+ reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->dstOffsets + i),
+ ptr);
}
}
-void reservedmarshal_VkImageCopy(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageCopy* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImageCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageCopy* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- reservedmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
+ reservedmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset), ptr);
- reservedmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
+ reservedmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->dstOffset), ptr);
reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent), ptr);
}
-void reservedmarshal_VkImageResolve(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageResolve* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImageResolve(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageResolve* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- reservedmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
+ reservedmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset), ptr);
- reservedmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
+ reservedmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->dstOffset), ptr);
reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent), ptr);
}
-void reservedmarshal_VkRenderPassBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassBeginInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkRenderPassBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassBeginInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -3405,11 +3091,10 @@
memcpy((*ptr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pClearValues)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->clearValueCount; ++i)
- {
- reservedmarshal_VkClearValue(vkStream, rootType, (const VkClearValue*)(forMarshaling->pClearValues + i), ptr);
+ if (forMarshaling->pClearValues) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->clearValueCount; ++i) {
+ reservedmarshal_VkClearValue(
+ vkStream, rootType, (const VkClearValue*)(forMarshaling->pClearValues + i), ptr);
}
}
}
@@ -3417,17 +3102,13 @@
#endif
#ifdef VK_VERSION_1_1
void reservedmarshal_VkPhysicalDeviceSubgroupProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSubgroupProperties* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSubgroupProperties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -3435,24 +3116,21 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->supportedStages, sizeof(VkShaderStageFlags));
*ptr += sizeof(VkShaderStageFlags);
- memcpy(*ptr, (VkSubgroupFeatureFlags*)&forMarshaling->supportedOperations, sizeof(VkSubgroupFeatureFlags));
+ memcpy(*ptr, (VkSubgroupFeatureFlags*)&forMarshaling->supportedOperations,
+ sizeof(VkSubgroupFeatureFlags));
*ptr += sizeof(VkSubgroupFeatureFlags);
memcpy(*ptr, (VkBool32*)&forMarshaling->quadOperationsInAllStages, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
-void reservedmarshal_VkBindBufferMemoryInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindBufferMemoryInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkBindBufferMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindBufferMemoryInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -3468,18 +3146,14 @@
*ptr += sizeof(VkDeviceSize);
}
-void reservedmarshal_VkBindImageMemoryInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindImageMemoryInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkBindImageMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindImageMemoryInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -3496,17 +3170,13 @@
}
void reservedmarshal_VkPhysicalDevice16BitStorageFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevice16BitStorageFeatures* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevice16BitStorageFeatures* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -3521,17 +3191,13 @@
}
void reservedmarshal_VkMemoryDedicatedRequirements(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryDedicatedRequirements* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryDedicatedRequirements* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -3542,17 +3208,13 @@
}
void reservedmarshal_VkMemoryDedicatedAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryDedicatedAllocateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryDedicatedAllocateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -3566,18 +3228,15 @@
*ptr += 1 * 8;
}
-void reservedmarshal_VkMemoryAllocateFlagsInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryAllocateFlagsInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkMemoryAllocateFlagsInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkMemoryAllocateFlagsInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -3588,17 +3247,13 @@
}
void reservedmarshal_VkDeviceGroupRenderPassBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupRenderPassBeginInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupRenderPassBeginInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -3606,24 +3261,20 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->deviceRenderAreaCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->deviceRenderAreaCount; ++i)
- {
- reservedmarshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pDeviceRenderAreas + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->deviceRenderAreaCount; ++i) {
+ reservedmarshal_VkRect2D(vkStream, rootType,
+ (const VkRect2D*)(forMarshaling->pDeviceRenderAreas + i), ptr);
}
}
void reservedmarshal_VkDeviceGroupCommandBufferBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupCommandBufferBeginInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupCommandBufferBeginInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -3631,47 +3282,43 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkDeviceGroupSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupSubmitInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDeviceGroupSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupSubmitInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const uint32_t*)forMarshaling->pWaitSemaphoreDeviceIndices, forMarshaling->waitSemaphoreCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pWaitSemaphoreDeviceIndices,
+ forMarshaling->waitSemaphoreCount * sizeof(const uint32_t));
*ptr += forMarshaling->waitSemaphoreCount * sizeof(const uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const uint32_t*)forMarshaling->pCommandBufferDeviceMasks, forMarshaling->commandBufferCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pCommandBufferDeviceMasks,
+ forMarshaling->commandBufferCount * sizeof(const uint32_t));
*ptr += forMarshaling->commandBufferCount * sizeof(const uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->signalSemaphoreCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const uint32_t*)forMarshaling->pSignalSemaphoreDeviceIndices, forMarshaling->signalSemaphoreCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pSignalSemaphoreDeviceIndices,
+ forMarshaling->signalSemaphoreCount * sizeof(const uint32_t));
*ptr += forMarshaling->signalSemaphoreCount * sizeof(const uint32_t);
}
-void reservedmarshal_VkDeviceGroupBindSparseInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupBindSparseInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDeviceGroupBindSparseInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDeviceGroupBindSparseInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -3682,100 +3329,85 @@
}
void reservedmarshal_VkBindBufferMemoryDeviceGroupInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindBufferMemoryDeviceGroupInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindBufferMemoryDeviceGroupInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->deviceIndexCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const uint32_t*)forMarshaling->pDeviceIndices, forMarshaling->deviceIndexCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pDeviceIndices,
+ forMarshaling->deviceIndexCount * sizeof(const uint32_t));
*ptr += forMarshaling->deviceIndexCount * sizeof(const uint32_t);
}
void reservedmarshal_VkBindImageMemoryDeviceGroupInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindImageMemoryDeviceGroupInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindImageMemoryDeviceGroupInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->deviceIndexCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const uint32_t*)forMarshaling->pDeviceIndices, forMarshaling->deviceIndexCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pDeviceIndices,
+ forMarshaling->deviceIndexCount * sizeof(const uint32_t));
*ptr += forMarshaling->deviceIndexCount * sizeof(const uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->splitInstanceBindRegionCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->splitInstanceBindRegionCount; ++i)
- {
- reservedmarshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pSplitInstanceBindRegions + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->splitInstanceBindRegionCount; ++i) {
+ reservedmarshal_VkRect2D(vkStream, rootType,
+ (const VkRect2D*)(forMarshaling->pSplitInstanceBindRegions + i),
+ ptr);
}
}
void reservedmarshal_VkPhysicalDeviceGroupProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceGroupProperties* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceGroupProperties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->physicalDeviceCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkPhysicalDevice*)forMarshaling->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice));
+ memcpy(*ptr, (VkPhysicalDevice*)forMarshaling->physicalDevices,
+ VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice));
*ptr += VK_MAX_DEVICE_GROUP_SIZE * sizeof(VkPhysicalDevice);
memcpy(*ptr, (VkBool32*)&forMarshaling->subsetAllocation, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkDeviceGroupDeviceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupDeviceCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupDeviceCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->physicalDeviceCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- if (forMarshaling->physicalDeviceCount)
- {
+ if (forMarshaling->physicalDeviceCount) {
uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->physicalDeviceCount; ++k)
- {
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->physicalDeviceCount; ++k) {
uint64_t tmpval = get_host_u64_VkPhysicalDevice(forMarshaling->pPhysicalDevices[k]);
memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -3785,17 +3417,13 @@
}
void reservedmarshal_VkBufferMemoryRequirementsInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferMemoryRequirementsInfo2* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferMemoryRequirementsInfo2* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -3806,17 +3434,13 @@
}
void reservedmarshal_VkImageMemoryRequirementsInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageMemoryRequirementsInfo2* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageMemoryRequirementsInfo2* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -3827,17 +3451,13 @@
}
void reservedmarshal_VkImageSparseMemoryRequirementsInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageSparseMemoryRequirementsInfo2* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSparseMemoryRequirementsInfo2* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -3847,126 +3467,106 @@
*ptr += 1 * 8;
}
-void reservedmarshal_VkMemoryRequirements2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryRequirements2* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkMemoryRequirements2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryRequirements2* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkMemoryRequirements(vkStream, rootType, (VkMemoryRequirements*)(&forMarshaling->memoryRequirements), ptr);
+ reservedmarshal_VkMemoryRequirements(
+ vkStream, rootType, (VkMemoryRequirements*)(&forMarshaling->memoryRequirements), ptr);
}
void reservedmarshal_VkSparseImageMemoryRequirements2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageMemoryRequirements2* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageMemoryRequirements2* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkSparseImageMemoryRequirements(vkStream, rootType, (VkSparseImageMemoryRequirements*)(&forMarshaling->memoryRequirements), ptr);
+ reservedmarshal_VkSparseImageMemoryRequirements(
+ vkStream, rootType, (VkSparseImageMemoryRequirements*)(&forMarshaling->memoryRequirements),
+ ptr);
}
-void reservedmarshal_VkPhysicalDeviceFeatures2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFeatures2* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPhysicalDeviceFeatures2(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkPhysicalDeviceFeatures2* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkPhysicalDeviceFeatures(vkStream, rootType, (VkPhysicalDeviceFeatures*)(&forMarshaling->features), ptr);
+ reservedmarshal_VkPhysicalDeviceFeatures(
+ vkStream, rootType, (VkPhysicalDeviceFeatures*)(&forMarshaling->features), ptr);
}
-void reservedmarshal_VkPhysicalDeviceProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceProperties2* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPhysicalDeviceProperties2(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkPhysicalDeviceProperties2* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkPhysicalDeviceProperties(vkStream, rootType, (VkPhysicalDeviceProperties*)(&forMarshaling->properties), ptr);
+ reservedmarshal_VkPhysicalDeviceProperties(
+ vkStream, rootType, (VkPhysicalDeviceProperties*)(&forMarshaling->properties), ptr);
}
-void reservedmarshal_VkFormatProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFormatProperties2* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkFormatProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFormatProperties2* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkFormatProperties(vkStream, rootType, (VkFormatProperties*)(&forMarshaling->formatProperties), ptr);
+ reservedmarshal_VkFormatProperties(
+ vkStream, rootType, (VkFormatProperties*)(&forMarshaling->formatProperties), ptr);
}
-void reservedmarshal_VkImageFormatProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageFormatProperties2* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImageFormatProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageFormatProperties2* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkImageFormatProperties(vkStream, rootType, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties), ptr);
+ reservedmarshal_VkImageFormatProperties(
+ vkStream, rootType, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties), ptr);
}
void reservedmarshal_VkPhysicalDeviceImageFormatInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceImageFormatInfo2* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceImageFormatInfo2* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -3982,72 +3582,60 @@
*ptr += sizeof(VkImageCreateFlags);
}
-void reservedmarshal_VkQueueFamilyProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueueFamilyProperties2* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkQueueFamilyProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyProperties2* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkQueueFamilyProperties(vkStream, rootType, (VkQueueFamilyProperties*)(&forMarshaling->queueFamilyProperties), ptr);
+ reservedmarshal_VkQueueFamilyProperties(
+ vkStream, rootType, (VkQueueFamilyProperties*)(&forMarshaling->queueFamilyProperties), ptr);
}
void reservedmarshal_VkPhysicalDeviceMemoryProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryProperties2* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryProperties2* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkPhysicalDeviceMemoryProperties(vkStream, rootType, (VkPhysicalDeviceMemoryProperties*)(&forMarshaling->memoryProperties), ptr);
+ reservedmarshal_VkPhysicalDeviceMemoryProperties(
+ vkStream, rootType, (VkPhysicalDeviceMemoryProperties*)(&forMarshaling->memoryProperties),
+ ptr);
}
void reservedmarshal_VkSparseImageFormatProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageFormatProperties2* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageFormatProperties2* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkSparseImageFormatProperties(vkStream, rootType, (VkSparseImageFormatProperties*)(&forMarshaling->properties), ptr);
+ reservedmarshal_VkSparseImageFormatProperties(
+ vkStream, rootType, (VkSparseImageFormatProperties*)(&forMarshaling->properties), ptr);
}
void reservedmarshal_VkPhysicalDeviceSparseImageFormatInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSparseImageFormatInfo2* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSparseImageFormatInfo2* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -4064,30 +3652,24 @@
}
void reservedmarshal_VkPhysicalDevicePointClippingProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePointClippingProperties* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePointClippingProperties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPointClippingBehavior*)&forMarshaling->pointClippingBehavior, sizeof(VkPointClippingBehavior));
+ memcpy(*ptr, (VkPointClippingBehavior*)&forMarshaling->pointClippingBehavior,
+ sizeof(VkPointClippingBehavior));
*ptr += sizeof(VkPointClippingBehavior);
}
void reservedmarshal_VkInputAttachmentAspectReference(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkInputAttachmentAspectReference* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkInputAttachmentAspectReference* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
@@ -4099,40 +3681,34 @@
}
void reservedmarshal_VkRenderPassInputAttachmentAspectCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassInputAttachmentAspectCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassInputAttachmentAspectCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->aspectReferenceCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->aspectReferenceCount; ++i)
- {
- reservedmarshal_VkInputAttachmentAspectReference(vkStream, rootType, (const VkInputAttachmentAspectReference*)(forMarshaling->pAspectReferences + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->aspectReferenceCount; ++i) {
+ reservedmarshal_VkInputAttachmentAspectReference(
+ vkStream, rootType,
+ (const VkInputAttachmentAspectReference*)(forMarshaling->pAspectReferences + i), ptr);
}
}
-void reservedmarshal_VkImageViewUsageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageViewUsageCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImageViewUsageCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkImageViewUsageCreateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -4141,65 +3717,57 @@
}
void reservedmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineTessellationDomainOriginStateCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineTessellationDomainOriginStateCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkTessellationDomainOrigin*)&forMarshaling->domainOrigin, sizeof(VkTessellationDomainOrigin));
+ memcpy(*ptr, (VkTessellationDomainOrigin*)&forMarshaling->domainOrigin,
+ sizeof(VkTessellationDomainOrigin));
*ptr += sizeof(VkTessellationDomainOrigin);
}
void reservedmarshal_VkRenderPassMultiviewCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassMultiviewCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassMultiviewCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->subpassCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const uint32_t*)forMarshaling->pViewMasks, forMarshaling->subpassCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pViewMasks,
+ forMarshaling->subpassCount * sizeof(const uint32_t));
*ptr += forMarshaling->subpassCount * sizeof(const uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->dependencyCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const int32_t*)forMarshaling->pViewOffsets, forMarshaling->dependencyCount * sizeof(const int32_t));
+ memcpy(*ptr, (const int32_t*)forMarshaling->pViewOffsets,
+ forMarshaling->dependencyCount * sizeof(const int32_t));
*ptr += forMarshaling->dependencyCount * sizeof(const int32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->correlationMaskCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const uint32_t*)forMarshaling->pCorrelationMasks, forMarshaling->correlationMaskCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pCorrelationMasks,
+ forMarshaling->correlationMaskCount * sizeof(const uint32_t));
*ptr += forMarshaling->correlationMaskCount * sizeof(const uint32_t);
}
void reservedmarshal_VkPhysicalDeviceMultiviewFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiviewFeatures* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMultiviewFeatures* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -4212,17 +3780,13 @@
}
void reservedmarshal_VkPhysicalDeviceMultiviewProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiviewProperties* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMultiviewProperties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -4233,17 +3797,13 @@
}
void reservedmarshal_VkPhysicalDeviceVariablePointersFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVariablePointersFeatures* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVariablePointersFeatures* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -4254,17 +3814,13 @@
}
void reservedmarshal_VkPhysicalDeviceProtectedMemoryFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceProtectedMemoryFeatures* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceProtectedMemoryFeatures* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -4273,17 +3829,13 @@
}
void reservedmarshal_VkPhysicalDeviceProtectedMemoryProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceProtectedMemoryProperties* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceProtectedMemoryProperties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -4291,22 +3843,18 @@
*ptr += sizeof(VkBool32);
}
-void reservedmarshal_VkDeviceQueueInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceQueueInfo2* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDeviceQueueInfo2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceQueueInfo2* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDeviceQueueCreateFlags*)&forMarshaling->flags, sizeof(VkDeviceQueueCreateFlags));
+ memcpy(*ptr, (VkDeviceQueueCreateFlags*)&forMarshaling->flags,
+ sizeof(VkDeviceQueueCreateFlags));
*ptr += sizeof(VkDeviceQueueCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -4314,18 +3862,14 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkProtectedSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkProtectedSubmitInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkProtectedSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkProtectedSubmitInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -4334,27 +3878,25 @@
}
void reservedmarshal_VkSamplerYcbcrConversionCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerYcbcrConversionCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerYcbcrConversionCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
*ptr += sizeof(VkFormat);
- memcpy(*ptr, (VkSamplerYcbcrModelConversion*)&forMarshaling->ycbcrModel, sizeof(VkSamplerYcbcrModelConversion));
+ memcpy(*ptr, (VkSamplerYcbcrModelConversion*)&forMarshaling->ycbcrModel,
+ sizeof(VkSamplerYcbcrModelConversion));
*ptr += sizeof(VkSamplerYcbcrModelConversion);
memcpy(*ptr, (VkSamplerYcbcrRange*)&forMarshaling->ycbcrRange, sizeof(VkSamplerYcbcrRange));
*ptr += sizeof(VkSamplerYcbcrRange);
- reservedmarshal_VkComponentMapping(vkStream, rootType, (VkComponentMapping*)(&forMarshaling->components), ptr);
+ reservedmarshal_VkComponentMapping(vkStream, rootType,
+ (VkComponentMapping*)(&forMarshaling->components), ptr);
memcpy(*ptr, (VkChromaLocation*)&forMarshaling->xChromaOffset, sizeof(VkChromaLocation));
*ptr += sizeof(VkChromaLocation);
memcpy(*ptr, (VkChromaLocation*)&forMarshaling->yChromaOffset, sizeof(VkChromaLocation));
@@ -4365,18 +3907,15 @@
*ptr += sizeof(VkBool32);
}
-void reservedmarshal_VkSamplerYcbcrConversionInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerYcbcrConversionInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSamplerYcbcrConversionInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkSamplerYcbcrConversionInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -4386,56 +3925,47 @@
*ptr += 1 * 8;
}
-void reservedmarshal_VkBindImagePlaneMemoryInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindImagePlaneMemoryInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkBindImagePlaneMemoryInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkBindImagePlaneMemoryInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkImageAspectFlagBits*)&forMarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
+ memcpy(*ptr, (VkImageAspectFlagBits*)&forMarshaling->planeAspect,
+ sizeof(VkImageAspectFlagBits));
*ptr += sizeof(VkImageAspectFlagBits);
}
void reservedmarshal_VkImagePlaneMemoryRequirementsInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImagePlaneMemoryRequirementsInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImagePlaneMemoryRequirementsInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkImageAspectFlagBits*)&forMarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
+ memcpy(*ptr, (VkImageAspectFlagBits*)&forMarshaling->planeAspect,
+ sizeof(VkImageAspectFlagBits));
*ptr += sizeof(VkImageAspectFlagBits);
}
void reservedmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSamplerYcbcrConversionFeatures* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSamplerYcbcrConversionFeatures* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -4444,17 +3974,13 @@
}
void reservedmarshal_VkSamplerYcbcrConversionImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerYcbcrConversionImageFormatProperties* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerYcbcrConversionImageFormatProperties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -4463,11 +3989,8 @@
}
void reservedmarshal_VkDescriptorUpdateTemplateEntry(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorUpdateTemplateEntry* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorUpdateTemplateEntry* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->dstBinding, sizeof(uint32_t));
@@ -4489,35 +4012,36 @@
}
void reservedmarshal_VkDescriptorUpdateTemplateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorUpdateTemplateCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorUpdateTemplateCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDescriptorUpdateTemplateCreateFlags*)&forMarshaling->flags, sizeof(VkDescriptorUpdateTemplateCreateFlags));
+ memcpy(*ptr, (VkDescriptorUpdateTemplateCreateFlags*)&forMarshaling->flags,
+ sizeof(VkDescriptorUpdateTemplateCreateFlags));
*ptr += sizeof(VkDescriptorUpdateTemplateCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->descriptorUpdateEntryCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorUpdateEntryCount; ++i)
- {
- reservedmarshal_VkDescriptorUpdateTemplateEntry(vkStream, rootType, (const VkDescriptorUpdateTemplateEntry*)(forMarshaling->pDescriptorUpdateEntries + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorUpdateEntryCount; ++i) {
+ reservedmarshal_VkDescriptorUpdateTemplateEntry(
+ vkStream, rootType,
+ (const VkDescriptorUpdateTemplateEntry*)(forMarshaling->pDescriptorUpdateEntries + i),
+ ptr);
}
- memcpy(*ptr, (VkDescriptorUpdateTemplateType*)&forMarshaling->templateType, sizeof(VkDescriptorUpdateTemplateType));
+ memcpy(*ptr, (VkDescriptorUpdateTemplateType*)&forMarshaling->templateType,
+ sizeof(VkDescriptorUpdateTemplateType));
*ptr += sizeof(VkDescriptorUpdateTemplateType);
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDescriptorSetLayout((*&forMarshaling->descriptorSetLayout));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
- memcpy(*ptr, (VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ memcpy(*ptr, (VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
*ptr += sizeof(VkPipelineBindPoint);
uint64_t cgen_var_1;
*&cgen_var_1 = get_host_u64_VkPipelineLayout((*&forMarshaling->pipelineLayout));
@@ -4527,71 +4051,63 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkExternalMemoryProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalMemoryProperties* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkExternalMemoryProperties(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkExternalMemoryProperties* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- memcpy(*ptr, (VkExternalMemoryFeatureFlags*)&forMarshaling->externalMemoryFeatures, sizeof(VkExternalMemoryFeatureFlags));
+ memcpy(*ptr, (VkExternalMemoryFeatureFlags*)&forMarshaling->externalMemoryFeatures,
+ sizeof(VkExternalMemoryFeatureFlags));
*ptr += sizeof(VkExternalMemoryFeatureFlags);
- memcpy(*ptr, (VkExternalMemoryHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+ memcpy(*ptr, (VkExternalMemoryHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlags));
*ptr += sizeof(VkExternalMemoryHandleTypeFlags);
- memcpy(*ptr, (VkExternalMemoryHandleTypeFlags*)&forMarshaling->compatibleHandleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+ memcpy(*ptr, (VkExternalMemoryHandleTypeFlags*)&forMarshaling->compatibleHandleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlags));
*ptr += sizeof(VkExternalMemoryHandleTypeFlags);
}
void reservedmarshal_VkPhysicalDeviceExternalImageFormatInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalImageFormatInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExternalImageFormatInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
}
void reservedmarshal_VkExternalImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalImageFormatProperties* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalImageFormatProperties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkExternalMemoryProperties(vkStream, rootType, (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties), ptr);
+ reservedmarshal_VkExternalMemoryProperties(
+ vkStream, rootType, (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties),
+ ptr);
}
void reservedmarshal_VkPhysicalDeviceExternalBufferInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalBufferInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExternalBufferInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -4599,40 +4115,37 @@
*ptr += sizeof(VkBufferCreateFlags);
memcpy(*ptr, (VkBufferUsageFlags*)&forMarshaling->usage, sizeof(VkBufferUsageFlags));
*ptr += sizeof(VkBufferUsageFlags);
- memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
}
-void reservedmarshal_VkExternalBufferProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalBufferProperties* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkExternalBufferProperties(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkExternalBufferProperties* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkExternalMemoryProperties(vkStream, rootType, (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties), ptr);
+ reservedmarshal_VkExternalMemoryProperties(
+ vkStream, rootType, (VkExternalMemoryProperties*)(&forMarshaling->externalMemoryProperties),
+ ptr);
}
-void reservedmarshal_VkPhysicalDeviceIDProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceIDProperties* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPhysicalDeviceIDProperties(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkPhysicalDeviceIDProperties* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -4649,196 +4162,172 @@
}
void reservedmarshal_VkExternalMemoryImageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalMemoryImageCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalMemoryImageCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+ memcpy(*ptr, (VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlags));
*ptr += sizeof(VkExternalMemoryHandleTypeFlags);
}
void reservedmarshal_VkExternalMemoryBufferCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalMemoryBufferCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalMemoryBufferCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+ memcpy(*ptr, (VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlags));
*ptr += sizeof(VkExternalMemoryHandleTypeFlags);
}
-void reservedmarshal_VkExportMemoryAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportMemoryAllocateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkExportMemoryAllocateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkExportMemoryAllocateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlags));
+ memcpy(*ptr, (VkExternalMemoryHandleTypeFlags*)&forMarshaling->handleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlags));
*ptr += sizeof(VkExternalMemoryHandleTypeFlags);
}
void reservedmarshal_VkPhysicalDeviceExternalFenceInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalFenceInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExternalFenceInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalFenceHandleTypeFlagBits));
*ptr += sizeof(VkExternalFenceHandleTypeFlagBits);
}
-void reservedmarshal_VkExternalFenceProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalFenceProperties* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkExternalFenceProperties(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkExternalFenceProperties* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkExternalFenceHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes, sizeof(VkExternalFenceHandleTypeFlags));
+ memcpy(*ptr, (VkExternalFenceHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes,
+ sizeof(VkExternalFenceHandleTypeFlags));
*ptr += sizeof(VkExternalFenceHandleTypeFlags);
- memcpy(*ptr, (VkExternalFenceHandleTypeFlags*)&forMarshaling->compatibleHandleTypes, sizeof(VkExternalFenceHandleTypeFlags));
+ memcpy(*ptr, (VkExternalFenceHandleTypeFlags*)&forMarshaling->compatibleHandleTypes,
+ sizeof(VkExternalFenceHandleTypeFlags));
*ptr += sizeof(VkExternalFenceHandleTypeFlags);
- memcpy(*ptr, (VkExternalFenceFeatureFlags*)&forMarshaling->externalFenceFeatures, sizeof(VkExternalFenceFeatureFlags));
+ memcpy(*ptr, (VkExternalFenceFeatureFlags*)&forMarshaling->externalFenceFeatures,
+ sizeof(VkExternalFenceFeatureFlags));
*ptr += sizeof(VkExternalFenceFeatureFlags);
}
-void reservedmarshal_VkExportFenceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportFenceCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkExportFenceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportFenceCreateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkExternalFenceHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalFenceHandleTypeFlags));
+ memcpy(*ptr, (VkExternalFenceHandleTypeFlags*)&forMarshaling->handleTypes,
+ sizeof(VkExternalFenceHandleTypeFlags));
*ptr += sizeof(VkExternalFenceHandleTypeFlags);
}
-void reservedmarshal_VkExportSemaphoreCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportSemaphoreCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkExportSemaphoreCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkExportSemaphoreCreateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->handleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
+ memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->handleTypes,
+ sizeof(VkExternalSemaphoreHandleTypeFlags));
*ptr += sizeof(VkExternalSemaphoreHandleTypeFlags);
}
void reservedmarshal_VkPhysicalDeviceExternalSemaphoreInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalSemaphoreInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExternalSemaphoreInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
*ptr += sizeof(VkExternalSemaphoreHandleTypeFlagBits);
}
void reservedmarshal_VkExternalSemaphoreProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalSemaphoreProperties* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalSemaphoreProperties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
+ memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->exportFromImportedHandleTypes,
+ sizeof(VkExternalSemaphoreHandleTypeFlags));
*ptr += sizeof(VkExternalSemaphoreHandleTypeFlags);
- memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->compatibleHandleTypes, sizeof(VkExternalSemaphoreHandleTypeFlags));
+ memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlags*)&forMarshaling->compatibleHandleTypes,
+ sizeof(VkExternalSemaphoreHandleTypeFlags));
*ptr += sizeof(VkExternalSemaphoreHandleTypeFlags);
- memcpy(*ptr, (VkExternalSemaphoreFeatureFlags*)&forMarshaling->externalSemaphoreFeatures, sizeof(VkExternalSemaphoreFeatureFlags));
+ memcpy(*ptr, (VkExternalSemaphoreFeatureFlags*)&forMarshaling->externalSemaphoreFeatures,
+ sizeof(VkExternalSemaphoreFeatureFlags));
*ptr += sizeof(VkExternalSemaphoreFeatureFlags);
}
void reservedmarshal_VkPhysicalDeviceMaintenance3Properties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMaintenance3Properties* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance3Properties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -4848,18 +4337,15 @@
*ptr += sizeof(VkDeviceSize);
}
-void reservedmarshal_VkDescriptorSetLayoutSupport(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetLayoutSupport* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDescriptorSetLayoutSupport(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDescriptorSetLayoutSupport* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -4868,17 +4354,13 @@
}
void reservedmarshal_VkPhysicalDeviceShaderDrawParametersFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderDrawParametersFeatures* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderDrawParametersFeatures* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -4889,17 +4371,13 @@
#endif
#ifdef VK_VERSION_1_2
void reservedmarshal_VkPhysicalDeviceVulkan11Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan11Features* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan11Features* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -4930,17 +4408,13 @@
}
void reservedmarshal_VkPhysicalDeviceVulkan11Properties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan11Properties* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan11Properties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -4956,13 +4430,16 @@
*ptr += sizeof(VkBool32);
memcpy(*ptr, (uint32_t*)&forMarshaling->subgroupSize, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->subgroupSupportedStages, sizeof(VkShaderStageFlags));
+ memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->subgroupSupportedStages,
+ sizeof(VkShaderStageFlags));
*ptr += sizeof(VkShaderStageFlags);
- memcpy(*ptr, (VkSubgroupFeatureFlags*)&forMarshaling->subgroupSupportedOperations, sizeof(VkSubgroupFeatureFlags));
+ memcpy(*ptr, (VkSubgroupFeatureFlags*)&forMarshaling->subgroupSupportedOperations,
+ sizeof(VkSubgroupFeatureFlags));
*ptr += sizeof(VkSubgroupFeatureFlags);
memcpy(*ptr, (VkBool32*)&forMarshaling->subgroupQuadOperationsInAllStages, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkPointClippingBehavior*)&forMarshaling->pointClippingBehavior, sizeof(VkPointClippingBehavior));
+ memcpy(*ptr, (VkPointClippingBehavior*)&forMarshaling->pointClippingBehavior,
+ sizeof(VkPointClippingBehavior));
*ptr += sizeof(VkPointClippingBehavior);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxMultiviewViewCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -4977,17 +4454,13 @@
}
void reservedmarshal_VkPhysicalDeviceVulkan12Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan12Features* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan12Features* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -5011,43 +4484,61 @@
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorIndexing, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderInputAttachmentArrayDynamicIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderInputAttachmentArrayDynamicIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayDynamicIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayDynamicIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayNonUniformIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayNonUniformIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingUniformBufferUpdateAfterBind, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingUniformBufferUpdateAfterBind,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingSampledImageUpdateAfterBind, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingSampledImageUpdateAfterBind,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingStorageImageUpdateAfterBind, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingStorageImageUpdateAfterBind,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingStorageBufferUpdateAfterBind, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingStorageBufferUpdateAfterBind,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingUniformTexelBufferUpdateAfterBind, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingUniformTexelBufferUpdateAfterBind,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingStorageTexelBufferUpdateAfterBind, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingStorageTexelBufferUpdateAfterBind,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingUpdateUnusedWhilePending, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingUpdateUnusedWhilePending,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingPartiallyBound, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingVariableDescriptorCount, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingVariableDescriptorCount,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->runtimeDescriptorArray, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -5077,7 +4568,8 @@
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->vulkanMemoryModelDeviceScope, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->vulkanMemoryModelAvailabilityVisibilityChains, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->vulkanMemoryModelAvailabilityVisibilityChains,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderOutputViewportIndex, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -5087,12 +4579,9 @@
*ptr += sizeof(VkBool32);
}
-void reservedmarshal_VkConformanceVersion(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkConformanceVersion* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkConformanceVersion(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkConformanceVersion* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint8_t*)&forMarshaling->major, sizeof(uint8_t));
@@ -5106,17 +4595,13 @@
}
void reservedmarshal_VkPhysicalDeviceVulkan12Properties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan12Properties* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan12Properties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -5126,16 +4611,22 @@
*ptr += VK_MAX_DRIVER_NAME_SIZE * sizeof(char);
memcpy(*ptr, (char*)forMarshaling->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
*ptr += VK_MAX_DRIVER_INFO_SIZE * sizeof(char);
- reservedmarshal_VkConformanceVersion(vkStream, rootType, (VkConformanceVersion*)(&forMarshaling->conformanceVersion), ptr);
- memcpy(*ptr, (VkShaderFloatControlsIndependence*)&forMarshaling->denormBehaviorIndependence, sizeof(VkShaderFloatControlsIndependence));
+ reservedmarshal_VkConformanceVersion(
+ vkStream, rootType, (VkConformanceVersion*)(&forMarshaling->conformanceVersion), ptr);
+ memcpy(*ptr, (VkShaderFloatControlsIndependence*)&forMarshaling->denormBehaviorIndependence,
+ sizeof(VkShaderFloatControlsIndependence));
*ptr += sizeof(VkShaderFloatControlsIndependence);
- memcpy(*ptr, (VkShaderFloatControlsIndependence*)&forMarshaling->roundingModeIndependence, sizeof(VkShaderFloatControlsIndependence));
+ memcpy(*ptr, (VkShaderFloatControlsIndependence*)&forMarshaling->roundingModeIndependence,
+ sizeof(VkShaderFloatControlsIndependence));
*ptr += sizeof(VkShaderFloatControlsIndependence);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat16, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat16,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat32, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat32,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat64, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat64,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderDenormPreserveFloat16, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -5161,55 +4652,77 @@
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderRoundingModeRTZFloat64, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxUpdateAfterBindDescriptorsInAllPools, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxUpdateAfterBindDescriptorsInAllPools,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexingNative, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexingNative, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexingNative, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->robustBufferAccessUpdateAfterBind, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->quadDivergentImplicitLod, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSamplers, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSamplers,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindUniformBuffers, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindUniformBuffers,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageBuffers, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageBuffers,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSampledImages, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSampledImages,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageImages, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageImages,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInputAttachments, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInputAttachments,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageUpdateAfterBindResources, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSamplers, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSamplers,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffers, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffers,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffers, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffers,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSampledImages, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSampledImages,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageImages, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageImages,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInputAttachments, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInputAttachments,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkResolveModeFlags*)&forMarshaling->supportedDepthResolveModes, sizeof(VkResolveModeFlags));
+ memcpy(*ptr, (VkResolveModeFlags*)&forMarshaling->supportedDepthResolveModes,
+ sizeof(VkResolveModeFlags));
*ptr += sizeof(VkResolveModeFlags);
- memcpy(*ptr, (VkResolveModeFlags*)&forMarshaling->supportedStencilResolveModes, sizeof(VkResolveModeFlags));
+ memcpy(*ptr, (VkResolveModeFlags*)&forMarshaling->supportedStencilResolveModes,
+ sizeof(VkResolveModeFlags));
*ptr += sizeof(VkResolveModeFlags);
memcpy(*ptr, (VkBool32*)&forMarshaling->independentResolveNone, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -5221,47 +4734,43 @@
*ptr += sizeof(VkBool32);
memcpy(*ptr, (uint64_t*)&forMarshaling->maxTimelineSemaphoreValueDifference, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
- memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->framebufferIntegerColorSampleCounts, sizeof(VkSampleCountFlags));
+ memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->framebufferIntegerColorSampleCounts,
+ sizeof(VkSampleCountFlags));
*ptr += sizeof(VkSampleCountFlags);
}
-void reservedmarshal_VkImageFormatListCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageFormatListCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImageFormatListCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkImageFormatListCreateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->viewFormatCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const VkFormat*)forMarshaling->pViewFormats, forMarshaling->viewFormatCount * sizeof(const VkFormat));
+ memcpy(*ptr, (const VkFormat*)forMarshaling->pViewFormats,
+ forMarshaling->viewFormatCount * sizeof(const VkFormat));
*ptr += forMarshaling->viewFormatCount * sizeof(const VkFormat);
}
-void reservedmarshal_VkAttachmentDescription2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentDescription2* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkAttachmentDescription2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentDescription2* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkAttachmentDescriptionFlags*)&forMarshaling->flags, sizeof(VkAttachmentDescriptionFlags));
+ memcpy(*ptr, (VkAttachmentDescriptionFlags*)&forMarshaling->flags,
+ sizeof(VkAttachmentDescriptionFlags));
*ptr += sizeof(VkAttachmentDescriptionFlags);
memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
*ptr += sizeof(VkFormat);
@@ -5281,18 +4790,14 @@
*ptr += sizeof(VkImageLayout);
}
-void reservedmarshal_VkAttachmentReference2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentReference2* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkAttachmentReference2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentReference2* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -5304,49 +4809,49 @@
*ptr += sizeof(VkImageAspectFlags);
}
-void reservedmarshal_VkSubpassDescription2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassDescription2* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSubpassDescription2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassDescription2* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkSubpassDescriptionFlags*)&forMarshaling->flags, sizeof(VkSubpassDescriptionFlags));
+ memcpy(*ptr, (VkSubpassDescriptionFlags*)&forMarshaling->flags,
+ sizeof(VkSubpassDescriptionFlags));
*ptr += sizeof(VkSubpassDescriptionFlags);
- memcpy(*ptr, (VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ memcpy(*ptr, (VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
*ptr += sizeof(VkPipelineBindPoint);
memcpy(*ptr, (uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->inputAttachmentCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->inputAttachmentCount; ++i)
- {
- reservedmarshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pInputAttachments + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->inputAttachmentCount; ++i) {
+ reservedmarshal_VkAttachmentReference2(
+ vkStream, rootType,
+ (const VkAttachmentReference2*)(forMarshaling->pInputAttachments + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
- {
- reservedmarshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pColorAttachments + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
+ reservedmarshal_VkAttachmentReference2(
+ vkStream, rootType,
+ (const VkAttachmentReference2*)(forMarshaling->pColorAttachments + i), ptr);
}
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pResolveAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
- {
- reservedmarshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pResolveAttachments + i), ptr);
+ if (forMarshaling->pResolveAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
+ reservedmarshal_VkAttachmentReference2(
+ vkStream, rootType,
+ (const VkAttachmentReference2*)(forMarshaling->pResolveAttachments + i), ptr);
}
}
// WARNING PTR CHECK
@@ -5354,28 +4859,26 @@
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pDepthStencilAttachment)
- {
- reservedmarshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pDepthStencilAttachment), ptr);
+ if (forMarshaling->pDepthStencilAttachment) {
+ reservedmarshal_VkAttachmentReference2(
+ vkStream, rootType,
+ (const VkAttachmentReference2*)(forMarshaling->pDepthStencilAttachment), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->preserveAttachmentCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const uint32_t*)forMarshaling->pPreserveAttachments, forMarshaling->preserveAttachmentCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pPreserveAttachments,
+ forMarshaling->preserveAttachmentCount * sizeof(const uint32_t));
*ptr += forMarshaling->preserveAttachmentCount * sizeof(const uint32_t);
}
-void reservedmarshal_VkSubpassDependency2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassDependency2* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSubpassDependency2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassDependency2* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -5397,18 +4900,14 @@
*ptr += sizeof(int32_t);
}
-void reservedmarshal_VkRenderPassCreateInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassCreateInfo2* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkRenderPassCreateInfo2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassCreateInfo2* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -5416,40 +4915,38 @@
*ptr += sizeof(VkRenderPassCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i)
- {
- reservedmarshal_VkAttachmentDescription2(vkStream, rootType, (const VkAttachmentDescription2*)(forMarshaling->pAttachments + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentCount; ++i) {
+ reservedmarshal_VkAttachmentDescription2(
+ vkStream, rootType, (const VkAttachmentDescription2*)(forMarshaling->pAttachments + i),
+ ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->subpassCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->subpassCount; ++i)
- {
- reservedmarshal_VkSubpassDescription2(vkStream, rootType, (const VkSubpassDescription2*)(forMarshaling->pSubpasses + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->subpassCount; ++i) {
+ reservedmarshal_VkSubpassDescription2(
+ vkStream, rootType, (const VkSubpassDescription2*)(forMarshaling->pSubpasses + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->dependencyCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->dependencyCount; ++i)
- {
- reservedmarshal_VkSubpassDependency2(vkStream, rootType, (const VkSubpassDependency2*)(forMarshaling->pDependencies + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->dependencyCount; ++i) {
+ reservedmarshal_VkSubpassDependency2(
+ vkStream, rootType, (const VkSubpassDependency2*)(forMarshaling->pDependencies + i),
+ ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->correlatedViewMaskCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const uint32_t*)forMarshaling->pCorrelatedViewMasks, forMarshaling->correlatedViewMaskCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pCorrelatedViewMasks,
+ forMarshaling->correlatedViewMaskCount * sizeof(const uint32_t));
*ptr += forMarshaling->correlatedViewMaskCount * sizeof(const uint32_t);
}
-void reservedmarshal_VkSubpassBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassBeginInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSubpassBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassBeginInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -5457,35 +4954,26 @@
*ptr += sizeof(VkSubpassContents);
}
-void reservedmarshal_VkSubpassEndInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassEndInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSubpassEndInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassEndInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
}
void reservedmarshal_VkPhysicalDevice8BitStorageFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevice8BitStorageFeatures* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevice8BitStorageFeatures* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -5498,17 +4986,13 @@
}
void reservedmarshal_VkPhysicalDeviceDriverProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDriverProperties* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDriverProperties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -5518,21 +5002,18 @@
*ptr += VK_MAX_DRIVER_NAME_SIZE * sizeof(char);
memcpy(*ptr, (char*)forMarshaling->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char));
*ptr += VK_MAX_DRIVER_INFO_SIZE * sizeof(char);
- reservedmarshal_VkConformanceVersion(vkStream, rootType, (VkConformanceVersion*)(&forMarshaling->conformanceVersion), ptr);
+ reservedmarshal_VkConformanceVersion(
+ vkStream, rootType, (VkConformanceVersion*)(&forMarshaling->conformanceVersion), ptr);
}
void reservedmarshal_VkPhysicalDeviceShaderAtomicInt64Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderAtomicInt64Features* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderAtomicInt64Features* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -5543,17 +5024,13 @@
}
void reservedmarshal_VkPhysicalDeviceShaderFloat16Int8Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderFloat16Int8Features* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderFloat16Int8Features* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -5564,29 +5041,30 @@
}
void reservedmarshal_VkPhysicalDeviceFloatControlsProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFloatControlsProperties* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFloatControlsProperties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkShaderFloatControlsIndependence*)&forMarshaling->denormBehaviorIndependence, sizeof(VkShaderFloatControlsIndependence));
+ memcpy(*ptr, (VkShaderFloatControlsIndependence*)&forMarshaling->denormBehaviorIndependence,
+ sizeof(VkShaderFloatControlsIndependence));
*ptr += sizeof(VkShaderFloatControlsIndependence);
- memcpy(*ptr, (VkShaderFloatControlsIndependence*)&forMarshaling->roundingModeIndependence, sizeof(VkShaderFloatControlsIndependence));
+ memcpy(*ptr, (VkShaderFloatControlsIndependence*)&forMarshaling->roundingModeIndependence,
+ sizeof(VkShaderFloatControlsIndependence));
*ptr += sizeof(VkShaderFloatControlsIndependence);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat16, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat16,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat32, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat32,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat64, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSignedZeroInfNanPreserveFloat64,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->shaderDenormPreserveFloat16, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -5615,17 +5093,13 @@
}
void reservedmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetLayoutBindingFlagsCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorSetLayoutBindingFlagsCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -5636,166 +5110,189 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pBindingFlags)
- {
- memcpy(*ptr, (const VkDescriptorBindingFlags*)forMarshaling->pBindingFlags, forMarshaling->bindingCount * sizeof(const VkDescriptorBindingFlags));
+ if (forMarshaling->pBindingFlags) {
+ memcpy(*ptr, (const VkDescriptorBindingFlags*)forMarshaling->pBindingFlags,
+ forMarshaling->bindingCount * sizeof(const VkDescriptorBindingFlags));
*ptr += forMarshaling->bindingCount * sizeof(const VkDescriptorBindingFlags);
}
}
void reservedmarshal_VkPhysicalDeviceDescriptorIndexingFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDescriptorIndexingFeatures* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDescriptorIndexingFeatures* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderInputAttachmentArrayDynamicIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderInputAttachmentArrayDynamicIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayDynamicIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayDynamicIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayDynamicIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayNonUniformIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderUniformTexelBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayNonUniformIndexing, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageTexelBufferArrayNonUniformIndexing,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingUniformBufferUpdateAfterBind, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingUniformBufferUpdateAfterBind,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingSampledImageUpdateAfterBind, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingSampledImageUpdateAfterBind,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingStorageImageUpdateAfterBind, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingStorageImageUpdateAfterBind,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingStorageBufferUpdateAfterBind, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingStorageBufferUpdateAfterBind,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingUniformTexelBufferUpdateAfterBind, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingUniformTexelBufferUpdateAfterBind,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingStorageTexelBufferUpdateAfterBind, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingStorageTexelBufferUpdateAfterBind,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingUpdateUnusedWhilePending, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingUpdateUnusedWhilePending,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingPartiallyBound, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingVariableDescriptorCount, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingVariableDescriptorCount,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->runtimeDescriptorArray, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPhysicalDeviceDescriptorIndexingProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDescriptorIndexingProperties* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDescriptorIndexingProperties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxUpdateAfterBindDescriptorsInAllPools, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxUpdateAfterBindDescriptorsInAllPools,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderUniformBufferArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexingNative, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSampledImageArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexingNative, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageBufferArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexingNative, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderStorageImageArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexingNative, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderInputAttachmentArrayNonUniformIndexingNative,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->robustBufferAccessUpdateAfterBind, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->quadDivergentImplicitLod, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSamplers, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSamplers,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindUniformBuffers, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindUniformBuffers,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageBuffers, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageBuffers,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSampledImages, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindSampledImages,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageImages, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindStorageImages,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInputAttachments, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInputAttachments,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageUpdateAfterBindResources, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSamplers, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSamplers,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffers, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffers,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffers, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffers,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSampledImages, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindSampledImages,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageImages, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindStorageImages,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInputAttachments, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInputAttachments,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
void reservedmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetVariableDescriptorCountAllocateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorSetVariableDescriptorCountAllocateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->descriptorSetCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const uint32_t*)forMarshaling->pDescriptorCounts, forMarshaling->descriptorSetCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pDescriptorCounts,
+ forMarshaling->descriptorSetCount * sizeof(const uint32_t));
*ptr += forMarshaling->descriptorSetCount * sizeof(const uint32_t);
}
void reservedmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetVariableDescriptorCountLayoutSupport* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorSetVariableDescriptorCountLayoutSupport* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -5804,53 +5301,50 @@
}
void reservedmarshal_VkSubpassDescriptionDepthStencilResolve(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassDescriptionDepthStencilResolve* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassDescriptionDepthStencilResolve* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkResolveModeFlagBits*)&forMarshaling->depthResolveMode, sizeof(VkResolveModeFlagBits));
+ memcpy(*ptr, (VkResolveModeFlagBits*)&forMarshaling->depthResolveMode,
+ sizeof(VkResolveModeFlagBits));
*ptr += sizeof(VkResolveModeFlagBits);
- memcpy(*ptr, (VkResolveModeFlagBits*)&forMarshaling->stencilResolveMode, sizeof(VkResolveModeFlagBits));
+ memcpy(*ptr, (VkResolveModeFlagBits*)&forMarshaling->stencilResolveMode,
+ sizeof(VkResolveModeFlagBits));
*ptr += sizeof(VkResolveModeFlagBits);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilResolveAttachment;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pDepthStencilResolveAttachment)
- {
- reservedmarshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pDepthStencilResolveAttachment), ptr);
+ if (forMarshaling->pDepthStencilResolveAttachment) {
+ reservedmarshal_VkAttachmentReference2(
+ vkStream, rootType,
+ (const VkAttachmentReference2*)(forMarshaling->pDepthStencilResolveAttachment), ptr);
}
}
void reservedmarshal_VkPhysicalDeviceDepthStencilResolveProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDepthStencilResolveProperties* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDepthStencilResolveProperties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkResolveModeFlags*)&forMarshaling->supportedDepthResolveModes, sizeof(VkResolveModeFlags));
+ memcpy(*ptr, (VkResolveModeFlags*)&forMarshaling->supportedDepthResolveModes,
+ sizeof(VkResolveModeFlags));
*ptr += sizeof(VkResolveModeFlags);
- memcpy(*ptr, (VkResolveModeFlags*)&forMarshaling->supportedStencilResolveModes, sizeof(VkResolveModeFlags));
+ memcpy(*ptr, (VkResolveModeFlags*)&forMarshaling->supportedStencilResolveModes,
+ sizeof(VkResolveModeFlags));
*ptr += sizeof(VkResolveModeFlags);
memcpy(*ptr, (VkBool32*)&forMarshaling->independentResolveNone, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -5859,17 +5353,13 @@
}
void reservedmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceScalarBlockLayoutFeatures* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceScalarBlockLayoutFeatures* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -5878,17 +5368,13 @@
}
void reservedmarshal_VkImageStencilUsageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageStencilUsageCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageStencilUsageCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -5897,36 +5383,29 @@
}
void reservedmarshal_VkSamplerReductionModeCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerReductionModeCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerReductionModeCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkSamplerReductionMode*)&forMarshaling->reductionMode, sizeof(VkSamplerReductionMode));
+ memcpy(*ptr, (VkSamplerReductionMode*)&forMarshaling->reductionMode,
+ sizeof(VkSamplerReductionMode));
*ptr += sizeof(VkSamplerReductionMode);
}
void reservedmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSamplerFilterMinmaxProperties* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSamplerFilterMinmaxProperties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -5937,17 +5416,13 @@
}
void reservedmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkanMemoryModelFeatures* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVulkanMemoryModelFeatures* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -5955,22 +5430,19 @@
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->vulkanMemoryModelDeviceScope, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->vulkanMemoryModelAvailabilityVisibilityChains, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->vulkanMemoryModelAvailabilityVisibilityChains,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPhysicalDeviceImagelessFramebufferFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceImagelessFramebufferFeatures* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceImagelessFramebufferFeatures* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -5979,17 +5451,13 @@
}
void reservedmarshal_VkFramebufferAttachmentImageInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFramebufferAttachmentImageInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFramebufferAttachmentImageInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6005,57 +5473,49 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->viewFormatCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const VkFormat*)forMarshaling->pViewFormats, forMarshaling->viewFormatCount * sizeof(const VkFormat));
+ memcpy(*ptr, (const VkFormat*)forMarshaling->pViewFormats,
+ forMarshaling->viewFormatCount * sizeof(const VkFormat));
*ptr += forMarshaling->viewFormatCount * sizeof(const VkFormat);
}
void reservedmarshal_VkFramebufferAttachmentsCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFramebufferAttachmentsCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFramebufferAttachmentsCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->attachmentImageInfoCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentImageInfoCount; ++i)
- {
- reservedmarshal_VkFramebufferAttachmentImageInfo(vkStream, rootType, (const VkFramebufferAttachmentImageInfo*)(forMarshaling->pAttachmentImageInfos + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentImageInfoCount; ++i) {
+ reservedmarshal_VkFramebufferAttachmentImageInfo(
+ vkStream, rootType,
+ (const VkFramebufferAttachmentImageInfo*)(forMarshaling->pAttachmentImageInfos + i),
+ ptr);
}
}
void reservedmarshal_VkRenderPassAttachmentBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassAttachmentBeginInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassAttachmentBeginInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- if (forMarshaling->attachmentCount)
- {
+ if (forMarshaling->attachmentCount) {
uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->attachmentCount; ++k)
- {
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->attachmentCount; ++k) {
uint64_t tmpval = get_host_u64_VkImageView(forMarshaling->pAttachments[k]);
memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -6065,17 +5525,13 @@
}
void reservedmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6084,17 +5540,13 @@
}
void reservedmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6103,17 +5555,13 @@
}
void reservedmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6122,17 +5570,13 @@
}
void reservedmarshal_VkAttachmentReferenceStencilLayout(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentReferenceStencilLayout* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentReferenceStencilLayout* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6141,17 +5585,13 @@
}
void reservedmarshal_VkAttachmentDescriptionStencilLayout(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentDescriptionStencilLayout* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentDescriptionStencilLayout* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6162,17 +5602,13 @@
}
void reservedmarshal_VkPhysicalDeviceHostQueryResetFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceHostQueryResetFeatures* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceHostQueryResetFeatures* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6181,17 +5617,13 @@
}
void reservedmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTimelineSemaphoreFeatures* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTimelineSemaphoreFeatures* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6200,17 +5632,13 @@
}
void reservedmarshal_VkPhysicalDeviceTimelineSemaphoreProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTimelineSemaphoreProperties* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTimelineSemaphoreProperties* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6218,18 +5646,15 @@
*ptr += sizeof(uint64_t);
}
-void reservedmarshal_VkSemaphoreTypeCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreTypeCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSemaphoreTypeCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkSemaphoreTypeCreateInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6240,17 +5665,13 @@
}
void reservedmarshal_VkTimelineSemaphoreSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkTimelineSemaphoreSubmitInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkTimelineSemaphoreSubmitInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6261,9 +5682,9 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pWaitSemaphoreValues)
- {
- memcpy(*ptr, (const uint64_t*)forMarshaling->pWaitSemaphoreValues, forMarshaling->waitSemaphoreValueCount * sizeof(const uint64_t));
+ if (forMarshaling->pWaitSemaphoreValues) {
+ memcpy(*ptr, (const uint64_t*)forMarshaling->pWaitSemaphoreValues,
+ forMarshaling->waitSemaphoreValueCount * sizeof(const uint64_t));
*ptr += forMarshaling->waitSemaphoreValueCount * sizeof(const uint64_t);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->signalSemaphoreValueCount, sizeof(uint32_t));
@@ -6273,25 +5694,20 @@
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pSignalSemaphoreValues)
- {
- memcpy(*ptr, (const uint64_t*)forMarshaling->pSignalSemaphoreValues, forMarshaling->signalSemaphoreValueCount * sizeof(const uint64_t));
+ if (forMarshaling->pSignalSemaphoreValues) {
+ memcpy(*ptr, (const uint64_t*)forMarshaling->pSignalSemaphoreValues,
+ forMarshaling->signalSemaphoreValueCount * sizeof(const uint64_t));
*ptr += forMarshaling->signalSemaphoreValueCount * sizeof(const uint64_t);
}
}
-void reservedmarshal_VkSemaphoreWaitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreWaitInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSemaphoreWaitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreWaitInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6299,35 +5715,29 @@
*ptr += sizeof(VkSemaphoreWaitFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->semaphoreCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- if (forMarshaling->semaphoreCount)
- {
+ if (forMarshaling->semaphoreCount) {
uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->semaphoreCount; ++k)
- {
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->semaphoreCount; ++k) {
uint64_t tmpval = get_host_u64_VkSemaphore(forMarshaling->pSemaphores[k]);
memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
}
*ptr += 8 * forMarshaling->semaphoreCount;
}
- memcpy(*ptr, (const uint64_t*)forMarshaling->pValues, forMarshaling->semaphoreCount * sizeof(const uint64_t));
+ memcpy(*ptr, (const uint64_t*)forMarshaling->pValues,
+ forMarshaling->semaphoreCount * sizeof(const uint64_t));
*ptr += forMarshaling->semaphoreCount * sizeof(const uint64_t);
}
-void reservedmarshal_VkSemaphoreSignalInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreSignalInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSemaphoreSignalInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreSignalInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6340,17 +5750,13 @@
}
void reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceBufferDeviceAddressFeatures* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceBufferDeviceAddressFeatures* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6362,18 +5768,15 @@
*ptr += sizeof(VkBool32);
}
-void reservedmarshal_VkBufferDeviceAddressInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferDeviceAddressInfo* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkBufferDeviceAddressInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkBufferDeviceAddressInfo* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6384,17 +5787,13 @@
}
void reservedmarshal_VkBufferOpaqueCaptureAddressCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferOpaqueCaptureAddressCreateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferOpaqueCaptureAddressCreateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6403,17 +5802,13 @@
}
void reservedmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryOpaqueCaptureAddressAllocateInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryOpaqueCaptureAddressAllocateInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6422,17 +5817,13 @@
}
void reservedmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceMemoryOpaqueCaptureAddressInfo* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceMemoryOpaqueCaptureAddressInfo* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6444,39 +5835,39 @@
#endif
#ifdef VK_KHR_surface
-void reservedmarshal_VkSurfaceCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceCapabilitiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSurfaceCapabilitiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceCapabilitiesKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->minImageCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxImageCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->currentExtent), ptr);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minImageExtent), ptr);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxImageExtent), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->currentExtent),
+ ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minImageExtent),
+ ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxImageExtent),
+ ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxImageArrayLayers, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
+ memcpy(*ptr, (VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms,
+ sizeof(VkSurfaceTransformFlagsKHR));
*ptr += sizeof(VkSurfaceTransformFlagsKHR);
- memcpy(*ptr, (VkSurfaceTransformFlagBitsKHR*)&forMarshaling->currentTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ memcpy(*ptr, (VkSurfaceTransformFlagBitsKHR*)&forMarshaling->currentTransform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
*ptr += sizeof(VkSurfaceTransformFlagBitsKHR);
- memcpy(*ptr, (VkCompositeAlphaFlagsKHR*)&forMarshaling->supportedCompositeAlpha, sizeof(VkCompositeAlphaFlagsKHR));
+ memcpy(*ptr, (VkCompositeAlphaFlagsKHR*)&forMarshaling->supportedCompositeAlpha,
+ sizeof(VkCompositeAlphaFlagsKHR));
*ptr += sizeof(VkCompositeAlphaFlagsKHR);
- memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->supportedUsageFlags, sizeof(VkImageUsageFlags));
+ memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->supportedUsageFlags,
+ sizeof(VkImageUsageFlags));
*ptr += sizeof(VkImageUsageFlags);
}
-void reservedmarshal_VkSurfaceFormatKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceFormatKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSurfaceFormatKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceFormatKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
@@ -6487,22 +5878,19 @@
#endif
#ifdef VK_KHR_swapchain
-void reservedmarshal_VkSwapchainCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSwapchainCreateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSwapchainCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSwapchainCreateInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkSwapchainCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkSwapchainCreateFlagsKHR));
+ memcpy(*ptr, (VkSwapchainCreateFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkSwapchainCreateFlagsKHR));
*ptr += sizeof(VkSwapchainCreateFlagsKHR);
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkSurfaceKHR((*&forMarshaling->surface));
@@ -6528,14 +5916,16 @@
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pQueueFamilyIndices)
- {
- memcpy(*ptr, (const uint32_t*)forMarshaling->pQueueFamilyIndices, forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ if (forMarshaling->pQueueFamilyIndices) {
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pQueueFamilyIndices,
+ forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
*ptr += forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t);
}
- memcpy(*ptr, (VkSurfaceTransformFlagBitsKHR*)&forMarshaling->preTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ memcpy(*ptr, (VkSurfaceTransformFlagBitsKHR*)&forMarshaling->preTransform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
*ptr += sizeof(VkSurfaceTransformFlagBitsKHR);
- memcpy(*ptr, (VkCompositeAlphaFlagBitsKHR*)&forMarshaling->compositeAlpha, sizeof(VkCompositeAlphaFlagBitsKHR));
+ memcpy(*ptr, (VkCompositeAlphaFlagBitsKHR*)&forMarshaling->compositeAlpha,
+ sizeof(VkCompositeAlphaFlagBitsKHR));
*ptr += sizeof(VkCompositeAlphaFlagBitsKHR);
memcpy(*ptr, (VkPresentModeKHR*)&forMarshaling->presentMode, sizeof(VkPresentModeKHR));
*ptr += sizeof(VkPresentModeKHR);
@@ -6547,30 +5937,22 @@
*ptr += 1 * 8;
}
-void reservedmarshal_VkPresentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPresentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- if (forMarshaling->waitSemaphoreCount)
- {
+ if (forMarshaling->waitSemaphoreCount) {
uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->waitSemaphoreCount; ++k)
- {
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->waitSemaphoreCount; ++k) {
uint64_t tmpval = get_host_u64_VkSemaphore(forMarshaling->pWaitSemaphores[k]);
memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -6579,45 +5961,39 @@
}
memcpy(*ptr, (uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- if (forMarshaling->swapchainCount)
- {
+ if (forMarshaling->swapchainCount) {
uint8_t* cgen_var_1_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->swapchainCount; ++k)
- {
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->swapchainCount; ++k) {
uint64_t tmpval = get_host_u64_VkSwapchainKHR(forMarshaling->pSwapchains[k]);
memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
}
*ptr += 8 * forMarshaling->swapchainCount;
}
- memcpy(*ptr, (const uint32_t*)forMarshaling->pImageIndices, forMarshaling->swapchainCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pImageIndices,
+ forMarshaling->swapchainCount * sizeof(const uint32_t));
*ptr += forMarshaling->swapchainCount * sizeof(const uint32_t);
// WARNING PTR CHECK
uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pResults;
memcpy((*ptr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pResults)
- {
- memcpy(*ptr, (VkResult*)forMarshaling->pResults, forMarshaling->swapchainCount * sizeof(VkResult));
+ if (forMarshaling->pResults) {
+ memcpy(*ptr, (VkResult*)forMarshaling->pResults,
+ forMarshaling->swapchainCount * sizeof(VkResult));
*ptr += forMarshaling->swapchainCount * sizeof(VkResult);
}
}
void reservedmarshal_VkImageSwapchainCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageSwapchainCreateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSwapchainCreateInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6628,17 +6004,13 @@
}
void reservedmarshal_VkBindImageMemorySwapchainInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindImageMemorySwapchainInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindImageMemorySwapchainInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6650,18 +6022,15 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkAcquireNextImageInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAcquireNextImageInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkAcquireNextImageInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkAcquireNextImageInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6684,144 +6053,139 @@
}
void reservedmarshal_VkDeviceGroupPresentCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupPresentCapabilitiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupPresentCapabilitiesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (uint32_t*)forMarshaling->presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)forMarshaling->presentMask,
+ VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t));
*ptr += VK_MAX_DEVICE_GROUP_SIZE * sizeof(uint32_t);
- memcpy(*ptr, (VkDeviceGroupPresentModeFlagsKHR*)&forMarshaling->modes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+ memcpy(*ptr, (VkDeviceGroupPresentModeFlagsKHR*)&forMarshaling->modes,
+ sizeof(VkDeviceGroupPresentModeFlagsKHR));
*ptr += sizeof(VkDeviceGroupPresentModeFlagsKHR);
}
-void reservedmarshal_VkDeviceGroupPresentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupPresentInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDeviceGroupPresentInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDeviceGroupPresentInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const uint32_t*)forMarshaling->pDeviceMasks, forMarshaling->swapchainCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pDeviceMasks,
+ forMarshaling->swapchainCount * sizeof(const uint32_t));
*ptr += forMarshaling->swapchainCount * sizeof(const uint32_t);
- memcpy(*ptr, (VkDeviceGroupPresentModeFlagBitsKHR*)&forMarshaling->mode, sizeof(VkDeviceGroupPresentModeFlagBitsKHR));
+ memcpy(*ptr, (VkDeviceGroupPresentModeFlagBitsKHR*)&forMarshaling->mode,
+ sizeof(VkDeviceGroupPresentModeFlagBitsKHR));
*ptr += sizeof(VkDeviceGroupPresentModeFlagBitsKHR);
}
void reservedmarshal_VkDeviceGroupSwapchainCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupSwapchainCreateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupSwapchainCreateInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDeviceGroupPresentModeFlagsKHR*)&forMarshaling->modes, sizeof(VkDeviceGroupPresentModeFlagsKHR));
+ memcpy(*ptr, (VkDeviceGroupPresentModeFlagsKHR*)&forMarshaling->modes,
+ sizeof(VkDeviceGroupPresentModeFlagsKHR));
*ptr += sizeof(VkDeviceGroupPresentModeFlagsKHR);
}
#endif
#ifdef VK_KHR_display
-void reservedmarshal_VkDisplayModeParametersKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayModeParametersKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDisplayModeParametersKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDisplayModeParametersKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->visibleRegion), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->visibleRegion),
+ ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->refreshRate, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkDisplayModeCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayModeCreateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDisplayModeCreateInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDisplayModeCreateInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDisplayModeCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkDisplayModeCreateFlagsKHR));
+ memcpy(*ptr, (VkDisplayModeCreateFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkDisplayModeCreateFlagsKHR));
*ptr += sizeof(VkDisplayModeCreateFlagsKHR);
- reservedmarshal_VkDisplayModeParametersKHR(vkStream, rootType, (VkDisplayModeParametersKHR*)(&forMarshaling->parameters), ptr);
+ reservedmarshal_VkDisplayModeParametersKHR(
+ vkStream, rootType, (VkDisplayModeParametersKHR*)(&forMarshaling->parameters), ptr);
}
-void reservedmarshal_VkDisplayModePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayModePropertiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDisplayModePropertiesKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDisplayModePropertiesKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDisplayModeKHR((*&forMarshaling->displayMode));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
- reservedmarshal_VkDisplayModeParametersKHR(vkStream, rootType, (VkDisplayModeParametersKHR*)(&forMarshaling->parameters), ptr);
+ reservedmarshal_VkDisplayModeParametersKHR(
+ vkStream, rootType, (VkDisplayModeParametersKHR*)(&forMarshaling->parameters), ptr);
}
void reservedmarshal_VkDisplayPlaneCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPlaneCapabilitiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPlaneCapabilitiesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- memcpy(*ptr, (VkDisplayPlaneAlphaFlagsKHR*)&forMarshaling->supportedAlpha, sizeof(VkDisplayPlaneAlphaFlagsKHR));
+ memcpy(*ptr, (VkDisplayPlaneAlphaFlagsKHR*)&forMarshaling->supportedAlpha,
+ sizeof(VkDisplayPlaneAlphaFlagsKHR));
*ptr += sizeof(VkDisplayPlaneAlphaFlagsKHR);
- reservedmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->minSrcPosition), ptr);
- reservedmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->maxSrcPosition), ptr);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minSrcExtent), ptr);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxSrcExtent), ptr);
- reservedmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->minDstPosition), ptr);
- reservedmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->maxDstPosition), ptr);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minDstExtent), ptr);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxDstExtent), ptr);
+ reservedmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->minSrcPosition),
+ ptr);
+ reservedmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->maxSrcPosition),
+ ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minSrcExtent),
+ ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxSrcExtent),
+ ptr);
+ reservedmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->minDstPosition),
+ ptr);
+ reservedmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->maxDstPosition),
+ ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minDstExtent),
+ ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxDstExtent),
+ ptr);
}
-void reservedmarshal_VkDisplayPlanePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPlanePropertiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDisplayPlanePropertiesKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDisplayPlanePropertiesKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
uint64_t cgen_var_0;
@@ -6832,12 +6196,9 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkDisplayPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPropertiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDisplayPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPropertiesKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
uint64_t cgen_var_0;
@@ -6845,16 +6206,19 @@
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
{
- uint32_t l = forMarshaling->displayName ? strlen(forMarshaling->displayName): 0;
+ uint32_t l = forMarshaling->displayName ? strlen(forMarshaling->displayName) : 0;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
memcpy(*ptr, (char*)forMarshaling->displayName, l);
*ptr += l;
}
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->physicalDimensions), ptr);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->physicalResolution), ptr);
- memcpy(*ptr, (VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
+ reservedmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->physicalDimensions), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->physicalResolution), ptr);
+ memcpy(*ptr, (VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms,
+ sizeof(VkSurfaceTransformFlagsKHR));
*ptr += sizeof(VkSurfaceTransformFlagsKHR);
memcpy(*ptr, (VkBool32*)&forMarshaling->planeReorderPossible, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -6863,21 +6227,18 @@
}
void reservedmarshal_VkDisplaySurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplaySurfaceCreateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplaySurfaceCreateInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDisplaySurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkDisplaySurfaceCreateFlagsKHR));
+ memcpy(*ptr, (VkDisplaySurfaceCreateFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkDisplaySurfaceCreateFlagsKHR));
*ptr += sizeof(VkDisplaySurfaceCreateFlagsKHR);
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkDisplayModeKHR((*&forMarshaling->displayMode));
@@ -6887,29 +6248,27 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->planeStackIndex, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ memcpy(*ptr, (VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
*ptr += sizeof(VkSurfaceTransformFlagBitsKHR);
memcpy(*ptr, (float*)&forMarshaling->globalAlpha, sizeof(float));
*ptr += sizeof(float);
- memcpy(*ptr, (VkDisplayPlaneAlphaFlagBitsKHR*)&forMarshaling->alphaMode, sizeof(VkDisplayPlaneAlphaFlagBitsKHR));
+ memcpy(*ptr, (VkDisplayPlaneAlphaFlagBitsKHR*)&forMarshaling->alphaMode,
+ sizeof(VkDisplayPlaneAlphaFlagBitsKHR));
*ptr += sizeof(VkDisplayPlaneAlphaFlagBitsKHR);
reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->imageExtent), ptr);
}
#endif
#ifdef VK_KHR_display_swapchain
-void reservedmarshal_VkDisplayPresentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPresentInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDisplayPresentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPresentInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -6921,30 +6280,27 @@
#endif
#ifdef VK_KHR_xlib_surface
-void reservedmarshal_VkXlibSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkXlibSurfaceCreateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkXlibSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkXlibSurfaceCreateInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkXlibSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkXlibSurfaceCreateFlagsKHR));
+ memcpy(*ptr, (VkXlibSurfaceCreateFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkXlibSurfaceCreateFlagsKHR));
*ptr += sizeof(VkXlibSurfaceCreateFlagsKHR);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->dpy;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->dpy)
- {
+ if (forMarshaling->dpy) {
memcpy(*ptr, (Display*)forMarshaling->dpy, sizeof(Display));
*ptr += sizeof(Display);
}
@@ -6954,44 +6310,36 @@
#endif
#ifdef VK_KHR_xcb_surface
-void reservedmarshal_VkXcbSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkXcbSurfaceCreateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
-
+void reservedmarshal_VkXcbSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkXcbSurfaceCreateInfoKHR* forMarshaling,
+ uint8_t** ptr) {
// This struct should never be marshaled / unmarshaled.
__builtin_trap();
-
}
#endif
#ifdef VK_KHR_wayland_surface
void reservedmarshal_VkWaylandSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWaylandSurfaceCreateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWaylandSurfaceCreateInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkWaylandSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkWaylandSurfaceCreateFlagsKHR));
+ memcpy(*ptr, (VkWaylandSurfaceCreateFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkWaylandSurfaceCreateFlagsKHR));
*ptr += sizeof(VkWaylandSurfaceCreateFlagsKHR);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->display;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->display)
- {
+ if (forMarshaling->display) {
memcpy(*ptr, (wl_display*)forMarshaling->display, sizeof(wl_display));
*ptr += sizeof(wl_display);
}
@@ -7000,8 +6348,7 @@
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->surface)
- {
+ if (forMarshaling->surface) {
memcpy(*ptr, (wl_surface*)forMarshaling->surface, sizeof(wl_surface));
*ptr += sizeof(wl_surface);
}
@@ -7010,29 +6357,25 @@
#endif
#ifdef VK_KHR_android_surface
void reservedmarshal_VkAndroidSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAndroidSurfaceCreateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAndroidSurfaceCreateInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkAndroidSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkAndroidSurfaceCreateFlagsKHR));
+ memcpy(*ptr, (VkAndroidSurfaceCreateFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkAndroidSurfaceCreateFlagsKHR));
*ptr += sizeof(VkAndroidSurfaceCreateFlagsKHR);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->window;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->window)
- {
+ if (forMarshaling->window) {
memcpy(*ptr, (ANativeWindow*)forMarshaling->window, sizeof(ANativeWindow));
*ptr += sizeof(ANativeWindow);
}
@@ -7040,22 +6383,20 @@
#endif
#ifdef VK_KHR_win32_surface
-void reservedmarshal_VkWin32SurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWin32SurfaceCreateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkWin32SurfaceCreateInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkWin32SurfaceCreateInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkWin32SurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkWin32SurfaceCreateFlagsKHR));
+ memcpy(*ptr, (VkWin32SurfaceCreateFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkWin32SurfaceCreateFlagsKHR));
*ptr += sizeof(VkWin32SurfaceCreateFlagsKHR);
memcpy(*ptr, (HINSTANCE*)&forMarshaling->hinstance, sizeof(HINSTANCE));
*ptr += sizeof(HINSTANCE);
@@ -7068,91 +6409,83 @@
#endif
#ifdef VK_KHR_video_queue
void reservedmarshal_VkVideoQueueFamilyProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoQueueFamilyProperties2KHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoQueueFamilyProperties2KHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkVideoCodecOperationFlagsKHR*)&forMarshaling->videoCodecOperations, sizeof(VkVideoCodecOperationFlagsKHR));
+ memcpy(*ptr, (VkVideoCodecOperationFlagsKHR*)&forMarshaling->videoCodecOperations,
+ sizeof(VkVideoCodecOperationFlagsKHR));
*ptr += sizeof(VkVideoCodecOperationFlagsKHR);
}
-void reservedmarshal_VkVideoProfileKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoProfileKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkVideoProfileKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoProfileKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkVideoCodecOperationFlagBitsKHR*)&forMarshaling->videoCodecOperation, sizeof(VkVideoCodecOperationFlagBitsKHR));
+ memcpy(*ptr, (VkVideoCodecOperationFlagBitsKHR*)&forMarshaling->videoCodecOperation,
+ sizeof(VkVideoCodecOperationFlagBitsKHR));
*ptr += sizeof(VkVideoCodecOperationFlagBitsKHR);
- memcpy(*ptr, (VkVideoChromaSubsamplingFlagsKHR*)&forMarshaling->chromaSubsampling, sizeof(VkVideoChromaSubsamplingFlagsKHR));
+ memcpy(*ptr, (VkVideoChromaSubsamplingFlagsKHR*)&forMarshaling->chromaSubsampling,
+ sizeof(VkVideoChromaSubsamplingFlagsKHR));
*ptr += sizeof(VkVideoChromaSubsamplingFlagsKHR);
- memcpy(*ptr, (VkVideoComponentBitDepthFlagsKHR*)&forMarshaling->lumaBitDepth, sizeof(VkVideoComponentBitDepthFlagsKHR));
+ memcpy(*ptr, (VkVideoComponentBitDepthFlagsKHR*)&forMarshaling->lumaBitDepth,
+ sizeof(VkVideoComponentBitDepthFlagsKHR));
*ptr += sizeof(VkVideoComponentBitDepthFlagsKHR);
- memcpy(*ptr, (VkVideoComponentBitDepthFlagsKHR*)&forMarshaling->chromaBitDepth, sizeof(VkVideoComponentBitDepthFlagsKHR));
+ memcpy(*ptr, (VkVideoComponentBitDepthFlagsKHR*)&forMarshaling->chromaBitDepth,
+ sizeof(VkVideoComponentBitDepthFlagsKHR));
*ptr += sizeof(VkVideoComponentBitDepthFlagsKHR);
}
-void reservedmarshal_VkVideoProfilesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoProfilesKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkVideoProfilesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoProfilesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->profileCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- reservedmarshal_VkVideoProfileKHR(vkStream, rootType, (const VkVideoProfileKHR*)(forMarshaling->pProfiles), ptr);
+ reservedmarshal_VkVideoProfileKHR(vkStream, rootType,
+ (const VkVideoProfileKHR*)(forMarshaling->pProfiles), ptr);
}
-void reservedmarshal_VkVideoCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoCapabilitiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkVideoCapabilitiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoCapabilitiesKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkVideoCapabilityFlagsKHR*)&forMarshaling->capabilityFlags, sizeof(VkVideoCapabilityFlagsKHR));
+ memcpy(*ptr, (VkVideoCapabilityFlagsKHR*)&forMarshaling->capabilityFlags,
+ sizeof(VkVideoCapabilityFlagsKHR));
*ptr += sizeof(VkVideoCapabilityFlagsKHR);
- memcpy(*ptr, (VkDeviceSize*)&forMarshaling->minBitstreamBufferOffsetAlignment, sizeof(VkDeviceSize));
+ memcpy(*ptr, (VkDeviceSize*)&forMarshaling->minBitstreamBufferOffsetAlignment,
+ sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
- memcpy(*ptr, (VkDeviceSize*)&forMarshaling->minBitstreamBufferSizeAlignment, sizeof(VkDeviceSize));
+ memcpy(*ptr, (VkDeviceSize*)&forMarshaling->minBitstreamBufferSizeAlignment,
+ sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->videoPictureExtentGranularity), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->videoPictureExtentGranularity), ptr);
reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minExtent), ptr);
reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxExtent), ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxReferencePicturesSlotsCount, sizeof(uint32_t));
@@ -7162,37 +6495,31 @@
}
void reservedmarshal_VkPhysicalDeviceVideoFormatInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVideoFormatInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVideoFormatInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->imageUsage, sizeof(VkImageUsageFlags));
*ptr += sizeof(VkImageUsageFlags);
- reservedmarshal_VkVideoProfilesKHR(vkStream, rootType, (const VkVideoProfilesKHR*)(forMarshaling->pVideoProfiles), ptr);
+ reservedmarshal_VkVideoProfilesKHR(
+ vkStream, rootType, (const VkVideoProfilesKHR*)(forMarshaling->pVideoProfiles), ptr);
}
-void reservedmarshal_VkVideoFormatPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoFormatPropertiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkVideoFormatPropertiesKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkVideoFormatPropertiesKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -7200,18 +6527,15 @@
*ptr += sizeof(VkFormat);
}
-void reservedmarshal_VkVideoPictureResourceKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoPictureResourceKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkVideoPictureResourceKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkVideoPictureResourceKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -7225,58 +6549,49 @@
*ptr += 1 * 8;
}
-void reservedmarshal_VkVideoReferenceSlotKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoReferenceSlotKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkVideoReferenceSlotKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoReferenceSlotKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (int8_t*)&forMarshaling->slotIndex, sizeof(int8_t));
*ptr += sizeof(int8_t);
- reservedmarshal_VkVideoPictureResourceKHR(vkStream, rootType, (const VkVideoPictureResourceKHR*)(forMarshaling->pPictureResource), ptr);
+ reservedmarshal_VkVideoPictureResourceKHR(
+ vkStream, rootType, (const VkVideoPictureResourceKHR*)(forMarshaling->pPictureResource),
+ ptr);
}
void reservedmarshal_VkVideoGetMemoryPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoGetMemoryPropertiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoGetMemoryPropertiesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->memoryBindIndex, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- reservedmarshal_VkMemoryRequirements2(vkStream, rootType, (VkMemoryRequirements2*)(forMarshaling->pMemoryRequirements), ptr);
+ reservedmarshal_VkMemoryRequirements2(
+ vkStream, rootType, (VkMemoryRequirements2*)(forMarshaling->pMemoryRequirements), ptr);
}
-void reservedmarshal_VkVideoBindMemoryKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoBindMemoryKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkVideoBindMemoryKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoBindMemoryKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -7292,29 +6607,29 @@
*ptr += sizeof(VkDeviceSize);
}
-void reservedmarshal_VkVideoSessionCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoSessionCreateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkVideoSessionCreateInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkVideoSessionCreateInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkVideoSessionCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkVideoSessionCreateFlagsKHR));
+ memcpy(*ptr, (VkVideoSessionCreateFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkVideoSessionCreateFlagsKHR));
*ptr += sizeof(VkVideoSessionCreateFlagsKHR);
- reservedmarshal_VkVideoProfileKHR(vkStream, rootType, (const VkVideoProfileKHR*)(forMarshaling->pVideoProfile), ptr);
+ reservedmarshal_VkVideoProfileKHR(
+ vkStream, rootType, (const VkVideoProfileKHR*)(forMarshaling->pVideoProfile), ptr);
memcpy(*ptr, (VkFormat*)&forMarshaling->pictureFormat, sizeof(VkFormat));
*ptr += sizeof(VkFormat);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxCodedExtent), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxCodedExtent),
+ ptr);
memcpy(*ptr, (VkFormat*)&forMarshaling->referencePicturesFormat, sizeof(VkFormat));
*ptr += sizeof(VkFormat);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxReferencePicturesSlotsCount, sizeof(uint32_t));
@@ -7324,17 +6639,13 @@
}
void reservedmarshal_VkVideoSessionParametersCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoSessionParametersCreateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoSessionParametersCreateInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -7349,17 +6660,13 @@
}
void reservedmarshal_VkVideoSessionParametersUpdateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoSessionParametersUpdateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoSessionParametersUpdateInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -7367,24 +6674,23 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkVideoBeginCodingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoBeginCodingInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkVideoBeginCodingInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkVideoBeginCodingInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkVideoBeginCodingFlagsKHR*)&forMarshaling->flags, sizeof(VkVideoBeginCodingFlagsKHR));
+ memcpy(*ptr, (VkVideoBeginCodingFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkVideoBeginCodingFlagsKHR));
*ptr += sizeof(VkVideoBeginCodingFlagsKHR);
- memcpy(*ptr, (VkVideoCodingQualityPresetFlagsKHR*)&forMarshaling->codecQualityPreset, sizeof(VkVideoCodingQualityPresetFlagsKHR));
+ memcpy(*ptr, (VkVideoCodingQualityPresetFlagsKHR*)&forMarshaling->codecQualityPreset,
+ sizeof(VkVideoCodingQualityPresetFlagsKHR));
*ptr += sizeof(VkVideoCodingQualityPresetFlagsKHR);
uint64_t cgen_var_0 = (uint64_t)forMarshaling->videoSession;
memcpy((*ptr), &cgen_var_0, 8);
@@ -7396,64 +6702,56 @@
*ptr += 8;
memcpy(*ptr, (uint32_t*)&forMarshaling->referenceSlotCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i)
- {
- reservedmarshal_VkVideoReferenceSlotKHR(vkStream, rootType, (const VkVideoReferenceSlotKHR*)(forMarshaling->pReferenceSlots + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i) {
+ reservedmarshal_VkVideoReferenceSlotKHR(
+ vkStream, rootType,
+ (const VkVideoReferenceSlotKHR*)(forMarshaling->pReferenceSlots + i), ptr);
}
}
-void reservedmarshal_VkVideoEndCodingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEndCodingInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkVideoEndCodingInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEndCodingInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkVideoEndCodingFlagsKHR*)&forMarshaling->flags, sizeof(VkVideoEndCodingFlagsKHR));
+ memcpy(*ptr, (VkVideoEndCodingFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkVideoEndCodingFlagsKHR));
*ptr += sizeof(VkVideoEndCodingFlagsKHR);
}
-void reservedmarshal_VkVideoCodingControlInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoCodingControlInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkVideoCodingControlInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkVideoCodingControlInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkVideoCodingControlFlagsKHR*)&forMarshaling->flags, sizeof(VkVideoCodingControlFlagsKHR));
+ memcpy(*ptr, (VkVideoCodingControlFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkVideoCodingControlFlagsKHR));
*ptr += sizeof(VkVideoCodingControlFlagsKHR);
}
#endif
#ifdef VK_KHR_video_decode_queue
-void reservedmarshal_VkVideoDecodeInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkVideoDecodeInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -7469,30 +6767,31 @@
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->srcBufferRange, sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
- reservedmarshal_VkVideoPictureResourceKHR(vkStream, rootType, (VkVideoPictureResourceKHR*)(&forMarshaling->dstPictureResource), ptr);
- reservedmarshal_VkVideoReferenceSlotKHR(vkStream, rootType, (const VkVideoReferenceSlotKHR*)(forMarshaling->pSetupReferenceSlot), ptr);
+ reservedmarshal_VkVideoPictureResourceKHR(
+ vkStream, rootType, (VkVideoPictureResourceKHR*)(&forMarshaling->dstPictureResource), ptr);
+ reservedmarshal_VkVideoReferenceSlotKHR(
+ vkStream, rootType, (const VkVideoReferenceSlotKHR*)(forMarshaling->pSetupReferenceSlot),
+ ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->referenceSlotCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i)
- {
- reservedmarshal_VkVideoReferenceSlotKHR(vkStream, rootType, (const VkVideoReferenceSlotKHR*)(forMarshaling->pReferenceSlots + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i) {
+ reservedmarshal_VkVideoReferenceSlotKHR(
+ vkStream, rootType,
+ (const VkVideoReferenceSlotKHR*)(forMarshaling->pReferenceSlots + i), ptr);
}
}
#endif
#ifdef VK_KHR_dynamic_rendering
-void reservedmarshal_VkRenderingAttachmentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderingAttachmentInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkRenderingAttachmentInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkRenderingAttachmentInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -7502,7 +6801,8 @@
*ptr += 1 * 8;
memcpy(*ptr, (VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
*ptr += sizeof(VkImageLayout);
- memcpy(*ptr, (VkResolveModeFlagBits*)&forMarshaling->resolveMode, sizeof(VkResolveModeFlagBits));
+ memcpy(*ptr, (VkResolveModeFlagBits*)&forMarshaling->resolveMode,
+ sizeof(VkResolveModeFlagBits));
*ptr += sizeof(VkResolveModeFlagBits);
uint64_t cgen_var_1;
*&cgen_var_1 = get_host_u64_VkImageView((*&forMarshaling->resolveImageView));
@@ -7514,21 +6814,17 @@
*ptr += sizeof(VkAttachmentLoadOp);
memcpy(*ptr, (VkAttachmentStoreOp*)&forMarshaling->storeOp, sizeof(VkAttachmentStoreOp));
*ptr += sizeof(VkAttachmentStoreOp);
- reservedmarshal_VkClearValue(vkStream, rootType, (VkClearValue*)(&forMarshaling->clearValue), ptr);
+ reservedmarshal_VkClearValue(vkStream, rootType, (VkClearValue*)(&forMarshaling->clearValue),
+ ptr);
}
-void reservedmarshal_VkRenderingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderingInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkRenderingInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -7541,42 +6837,41 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
- {
- reservedmarshal_VkRenderingAttachmentInfoKHR(vkStream, rootType, (const VkRenderingAttachmentInfoKHR*)(forMarshaling->pColorAttachments + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
+ reservedmarshal_VkRenderingAttachmentInfoKHR(
+ vkStream, rootType,
+ (const VkRenderingAttachmentInfoKHR*)(forMarshaling->pColorAttachments + i), ptr);
}
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pDepthAttachment;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pDepthAttachment)
- {
- reservedmarshal_VkRenderingAttachmentInfoKHR(vkStream, rootType, (const VkRenderingAttachmentInfoKHR*)(forMarshaling->pDepthAttachment), ptr);
+ if (forMarshaling->pDepthAttachment) {
+ reservedmarshal_VkRenderingAttachmentInfoKHR(
+ vkStream, rootType,
+ (const VkRenderingAttachmentInfoKHR*)(forMarshaling->pDepthAttachment), ptr);
}
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pStencilAttachment;
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pStencilAttachment)
- {
- reservedmarshal_VkRenderingAttachmentInfoKHR(vkStream, rootType, (const VkRenderingAttachmentInfoKHR*)(forMarshaling->pStencilAttachment), ptr);
+ if (forMarshaling->pStencilAttachment) {
+ reservedmarshal_VkRenderingAttachmentInfoKHR(
+ vkStream, rootType,
+ (const VkRenderingAttachmentInfoKHR*)(forMarshaling->pStencilAttachment), ptr);
}
}
void reservedmarshal_VkPipelineRenderingCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRenderingCreateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRenderingCreateInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -7584,7 +6879,8 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const VkFormat*)forMarshaling->pColorAttachmentFormats, forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
+ memcpy(*ptr, (const VkFormat*)forMarshaling->pColorAttachmentFormats,
+ forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
*ptr += forMarshaling->colorAttachmentCount * sizeof(const VkFormat);
memcpy(*ptr, (VkFormat*)&forMarshaling->depthAttachmentFormat, sizeof(VkFormat));
*ptr += sizeof(VkFormat);
@@ -7593,17 +6889,13 @@
}
void reservedmarshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDynamicRenderingFeaturesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDynamicRenderingFeaturesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -7612,17 +6904,13 @@
}
void reservedmarshal_VkCommandBufferInheritanceRenderingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferInheritanceRenderingInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferInheritanceRenderingInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -7632,28 +6920,26 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const VkFormat*)forMarshaling->pColorAttachmentFormats, forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
+ memcpy(*ptr, (const VkFormat*)forMarshaling->pColorAttachmentFormats,
+ forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
*ptr += forMarshaling->colorAttachmentCount * sizeof(const VkFormat);
memcpy(*ptr, (VkFormat*)&forMarshaling->depthAttachmentFormat, sizeof(VkFormat));
*ptr += sizeof(VkFormat);
memcpy(*ptr, (VkFormat*)&forMarshaling->stencilAttachmentFormat, sizeof(VkFormat));
*ptr += sizeof(VkFormat);
- memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples, sizeof(VkSampleCountFlagBits));
+ memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples,
+ sizeof(VkSampleCountFlagBits));
*ptr += sizeof(VkSampleCountFlagBits);
}
void reservedmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderingFragmentShadingRateAttachmentInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingFragmentShadingRateAttachmentInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -7663,21 +6949,18 @@
*ptr += 1 * 8;
memcpy(*ptr, (VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
*ptr += sizeof(VkImageLayout);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->shadingRateAttachmentTexelSize), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->shadingRateAttachmentTexelSize), ptr);
}
void reservedmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderingFragmentDensityMapAttachmentInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingFragmentDensityMapAttachmentInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -7690,17 +6973,13 @@
}
void reservedmarshal_VkAttachmentSampleCountInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentSampleCountInfoAMD* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentSampleCountInfoAMD* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -7711,27 +6990,24 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pColorAttachmentSamples)
- {
- memcpy(*ptr, (const VkSampleCountFlagBits*)forMarshaling->pColorAttachmentSamples, forMarshaling->colorAttachmentCount * sizeof(const VkSampleCountFlagBits));
+ if (forMarshaling->pColorAttachmentSamples) {
+ memcpy(*ptr, (const VkSampleCountFlagBits*)forMarshaling->pColorAttachmentSamples,
+ forMarshaling->colorAttachmentCount * sizeof(const VkSampleCountFlagBits));
*ptr += forMarshaling->colorAttachmentCount * sizeof(const VkSampleCountFlagBits);
}
- memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->depthStencilAttachmentSamples, sizeof(VkSampleCountFlagBits));
+ memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->depthStencilAttachmentSamples,
+ sizeof(VkSampleCountFlagBits));
*ptr += sizeof(VkSampleCountFlagBits);
}
void reservedmarshal_VkMultiviewPerViewAttributesInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMultiviewPerViewAttributesInfoNVX* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMultiviewPerViewAttributesInfoNVX* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -7760,21 +7036,18 @@
#endif
#ifdef VK_KHR_external_memory_win32
void reservedmarshal_VkImportMemoryWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportMemoryWin32HandleInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportMemoryWin32HandleInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
memcpy(*ptr, (HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
*ptr += sizeof(HANDLE);
@@ -7783,17 +7056,13 @@
}
void reservedmarshal_VkExportMemoryWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportMemoryWin32HandleInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportMemoryWin32HandleInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -7802,9 +7071,9 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pAttributes)
- {
- memcpy(*ptr, (const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ if (forMarshaling->pAttributes) {
+ memcpy(*ptr, (const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes,
+ sizeof(const SECURITY_ATTRIBUTES));
*ptr += sizeof(const SECURITY_ATTRIBUTES);
}
memcpy(*ptr, (DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
@@ -7814,17 +7083,13 @@
}
void reservedmarshal_VkMemoryWin32HandlePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryWin32HandlePropertiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryWin32HandlePropertiesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -7833,17 +7098,13 @@
}
void reservedmarshal_VkMemoryGetWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryGetWin32HandleInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryGetWin32HandleInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -7851,45 +7112,39 @@
*&cgen_var_0 = get_host_u64_VkDeviceMemory((*&forMarshaling->memory));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
- memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
}
#endif
#ifdef VK_KHR_external_memory_fd
-void reservedmarshal_VkImportMemoryFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportMemoryFdInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImportMemoryFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportMemoryFdInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
memcpy(*ptr, (int*)&forMarshaling->fd, sizeof(int));
*ptr += sizeof(int);
}
-void reservedmarshal_VkMemoryFdPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryFdPropertiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkMemoryFdPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryFdPropertiesKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -7897,18 +7152,14 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkMemoryGetFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryGetFdInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkMemoryGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryGetFdInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -7916,62 +7167,56 @@
*&cgen_var_0 = get_host_u64_VkDeviceMemory((*&forMarshaling->memory));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
- memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
}
#endif
#ifdef VK_KHR_win32_keyed_mutex
void reservedmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWin32KeyedMutexAcquireReleaseInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWin32KeyedMutexAcquireReleaseInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->acquireCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- if (forMarshaling->acquireCount)
- {
+ if (forMarshaling->acquireCount) {
uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->acquireCount; ++k)
- {
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->acquireCount; ++k) {
uint64_t tmpval = get_host_u64_VkDeviceMemory(forMarshaling->pAcquireSyncs[k]);
memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
}
*ptr += 8 * forMarshaling->acquireCount;
}
- memcpy(*ptr, (const uint64_t*)forMarshaling->pAcquireKeys, forMarshaling->acquireCount * sizeof(const uint64_t));
+ memcpy(*ptr, (const uint64_t*)forMarshaling->pAcquireKeys,
+ forMarshaling->acquireCount * sizeof(const uint64_t));
*ptr += forMarshaling->acquireCount * sizeof(const uint64_t);
- memcpy(*ptr, (const uint32_t*)forMarshaling->pAcquireTimeouts, forMarshaling->acquireCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pAcquireTimeouts,
+ forMarshaling->acquireCount * sizeof(const uint32_t));
*ptr += forMarshaling->acquireCount * sizeof(const uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->releaseCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- if (forMarshaling->releaseCount)
- {
+ if (forMarshaling->releaseCount) {
uint8_t* cgen_var_1_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->releaseCount; ++k)
- {
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->releaseCount; ++k) {
uint64_t tmpval = get_host_u64_VkDeviceMemory(forMarshaling->pReleaseSyncs[k]);
memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
}
*ptr += 8 * forMarshaling->releaseCount;
}
- memcpy(*ptr, (const uint64_t*)forMarshaling->pReleaseKeys, forMarshaling->releaseCount * sizeof(const uint64_t));
+ memcpy(*ptr, (const uint64_t*)forMarshaling->pReleaseKeys,
+ forMarshaling->releaseCount * sizeof(const uint64_t));
*ptr += forMarshaling->releaseCount * sizeof(const uint64_t);
}
@@ -7982,17 +7227,13 @@
#endif
#ifdef VK_KHR_external_semaphore_win32
void reservedmarshal_VkImportSemaphoreWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportSemaphoreWin32HandleInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportSemaphoreWin32HandleInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8002,7 +7243,8 @@
*ptr += 1 * 8;
memcpy(*ptr, (VkSemaphoreImportFlags*)&forMarshaling->flags, sizeof(VkSemaphoreImportFlags));
*ptr += sizeof(VkSemaphoreImportFlags);
- memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
*ptr += sizeof(VkExternalSemaphoreHandleTypeFlagBits);
memcpy(*ptr, (HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
*ptr += sizeof(HANDLE);
@@ -8011,17 +7253,13 @@
}
void reservedmarshal_VkExportSemaphoreWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportSemaphoreWin32HandleInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportSemaphoreWin32HandleInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8030,9 +7268,9 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pAttributes)
- {
- memcpy(*ptr, (const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ if (forMarshaling->pAttributes) {
+ memcpy(*ptr, (const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes,
+ sizeof(const SECURITY_ATTRIBUTES));
*ptr += sizeof(const SECURITY_ATTRIBUTES);
}
memcpy(*ptr, (DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
@@ -8041,18 +7279,15 @@
*ptr += sizeof(LPCWSTR);
}
-void reservedmarshal_VkD3D12FenceSubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkD3D12FenceSubmitInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkD3D12FenceSubmitInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkD3D12FenceSubmitInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8063,9 +7298,9 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pWaitSemaphoreValues)
- {
- memcpy(*ptr, (const uint64_t*)forMarshaling->pWaitSemaphoreValues, forMarshaling->waitSemaphoreValuesCount * sizeof(const uint64_t));
+ if (forMarshaling->pWaitSemaphoreValues) {
+ memcpy(*ptr, (const uint64_t*)forMarshaling->pWaitSemaphoreValues,
+ forMarshaling->waitSemaphoreValuesCount * sizeof(const uint64_t));
*ptr += forMarshaling->waitSemaphoreValuesCount * sizeof(const uint64_t);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->signalSemaphoreValuesCount, sizeof(uint32_t));
@@ -8075,25 +7310,21 @@
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pSignalSemaphoreValues)
- {
- memcpy(*ptr, (const uint64_t*)forMarshaling->pSignalSemaphoreValues, forMarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t));
+ if (forMarshaling->pSignalSemaphoreValues) {
+ memcpy(*ptr, (const uint64_t*)forMarshaling->pSignalSemaphoreValues,
+ forMarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t));
*ptr += forMarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t);
}
}
void reservedmarshal_VkSemaphoreGetWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreGetWin32HandleInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreGetWin32HandleInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8101,24 +7332,22 @@
*&cgen_var_0 = get_host_u64_VkSemaphore((*&forMarshaling->semaphore));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
- memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
*ptr += sizeof(VkExternalSemaphoreHandleTypeFlagBits);
}
#endif
#ifdef VK_KHR_external_semaphore_fd
-void reservedmarshal_VkImportSemaphoreFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportSemaphoreFdInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImportSemaphoreFdInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkImportSemaphoreFdInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8128,24 +7357,21 @@
*ptr += 1 * 8;
memcpy(*ptr, (VkSemaphoreImportFlags*)&forMarshaling->flags, sizeof(VkSemaphoreImportFlags));
*ptr += sizeof(VkSemaphoreImportFlags);
- memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
*ptr += sizeof(VkExternalSemaphoreHandleTypeFlagBits);
memcpy(*ptr, (int*)&forMarshaling->fd, sizeof(int));
*ptr += sizeof(int);
}
-void reservedmarshal_VkSemaphoreGetFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreGetFdInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSemaphoreGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreGetFdInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8153,24 +7379,21 @@
*&cgen_var_0 = get_host_u64_VkSemaphore((*&forMarshaling->semaphore));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
- memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
*ptr += sizeof(VkExternalSemaphoreHandleTypeFlagBits);
}
#endif
#ifdef VK_KHR_push_descriptor
void reservedmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePushDescriptorPropertiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePushDescriptorPropertiesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8184,12 +7407,8 @@
#ifdef VK_KHR_16bit_storage
#endif
#ifdef VK_KHR_incremental_present
-void reservedmarshal_VkRectLayerKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRectLayerKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkRectLayerKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRectLayerKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
reservedmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->offset), ptr);
@@ -8198,12 +7417,8 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkPresentRegionKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentRegionKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPresentRegionKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentRegionKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->rectangleCount, sizeof(uint32_t));
@@ -8213,27 +7428,21 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pRectangles)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->rectangleCount; ++i)
- {
- reservedmarshal_VkRectLayerKHR(vkStream, rootType, (const VkRectLayerKHR*)(forMarshaling->pRectangles + i), ptr);
+ if (forMarshaling->pRectangles) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->rectangleCount; ++i) {
+ reservedmarshal_VkRectLayerKHR(
+ vkStream, rootType, (const VkRectLayerKHR*)(forMarshaling->pRectangles + i), ptr);
}
}
}
-void reservedmarshal_VkPresentRegionsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentRegionsKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPresentRegionsKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentRegionsKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8244,11 +7453,10 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i)
- {
- reservedmarshal_VkPresentRegionKHR(vkStream, rootType, (const VkPresentRegionKHR*)(forMarshaling->pRegions + i), ptr);
+ if (forMarshaling->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i) {
+ reservedmarshal_VkPresentRegionKHR(
+ vkStream, rootType, (const VkPresentRegionKHR*)(forMarshaling->pRegions + i), ptr);
}
}
}
@@ -8262,21 +7470,18 @@
#endif
#ifdef VK_KHR_shared_presentable_image
void reservedmarshal_VkSharedPresentSurfaceCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSharedPresentSurfaceCapabilitiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSharedPresentSurfaceCapabilitiesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->sharedPresentSupportedUsageFlags, sizeof(VkImageUsageFlags));
+ memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->sharedPresentSupportedUsageFlags,
+ sizeof(VkImageUsageFlags));
*ptr += sizeof(VkImageUsageFlags);
}
@@ -8287,17 +7492,13 @@
#endif
#ifdef VK_KHR_external_fence_win32
void reservedmarshal_VkImportFenceWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportFenceWin32HandleInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportFenceWin32HandleInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8307,7 +7508,8 @@
*ptr += 1 * 8;
memcpy(*ptr, (VkFenceImportFlags*)&forMarshaling->flags, sizeof(VkFenceImportFlags));
*ptr += sizeof(VkFenceImportFlags);
- memcpy(*ptr, (VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalFenceHandleTypeFlagBits));
*ptr += sizeof(VkExternalFenceHandleTypeFlagBits);
memcpy(*ptr, (HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
*ptr += sizeof(HANDLE);
@@ -8316,17 +7518,13 @@
}
void reservedmarshal_VkExportFenceWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportFenceWin32HandleInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportFenceWin32HandleInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8335,9 +7533,9 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pAttributes)
- {
- memcpy(*ptr, (const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ if (forMarshaling->pAttributes) {
+ memcpy(*ptr, (const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes,
+ sizeof(const SECURITY_ATTRIBUTES));
*ptr += sizeof(const SECURITY_ATTRIBUTES);
}
memcpy(*ptr, (DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
@@ -8346,18 +7544,15 @@
*ptr += sizeof(LPCWSTR);
}
-void reservedmarshal_VkFenceGetWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFenceGetWin32HandleInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkFenceGetWin32HandleInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkFenceGetWin32HandleInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8365,24 +7560,21 @@
*&cgen_var_0 = get_host_u64_VkFence((*&forMarshaling->fence));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
- memcpy(*ptr, (VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalFenceHandleTypeFlagBits));
*ptr += sizeof(VkExternalFenceHandleTypeFlagBits);
}
#endif
#ifdef VK_KHR_external_fence_fd
-void reservedmarshal_VkImportFenceFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportFenceFdInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImportFenceFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportFenceFdInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8392,24 +7584,20 @@
*ptr += 1 * 8;
memcpy(*ptr, (VkFenceImportFlags*)&forMarshaling->flags, sizeof(VkFenceImportFlags));
*ptr += sizeof(VkFenceImportFlags);
- memcpy(*ptr, (VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalFenceHandleTypeFlagBits));
*ptr += sizeof(VkExternalFenceHandleTypeFlagBits);
memcpy(*ptr, (int*)&forMarshaling->fd, sizeof(int));
*ptr += sizeof(int);
}
-void reservedmarshal_VkFenceGetFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFenceGetFdInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkFenceGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFenceGetFdInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8417,24 +7605,21 @@
*&cgen_var_0 = get_host_u64_VkFence((*&forMarshaling->fence));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
- memcpy(*ptr, (VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalFenceHandleTypeFlagBits));
*ptr += sizeof(VkExternalFenceHandleTypeFlagBits);
}
#endif
#ifdef VK_KHR_performance_query
void reservedmarshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePerformanceQueryFeaturesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePerformanceQueryFeaturesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8445,17 +7630,13 @@
}
void reservedmarshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePerformanceQueryPropertiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePerformanceQueryPropertiesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8463,47 +7644,43 @@
*ptr += sizeof(VkBool32);
}
-void reservedmarshal_VkPerformanceCounterKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceCounterKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPerformanceCounterKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceCounterKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPerformanceCounterUnitKHR*)&forMarshaling->unit, sizeof(VkPerformanceCounterUnitKHR));
+ memcpy(*ptr, (VkPerformanceCounterUnitKHR*)&forMarshaling->unit,
+ sizeof(VkPerformanceCounterUnitKHR));
*ptr += sizeof(VkPerformanceCounterUnitKHR);
- memcpy(*ptr, (VkPerformanceCounterScopeKHR*)&forMarshaling->scope, sizeof(VkPerformanceCounterScopeKHR));
+ memcpy(*ptr, (VkPerformanceCounterScopeKHR*)&forMarshaling->scope,
+ sizeof(VkPerformanceCounterScopeKHR));
*ptr += sizeof(VkPerformanceCounterScopeKHR);
- memcpy(*ptr, (VkPerformanceCounterStorageKHR*)&forMarshaling->storage, sizeof(VkPerformanceCounterStorageKHR));
+ memcpy(*ptr, (VkPerformanceCounterStorageKHR*)&forMarshaling->storage,
+ sizeof(VkPerformanceCounterStorageKHR));
*ptr += sizeof(VkPerformanceCounterStorageKHR);
memcpy(*ptr, (uint8_t*)forMarshaling->uuid, VK_UUID_SIZE * sizeof(uint8_t));
*ptr += VK_UUID_SIZE * sizeof(uint8_t);
}
void reservedmarshal_VkPerformanceCounterDescriptionKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceCounterDescriptionKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceCounterDescriptionKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPerformanceCounterDescriptionFlagsKHR*)&forMarshaling->flags, sizeof(VkPerformanceCounterDescriptionFlagsKHR));
+ memcpy(*ptr, (VkPerformanceCounterDescriptionFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkPerformanceCounterDescriptionFlagsKHR));
*ptr += sizeof(VkPerformanceCounterDescriptionFlagsKHR);
memcpy(*ptr, (char*)forMarshaling->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
*ptr += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
@@ -8514,17 +7691,13 @@
}
void reservedmarshal_VkQueryPoolPerformanceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueryPoolPerformanceCreateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueryPoolPerformanceCreateInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8532,16 +7705,14 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->counterIndexCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const uint32_t*)forMarshaling->pCounterIndices, forMarshaling->counterIndexCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pCounterIndices,
+ forMarshaling->counterIndexCount * sizeof(const uint32_t));
*ptr += forMarshaling->counterIndexCount * sizeof(const uint32_t);
}
void reservedmarshal_VkPerformanceCounterResultKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceCounterResultKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceCounterResultKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (int32_t*)&forMarshaling->int32, sizeof(int32_t));
@@ -8549,38 +7720,31 @@
}
void reservedmarshal_VkAcquireProfilingLockInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAcquireProfilingLockInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAcquireProfilingLockInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkAcquireProfilingLockFlagsKHR*)&forMarshaling->flags, sizeof(VkAcquireProfilingLockFlagsKHR));
+ memcpy(*ptr, (VkAcquireProfilingLockFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkAcquireProfilingLockFlagsKHR));
*ptr += sizeof(VkAcquireProfilingLockFlagsKHR);
memcpy(*ptr, (uint64_t*)&forMarshaling->timeout, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
}
void reservedmarshal_VkPerformanceQuerySubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceQuerySubmitInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceQuerySubmitInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8593,17 +7757,13 @@
#endif
#ifdef VK_KHR_get_surface_capabilities2
void reservedmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSurfaceInfo2KHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSurfaceInfo2KHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8613,112 +7773,97 @@
*ptr += 1 * 8;
}
-void reservedmarshal_VkSurfaceCapabilities2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceCapabilities2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSurfaceCapabilities2KHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkSurfaceCapabilities2KHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkSurfaceCapabilitiesKHR(vkStream, rootType, (VkSurfaceCapabilitiesKHR*)(&forMarshaling->surfaceCapabilities), ptr);
+ reservedmarshal_VkSurfaceCapabilitiesKHR(
+ vkStream, rootType, (VkSurfaceCapabilitiesKHR*)(&forMarshaling->surfaceCapabilities), ptr);
}
-void reservedmarshal_VkSurfaceFormat2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceFormat2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSurfaceFormat2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceFormat2KHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkSurfaceFormatKHR(vkStream, rootType, (VkSurfaceFormatKHR*)(&forMarshaling->surfaceFormat), ptr);
+ reservedmarshal_VkSurfaceFormatKHR(vkStream, rootType,
+ (VkSurfaceFormatKHR*)(&forMarshaling->surfaceFormat), ptr);
}
#endif
#ifdef VK_KHR_variable_pointers
#endif
#ifdef VK_KHR_get_display_properties2
-void reservedmarshal_VkDisplayProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayProperties2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDisplayProperties2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayProperties2KHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkDisplayPropertiesKHR(vkStream, rootType, (VkDisplayPropertiesKHR*)(&forMarshaling->displayProperties), ptr);
+ reservedmarshal_VkDisplayPropertiesKHR(
+ vkStream, rootType, (VkDisplayPropertiesKHR*)(&forMarshaling->displayProperties), ptr);
}
-void reservedmarshal_VkDisplayPlaneProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPlaneProperties2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDisplayPlaneProperties2KHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDisplayPlaneProperties2KHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkDisplayPlanePropertiesKHR(vkStream, rootType, (VkDisplayPlanePropertiesKHR*)(&forMarshaling->displayPlaneProperties), ptr);
+ reservedmarshal_VkDisplayPlanePropertiesKHR(
+ vkStream, rootType, (VkDisplayPlanePropertiesKHR*)(&forMarshaling->displayPlaneProperties),
+ ptr);
}
-void reservedmarshal_VkDisplayModeProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayModeProperties2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDisplayModeProperties2KHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDisplayModeProperties2KHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkDisplayModePropertiesKHR(vkStream, rootType, (VkDisplayModePropertiesKHR*)(&forMarshaling->displayModeProperties), ptr);
+ reservedmarshal_VkDisplayModePropertiesKHR(
+ vkStream, rootType, (VkDisplayModePropertiesKHR*)(&forMarshaling->displayModeProperties),
+ ptr);
}
-void reservedmarshal_VkDisplayPlaneInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPlaneInfo2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDisplayPlaneInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPlaneInfo2KHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8731,21 +7876,18 @@
}
void reservedmarshal_VkDisplayPlaneCapabilities2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPlaneCapabilities2KHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPlaneCapabilities2KHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkDisplayPlaneCapabilitiesKHR(vkStream, rootType, (VkDisplayPlaneCapabilitiesKHR*)(&forMarshaling->capabilities), ptr);
+ reservedmarshal_VkDisplayPlaneCapabilitiesKHR(
+ vkStream, rootType, (VkDisplayPlaneCapabilitiesKHR*)(&forMarshaling->capabilities), ptr);
}
#endif
@@ -8765,17 +7907,13 @@
#endif
#ifdef VK_KHR_portability_subset
void reservedmarshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePortabilitySubsetFeaturesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePortabilitySubsetFeaturesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8799,7 +7937,8 @@
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->separateStencilMaskRef, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSampleRateInterpolationFunctions, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->shaderSampleRateInterpolationFunctions,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->tessellationIsolines, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -8812,17 +7951,13 @@
}
void reservedmarshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePortabilitySubsetPropertiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePortabilitySubsetPropertiesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8843,17 +7978,13 @@
#endif
#ifdef VK_KHR_shader_clock
void reservedmarshal_VkPhysicalDeviceShaderClockFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderClockFeaturesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderClockFeaturesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8878,17 +8009,13 @@
#endif
#ifdef VK_KHR_shader_terminate_invocation
void reservedmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8899,17 +8026,13 @@
#endif
#ifdef VK_KHR_fragment_shading_rate
void reservedmarshal_VkFragmentShadingRateAttachmentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFragmentShadingRateAttachmentInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFragmentShadingRateAttachmentInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8918,45 +8041,41 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pFragmentShadingRateAttachment)
- {
- reservedmarshal_VkAttachmentReference2(vkStream, rootType, (const VkAttachmentReference2*)(forMarshaling->pFragmentShadingRateAttachment), ptr);
+ if (forMarshaling->pFragmentShadingRateAttachment) {
+ reservedmarshal_VkAttachmentReference2(
+ vkStream, rootType,
+ (const VkAttachmentReference2*)(forMarshaling->pFragmentShadingRateAttachment), ptr);
}
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->shadingRateAttachmentTexelSize), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->shadingRateAttachmentTexelSize), ptr);
}
void reservedmarshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineFragmentShadingRateStateCreateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineFragmentShadingRateStateCreateInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->fragmentSize), ptr);
- memcpy(*ptr, (VkFragmentShadingRateCombinerOpKHR*)forMarshaling->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
+ reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->fragmentSize),
+ ptr);
+ memcpy(*ptr, (VkFragmentShadingRateCombinerOpKHR*)forMarshaling->combinerOps,
+ 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
*ptr += 2 * sizeof(VkFragmentShadingRateCombinerOpKHR);
}
void reservedmarshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -8969,71 +8088,80 @@
}
void reservedmarshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minFragmentShadingRateAttachmentTexelSize), ptr);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxFragmentShadingRateAttachmentTexelSize), ptr);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxFragmentShadingRateAttachmentTexelSizeAspectRatio, sizeof(uint32_t));
+ reservedmarshal_VkExtent2D(
+ vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->minFragmentShadingRateAttachmentTexelSize), ptr);
+ reservedmarshal_VkExtent2D(
+ vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->maxFragmentShadingRateAttachmentTexelSize), ptr);
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxFragmentShadingRateAttachmentTexelSizeAspectRatio,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkBool32*)&forMarshaling->primitiveFragmentShadingRateWithMultipleViewports, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->primitiveFragmentShadingRateWithMultipleViewports,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->layeredShadingRateAttachments, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateNonTrivialCombinerOps, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateNonTrivialCombinerOps,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxFragmentSize), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxFragmentSize),
+ ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxFragmentSizeAspectRatio, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxFragmentShadingRateCoverageSamples, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxFragmentShadingRateCoverageSamples,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->maxFragmentShadingRateRasterizationSamples, sizeof(VkSampleCountFlagBits));
+ memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->maxFragmentShadingRateRasterizationSamples,
+ sizeof(VkSampleCountFlagBits));
*ptr += sizeof(VkSampleCountFlagBits);
- memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateWithShaderDepthStencilWrites, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateWithShaderDepthStencilWrites,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateWithSampleMask, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateWithShaderSampleMask, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateWithShaderSampleMask,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateWithConservativeRasterization, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateWithConservativeRasterization,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateWithFragmentShaderInterlock, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateWithFragmentShaderInterlock,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateWithCustomSampleLocations, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateWithCustomSampleLocations,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateStrictMultiplyCombiner, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentShadingRateStrictMultiplyCombiner,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPhysicalDeviceFragmentShadingRateKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRateKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->sampleCounts, sizeof(VkSampleCountFlags));
*ptr += sizeof(VkSampleCountFlags);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->fragmentSize), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->fragmentSize),
+ ptr);
}
#endif
@@ -9041,17 +8169,13 @@
#endif
#ifdef VK_KHR_surface_protected_capabilities
void reservedmarshal_VkSurfaceProtectedCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceProtectedCapabilitiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceProtectedCapabilitiesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9064,17 +8188,13 @@
#endif
#ifdef VK_KHR_present_wait
void reservedmarshal_VkPhysicalDevicePresentWaitFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePresentWaitFeaturesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePresentWaitFeaturesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9091,17 +8211,13 @@
#endif
#ifdef VK_KHR_pipeline_executable_properties
void reservedmarshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9109,18 +8225,13 @@
*ptr += sizeof(VkBool32);
}
-void reservedmarshal_VkPipelineInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPipelineInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9131,17 +8242,13 @@
}
void reservedmarshal_VkPipelineExecutablePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineExecutablePropertiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineExecutablePropertiesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9155,18 +8262,15 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkPipelineExecutableInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineExecutableInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPipelineExecutableInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkPipelineExecutableInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9179,11 +8283,8 @@
}
void reservedmarshal_VkPipelineExecutableStatisticValueKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineExecutableStatisticValueKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineExecutableStatisticValueKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkBool32*)&forMarshaling->b32, sizeof(VkBool32));
@@ -9191,17 +8292,13 @@
}
void reservedmarshal_VkPipelineExecutableStatisticKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineExecutableStatisticKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineExecutableStatisticKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9209,23 +8306,21 @@
*ptr += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
memcpy(*ptr, (char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
*ptr += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
- memcpy(*ptr, (VkPipelineExecutableStatisticFormatKHR*)&forMarshaling->format, sizeof(VkPipelineExecutableStatisticFormatKHR));
+ memcpy(*ptr, (VkPipelineExecutableStatisticFormatKHR*)&forMarshaling->format,
+ sizeof(VkPipelineExecutableStatisticFormatKHR));
*ptr += sizeof(VkPipelineExecutableStatisticFormatKHR);
- reservedmarshal_VkPipelineExecutableStatisticValueKHR(vkStream, rootType, (VkPipelineExecutableStatisticValueKHR*)(&forMarshaling->value), ptr);
+ reservedmarshal_VkPipelineExecutableStatisticValueKHR(
+ vkStream, rootType, (VkPipelineExecutableStatisticValueKHR*)(&forMarshaling->value), ptr);
}
void reservedmarshal_VkPipelineExecutableInternalRepresentationKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineExecutableInternalRepresentationKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineExecutableInternalRepresentationKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9244,8 +8339,7 @@
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pData)
- {
+ if (forMarshaling->pData) {
memcpy(*ptr, (void*)forMarshaling->pData, forMarshaling->dataSize * sizeof(uint8_t));
*ptr += forMarshaling->dataSize * sizeof(uint8_t);
}
@@ -9254,17 +8348,13 @@
#endif
#ifdef VK_KHR_shader_integer_dot_product
void reservedmarshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9273,108 +8363,153 @@
}
void reservedmarshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct8BitUnsignedAccelerated, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct8BitUnsignedAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct8BitSignedAccelerated, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct8BitSignedAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct8BitMixedSignednessAccelerated, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct8BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedUnsignedAccelerated, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedUnsignedAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedSignedAccelerated, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedSignedAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedMixedSignednessAccelerated, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedMixedSignednessAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct16BitUnsignedAccelerated, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct16BitUnsignedAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct16BitSignedAccelerated, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct16BitSignedAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct16BitMixedSignednessAccelerated, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct16BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct32BitUnsignedAccelerated, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct32BitUnsignedAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct32BitSignedAccelerated, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct32BitSignedAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct32BitMixedSignednessAccelerated, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct32BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct64BitUnsignedAccelerated, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct64BitUnsignedAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct64BitSignedAccelerated, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct64BitSignedAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct64BitMixedSignednessAccelerated, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProduct64BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, sizeof(VkBool32));
+ memcpy(
+ *ptr,
+ (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating8BitSignedAccelerated, sizeof(VkBool32));
+ memcpy(*ptr,
+ (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating8BitSignedAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, sizeof(VkBool32));
+ memcpy(*ptr,
+ (VkBool32*)&forMarshaling
+ ->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, sizeof(VkBool32));
+ memcpy(*ptr,
+ (VkBool32*)&forMarshaling
+ ->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, sizeof(VkBool32));
+ memcpy(*ptr,
+ (VkBool32*)&forMarshaling
+ ->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, sizeof(VkBool32));
+ memcpy(*ptr,
+ (VkBool32*)&forMarshaling
+ ->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, sizeof(VkBool32));
+ memcpy(
+ *ptr,
+ (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating16BitSignedAccelerated, sizeof(VkBool32));
+ memcpy(*ptr,
+ (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating16BitSignedAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, sizeof(VkBool32));
+ memcpy(*ptr,
+ (VkBool32*)&forMarshaling
+ ->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, sizeof(VkBool32));
+ memcpy(
+ *ptr,
+ (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating32BitSignedAccelerated, sizeof(VkBool32));
+ memcpy(*ptr,
+ (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating32BitSignedAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, sizeof(VkBool32));
+ memcpy(*ptr,
+ (VkBool32*)&forMarshaling
+ ->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, sizeof(VkBool32));
+ memcpy(
+ *ptr,
+ (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating64BitSignedAccelerated, sizeof(VkBool32));
+ memcpy(*ptr,
+ (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating64BitSignedAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated, sizeof(VkBool32));
+ memcpy(*ptr,
+ (VkBool32*)&forMarshaling
+ ->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
#endif
#ifdef VK_KHR_pipeline_library
void reservedmarshal_VkPipelineLibraryCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineLibraryCreateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineLibraryCreateInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->libraryCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- if (forMarshaling->libraryCount)
- {
+ if (forMarshaling->libraryCount) {
uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->libraryCount; ++k)
- {
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->libraryCount; ++k) {
uint64_t tmpval = get_host_u64_VkPipeline(forMarshaling->pLibraries[k]);
memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -9387,18 +8522,13 @@
#ifdef VK_KHR_shader_non_semantic_info
#endif
#ifdef VK_KHR_present_id
-void reservedmarshal_VkPresentIdKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentIdKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPresentIdKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentIdKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9409,25 +8539,21 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pPresentIds)
- {
- memcpy(*ptr, (const uint64_t*)forMarshaling->pPresentIds, forMarshaling->swapchainCount * sizeof(const uint64_t));
+ if (forMarshaling->pPresentIds) {
+ memcpy(*ptr, (const uint64_t*)forMarshaling->pPresentIds,
+ forMarshaling->swapchainCount * sizeof(const uint64_t));
*ptr += forMarshaling->swapchainCount * sizeof(const uint64_t);
}
}
void reservedmarshal_VkPhysicalDevicePresentIdFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePresentIdFeaturesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePresentIdFeaturesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9437,18 +8563,14 @@
#endif
#ifdef VK_KHR_video_encode_queue
-void reservedmarshal_VkVideoEncodeInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkVideoEncodeInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9465,34 +8587,36 @@
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->dstBitstreamBufferMaxRange, sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
- reservedmarshal_VkVideoPictureResourceKHR(vkStream, rootType, (VkVideoPictureResourceKHR*)(&forMarshaling->srcPictureResource), ptr);
- reservedmarshal_VkVideoReferenceSlotKHR(vkStream, rootType, (const VkVideoReferenceSlotKHR*)(forMarshaling->pSetupReferenceSlot), ptr);
+ reservedmarshal_VkVideoPictureResourceKHR(
+ vkStream, rootType, (VkVideoPictureResourceKHR*)(&forMarshaling->srcPictureResource), ptr);
+ reservedmarshal_VkVideoReferenceSlotKHR(
+ vkStream, rootType, (const VkVideoReferenceSlotKHR*)(forMarshaling->pSetupReferenceSlot),
+ ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->referenceSlotCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i)
- {
- reservedmarshal_VkVideoReferenceSlotKHR(vkStream, rootType, (const VkVideoReferenceSlotKHR*)(forMarshaling->pReferenceSlots + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i) {
+ reservedmarshal_VkVideoReferenceSlotKHR(
+ vkStream, rootType,
+ (const VkVideoReferenceSlotKHR*)(forMarshaling->pReferenceSlots + i), ptr);
}
}
void reservedmarshal_VkVideoEncodeRateControlInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeRateControlInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeRateControlInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkVideoEncodeRateControlFlagsKHR*)&forMarshaling->flags, sizeof(VkVideoEncodeRateControlFlagsKHR));
+ memcpy(*ptr, (VkVideoEncodeRateControlFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkVideoEncodeRateControlFlagsKHR));
*ptr += sizeof(VkVideoEncodeRateControlFlagsKHR);
- memcpy(*ptr, (VkVideoEncodeRateControlModeFlagBitsKHR*)&forMarshaling->rateControlMode, sizeof(VkVideoEncodeRateControlModeFlagBitsKHR));
+ memcpy(*ptr, (VkVideoEncodeRateControlModeFlagBitsKHR*)&forMarshaling->rateControlMode,
+ sizeof(VkVideoEncodeRateControlModeFlagBitsKHR));
*ptr += sizeof(VkVideoEncodeRateControlModeFlagBitsKHR);
memcpy(*ptr, (uint32_t*)&forMarshaling->averageBitrate, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -9508,51 +8632,47 @@
#endif
#ifdef VK_KHR_synchronization2
-void reservedmarshal_VkMemoryBarrier2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryBarrier2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkMemoryBarrier2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryBarrier2KHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->srcStageMask, sizeof(VkPipelineStageFlags2KHR));
+ memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->srcStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
*ptr += sizeof(VkPipelineStageFlags2KHR);
memcpy(*ptr, (VkAccessFlags2KHR*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags2KHR));
*ptr += sizeof(VkAccessFlags2KHR);
- memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->dstStageMask, sizeof(VkPipelineStageFlags2KHR));
+ memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->dstStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
*ptr += sizeof(VkPipelineStageFlags2KHR);
memcpy(*ptr, (VkAccessFlags2KHR*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags2KHR));
*ptr += sizeof(VkAccessFlags2KHR);
}
-void reservedmarshal_VkBufferMemoryBarrier2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferMemoryBarrier2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkBufferMemoryBarrier2KHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkBufferMemoryBarrier2KHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->srcStageMask, sizeof(VkPipelineStageFlags2KHR));
+ memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->srcStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
*ptr += sizeof(VkPipelineStageFlags2KHR);
memcpy(*ptr, (VkAccessFlags2KHR*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags2KHR));
*ptr += sizeof(VkAccessFlags2KHR);
- memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->dstStageMask, sizeof(VkPipelineStageFlags2KHR));
+ memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->dstStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
*ptr += sizeof(VkPipelineStageFlags2KHR);
memcpy(*ptr, (VkAccessFlags2KHR*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags2KHR));
*ptr += sizeof(VkAccessFlags2KHR);
@@ -9570,26 +8690,24 @@
*ptr += sizeof(VkDeviceSize);
}
-void reservedmarshal_VkImageMemoryBarrier2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageMemoryBarrier2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImageMemoryBarrier2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageMemoryBarrier2KHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->srcStageMask, sizeof(VkPipelineStageFlags2KHR));
+ memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->srcStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
*ptr += sizeof(VkPipelineStageFlags2KHR);
memcpy(*ptr, (VkAccessFlags2KHR*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags2KHR));
*ptr += sizeof(VkAccessFlags2KHR);
- memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->dstStageMask, sizeof(VkPipelineStageFlags2KHR));
+ memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->dstStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
*ptr += sizeof(VkPipelineStageFlags2KHR);
memcpy(*ptr, (VkAccessFlags2KHR*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags2KHR));
*ptr += sizeof(VkAccessFlags2KHR);
@@ -9605,21 +8723,17 @@
*&cgen_var_0 = get_host_u64_VkImage((*&forMarshaling->image));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
- reservedmarshal_VkImageSubresourceRange(vkStream, rootType, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange), ptr);
+ reservedmarshal_VkImageSubresourceRange(
+ vkStream, rootType, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange), ptr);
}
-void reservedmarshal_VkDependencyInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDependencyInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDependencyInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDependencyInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9627,36 +8741,35 @@
*ptr += sizeof(VkDependencyFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->memoryBarrierCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->memoryBarrierCount; ++i)
- {
- reservedmarshal_VkMemoryBarrier2KHR(vkStream, rootType, (const VkMemoryBarrier2KHR*)(forMarshaling->pMemoryBarriers + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->memoryBarrierCount; ++i) {
+ reservedmarshal_VkMemoryBarrier2KHR(
+ vkStream, rootType, (const VkMemoryBarrier2KHR*)(forMarshaling->pMemoryBarriers + i),
+ ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->bufferMemoryBarrierCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->bufferMemoryBarrierCount; ++i)
- {
- reservedmarshal_VkBufferMemoryBarrier2KHR(vkStream, rootType, (const VkBufferMemoryBarrier2KHR*)(forMarshaling->pBufferMemoryBarriers + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->bufferMemoryBarrierCount; ++i) {
+ reservedmarshal_VkBufferMemoryBarrier2KHR(
+ vkStream, rootType,
+ (const VkBufferMemoryBarrier2KHR*)(forMarshaling->pBufferMemoryBarriers + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->imageMemoryBarrierCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageMemoryBarrierCount; ++i)
- {
- reservedmarshal_VkImageMemoryBarrier2KHR(vkStream, rootType, (const VkImageMemoryBarrier2KHR*)(forMarshaling->pImageMemoryBarriers + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageMemoryBarrierCount; ++i) {
+ reservedmarshal_VkImageMemoryBarrier2KHR(
+ vkStream, rootType,
+ (const VkImageMemoryBarrier2KHR*)(forMarshaling->pImageMemoryBarriers + i), ptr);
}
}
-void reservedmarshal_VkSemaphoreSubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreSubmitInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSemaphoreSubmitInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreSubmitInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9666,24 +8779,22 @@
*ptr += 1 * 8;
memcpy(*ptr, (uint64_t*)&forMarshaling->value, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
- memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->stageMask, sizeof(VkPipelineStageFlags2KHR));
+ memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->stageMask,
+ sizeof(VkPipelineStageFlags2KHR));
*ptr += sizeof(VkPipelineStageFlags2KHR);
memcpy(*ptr, (uint32_t*)&forMarshaling->deviceIndex, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkCommandBufferSubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferSubmitInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkCommandBufferSubmitInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkCommandBufferSubmitInfoKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9695,18 +8806,13 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkSubmitInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubmitInfo2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSubmitInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubmitInfo2KHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9714,36 +8820,35 @@
*ptr += sizeof(VkSubmitFlagsKHR);
memcpy(*ptr, (uint32_t*)&forMarshaling->waitSemaphoreInfoCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->waitSemaphoreInfoCount; ++i)
- {
- reservedmarshal_VkSemaphoreSubmitInfoKHR(vkStream, rootType, (const VkSemaphoreSubmitInfoKHR*)(forMarshaling->pWaitSemaphoreInfos + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->waitSemaphoreInfoCount; ++i) {
+ reservedmarshal_VkSemaphoreSubmitInfoKHR(
+ vkStream, rootType,
+ (const VkSemaphoreSubmitInfoKHR*)(forMarshaling->pWaitSemaphoreInfos + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->commandBufferInfoCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->commandBufferInfoCount; ++i)
- {
- reservedmarshal_VkCommandBufferSubmitInfoKHR(vkStream, rootType, (const VkCommandBufferSubmitInfoKHR*)(forMarshaling->pCommandBufferInfos + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->commandBufferInfoCount; ++i) {
+ reservedmarshal_VkCommandBufferSubmitInfoKHR(
+ vkStream, rootType,
+ (const VkCommandBufferSubmitInfoKHR*)(forMarshaling->pCommandBufferInfos + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->signalSemaphoreInfoCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->signalSemaphoreInfoCount; ++i)
- {
- reservedmarshal_VkSemaphoreSubmitInfoKHR(vkStream, rootType, (const VkSemaphoreSubmitInfoKHR*)(forMarshaling->pSignalSemaphoreInfos + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->signalSemaphoreInfoCount; ++i) {
+ reservedmarshal_VkSemaphoreSubmitInfoKHR(
+ vkStream, rootType,
+ (const VkSemaphoreSubmitInfoKHR*)(forMarshaling->pSignalSemaphoreInfos + i), ptr);
}
}
void reservedmarshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSynchronization2FeaturesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSynchronization2FeaturesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9752,48 +8857,40 @@
}
void reservedmarshal_VkQueueFamilyCheckpointProperties2NV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueueFamilyCheckpointProperties2NV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyCheckpointProperties2NV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->checkpointExecutionStageMask, sizeof(VkPipelineStageFlags2KHR));
+ memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->checkpointExecutionStageMask,
+ sizeof(VkPipelineStageFlags2KHR));
*ptr += sizeof(VkPipelineStageFlags2KHR);
}
-void reservedmarshal_VkCheckpointData2NV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCheckpointData2NV* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkCheckpointData2NV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCheckpointData2NV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->stage, sizeof(VkPipelineStageFlags2KHR));
+ memcpy(*ptr, (VkPipelineStageFlags2KHR*)&forMarshaling->stage,
+ sizeof(VkPipelineStageFlags2KHR));
*ptr += sizeof(VkPipelineStageFlags2KHR);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pCheckpointMarker;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pCheckpointMarker)
- {
+ if (forMarshaling->pCheckpointMarker) {
memcpy(*ptr, (void*)forMarshaling->pCheckpointMarker, sizeof(uint8_t));
*ptr += sizeof(uint8_t);
}
@@ -9802,17 +8899,14 @@
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
void reservedmarshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9823,17 +8917,13 @@
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
void reservedmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9844,44 +8934,38 @@
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
void reservedmarshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->workgroupMemoryExplicitLayout, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->workgroupMemoryExplicitLayoutScalarBlockLayout, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->workgroupMemoryExplicitLayoutScalarBlockLayout,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->workgroupMemoryExplicitLayout8BitAccess, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->workgroupMemoryExplicitLayout8BitAccess,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->workgroupMemoryExplicitLayout16BitAccess, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->workgroupMemoryExplicitLayout16BitAccess,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
#endif
#ifdef VK_KHR_copy_commands2
-void reservedmarshal_VkBufferCopy2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCopy2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkBufferCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCopy2KHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9893,18 +8977,14 @@
*ptr += sizeof(VkDeviceSize);
}
-void reservedmarshal_VkCopyBufferInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyBufferInfo2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkCopyBufferInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyBufferInfo2KHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9918,46 +8998,38 @@
*ptr += 1 * 8;
memcpy(*ptr, (uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
- {
- reservedmarshal_VkBufferCopy2KHR(vkStream, rootType, (const VkBufferCopy2KHR*)(forMarshaling->pRegions + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+ reservedmarshal_VkBufferCopy2KHR(
+ vkStream, rootType, (const VkBufferCopy2KHR*)(forMarshaling->pRegions + i), ptr);
}
}
-void reservedmarshal_VkImageCopy2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageCopy2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImageCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageCopy2KHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
+ reservedmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset), ptr);
- reservedmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
+ reservedmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->dstOffset), ptr);
reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent), ptr);
}
-void reservedmarshal_VkCopyImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyImageInfo2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkCopyImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyImageInfo2KHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -9975,24 +9047,20 @@
*ptr += sizeof(VkImageLayout);
memcpy(*ptr, (uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
- {
- reservedmarshal_VkImageCopy2KHR(vkStream, rootType, (const VkImageCopy2KHR*)(forMarshaling->pRegions + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+ reservedmarshal_VkImageCopy2KHR(vkStream, rootType,
+ (const VkImageCopy2KHR*)(forMarshaling->pRegions + i), ptr);
}
}
-void reservedmarshal_VkBufferImageCopy2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferImageCopy2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkBufferImageCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferImageCopy2KHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10002,23 +9070,21 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->bufferImageHeight, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- reservedmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource), ptr);
+ reservedmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource), ptr);
reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset), ptr);
reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent), ptr);
}
-void reservedmarshal_VkCopyBufferToImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyBufferToImageInfo2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkCopyBufferToImageInfo2KHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkCopyBufferToImageInfo2KHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10034,24 +9100,21 @@
*ptr += sizeof(VkImageLayout);
memcpy(*ptr, (uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
- {
- reservedmarshal_VkBufferImageCopy2KHR(vkStream, rootType, (const VkBufferImageCopy2KHR*)(forMarshaling->pRegions + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+ reservedmarshal_VkBufferImageCopy2KHR(
+ vkStream, rootType, (const VkBufferImageCopy2KHR*)(forMarshaling->pRegions + i), ptr);
}
}
-void reservedmarshal_VkCopyImageToBufferInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyImageToBufferInfo2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkCopyImageToBufferInfo2KHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkCopyImageToBufferInfo2KHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10067,51 +9130,43 @@
*ptr += 1 * 8;
memcpy(*ptr, (uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
- {
- reservedmarshal_VkBufferImageCopy2KHR(vkStream, rootType, (const VkBufferImageCopy2KHR*)(forMarshaling->pRegions + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+ reservedmarshal_VkBufferImageCopy2KHR(
+ vkStream, rootType, (const VkBufferImageCopy2KHR*)(forMarshaling->pRegions + i), ptr);
}
}
-void reservedmarshal_VkImageBlit2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageBlit2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImageBlit2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageBlit2KHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
- reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->srcOffsets + i), ptr);
+ reservedmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+ reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->srcOffsets + i),
+ ptr);
}
- reservedmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
- reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->dstOffsets + i), ptr);
+ reservedmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+ reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->dstOffsets + i),
+ ptr);
}
}
-void reservedmarshal_VkBlitImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBlitImageInfo2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkBlitImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBlitImageInfo2KHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10129,48 +9184,41 @@
*ptr += sizeof(VkImageLayout);
memcpy(*ptr, (uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
- {
- reservedmarshal_VkImageBlit2KHR(vkStream, rootType, (const VkImageBlit2KHR*)(forMarshaling->pRegions + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+ reservedmarshal_VkImageBlit2KHR(vkStream, rootType,
+ (const VkImageBlit2KHR*)(forMarshaling->pRegions + i), ptr);
}
memcpy(*ptr, (VkFilter*)&forMarshaling->filter, sizeof(VkFilter));
*ptr += sizeof(VkFilter);
}
-void reservedmarshal_VkImageResolve2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageResolve2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImageResolve2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageResolve2KHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
+ reservedmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource), ptr);
reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset), ptr);
- reservedmarshal_VkImageSubresourceLayers(vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
+ reservedmarshal_VkImageSubresourceLayers(
+ vkStream, rootType, (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource), ptr);
reservedmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->dstOffset), ptr);
reservedmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent), ptr);
}
-void reservedmarshal_VkResolveImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkResolveImageInfo2KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkResolveImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkResolveImageInfo2KHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10188,51 +9236,46 @@
*ptr += sizeof(VkImageLayout);
memcpy(*ptr, (uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i)
- {
- reservedmarshal_VkImageResolve2KHR(vkStream, rootType, (const VkImageResolve2KHR*)(forMarshaling->pRegions + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+ reservedmarshal_VkImageResolve2KHR(
+ vkStream, rootType, (const VkImageResolve2KHR*)(forMarshaling->pRegions + i), ptr);
}
}
#endif
#ifdef VK_KHR_format_feature_flags2
-void reservedmarshal_VkFormatProperties3KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFormatProperties3KHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkFormatProperties3KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFormatProperties3KHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkFormatFeatureFlags2KHR*)&forMarshaling->linearTilingFeatures, sizeof(VkFormatFeatureFlags2KHR));
+ memcpy(*ptr, (VkFormatFeatureFlags2KHR*)&forMarshaling->linearTilingFeatures,
+ sizeof(VkFormatFeatureFlags2KHR));
*ptr += sizeof(VkFormatFeatureFlags2KHR);
- memcpy(*ptr, (VkFormatFeatureFlags2KHR*)&forMarshaling->optimalTilingFeatures, sizeof(VkFormatFeatureFlags2KHR));
+ memcpy(*ptr, (VkFormatFeatureFlags2KHR*)&forMarshaling->optimalTilingFeatures,
+ sizeof(VkFormatFeatureFlags2KHR));
*ptr += sizeof(VkFormatFeatureFlags2KHR);
- memcpy(*ptr, (VkFormatFeatureFlags2KHR*)&forMarshaling->bufferFeatures, sizeof(VkFormatFeatureFlags2KHR));
+ memcpy(*ptr, (VkFormatFeatureFlags2KHR*)&forMarshaling->bufferFeatures,
+ sizeof(VkFormatFeatureFlags2KHR));
*ptr += sizeof(VkFormatFeatureFlags2KHR);
}
#endif
#ifdef VK_KHR_maintenance4
void reservedmarshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMaintenance4FeaturesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance4FeaturesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10241,17 +9284,13 @@
}
void reservedmarshal_VkPhysicalDeviceMaintenance4PropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMaintenance4PropertiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance4PropertiesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10260,57 +9299,48 @@
}
void reservedmarshal_VkDeviceBufferMemoryRequirementsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceBufferMemoryRequirementsKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceBufferMemoryRequirementsKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkBufferCreateInfo(vkStream, rootType, (const VkBufferCreateInfo*)(forMarshaling->pCreateInfo), ptr);
+ reservedmarshal_VkBufferCreateInfo(
+ vkStream, rootType, (const VkBufferCreateInfo*)(forMarshaling->pCreateInfo), ptr);
}
void reservedmarshal_VkDeviceImageMemoryRequirementsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceImageMemoryRequirementsKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceImageMemoryRequirementsKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkImageCreateInfo(vkStream, rootType, (const VkImageCreateInfo*)(forMarshaling->pCreateInfo), ptr);
- memcpy(*ptr, (VkImageAspectFlagBits*)&forMarshaling->planeAspect, sizeof(VkImageAspectFlagBits));
+ reservedmarshal_VkImageCreateInfo(vkStream, rootType,
+ (const VkImageCreateInfo*)(forMarshaling->pCreateInfo), ptr);
+ memcpy(*ptr, (VkImageAspectFlagBits*)&forMarshaling->planeAspect,
+ sizeof(VkImageAspectFlagBits));
*ptr += sizeof(VkImageAspectFlagBits);
}
#endif
#ifdef VK_ANDROID_native_buffer
-void reservedmarshal_VkNativeBufferANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkNativeBufferANDROID* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkNativeBufferANDROID(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkNativeBufferANDROID* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10319,8 +9349,7 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->handle)
- {
+ if (forMarshaling->handle) {
memcpy(*ptr, (const uint32_t*)forMarshaling->handle, sizeof(const uint32_t));
*ptr += sizeof(const uint32_t);
}
@@ -10339,17 +9368,13 @@
#endif
#ifdef VK_EXT_debug_report
void reservedmarshal_VkDebugReportCallbackCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugReportCallbackCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugReportCallbackCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10364,8 +9389,7 @@
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pUserData)
- {
+ if (forMarshaling->pUserData) {
memcpy(*ptr, (void*)forMarshaling->pUserData, sizeof(uint8_t));
*ptr += sizeof(uint8_t);
}
@@ -10380,21 +9404,18 @@
#endif
#ifdef VK_AMD_rasterization_order
void reservedmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationStateRasterizationOrderAMD* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationStateRasterizationOrderAMD* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkRasterizationOrderAMD*)&forMarshaling->rasterizationOrder, sizeof(VkRasterizationOrderAMD));
+ memcpy(*ptr, (VkRasterizationOrderAMD*)&forMarshaling->rasterizationOrder,
+ sizeof(VkRasterizationOrderAMD));
*ptr += sizeof(VkRasterizationOrderAMD);
}
@@ -10405,26 +9426,23 @@
#endif
#ifdef VK_EXT_debug_marker
void reservedmarshal_VkDebugMarkerObjectNameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugMarkerObjectNameInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugMarkerObjectNameInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDebugReportObjectTypeEXT*)&forMarshaling->objectType, sizeof(VkDebugReportObjectTypeEXT));
+ memcpy(*ptr, (VkDebugReportObjectTypeEXT*)&forMarshaling->objectType,
+ sizeof(VkDebugReportObjectTypeEXT));
*ptr += sizeof(VkDebugReportObjectTypeEXT);
memcpy(*ptr, (uint64_t*)&forMarshaling->object, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
{
- uint32_t l = forMarshaling->pObjectName ? strlen(forMarshaling->pObjectName): 0;
+ uint32_t l = forMarshaling->pObjectName ? strlen(forMarshaling->pObjectName) : 0;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
@@ -10434,21 +9452,18 @@
}
void reservedmarshal_VkDebugMarkerObjectTagInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugMarkerObjectTagInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugMarkerObjectTagInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDebugReportObjectTypeEXT*)&forMarshaling->objectType, sizeof(VkDebugReportObjectTypeEXT));
+ memcpy(*ptr, (VkDebugReportObjectTypeEXT*)&forMarshaling->objectType,
+ sizeof(VkDebugReportObjectTypeEXT));
*ptr += sizeof(VkDebugReportObjectTypeEXT);
memcpy(*ptr, (uint64_t*)&forMarshaling->object, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
@@ -10462,23 +9477,20 @@
*ptr += forMarshaling->tagSize * sizeof(const uint8_t);
}
-void reservedmarshal_VkDebugMarkerMarkerInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugMarkerMarkerInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDebugMarkerMarkerInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDebugMarkerMarkerInfoEXT* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
{
- uint32_t l = forMarshaling->pMarkerName ? strlen(forMarshaling->pMarkerName): 0;
+ uint32_t l = forMarshaling->pMarkerName ? strlen(forMarshaling->pMarkerName) : 0;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
@@ -10494,17 +9506,13 @@
#endif
#ifdef VK_NV_dedicated_allocation
void reservedmarshal_VkDedicatedAllocationImageCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDedicatedAllocationImageCreateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDedicatedAllocationImageCreateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10513,17 +9521,13 @@
}
void reservedmarshal_VkDedicatedAllocationBufferCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDedicatedAllocationBufferCreateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDedicatedAllocationBufferCreateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10532,17 +9536,13 @@
}
void reservedmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDedicatedAllocationMemoryAllocateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDedicatedAllocationMemoryAllocateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10559,17 +9559,13 @@
#endif
#ifdef VK_EXT_transform_feedback
void reservedmarshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTransformFeedbackFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTransformFeedbackFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10580,17 +9576,13 @@
}
void reservedmarshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTransformFeedbackPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTransformFeedbackPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10598,7 +9590,8 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxTransformFeedbackBuffers, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkDeviceSize*)&forMarshaling->maxTransformFeedbackBufferSize, sizeof(VkDeviceSize));
+ memcpy(*ptr, (VkDeviceSize*)&forMarshaling->maxTransformFeedbackBufferSize,
+ sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxTransformFeedbackStreamDataSize, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -10608,30 +9601,29 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (VkBool32*)&forMarshaling->transformFeedbackQueries, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->transformFeedbackStreamsLinesTriangles, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->transformFeedbackStreamsLinesTriangles,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->transformFeedbackRasterizationStreamSelect, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->transformFeedbackRasterizationStreamSelect,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->transformFeedbackDraw, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPipelineRasterizationStateStreamCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationStateStreamCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationStateStreamCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineRasterizationStateStreamCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkPipelineRasterizationStateStreamCreateFlagsEXT));
+ memcpy(*ptr, (VkPipelineRasterizationStateStreamCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkPipelineRasterizationStateStreamCreateFlagsEXT));
*ptr += sizeof(VkPipelineRasterizationStateStreamCreateFlagsEXT);
memcpy(*ptr, (uint32_t*)&forMarshaling->rasterizationStream, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -10639,18 +9631,14 @@
#endif
#ifdef VK_NVX_binary_import
-void reservedmarshal_VkCuModuleCreateInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCuModuleCreateInfoNVX* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkCuModuleCreateInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCuModuleCreateInfoNVX* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10658,22 +9646,20 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- memcpy(*ptr, (const void*)forMarshaling->pData, forMarshaling->dataSize * sizeof(const uint8_t));
+ memcpy(*ptr, (const void*)forMarshaling->pData,
+ forMarshaling->dataSize * sizeof(const uint8_t));
*ptr += forMarshaling->dataSize * sizeof(const uint8_t);
}
-void reservedmarshal_VkCuFunctionCreateInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCuFunctionCreateInfoNVX* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkCuFunctionCreateInfoNVX(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkCuFunctionCreateInfoNVX* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10682,7 +9668,7 @@
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
{
- uint32_t l = forMarshaling->pName ? strlen(forMarshaling->pName): 0;
+ uint32_t l = forMarshaling->pName ? strlen(forMarshaling->pName) : 0;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
@@ -10691,18 +9677,13 @@
}
}
-void reservedmarshal_VkCuLaunchInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCuLaunchInfoNVX* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkCuLaunchInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCuLaunchInfoNVX* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10736,18 +9717,14 @@
#endif
#ifdef VK_NVX_image_view_handle
-void reservedmarshal_VkImageViewHandleInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageViewHandleInfoNVX* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImageViewHandleInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageViewHandleInfoNVX* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10764,17 +9741,13 @@
}
void reservedmarshal_VkImageViewAddressPropertiesNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageViewAddressPropertiesNVX* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageViewAddressPropertiesNVX* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10795,29 +9768,31 @@
#endif
#ifdef VK_EXT_video_encode_h264
void reservedmarshal_VkVideoEncodeH264CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264CapabilitiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264CapabilitiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkVideoEncodeH264CapabilityFlagsEXT*)&forMarshaling->flags, sizeof(VkVideoEncodeH264CapabilityFlagsEXT));
+ memcpy(*ptr, (VkVideoEncodeH264CapabilityFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkVideoEncodeH264CapabilityFlagsEXT));
*ptr += sizeof(VkVideoEncodeH264CapabilityFlagsEXT);
- memcpy(*ptr, (VkVideoEncodeH264InputModeFlagsEXT*)&forMarshaling->inputModeFlags, sizeof(VkVideoEncodeH264InputModeFlagsEXT));
+ memcpy(*ptr, (VkVideoEncodeH264InputModeFlagsEXT*)&forMarshaling->inputModeFlags,
+ sizeof(VkVideoEncodeH264InputModeFlagsEXT));
*ptr += sizeof(VkVideoEncodeH264InputModeFlagsEXT);
- memcpy(*ptr, (VkVideoEncodeH264OutputModeFlagsEXT*)&forMarshaling->outputModeFlags, sizeof(VkVideoEncodeH264OutputModeFlagsEXT));
+ memcpy(*ptr, (VkVideoEncodeH264OutputModeFlagsEXT*)&forMarshaling->outputModeFlags,
+ sizeof(VkVideoEncodeH264OutputModeFlagsEXT));
*ptr += sizeof(VkVideoEncodeH264OutputModeFlagsEXT);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minPictureSizeInMbs), ptr);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxPictureSizeInMbs), ptr);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->inputImageDataAlignment), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->minPictureSizeInMbs), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->maxPictureSizeInMbs), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->inputImageDataAlignment), ptr);
memcpy(*ptr, (uint8_t*)&forMarshaling->maxNumL0ReferenceForP, sizeof(uint8_t));
*ptr += sizeof(uint8_t);
memcpy(*ptr, (uint8_t*)&forMarshaling->maxNumL0ReferenceForB, sizeof(uint8_t));
@@ -10826,42 +9801,39 @@
*ptr += sizeof(uint8_t);
memcpy(*ptr, (uint8_t*)&forMarshaling->qualityLevelCount, sizeof(uint8_t));
*ptr += sizeof(uint8_t);
- reservedmarshal_VkExtensionProperties(vkStream, rootType, (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion), ptr);
+ reservedmarshal_VkExtensionProperties(
+ vkStream, rootType, (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion), ptr);
}
void reservedmarshal_VkVideoEncodeH264SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264SessionCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264SessionCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkVideoEncodeH264CreateFlagsEXT*)&forMarshaling->flags, sizeof(VkVideoEncodeH264CreateFlagsEXT));
+ memcpy(*ptr, (VkVideoEncodeH264CreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkVideoEncodeH264CreateFlagsEXT));
*ptr += sizeof(VkVideoEncodeH264CreateFlagsEXT);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxPictureSizeInMbs), ptr);
- reservedmarshal_VkExtensionProperties(vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->maxPictureSizeInMbs), ptr);
+ reservedmarshal_VkExtensionProperties(
+ vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion),
+ ptr);
}
void reservedmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264SessionParametersAddInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264SessionParametersAddInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10872,9 +9844,9 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pSpsStd)
- {
- memcpy(*ptr, (const StdVideoH264SequenceParameterSet*)forMarshaling->pSpsStd, forMarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
+ if (forMarshaling->pSpsStd) {
+ memcpy(*ptr, (const StdVideoH264SequenceParameterSet*)forMarshaling->pSpsStd,
+ forMarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
*ptr += forMarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->ppsStdCount, sizeof(uint32_t));
@@ -10884,25 +9856,21 @@
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pPpsStd)
- {
- memcpy(*ptr, (const StdVideoH264PictureParameterSet*)forMarshaling->pPpsStd, forMarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
+ if (forMarshaling->pPpsStd) {
+ memcpy(*ptr, (const StdVideoH264PictureParameterSet*)forMarshaling->pPpsStd,
+ forMarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
*ptr += forMarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet);
}
}
void reservedmarshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264SessionParametersCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264SessionParametersCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -10915,63 +9883,64 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pParametersAddInfo)
- {
- reservedmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(vkStream, rootType, (const VkVideoEncodeH264SessionParametersAddInfoEXT*)(forMarshaling->pParametersAddInfo), ptr);
+ if (forMarshaling->pParametersAddInfo) {
+ reservedmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH264SessionParametersAddInfoEXT*)(forMarshaling
+ ->pParametersAddInfo),
+ ptr);
}
}
void reservedmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264DpbSlotInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264DpbSlotInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (int8_t*)&forMarshaling->slotIndex, sizeof(int8_t));
*ptr += sizeof(int8_t);
- memcpy(*ptr, (const StdVideoEncodeH264PictureInfo*)forMarshaling->pStdPictureInfo, sizeof(const StdVideoEncodeH264PictureInfo));
+ memcpy(*ptr, (const StdVideoEncodeH264PictureInfo*)forMarshaling->pStdPictureInfo,
+ sizeof(const StdVideoEncodeH264PictureInfo));
*ptr += sizeof(const StdVideoEncodeH264PictureInfo);
}
void reservedmarshal_VkVideoEncodeH264NaluSliceEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264NaluSliceEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264NaluSliceEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (const StdVideoEncodeH264SliceHeader*)forMarshaling->pSliceHeaderStd, sizeof(const StdVideoEncodeH264SliceHeader));
+ memcpy(*ptr, (const StdVideoEncodeH264SliceHeader*)forMarshaling->pSliceHeaderStd,
+ sizeof(const StdVideoEncodeH264SliceHeader));
*ptr += sizeof(const StdVideoEncodeH264SliceHeader);
memcpy(*ptr, (uint32_t*)&forMarshaling->mbCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint8_t*)&forMarshaling->refFinalList0EntryCount, sizeof(uint8_t));
*ptr += sizeof(uint8_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->refFinalList0EntryCount; ++i)
- {
- reservedmarshal_VkVideoEncodeH264DpbSlotInfoEXT(vkStream, rootType, (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pRefFinalList0Entries + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->refFinalList0EntryCount; ++i) {
+ reservedmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pRefFinalList0Entries + i),
+ ptr);
}
memcpy(*ptr, (uint8_t*)&forMarshaling->refFinalList1EntryCount, sizeof(uint8_t));
*ptr += sizeof(uint8_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->refFinalList1EntryCount; ++i)
- {
- reservedmarshal_VkVideoEncodeH264DpbSlotInfoEXT(vkStream, rootType, (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pRefFinalList1Entries + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->refFinalList1EntryCount; ++i) {
+ reservedmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pRefFinalList1Entries + i),
+ ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->precedingNaluBytes, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -10982,53 +9951,54 @@
}
void reservedmarshal_VkVideoEncodeH264VclFrameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264VclFrameInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264VclFrameInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint8_t*)&forMarshaling->refDefaultFinalList0EntryCount, sizeof(uint8_t));
*ptr += sizeof(uint8_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->refDefaultFinalList0EntryCount; ++i)
- {
- reservedmarshal_VkVideoEncodeH264DpbSlotInfoEXT(vkStream, rootType, (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pRefDefaultFinalList0Entries + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->refDefaultFinalList0EntryCount; ++i) {
+ reservedmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pRefDefaultFinalList0Entries +
+ i),
+ ptr);
}
memcpy(*ptr, (uint8_t*)&forMarshaling->refDefaultFinalList1EntryCount, sizeof(uint8_t));
*ptr += sizeof(uint8_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->refDefaultFinalList1EntryCount; ++i)
- {
- reservedmarshal_VkVideoEncodeH264DpbSlotInfoEXT(vkStream, rootType, (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pRefDefaultFinalList1Entries + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->refDefaultFinalList1EntryCount; ++i) {
+ reservedmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pRefDefaultFinalList1Entries +
+ i),
+ ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->naluSliceEntryCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->naluSliceEntryCount; ++i)
- {
- reservedmarshal_VkVideoEncodeH264NaluSliceEXT(vkStream, rootType, (const VkVideoEncodeH264NaluSliceEXT*)(forMarshaling->pNaluSliceEntries + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->naluSliceEntryCount; ++i) {
+ reservedmarshal_VkVideoEncodeH264NaluSliceEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH264NaluSliceEXT*)(forMarshaling->pNaluSliceEntries + i), ptr);
}
- reservedmarshal_VkVideoEncodeH264DpbSlotInfoEXT(vkStream, rootType, (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pCurrentPictureInfo), ptr);
+ reservedmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pCurrentPictureInfo), ptr);
}
void reservedmarshal_VkVideoEncodeH264EmitPictureParametersEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264EmitPictureParametersEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264EmitPictureParametersEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -11038,55 +10008,55 @@
*ptr += sizeof(VkBool32);
memcpy(*ptr, (uint32_t*)&forMarshaling->ppsIdEntryCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const uint8_t*)forMarshaling->ppsIdEntries, forMarshaling->ppsIdEntryCount * sizeof(const uint8_t));
+ memcpy(*ptr, (const uint8_t*)forMarshaling->ppsIdEntries,
+ forMarshaling->ppsIdEntryCount * sizeof(const uint8_t));
*ptr += forMarshaling->ppsIdEntryCount * sizeof(const uint8_t);
}
-void reservedmarshal_VkVideoEncodeH264ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264ProfileEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkVideoEncodeH264ProfileEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkVideoEncodeH264ProfileEXT* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (StdVideoH264ProfileIdc*)&forMarshaling->stdProfileIdc, sizeof(StdVideoH264ProfileIdc));
+ memcpy(*ptr, (StdVideoH264ProfileIdc*)&forMarshaling->stdProfileIdc,
+ sizeof(StdVideoH264ProfileIdc));
*ptr += sizeof(StdVideoH264ProfileIdc);
}
#endif
#ifdef VK_EXT_video_encode_h265
void reservedmarshal_VkVideoEncodeH265CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265CapabilitiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265CapabilitiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkVideoEncodeH265CapabilityFlagsEXT*)&forMarshaling->flags, sizeof(VkVideoEncodeH265CapabilityFlagsEXT));
+ memcpy(*ptr, (VkVideoEncodeH265CapabilityFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkVideoEncodeH265CapabilityFlagsEXT));
*ptr += sizeof(VkVideoEncodeH265CapabilityFlagsEXT);
- memcpy(*ptr, (VkVideoEncodeH265InputModeFlagsEXT*)&forMarshaling->inputModeFlags, sizeof(VkVideoEncodeH265InputModeFlagsEXT));
+ memcpy(*ptr, (VkVideoEncodeH265InputModeFlagsEXT*)&forMarshaling->inputModeFlags,
+ sizeof(VkVideoEncodeH265InputModeFlagsEXT));
*ptr += sizeof(VkVideoEncodeH265InputModeFlagsEXT);
- memcpy(*ptr, (VkVideoEncodeH265OutputModeFlagsEXT*)&forMarshaling->outputModeFlags, sizeof(VkVideoEncodeH265OutputModeFlagsEXT));
+ memcpy(*ptr, (VkVideoEncodeH265OutputModeFlagsEXT*)&forMarshaling->outputModeFlags,
+ sizeof(VkVideoEncodeH265OutputModeFlagsEXT));
*ptr += sizeof(VkVideoEncodeH265OutputModeFlagsEXT);
- memcpy(*ptr, (VkVideoEncodeH265CtbSizeFlagsEXT*)&forMarshaling->ctbSizes, sizeof(VkVideoEncodeH265CtbSizeFlagsEXT));
+ memcpy(*ptr, (VkVideoEncodeH265CtbSizeFlagsEXT*)&forMarshaling->ctbSizes,
+ sizeof(VkVideoEncodeH265CtbSizeFlagsEXT));
*ptr += sizeof(VkVideoEncodeH265CtbSizeFlagsEXT);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->inputImageDataAlignment), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->inputImageDataAlignment), ptr);
memcpy(*ptr, (uint8_t*)&forMarshaling->maxNumL0ReferenceForP, sizeof(uint8_t));
*ptr += sizeof(uint8_t);
memcpy(*ptr, (uint8_t*)&forMarshaling->maxNumL0ReferenceForB, sizeof(uint8_t));
@@ -11097,41 +10067,37 @@
*ptr += sizeof(uint8_t);
memcpy(*ptr, (uint8_t*)&forMarshaling->qualityLevelCount, sizeof(uint8_t));
*ptr += sizeof(uint8_t);
- reservedmarshal_VkExtensionProperties(vkStream, rootType, (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion), ptr);
+ reservedmarshal_VkExtensionProperties(
+ vkStream, rootType, (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion), ptr);
}
void reservedmarshal_VkVideoEncodeH265SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265SessionCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265SessionCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkVideoEncodeH265CreateFlagsEXT*)&forMarshaling->flags, sizeof(VkVideoEncodeH265CreateFlagsEXT));
+ memcpy(*ptr, (VkVideoEncodeH265CreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkVideoEncodeH265CreateFlagsEXT));
*ptr += sizeof(VkVideoEncodeH265CreateFlagsEXT);
- reservedmarshal_VkExtensionProperties(vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion), ptr);
+ reservedmarshal_VkExtensionProperties(
+ vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion),
+ ptr);
}
void reservedmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265SessionParametersAddInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265SessionParametersAddInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -11142,9 +10108,9 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pVpsStd)
- {
- memcpy(*ptr, (const StdVideoH265VideoParameterSet*)forMarshaling->pVpsStd, forMarshaling->vpsStdCount * sizeof(const StdVideoH265VideoParameterSet));
+ if (forMarshaling->pVpsStd) {
+ memcpy(*ptr, (const StdVideoH265VideoParameterSet*)forMarshaling->pVpsStd,
+ forMarshaling->vpsStdCount * sizeof(const StdVideoH265VideoParameterSet));
*ptr += forMarshaling->vpsStdCount * sizeof(const StdVideoH265VideoParameterSet);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->spsStdCount, sizeof(uint32_t));
@@ -11154,9 +10120,9 @@
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pSpsStd)
- {
- memcpy(*ptr, (const StdVideoH265SequenceParameterSet*)forMarshaling->pSpsStd, forMarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
+ if (forMarshaling->pSpsStd) {
+ memcpy(*ptr, (const StdVideoH265SequenceParameterSet*)forMarshaling->pSpsStd,
+ forMarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
*ptr += forMarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->ppsStdCount, sizeof(uint32_t));
@@ -11166,25 +10132,21 @@
memcpy((*ptr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pPpsStd)
- {
- memcpy(*ptr, (const StdVideoH265PictureParameterSet*)forMarshaling->pPpsStd, forMarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
+ if (forMarshaling->pPpsStd) {
+ memcpy(*ptr, (const StdVideoH265PictureParameterSet*)forMarshaling->pPpsStd,
+ forMarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
*ptr += forMarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet);
}
}
void reservedmarshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265SessionParametersCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265SessionParametersCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -11199,76 +10161,74 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pParametersAddInfo)
- {
- reservedmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(vkStream, rootType, (const VkVideoEncodeH265SessionParametersAddInfoEXT*)(forMarshaling->pParametersAddInfo), ptr);
+ if (forMarshaling->pParametersAddInfo) {
+ reservedmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH265SessionParametersAddInfoEXT*)(forMarshaling
+ ->pParametersAddInfo),
+ ptr);
}
}
void reservedmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265DpbSlotInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265DpbSlotInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (int8_t*)&forMarshaling->slotIndex, sizeof(int8_t));
*ptr += sizeof(int8_t);
- memcpy(*ptr, (const StdVideoEncodeH265ReferenceInfo*)forMarshaling->pStdReferenceInfo, sizeof(const StdVideoEncodeH265ReferenceInfo));
+ memcpy(*ptr, (const StdVideoEncodeH265ReferenceInfo*)forMarshaling->pStdReferenceInfo,
+ sizeof(const StdVideoEncodeH265ReferenceInfo));
*ptr += sizeof(const StdVideoEncodeH265ReferenceInfo);
}
void reservedmarshal_VkVideoEncodeH265ReferenceListsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265ReferenceListsEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265ReferenceListsEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint8_t*)&forMarshaling->referenceList0EntryCount, sizeof(uint8_t));
*ptr += sizeof(uint8_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceList0EntryCount; ++i)
- {
- reservedmarshal_VkVideoEncodeH265DpbSlotInfoEXT(vkStream, rootType, (const VkVideoEncodeH265DpbSlotInfoEXT*)(forMarshaling->pReferenceList0Entries + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceList0EntryCount; ++i) {
+ reservedmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH265DpbSlotInfoEXT*)(forMarshaling->pReferenceList0Entries + i),
+ ptr);
}
memcpy(*ptr, (uint8_t*)&forMarshaling->referenceList1EntryCount, sizeof(uint8_t));
*ptr += sizeof(uint8_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceList1EntryCount; ++i)
- {
- reservedmarshal_VkVideoEncodeH265DpbSlotInfoEXT(vkStream, rootType, (const VkVideoEncodeH265DpbSlotInfoEXT*)(forMarshaling->pReferenceList1Entries + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceList1EntryCount; ++i) {
+ reservedmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH265DpbSlotInfoEXT*)(forMarshaling->pReferenceList1Entries + i),
+ ptr);
}
- memcpy(*ptr, (const StdVideoEncodeH265ReferenceModifications*)forMarshaling->pReferenceModifications, sizeof(const StdVideoEncodeH265ReferenceModifications));
+ memcpy(*ptr,
+ (const StdVideoEncodeH265ReferenceModifications*)forMarshaling->pReferenceModifications,
+ sizeof(const StdVideoEncodeH265ReferenceModifications));
*ptr += sizeof(const StdVideoEncodeH265ReferenceModifications);
}
void reservedmarshal_VkVideoEncodeH265NaluSliceEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265NaluSliceEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265NaluSliceEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -11279,26 +10239,24 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pReferenceFinalLists)
- {
- reservedmarshal_VkVideoEncodeH265ReferenceListsEXT(vkStream, rootType, (const VkVideoEncodeH265ReferenceListsEXT*)(forMarshaling->pReferenceFinalLists), ptr);
+ if (forMarshaling->pReferenceFinalLists) {
+ reservedmarshal_VkVideoEncodeH265ReferenceListsEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH265ReferenceListsEXT*)(forMarshaling->pReferenceFinalLists), ptr);
}
- memcpy(*ptr, (const StdVideoEncodeH265SliceHeader*)forMarshaling->pSliceHeaderStd, sizeof(const StdVideoEncodeH265SliceHeader));
+ memcpy(*ptr, (const StdVideoEncodeH265SliceHeader*)forMarshaling->pSliceHeaderStd,
+ sizeof(const StdVideoEncodeH265SliceHeader));
*ptr += sizeof(const StdVideoEncodeH265SliceHeader);
}
void reservedmarshal_VkVideoEncodeH265VclFrameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265VclFrameInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265VclFrameInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -11307,32 +10265,31 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pReferenceFinalLists)
- {
- reservedmarshal_VkVideoEncodeH265ReferenceListsEXT(vkStream, rootType, (const VkVideoEncodeH265ReferenceListsEXT*)(forMarshaling->pReferenceFinalLists), ptr);
+ if (forMarshaling->pReferenceFinalLists) {
+ reservedmarshal_VkVideoEncodeH265ReferenceListsEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH265ReferenceListsEXT*)(forMarshaling->pReferenceFinalLists), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->naluSliceEntryCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->naluSliceEntryCount; ++i)
- {
- reservedmarshal_VkVideoEncodeH265NaluSliceEXT(vkStream, rootType, (const VkVideoEncodeH265NaluSliceEXT*)(forMarshaling->pNaluSliceEntries + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->naluSliceEntryCount; ++i) {
+ reservedmarshal_VkVideoEncodeH265NaluSliceEXT(
+ vkStream, rootType,
+ (const VkVideoEncodeH265NaluSliceEXT*)(forMarshaling->pNaluSliceEntries + i), ptr);
}
- memcpy(*ptr, (const StdVideoEncodeH265PictureInfo*)forMarshaling->pCurrentPictureInfo, sizeof(const StdVideoEncodeH265PictureInfo));
+ memcpy(*ptr, (const StdVideoEncodeH265PictureInfo*)forMarshaling->pCurrentPictureInfo,
+ sizeof(const StdVideoEncodeH265PictureInfo));
*ptr += sizeof(const StdVideoEncodeH265PictureInfo);
}
void reservedmarshal_VkVideoEncodeH265EmitPictureParametersEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265EmitPictureParametersEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265EmitPictureParametersEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -11346,105 +10303,96 @@
*ptr += sizeof(VkBool32);
memcpy(*ptr, (uint32_t*)&forMarshaling->ppsIdEntryCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const uint8_t*)forMarshaling->ppsIdEntries, forMarshaling->ppsIdEntryCount * sizeof(const uint8_t));
+ memcpy(*ptr, (const uint8_t*)forMarshaling->ppsIdEntries,
+ forMarshaling->ppsIdEntryCount * sizeof(const uint8_t));
*ptr += forMarshaling->ppsIdEntryCount * sizeof(const uint8_t);
}
-void reservedmarshal_VkVideoEncodeH265ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265ProfileEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkVideoEncodeH265ProfileEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkVideoEncodeH265ProfileEXT* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (StdVideoH265ProfileIdc*)&forMarshaling->stdProfileIdc, sizeof(StdVideoH265ProfileIdc));
+ memcpy(*ptr, (StdVideoH265ProfileIdc*)&forMarshaling->stdProfileIdc,
+ sizeof(StdVideoH265ProfileIdc));
*ptr += sizeof(StdVideoH265ProfileIdc);
}
#endif
#ifdef VK_EXT_video_decode_h264
-void reservedmarshal_VkVideoDecodeH264ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264ProfileEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkVideoDecodeH264ProfileEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkVideoDecodeH264ProfileEXT* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (StdVideoH264ProfileIdc*)&forMarshaling->stdProfileIdc, sizeof(StdVideoH264ProfileIdc));
+ memcpy(*ptr, (StdVideoH264ProfileIdc*)&forMarshaling->stdProfileIdc,
+ sizeof(StdVideoH264ProfileIdc));
*ptr += sizeof(StdVideoH264ProfileIdc);
- memcpy(*ptr, (VkVideoDecodeH264PictureLayoutFlagsEXT*)&forMarshaling->pictureLayout, sizeof(VkVideoDecodeH264PictureLayoutFlagsEXT));
+ memcpy(*ptr, (VkVideoDecodeH264PictureLayoutFlagsEXT*)&forMarshaling->pictureLayout,
+ sizeof(VkVideoDecodeH264PictureLayoutFlagsEXT));
*ptr += sizeof(VkVideoDecodeH264PictureLayoutFlagsEXT);
}
void reservedmarshal_VkVideoDecodeH264CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264CapabilitiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264CapabilitiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxLevel, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- reservedmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->fieldOffsetGranularity), ptr);
- reservedmarshal_VkExtensionProperties(vkStream, rootType, (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion), ptr);
+ reservedmarshal_VkOffset2D(vkStream, rootType,
+ (VkOffset2D*)(&forMarshaling->fieldOffsetGranularity), ptr);
+ reservedmarshal_VkExtensionProperties(
+ vkStream, rootType, (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion), ptr);
}
void reservedmarshal_VkVideoDecodeH264SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264SessionCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264SessionCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkVideoDecodeH264CreateFlagsEXT*)&forMarshaling->flags, sizeof(VkVideoDecodeH264CreateFlagsEXT));
+ memcpy(*ptr, (VkVideoDecodeH264CreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkVideoDecodeH264CreateFlagsEXT));
*ptr += sizeof(VkVideoDecodeH264CreateFlagsEXT);
- reservedmarshal_VkExtensionProperties(vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion), ptr);
+ reservedmarshal_VkExtensionProperties(
+ vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion),
+ ptr);
}
void reservedmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264SessionParametersAddInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264SessionParametersAddInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -11455,9 +10403,9 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pSpsStd)
- {
- memcpy(*ptr, (const StdVideoH264SequenceParameterSet*)forMarshaling->pSpsStd, forMarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
+ if (forMarshaling->pSpsStd) {
+ memcpy(*ptr, (const StdVideoH264SequenceParameterSet*)forMarshaling->pSpsStd,
+ forMarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
*ptr += forMarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->ppsStdCount, sizeof(uint32_t));
@@ -11467,25 +10415,21 @@
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pPpsStd)
- {
- memcpy(*ptr, (const StdVideoH264PictureParameterSet*)forMarshaling->pPpsStd, forMarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
+ if (forMarshaling->pPpsStd) {
+ memcpy(*ptr, (const StdVideoH264PictureParameterSet*)forMarshaling->pPpsStd,
+ forMarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
*ptr += forMarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet);
}
}
void reservedmarshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264SessionParametersCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264SessionParametersCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -11498,87 +10442,78 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pParametersAddInfo)
- {
- reservedmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(vkStream, rootType, (const VkVideoDecodeH264SessionParametersAddInfoEXT*)(forMarshaling->pParametersAddInfo), ptr);
+ if (forMarshaling->pParametersAddInfo) {
+ reservedmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ (const VkVideoDecodeH264SessionParametersAddInfoEXT*)(forMarshaling
+ ->pParametersAddInfo),
+ ptr);
}
}
void reservedmarshal_VkVideoDecodeH264PictureInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264PictureInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264PictureInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (const StdVideoDecodeH264PictureInfo*)forMarshaling->pStdPictureInfo, sizeof(const StdVideoDecodeH264PictureInfo));
+ memcpy(*ptr, (const StdVideoDecodeH264PictureInfo*)forMarshaling->pStdPictureInfo,
+ sizeof(const StdVideoDecodeH264PictureInfo));
*ptr += sizeof(const StdVideoDecodeH264PictureInfo);
memcpy(*ptr, (uint32_t*)&forMarshaling->slicesCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const uint32_t*)forMarshaling->pSlicesDataOffsets, forMarshaling->slicesCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pSlicesDataOffsets,
+ forMarshaling->slicesCount * sizeof(const uint32_t));
*ptr += forMarshaling->slicesCount * sizeof(const uint32_t);
}
-void reservedmarshal_VkVideoDecodeH264MvcEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264MvcEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkVideoDecodeH264MvcEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264MvcEXT* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (const StdVideoDecodeH264Mvc*)forMarshaling->pStdMvc, sizeof(const StdVideoDecodeH264Mvc));
+ memcpy(*ptr, (const StdVideoDecodeH264Mvc*)forMarshaling->pStdMvc,
+ sizeof(const StdVideoDecodeH264Mvc));
*ptr += sizeof(const StdVideoDecodeH264Mvc);
}
void reservedmarshal_VkVideoDecodeH264DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264DpbSlotInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264DpbSlotInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (const StdVideoDecodeH264ReferenceInfo*)forMarshaling->pStdReferenceInfo, sizeof(const StdVideoDecodeH264ReferenceInfo));
+ memcpy(*ptr, (const StdVideoDecodeH264ReferenceInfo*)forMarshaling->pStdReferenceInfo,
+ sizeof(const StdVideoDecodeH264ReferenceInfo));
*ptr += sizeof(const StdVideoDecodeH264ReferenceInfo);
}
#endif
#ifdef VK_AMD_texture_gather_bias_lod
void reservedmarshal_VkTextureLODGatherFormatPropertiesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkTextureLODGatherFormatPropertiesAMD* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkTextureLODGatherFormatPropertiesAMD* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -11588,12 +10523,9 @@
#endif
#ifdef VK_AMD_shader_info
-void reservedmarshal_VkShaderResourceUsageAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkShaderResourceUsageAMD* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkShaderResourceUsageAMD(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkShaderResourceUsageAMD* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->numUsedVgprs, sizeof(uint32_t));
@@ -11612,17 +10544,16 @@
*ptr += 8;
}
-void reservedmarshal_VkShaderStatisticsInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkShaderStatisticsInfoAMD* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkShaderStatisticsInfoAMD(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkShaderStatisticsInfoAMD* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->shaderStageMask, sizeof(VkShaderStageFlags));
*ptr += sizeof(VkShaderStageFlags);
- reservedmarshal_VkShaderResourceUsageAMD(vkStream, rootType, (VkShaderResourceUsageAMD*)(&forMarshaling->resourceUsage), ptr);
+ reservedmarshal_VkShaderResourceUsageAMD(
+ vkStream, rootType, (VkShaderResourceUsageAMD*)(&forMarshaling->resourceUsage), ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->numPhysicalVgprs, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->numPhysicalSgprs, sizeof(uint32_t));
@@ -11640,40 +10571,34 @@
#endif
#ifdef VK_GGP_stream_descriptor_surface
void reservedmarshal_VkStreamDescriptorSurfaceCreateInfoGGP(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkStreamDescriptorSurfaceCreateInfoGGP* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkStreamDescriptorSurfaceCreateInfoGGP* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkStreamDescriptorSurfaceCreateFlagsGGP*)&forMarshaling->flags, sizeof(VkStreamDescriptorSurfaceCreateFlagsGGP));
+ memcpy(*ptr, (VkStreamDescriptorSurfaceCreateFlagsGGP*)&forMarshaling->flags,
+ sizeof(VkStreamDescriptorSurfaceCreateFlagsGGP));
*ptr += sizeof(VkStreamDescriptorSurfaceCreateFlagsGGP);
- memcpy(*ptr, (GgpStreamDescriptor*)&forMarshaling->streamDescriptor, sizeof(GgpStreamDescriptor));
+ memcpy(*ptr, (GgpStreamDescriptor*)&forMarshaling->streamDescriptor,
+ sizeof(GgpStreamDescriptor));
*ptr += sizeof(GgpStreamDescriptor);
}
#endif
#ifdef VK_NV_corner_sampled_image
void reservedmarshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCornerSampledImageFeaturesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCornerSampledImageFeaturesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -11686,97 +10611,86 @@
#endif
#ifdef VK_NV_external_memory_capabilities
void reservedmarshal_VkExternalImageFormatPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalImageFormatPropertiesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalImageFormatPropertiesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- reservedmarshal_VkImageFormatProperties(vkStream, rootType, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties), ptr);
- memcpy(*ptr, (VkExternalMemoryFeatureFlagsNV*)&forMarshaling->externalMemoryFeatures, sizeof(VkExternalMemoryFeatureFlagsNV));
+ reservedmarshal_VkImageFormatProperties(
+ vkStream, rootType, (VkImageFormatProperties*)(&forMarshaling->imageFormatProperties), ptr);
+ memcpy(*ptr, (VkExternalMemoryFeatureFlagsNV*)&forMarshaling->externalMemoryFeatures,
+ sizeof(VkExternalMemoryFeatureFlagsNV));
*ptr += sizeof(VkExternalMemoryFeatureFlagsNV);
- memcpy(*ptr, (VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->exportFromImportedHandleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ memcpy(*ptr, (VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->exportFromImportedHandleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlagsNV));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagsNV);
- memcpy(*ptr, (VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->compatibleHandleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ memcpy(*ptr, (VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->compatibleHandleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlagsNV));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagsNV);
}
#endif
#ifdef VK_NV_external_memory
void reservedmarshal_VkExternalMemoryImageCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalMemoryImageCreateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalMemoryImageCreateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ memcpy(*ptr, (VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlagsNV));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagsNV);
}
-void reservedmarshal_VkExportMemoryAllocateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportMemoryAllocateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkExportMemoryAllocateInfoNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkExportMemoryAllocateInfoNV* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleTypes, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ memcpy(*ptr, (VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleTypes,
+ sizeof(VkExternalMemoryHandleTypeFlagsNV));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagsNV);
}
#endif
#ifdef VK_NV_external_memory_win32
void reservedmarshal_VkImportMemoryWin32HandleInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportMemoryWin32HandleInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportMemoryWin32HandleInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagsNV));
+ memcpy(*ptr, (VkExternalMemoryHandleTypeFlagsNV*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagsNV));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagsNV);
memcpy(*ptr, (HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
*ptr += sizeof(HANDLE);
}
void reservedmarshal_VkExportMemoryWin32HandleInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportMemoryWin32HandleInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportMemoryWin32HandleInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -11785,9 +10699,9 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pAttributes)
- {
- memcpy(*ptr, (const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
+ if (forMarshaling->pAttributes) {
+ memcpy(*ptr, (const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes,
+ sizeof(const SECURITY_ATTRIBUTES));
*ptr += sizeof(const SECURITY_ATTRIBUTES);
}
memcpy(*ptr, (DWORD*)&forMarshaling->dwAccess, sizeof(DWORD));
@@ -11797,107 +10711,93 @@
#endif
#ifdef VK_NV_win32_keyed_mutex
void reservedmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWin32KeyedMutexAcquireReleaseInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWin32KeyedMutexAcquireReleaseInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->acquireCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- if (forMarshaling->acquireCount)
- {
+ if (forMarshaling->acquireCount) {
uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->acquireCount; ++k)
- {
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->acquireCount; ++k) {
uint64_t tmpval = get_host_u64_VkDeviceMemory(forMarshaling->pAcquireSyncs[k]);
memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
}
*ptr += 8 * forMarshaling->acquireCount;
}
- memcpy(*ptr, (const uint64_t*)forMarshaling->pAcquireKeys, forMarshaling->acquireCount * sizeof(const uint64_t));
+ memcpy(*ptr, (const uint64_t*)forMarshaling->pAcquireKeys,
+ forMarshaling->acquireCount * sizeof(const uint64_t));
*ptr += forMarshaling->acquireCount * sizeof(const uint64_t);
- memcpy(*ptr, (const uint32_t*)forMarshaling->pAcquireTimeoutMilliseconds, forMarshaling->acquireCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pAcquireTimeoutMilliseconds,
+ forMarshaling->acquireCount * sizeof(const uint32_t));
*ptr += forMarshaling->acquireCount * sizeof(const uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->releaseCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- if (forMarshaling->releaseCount)
- {
+ if (forMarshaling->releaseCount) {
uint8_t* cgen_var_1_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->releaseCount; ++k)
- {
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->releaseCount; ++k) {
uint64_t tmpval = get_host_u64_VkDeviceMemory(forMarshaling->pReleaseSyncs[k]);
memcpy(cgen_var_1_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
}
*ptr += 8 * forMarshaling->releaseCount;
}
- memcpy(*ptr, (const uint64_t*)forMarshaling->pReleaseKeys, forMarshaling->releaseCount * sizeof(const uint64_t));
+ memcpy(*ptr, (const uint64_t*)forMarshaling->pReleaseKeys,
+ forMarshaling->releaseCount * sizeof(const uint64_t));
*ptr += forMarshaling->releaseCount * sizeof(const uint64_t);
}
#endif
#ifdef VK_EXT_validation_flags
-void reservedmarshal_VkValidationFlagsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkValidationFlagsEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkValidationFlagsEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkValidationFlagsEXT* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->disabledValidationCheckCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const VkValidationCheckEXT*)forMarshaling->pDisabledValidationChecks, forMarshaling->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
+ memcpy(*ptr, (const VkValidationCheckEXT*)forMarshaling->pDisabledValidationChecks,
+ forMarshaling->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT));
*ptr += forMarshaling->disabledValidationCheckCount * sizeof(const VkValidationCheckEXT);
}
#endif
#ifdef VK_NN_vi_surface
-void reservedmarshal_VkViSurfaceCreateInfoNN(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkViSurfaceCreateInfoNN* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkViSurfaceCreateInfoNN(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkViSurfaceCreateInfoNN* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkViSurfaceCreateFlagsNN*)&forMarshaling->flags, sizeof(VkViSurfaceCreateFlagsNN));
+ memcpy(*ptr, (VkViSurfaceCreateFlagsNN*)&forMarshaling->flags,
+ sizeof(VkViSurfaceCreateFlagsNN));
*ptr += sizeof(VkViSurfaceCreateFlagsNN);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->window;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->window)
- {
+ if (forMarshaling->window) {
memcpy(*ptr, (void*)forMarshaling->window, sizeof(uint8_t));
*ptr += sizeof(uint8_t);
}
@@ -11910,17 +10810,13 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
void reservedmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -11930,18 +10826,15 @@
#endif
#ifdef VK_EXT_astc_decode_mode
-void reservedmarshal_VkImageViewASTCDecodeModeEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageViewASTCDecodeModeEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImageViewASTCDecodeModeEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkImageViewASTCDecodeModeEXT* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -11950,17 +10843,13 @@
}
void reservedmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceASTCDecodeFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceASTCDecodeFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -11971,17 +10860,13 @@
#endif
#ifdef VK_EXT_conditional_rendering
void reservedmarshal_VkConditionalRenderingBeginInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkConditionalRenderingBeginInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkConditionalRenderingBeginInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -11991,22 +10876,19 @@
*ptr += 1 * 8;
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
- memcpy(*ptr, (VkConditionalRenderingFlagsEXT*)&forMarshaling->flags, sizeof(VkConditionalRenderingFlagsEXT));
+ memcpy(*ptr, (VkConditionalRenderingFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkConditionalRenderingFlagsEXT));
*ptr += sizeof(VkConditionalRenderingFlagsEXT);
}
void reservedmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceConditionalRenderingFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceConditionalRenderingFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -12017,17 +10899,13 @@
}
void reservedmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferInheritanceConditionalRenderingInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferInheritanceConditionalRenderingInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -12037,12 +10915,9 @@
#endif
#ifdef VK_NV_clip_space_w_scaling
-void reservedmarshal_VkViewportWScalingNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkViewportWScalingNV* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkViewportWScalingNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkViewportWScalingNV* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (float*)&forMarshaling->xcoeff, sizeof(float));
@@ -12052,17 +10927,13 @@
}
void reservedmarshal_VkPipelineViewportWScalingStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineViewportWScalingStateCreateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineViewportWScalingStateCreateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -12075,11 +10946,11 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pViewportWScalings)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
- {
- reservedmarshal_VkViewportWScalingNV(vkStream, rootType, (const VkViewportWScalingNV*)(forMarshaling->pViewportWScalings + i), ptr);
+ if (forMarshaling->pViewportWScalings) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i) {
+ reservedmarshal_VkViewportWScalingNV(
+ vkStream, rootType,
+ (const VkViewportWScalingNV*)(forMarshaling->pViewportWScalings + i), ptr);
}
}
}
@@ -12090,18 +10961,15 @@
#ifdef VK_EXT_acquire_xlib_display
#endif
#ifdef VK_EXT_display_surface_counter
-void reservedmarshal_VkSurfaceCapabilities2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceCapabilities2EXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSurfaceCapabilities2EXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkSurfaceCapabilities2EXT* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -12109,56 +10977,57 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxImageCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->currentExtent), ptr);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minImageExtent), ptr);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxImageExtent), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->currentExtent),
+ ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minImageExtent),
+ ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxImageExtent),
+ ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxImageArrayLayers, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms, sizeof(VkSurfaceTransformFlagsKHR));
+ memcpy(*ptr, (VkSurfaceTransformFlagsKHR*)&forMarshaling->supportedTransforms,
+ sizeof(VkSurfaceTransformFlagsKHR));
*ptr += sizeof(VkSurfaceTransformFlagsKHR);
- memcpy(*ptr, (VkSurfaceTransformFlagBitsKHR*)&forMarshaling->currentTransform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ memcpy(*ptr, (VkSurfaceTransformFlagBitsKHR*)&forMarshaling->currentTransform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
*ptr += sizeof(VkSurfaceTransformFlagBitsKHR);
- memcpy(*ptr, (VkCompositeAlphaFlagsKHR*)&forMarshaling->supportedCompositeAlpha, sizeof(VkCompositeAlphaFlagsKHR));
+ memcpy(*ptr, (VkCompositeAlphaFlagsKHR*)&forMarshaling->supportedCompositeAlpha,
+ sizeof(VkCompositeAlphaFlagsKHR));
*ptr += sizeof(VkCompositeAlphaFlagsKHR);
- memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->supportedUsageFlags, sizeof(VkImageUsageFlags));
+ memcpy(*ptr, (VkImageUsageFlags*)&forMarshaling->supportedUsageFlags,
+ sizeof(VkImageUsageFlags));
*ptr += sizeof(VkImageUsageFlags);
- memcpy(*ptr, (VkSurfaceCounterFlagsEXT*)&forMarshaling->supportedSurfaceCounters, sizeof(VkSurfaceCounterFlagsEXT));
+ memcpy(*ptr, (VkSurfaceCounterFlagsEXT*)&forMarshaling->supportedSurfaceCounters,
+ sizeof(VkSurfaceCounterFlagsEXT));
*ptr += sizeof(VkSurfaceCounterFlagsEXT);
}
#endif
#ifdef VK_EXT_display_control
-void reservedmarshal_VkDisplayPowerInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPowerInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDisplayPowerInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPowerInfoEXT* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDisplayPowerStateEXT*)&forMarshaling->powerState, sizeof(VkDisplayPowerStateEXT));
+ memcpy(*ptr, (VkDisplayPowerStateEXT*)&forMarshaling->powerState,
+ sizeof(VkDisplayPowerStateEXT));
*ptr += sizeof(VkDisplayPowerStateEXT);
}
-void reservedmarshal_VkDeviceEventInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceEventInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDeviceEventInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceEventInfoEXT* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -12166,52 +11035,44 @@
*ptr += sizeof(VkDeviceEventTypeEXT);
}
-void reservedmarshal_VkDisplayEventInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayEventInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDisplayEventInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayEventInfoEXT* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDisplayEventTypeEXT*)&forMarshaling->displayEvent, sizeof(VkDisplayEventTypeEXT));
+ memcpy(*ptr, (VkDisplayEventTypeEXT*)&forMarshaling->displayEvent,
+ sizeof(VkDisplayEventTypeEXT));
*ptr += sizeof(VkDisplayEventTypeEXT);
}
void reservedmarshal_VkSwapchainCounterCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSwapchainCounterCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSwapchainCounterCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkSurfaceCounterFlagsEXT*)&forMarshaling->surfaceCounters, sizeof(VkSurfaceCounterFlagsEXT));
+ memcpy(*ptr, (VkSurfaceCounterFlagsEXT*)&forMarshaling->surfaceCounters,
+ sizeof(VkSurfaceCounterFlagsEXT));
*ptr += sizeof(VkSurfaceCounterFlagsEXT);
}
#endif
#ifdef VK_GOOGLE_display_timing
-void reservedmarshal_VkRefreshCycleDurationGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRefreshCycleDurationGOOGLE* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkRefreshCycleDurationGOOGLE(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkRefreshCycleDurationGOOGLE* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint64_t*)&forMarshaling->refreshDuration, sizeof(uint64_t));
@@ -12219,11 +11080,8 @@
}
void reservedmarshal_VkPastPresentationTimingGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPastPresentationTimingGOOGLE* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPastPresentationTimingGOOGLE* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->presentID, sizeof(uint32_t));
@@ -12238,12 +11096,8 @@
*ptr += sizeof(uint64_t);
}
-void reservedmarshal_VkPresentTimeGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentTimeGOOGLE* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPresentTimeGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentTimeGOOGLE* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->presentID, sizeof(uint32_t));
@@ -12252,18 +11106,14 @@
*ptr += sizeof(uint64_t);
}
-void reservedmarshal_VkPresentTimesInfoGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentTimesInfoGOOGLE* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPresentTimesInfoGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentTimesInfoGOOGLE* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -12274,11 +11124,10 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pTimes)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i)
- {
- reservedmarshal_VkPresentTimeGOOGLE(vkStream, rootType, (const VkPresentTimeGOOGLE*)(forMarshaling->pTimes + i), ptr);
+ if (forMarshaling->pTimes) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i) {
+ reservedmarshal_VkPresentTimeGOOGLE(
+ vkStream, rootType, (const VkPresentTimeGOOGLE*)(forMarshaling->pTimes + i), ptr);
}
}
}
@@ -12292,17 +11141,13 @@
#endif
#ifdef VK_NVX_multiview_per_view_attributes
void reservedmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -12312,40 +11157,37 @@
#endif
#ifdef VK_NV_viewport_swizzle
-void reservedmarshal_VkViewportSwizzleNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkViewportSwizzleNV* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkViewportSwizzleNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkViewportSwizzleNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- memcpy(*ptr, (VkViewportCoordinateSwizzleNV*)&forMarshaling->x, sizeof(VkViewportCoordinateSwizzleNV));
+ memcpy(*ptr, (VkViewportCoordinateSwizzleNV*)&forMarshaling->x,
+ sizeof(VkViewportCoordinateSwizzleNV));
*ptr += sizeof(VkViewportCoordinateSwizzleNV);
- memcpy(*ptr, (VkViewportCoordinateSwizzleNV*)&forMarshaling->y, sizeof(VkViewportCoordinateSwizzleNV));
+ memcpy(*ptr, (VkViewportCoordinateSwizzleNV*)&forMarshaling->y,
+ sizeof(VkViewportCoordinateSwizzleNV));
*ptr += sizeof(VkViewportCoordinateSwizzleNV);
- memcpy(*ptr, (VkViewportCoordinateSwizzleNV*)&forMarshaling->z, sizeof(VkViewportCoordinateSwizzleNV));
+ memcpy(*ptr, (VkViewportCoordinateSwizzleNV*)&forMarshaling->z,
+ sizeof(VkViewportCoordinateSwizzleNV));
*ptr += sizeof(VkViewportCoordinateSwizzleNV);
- memcpy(*ptr, (VkViewportCoordinateSwizzleNV*)&forMarshaling->w, sizeof(VkViewportCoordinateSwizzleNV));
+ memcpy(*ptr, (VkViewportCoordinateSwizzleNV*)&forMarshaling->w,
+ sizeof(VkViewportCoordinateSwizzleNV));
*ptr += sizeof(VkViewportCoordinateSwizzleNV);
}
void reservedmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineViewportSwizzleStateCreateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineViewportSwizzleStateCreateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineViewportSwizzleStateCreateFlagsNV*)&forMarshaling->flags, sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV));
+ memcpy(*ptr, (VkPipelineViewportSwizzleStateCreateFlagsNV*)&forMarshaling->flags,
+ sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV));
*ptr += sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV);
memcpy(*ptr, (uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -12354,11 +11196,11 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pViewportSwizzles)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
- {
- reservedmarshal_VkViewportSwizzleNV(vkStream, rootType, (const VkViewportSwizzleNV*)(forMarshaling->pViewportSwizzles + i), ptr);
+ if (forMarshaling->pViewportSwizzles) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i) {
+ reservedmarshal_VkViewportSwizzleNV(
+ vkStream, rootType,
+ (const VkViewportSwizzleNV*)(forMarshaling->pViewportSwizzles + i), ptr);
}
}
}
@@ -12366,17 +11208,13 @@
#endif
#ifdef VK_EXT_discard_rectangles
void reservedmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDiscardRectanglePropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDiscardRectanglePropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -12385,23 +11223,21 @@
}
void reservedmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineDiscardRectangleStateCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineDiscardRectangleStateCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineDiscardRectangleStateCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkPipelineDiscardRectangleStateCreateFlagsEXT));
+ memcpy(*ptr, (VkPipelineDiscardRectangleStateCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkPipelineDiscardRectangleStateCreateFlagsEXT));
*ptr += sizeof(VkPipelineDiscardRectangleStateCreateFlagsEXT);
- memcpy(*ptr, (VkDiscardRectangleModeEXT*)&forMarshaling->discardRectangleMode, sizeof(VkDiscardRectangleModeEXT));
+ memcpy(*ptr, (VkDiscardRectangleModeEXT*)&forMarshaling->discardRectangleMode,
+ sizeof(VkDiscardRectangleModeEXT));
*ptr += sizeof(VkDiscardRectangleModeEXT);
memcpy(*ptr, (uint32_t*)&forMarshaling->discardRectangleCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -12410,11 +11246,10 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pDiscardRectangles)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->discardRectangleCount; ++i)
- {
- reservedmarshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pDiscardRectangles + i), ptr);
+ if (forMarshaling->pDiscardRectangles) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->discardRectangleCount; ++i) {
+ reservedmarshal_VkRect2D(vkStream, rootType,
+ (const VkRect2D*)(forMarshaling->pDiscardRectangles + i), ptr);
}
}
}
@@ -12422,17 +11257,13 @@
#endif
#ifdef VK_EXT_conservative_rasterization
void reservedmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -12440,40 +11271,42 @@
*ptr += sizeof(float);
memcpy(*ptr, (float*)&forMarshaling->maxExtraPrimitiveOverestimationSize, sizeof(float));
*ptr += sizeof(float);
- memcpy(*ptr, (float*)&forMarshaling->extraPrimitiveOverestimationSizeGranularity, sizeof(float));
+ memcpy(*ptr, (float*)&forMarshaling->extraPrimitiveOverestimationSizeGranularity,
+ sizeof(float));
*ptr += sizeof(float);
memcpy(*ptr, (VkBool32*)&forMarshaling->primitiveUnderestimation, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->conservativePointAndLineRasterization, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->conservativePointAndLineRasterization,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->degenerateTrianglesRasterized, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->degenerateLinesRasterized, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->fullyCoveredFragmentShaderInputVariable, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->fullyCoveredFragmentShaderInputVariable,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->conservativeRasterizationPostDepthCoverage, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->conservativeRasterizationPostDepthCoverage,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationConservativeStateCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationConservativeStateCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineRasterizationConservativeStateCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkPipelineRasterizationConservativeStateCreateFlagsEXT));
+ memcpy(*ptr, (VkPipelineRasterizationConservativeStateCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkPipelineRasterizationConservativeStateCreateFlagsEXT));
*ptr += sizeof(VkPipelineRasterizationConservativeStateCreateFlagsEXT);
- memcpy(*ptr, (VkConservativeRasterizationModeEXT*)&forMarshaling->conservativeRasterizationMode, sizeof(VkConservativeRasterizationModeEXT));
+ memcpy(*ptr, (VkConservativeRasterizationModeEXT*)&forMarshaling->conservativeRasterizationMode,
+ sizeof(VkConservativeRasterizationModeEXT));
*ptr += sizeof(VkConservativeRasterizationModeEXT);
memcpy(*ptr, (float*)&forMarshaling->extraPrimitiveOverestimationSize, sizeof(float));
*ptr += sizeof(float);
@@ -12482,17 +11315,13 @@
#endif
#ifdef VK_EXT_depth_clip_enable
void reservedmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -12501,21 +11330,18 @@
}
void reservedmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineRasterizationDepthClipStateCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT));
+ memcpy(*ptr, (VkPipelineRasterizationDepthClipStateCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT));
*ptr += sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT);
memcpy(*ptr, (VkBool32*)&forMarshaling->depthClipEnable, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -12525,12 +11351,8 @@
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
-void reservedmarshal_VkXYColorEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkXYColorEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkXYColorEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkXYColorEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (float*)&forMarshaling->x, sizeof(float));
@@ -12539,25 +11361,24 @@
*ptr += sizeof(float);
}
-void reservedmarshal_VkHdrMetadataEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkHdrMetadataEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkHdrMetadataEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkHdrMetadataEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkXYColorEXT(vkStream, rootType, (VkXYColorEXT*)(&forMarshaling->displayPrimaryRed), ptr);
- reservedmarshal_VkXYColorEXT(vkStream, rootType, (VkXYColorEXT*)(&forMarshaling->displayPrimaryGreen), ptr);
- reservedmarshal_VkXYColorEXT(vkStream, rootType, (VkXYColorEXT*)(&forMarshaling->displayPrimaryBlue), ptr);
- reservedmarshal_VkXYColorEXT(vkStream, rootType, (VkXYColorEXT*)(&forMarshaling->whitePoint), ptr);
+ reservedmarshal_VkXYColorEXT(vkStream, rootType,
+ (VkXYColorEXT*)(&forMarshaling->displayPrimaryRed), ptr);
+ reservedmarshal_VkXYColorEXT(vkStream, rootType,
+ (VkXYColorEXT*)(&forMarshaling->displayPrimaryGreen), ptr);
+ reservedmarshal_VkXYColorEXT(vkStream, rootType,
+ (VkXYColorEXT*)(&forMarshaling->displayPrimaryBlue), ptr);
+ reservedmarshal_VkXYColorEXT(vkStream, rootType, (VkXYColorEXT*)(&forMarshaling->whitePoint),
+ ptr);
memcpy(*ptr, (float*)&forMarshaling->maxLuminance, sizeof(float));
*ptr += sizeof(float);
memcpy(*ptr, (float*)&forMarshaling->minLuminance, sizeof(float));
@@ -12570,30 +11391,27 @@
#endif
#ifdef VK_MVK_ios_surface
-void reservedmarshal_VkIOSSurfaceCreateInfoMVK(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkIOSSurfaceCreateInfoMVK* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkIOSSurfaceCreateInfoMVK(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkIOSSurfaceCreateInfoMVK* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkIOSSurfaceCreateFlagsMVK*)&forMarshaling->flags, sizeof(VkIOSSurfaceCreateFlagsMVK));
+ memcpy(*ptr, (VkIOSSurfaceCreateFlagsMVK*)&forMarshaling->flags,
+ sizeof(VkIOSSurfaceCreateFlagsMVK));
*ptr += sizeof(VkIOSSurfaceCreateFlagsMVK);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pView;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pView)
- {
+ if (forMarshaling->pView) {
memcpy(*ptr, (const void*)forMarshaling->pView, sizeof(const uint8_t));
*ptr += sizeof(const uint8_t);
}
@@ -12601,30 +11419,27 @@
#endif
#ifdef VK_MVK_macos_surface
-void reservedmarshal_VkMacOSSurfaceCreateInfoMVK(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMacOSSurfaceCreateInfoMVK* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkMacOSSurfaceCreateInfoMVK(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkMacOSSurfaceCreateInfoMVK* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkMacOSSurfaceCreateFlagsMVK*)&forMarshaling->flags, sizeof(VkMacOSSurfaceCreateFlagsMVK));
+ memcpy(*ptr, (VkMacOSSurfaceCreateFlagsMVK*)&forMarshaling->flags,
+ sizeof(VkMacOSSurfaceCreateFlagsMVK));
*ptr += sizeof(VkMacOSSurfaceCreateFlagsMVK);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pView;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pView)
- {
+ if (forMarshaling->pView) {
memcpy(*ptr, (const void*)forMarshaling->pView, sizeof(const uint8_t));
*ptr += sizeof(const uint8_t);
}
@@ -12638,23 +11453,19 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
-void reservedmarshal_VkDebugUtilsLabelEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugUtilsLabelEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDebugUtilsLabelEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugUtilsLabelEXT* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
{
- uint32_t l = forMarshaling->pLabelName ? strlen(forMarshaling->pLabelName): 0;
+ uint32_t l = forMarshaling->pLabelName ? strlen(forMarshaling->pLabelName) : 0;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
@@ -12666,17 +11477,13 @@
}
void reservedmarshal_VkDebugUtilsObjectNameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugUtilsObjectNameInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugUtilsObjectNameInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -12684,17 +11491,15 @@
*ptr += sizeof(VkObjectType);
memcpy(*ptr, (uint64_t*)&forMarshaling->objectHandle, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
- {
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pObjectName;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pObjectName)
- {
+ if (forMarshaling->pObjectName) {
{
- uint32_t l = forMarshaling->pObjectName ? strlen(forMarshaling->pObjectName): 0;
+ uint32_t l = forMarshaling->pObjectName ? strlen(forMarshaling->pObjectName) : 0;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
@@ -12702,11 +11507,9 @@
*ptr += l;
}
}
- }
- else
- {
+ } else {
{
- uint32_t l = forMarshaling->pObjectName ? strlen(forMarshaling->pObjectName): 0;
+ uint32_t l = forMarshaling->pObjectName ? strlen(forMarshaling->pObjectName) : 0;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
@@ -12717,33 +11520,29 @@
}
void reservedmarshal_VkDebugUtilsMessengerCallbackDataEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugUtilsMessengerCallbackDataEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugUtilsMessengerCallbackDataEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDebugUtilsMessengerCallbackDataFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT));
+ memcpy(*ptr, (VkDebugUtilsMessengerCallbackDataFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT));
*ptr += sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT);
- if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
- {
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pMessageIdName;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pMessageIdName)
- {
+ if (forMarshaling->pMessageIdName) {
{
- uint32_t l = forMarshaling->pMessageIdName ? strlen(forMarshaling->pMessageIdName): 0;
+ uint32_t l =
+ forMarshaling->pMessageIdName ? strlen(forMarshaling->pMessageIdName) : 0;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
@@ -12751,11 +11550,9 @@
*ptr += l;
}
}
- }
- else
- {
+ } else {
{
- uint32_t l = forMarshaling->pMessageIdName ? strlen(forMarshaling->pMessageIdName): 0;
+ uint32_t l = forMarshaling->pMessageIdName ? strlen(forMarshaling->pMessageIdName) : 0;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
@@ -12766,7 +11563,7 @@
memcpy(*ptr, (int32_t*)&forMarshaling->messageIdNumber, sizeof(int32_t));
*ptr += sizeof(int32_t);
{
- uint32_t l = forMarshaling->pMessage ? strlen(forMarshaling->pMessage): 0;
+ uint32_t l = forMarshaling->pMessage ? strlen(forMarshaling->pMessage) : 0;
memcpy(*ptr, (uint32_t*)&l, sizeof(uint32_t));
android::base::Stream::toBe32((uint8_t*)*ptr);
*ptr += sizeof(uint32_t);
@@ -12780,11 +11577,10 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pQueueLabels)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueLabelCount; ++i)
- {
- reservedmarshal_VkDebugUtilsLabelEXT(vkStream, rootType, (VkDebugUtilsLabelEXT*)(forMarshaling->pQueueLabels + i), ptr);
+ if (forMarshaling->pQueueLabels) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueLabelCount; ++i) {
+ reservedmarshal_VkDebugUtilsLabelEXT(
+ vkStream, rootType, (VkDebugUtilsLabelEXT*)(forMarshaling->pQueueLabels + i), ptr);
}
}
memcpy(*ptr, (uint32_t*)&forMarshaling->cmdBufLabelCount, sizeof(uint32_t));
@@ -12794,11 +11590,10 @@
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pCmdBufLabels)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->cmdBufLabelCount; ++i)
- {
- reservedmarshal_VkDebugUtilsLabelEXT(vkStream, rootType, (VkDebugUtilsLabelEXT*)(forMarshaling->pCmdBufLabels + i), ptr);
+ if (forMarshaling->pCmdBufLabels) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->cmdBufLabelCount; ++i) {
+ reservedmarshal_VkDebugUtilsLabelEXT(
+ vkStream, rootType, (VkDebugUtilsLabelEXT*)(forMarshaling->pCmdBufLabels + i), ptr);
}
}
memcpy(*ptr, (uint32_t*)&forMarshaling->objectCount, sizeof(uint32_t));
@@ -12808,35 +11603,34 @@
memcpy((*ptr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pObjects)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->objectCount; ++i)
- {
- reservedmarshal_VkDebugUtilsObjectNameInfoEXT(vkStream, rootType, (VkDebugUtilsObjectNameInfoEXT*)(forMarshaling->pObjects + i), ptr);
+ if (forMarshaling->pObjects) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->objectCount; ++i) {
+ reservedmarshal_VkDebugUtilsObjectNameInfoEXT(
+ vkStream, rootType, (VkDebugUtilsObjectNameInfoEXT*)(forMarshaling->pObjects + i),
+ ptr);
}
}
}
void reservedmarshal_VkDebugUtilsMessengerCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugUtilsMessengerCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugUtilsMessengerCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDebugUtilsMessengerCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugUtilsMessengerCreateFlagsEXT));
+ memcpy(*ptr, (VkDebugUtilsMessengerCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkDebugUtilsMessengerCreateFlagsEXT));
*ptr += sizeof(VkDebugUtilsMessengerCreateFlagsEXT);
- memcpy(*ptr, (VkDebugUtilsMessageSeverityFlagsEXT*)&forMarshaling->messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagsEXT));
+ memcpy(*ptr, (VkDebugUtilsMessageSeverityFlagsEXT*)&forMarshaling->messageSeverity,
+ sizeof(VkDebugUtilsMessageSeverityFlagsEXT));
*ptr += sizeof(VkDebugUtilsMessageSeverityFlagsEXT);
- memcpy(*ptr, (VkDebugUtilsMessageTypeFlagsEXT*)&forMarshaling->messageType, sizeof(VkDebugUtilsMessageTypeFlagsEXT));
+ memcpy(*ptr, (VkDebugUtilsMessageTypeFlagsEXT*)&forMarshaling->messageType,
+ sizeof(VkDebugUtilsMessageTypeFlagsEXT));
*ptr += sizeof(VkDebugUtilsMessageTypeFlagsEXT);
uint64_t cgen_var_0 = (uint64_t)forMarshaling->pfnUserCallback;
memcpy((*ptr), &cgen_var_0, 8);
@@ -12847,25 +11641,21 @@
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pUserData)
- {
+ if (forMarshaling->pUserData) {
memcpy(*ptr, (void*)forMarshaling->pUserData, sizeof(uint8_t));
*ptr += sizeof(uint8_t);
}
}
-void reservedmarshal_VkDebugUtilsObjectTagInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugUtilsObjectTagInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDebugUtilsObjectTagInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDebugUtilsObjectTagInfoEXT* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -12886,17 +11676,13 @@
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
void reservedmarshal_VkAndroidHardwareBufferUsageANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAndroidHardwareBufferUsageANDROID* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAndroidHardwareBufferUsageANDROID* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -12905,17 +11691,13 @@
}
void reservedmarshal_VkAndroidHardwareBufferPropertiesANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAndroidHardwareBufferPropertiesANDROID* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAndroidHardwareBufferPropertiesANDROID* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -12926,17 +11708,13 @@
}
void reservedmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAndroidHardwareBufferFormatPropertiesANDROID* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAndroidHardwareBufferFormatPropertiesANDROID* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -12944,31 +11722,34 @@
*ptr += sizeof(VkFormat);
memcpy(*ptr, (uint64_t*)&forMarshaling->externalFormat, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
- memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->formatFeatures, sizeof(VkFormatFeatureFlags));
+ memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->formatFeatures,
+ sizeof(VkFormatFeatureFlags));
*ptr += sizeof(VkFormatFeatureFlags);
- reservedmarshal_VkComponentMapping(vkStream, rootType, (VkComponentMapping*)(&forMarshaling->samplerYcbcrConversionComponents), ptr);
- memcpy(*ptr, (VkSamplerYcbcrModelConversion*)&forMarshaling->suggestedYcbcrModel, sizeof(VkSamplerYcbcrModelConversion));
+ reservedmarshal_VkComponentMapping(
+ vkStream, rootType, (VkComponentMapping*)(&forMarshaling->samplerYcbcrConversionComponents),
+ ptr);
+ memcpy(*ptr, (VkSamplerYcbcrModelConversion*)&forMarshaling->suggestedYcbcrModel,
+ sizeof(VkSamplerYcbcrModelConversion));
*ptr += sizeof(VkSamplerYcbcrModelConversion);
- memcpy(*ptr, (VkSamplerYcbcrRange*)&forMarshaling->suggestedYcbcrRange, sizeof(VkSamplerYcbcrRange));
+ memcpy(*ptr, (VkSamplerYcbcrRange*)&forMarshaling->suggestedYcbcrRange,
+ sizeof(VkSamplerYcbcrRange));
*ptr += sizeof(VkSamplerYcbcrRange);
- memcpy(*ptr, (VkChromaLocation*)&forMarshaling->suggestedXChromaOffset, sizeof(VkChromaLocation));
+ memcpy(*ptr, (VkChromaLocation*)&forMarshaling->suggestedXChromaOffset,
+ sizeof(VkChromaLocation));
*ptr += sizeof(VkChromaLocation);
- memcpy(*ptr, (VkChromaLocation*)&forMarshaling->suggestedYChromaOffset, sizeof(VkChromaLocation));
+ memcpy(*ptr, (VkChromaLocation*)&forMarshaling->suggestedYChromaOffset,
+ sizeof(VkChromaLocation));
*ptr += sizeof(VkChromaLocation);
}
void reservedmarshal_VkImportAndroidHardwareBufferInfoANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportAndroidHardwareBufferInfoANDROID* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportAndroidHardwareBufferInfoANDROID* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -12977,17 +11758,13 @@
}
void reservedmarshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryGetAndroidHardwareBufferInfoANDROID* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryGetAndroidHardwareBufferInfoANDROID* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -12997,18 +11774,14 @@
*ptr += 1 * 8;
}
-void reservedmarshal_VkExternalFormatANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalFormatANDROID* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkExternalFormatANDROID(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalFormatANDROID* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -13017,17 +11790,13 @@
}
void reservedmarshal_VkAndroidHardwareBufferFormatProperties2ANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAndroidHardwareBufferFormatProperties2ANDROID* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAndroidHardwareBufferFormatProperties2ANDROID* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -13035,16 +11804,23 @@
*ptr += sizeof(VkFormat);
memcpy(*ptr, (uint64_t*)&forMarshaling->externalFormat, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
- memcpy(*ptr, (VkFormatFeatureFlags2KHR*)&forMarshaling->formatFeatures, sizeof(VkFormatFeatureFlags2KHR));
+ memcpy(*ptr, (VkFormatFeatureFlags2KHR*)&forMarshaling->formatFeatures,
+ sizeof(VkFormatFeatureFlags2KHR));
*ptr += sizeof(VkFormatFeatureFlags2KHR);
- reservedmarshal_VkComponentMapping(vkStream, rootType, (VkComponentMapping*)(&forMarshaling->samplerYcbcrConversionComponents), ptr);
- memcpy(*ptr, (VkSamplerYcbcrModelConversion*)&forMarshaling->suggestedYcbcrModel, sizeof(VkSamplerYcbcrModelConversion));
+ reservedmarshal_VkComponentMapping(
+ vkStream, rootType, (VkComponentMapping*)(&forMarshaling->samplerYcbcrConversionComponents),
+ ptr);
+ memcpy(*ptr, (VkSamplerYcbcrModelConversion*)&forMarshaling->suggestedYcbcrModel,
+ sizeof(VkSamplerYcbcrModelConversion));
*ptr += sizeof(VkSamplerYcbcrModelConversion);
- memcpy(*ptr, (VkSamplerYcbcrRange*)&forMarshaling->suggestedYcbcrRange, sizeof(VkSamplerYcbcrRange));
+ memcpy(*ptr, (VkSamplerYcbcrRange*)&forMarshaling->suggestedYcbcrRange,
+ sizeof(VkSamplerYcbcrRange));
*ptr += sizeof(VkSamplerYcbcrRange);
- memcpy(*ptr, (VkChromaLocation*)&forMarshaling->suggestedXChromaOffset, sizeof(VkChromaLocation));
+ memcpy(*ptr, (VkChromaLocation*)&forMarshaling->suggestedXChromaOffset,
+ sizeof(VkChromaLocation));
*ptr += sizeof(VkChromaLocation);
- memcpy(*ptr, (VkChromaLocation*)&forMarshaling->suggestedYChromaOffset, sizeof(VkChromaLocation));
+ memcpy(*ptr, (VkChromaLocation*)&forMarshaling->suggestedYChromaOffset,
+ sizeof(VkChromaLocation));
*ptr += sizeof(VkChromaLocation);
}
@@ -13059,86 +11835,75 @@
#endif
#ifdef VK_EXT_inline_uniform_block
void reservedmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->inlineUniformBlock, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingInlineUniformBlockUpdateAfterBind, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingInlineUniformBlockUpdateAfterBind,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxInlineUniformBlockSize, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorInlineUniformBlocks, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorInlineUniformBlocks,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetInlineUniformBlocks, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInlineUniformBlocks, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInlineUniformBlocks,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
void reservedmarshal_VkWriteDescriptorSetInlineUniformBlockEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWriteDescriptorSetInlineUniformBlockEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWriteDescriptorSetInlineUniformBlockEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->dataSize, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const void*)forMarshaling->pData, forMarshaling->dataSize * sizeof(const uint8_t));
+ memcpy(*ptr, (const void*)forMarshaling->pData,
+ forMarshaling->dataSize * sizeof(const uint8_t));
*ptr += forMarshaling->dataSize * sizeof(const uint8_t);
}
void reservedmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -13150,12 +11915,8 @@
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
-void reservedmarshal_VkSampleLocationEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSampleLocationEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSampleLocationEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSampleLocationEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (float*)&forMarshaling->x, sizeof(float));
@@ -13164,125 +11925,119 @@
*ptr += sizeof(float);
}
-void reservedmarshal_VkSampleLocationsInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSampleLocationsInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSampleLocationsInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSampleLocationsInfoEXT* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->sampleLocationsPerPixel, sizeof(VkSampleCountFlagBits));
+ memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->sampleLocationsPerPixel,
+ sizeof(VkSampleCountFlagBits));
*ptr += sizeof(VkSampleCountFlagBits);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->sampleLocationGridSize), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->sampleLocationGridSize), ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->sampleLocationsCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->sampleLocationsCount; ++i)
- {
- reservedmarshal_VkSampleLocationEXT(vkStream, rootType, (const VkSampleLocationEXT*)(forMarshaling->pSampleLocations + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->sampleLocationsCount; ++i) {
+ reservedmarshal_VkSampleLocationEXT(
+ vkStream, rootType, (const VkSampleLocationEXT*)(forMarshaling->pSampleLocations + i),
+ ptr);
}
}
void reservedmarshal_VkAttachmentSampleLocationsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentSampleLocationsEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentSampleLocationsEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->attachmentIndex, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- reservedmarshal_VkSampleLocationsInfoEXT(vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo), ptr);
+ reservedmarshal_VkSampleLocationsInfoEXT(
+ vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo), ptr);
}
-void reservedmarshal_VkSubpassSampleLocationsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassSampleLocationsEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSubpassSampleLocationsEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkSubpassSampleLocationsEXT* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->subpassIndex, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- reservedmarshal_VkSampleLocationsInfoEXT(vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo), ptr);
+ reservedmarshal_VkSampleLocationsInfoEXT(
+ vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo), ptr);
}
void reservedmarshal_VkRenderPassSampleLocationsBeginInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassSampleLocationsBeginInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassSampleLocationsBeginInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (uint32_t*)&forMarshaling->attachmentInitialSampleLocationsCount, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->attachmentInitialSampleLocationsCount,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentInitialSampleLocationsCount; ++i)
- {
- reservedmarshal_VkAttachmentSampleLocationsEXT(vkStream, rootType, (const VkAttachmentSampleLocationsEXT*)(forMarshaling->pAttachmentInitialSampleLocations + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->attachmentInitialSampleLocationsCount; ++i) {
+ reservedmarshal_VkAttachmentSampleLocationsEXT(
+ vkStream, rootType,
+ (const VkAttachmentSampleLocationsEXT*)(forMarshaling
+ ->pAttachmentInitialSampleLocations +
+ i),
+ ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->postSubpassSampleLocationsCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->postSubpassSampleLocationsCount; ++i)
- {
- reservedmarshal_VkSubpassSampleLocationsEXT(vkStream, rootType, (const VkSubpassSampleLocationsEXT*)(forMarshaling->pPostSubpassSampleLocations + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->postSubpassSampleLocationsCount; ++i) {
+ reservedmarshal_VkSubpassSampleLocationsEXT(
+ vkStream, rootType,
+ (const VkSubpassSampleLocationsEXT*)(forMarshaling->pPostSubpassSampleLocations + i),
+ ptr);
}
}
void reservedmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineSampleLocationsStateCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineSampleLocationsStateCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->sampleLocationsEnable, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- reservedmarshal_VkSampleLocationsInfoEXT(vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo), ptr);
+ reservedmarshal_VkSampleLocationsInfoEXT(
+ vkStream, rootType, (VkSampleLocationsInfoEXT*)(&forMarshaling->sampleLocationsInfo), ptr);
}
void reservedmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSampleLocationsPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSampleLocationsPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->sampleLocationSampleCounts, sizeof(VkSampleCountFlags));
+ memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->sampleLocationSampleCounts,
+ sizeof(VkSampleCountFlags));
*ptr += sizeof(VkSampleCountFlags);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxSampleLocationGridSize), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->maxSampleLocationGridSize), ptr);
memcpy(*ptr, (float*)forMarshaling->sampleLocationCoordinateRange, 2 * sizeof(float));
*ptr += 2 * sizeof(float);
memcpy(*ptr, (uint32_t*)&forMarshaling->sampleLocationSubPixelBits, sizeof(uint32_t));
@@ -13291,38 +12046,32 @@
*ptr += sizeof(VkBool32);
}
-void reservedmarshal_VkMultisamplePropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMultisamplePropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkMultisamplePropertiesEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkMultisamplePropertiesEXT* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxSampleLocationGridSize), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->maxSampleLocationGridSize), ptr);
}
#endif
#ifdef VK_EXT_blend_operation_advanced
void reservedmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -13331,17 +12080,13 @@
}
void reservedmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -13349,9 +12094,11 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (VkBool32*)&forMarshaling->advancedBlendIndependentBlend, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->advancedBlendNonPremultipliedSrcColor, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->advancedBlendNonPremultipliedSrcColor,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->advancedBlendNonPremultipliedDstColor, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->advancedBlendNonPremultipliedDstColor,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->advancedBlendCorrelatedOverlap, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -13360,17 +12107,13 @@
}
void reservedmarshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineColorBlendAdvancedStateCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineColorBlendAdvancedStateCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -13385,21 +12128,18 @@
#endif
#ifdef VK_NV_fragment_coverage_to_color
void reservedmarshal_VkPipelineCoverageToColorStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCoverageToColorStateCreateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCoverageToColorStateCreateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineCoverageToColorStateCreateFlagsNV*)&forMarshaling->flags, sizeof(VkPipelineCoverageToColorStateCreateFlagsNV));
+ memcpy(*ptr, (VkPipelineCoverageToColorStateCreateFlagsNV*)&forMarshaling->flags,
+ sizeof(VkPipelineCoverageToColorStateCreateFlagsNV));
*ptr += sizeof(VkPipelineCoverageToColorStateCreateFlagsNV);
memcpy(*ptr, (VkBool32*)&forMarshaling->coverageToColorEnable, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -13410,23 +12150,21 @@
#endif
#ifdef VK_NV_framebuffer_mixed_samples
void reservedmarshal_VkPipelineCoverageModulationStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCoverageModulationStateCreateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCoverageModulationStateCreateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineCoverageModulationStateCreateFlagsNV*)&forMarshaling->flags, sizeof(VkPipelineCoverageModulationStateCreateFlagsNV));
+ memcpy(*ptr, (VkPipelineCoverageModulationStateCreateFlagsNV*)&forMarshaling->flags,
+ sizeof(VkPipelineCoverageModulationStateCreateFlagsNV));
*ptr += sizeof(VkPipelineCoverageModulationStateCreateFlagsNV);
- memcpy(*ptr, (VkCoverageModulationModeNV*)&forMarshaling->coverageModulationMode, sizeof(VkCoverageModulationModeNV));
+ memcpy(*ptr, (VkCoverageModulationModeNV*)&forMarshaling->coverageModulationMode,
+ sizeof(VkCoverageModulationModeNV));
*ptr += sizeof(VkCoverageModulationModeNV);
memcpy(*ptr, (VkBool32*)&forMarshaling->coverageModulationTableEnable, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -13437,9 +12175,9 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pCoverageModulationTable)
- {
- memcpy(*ptr, (const float*)forMarshaling->pCoverageModulationTable, forMarshaling->coverageModulationTableCount * sizeof(const float));
+ if (forMarshaling->pCoverageModulationTable) {
+ memcpy(*ptr, (const float*)forMarshaling->pCoverageModulationTable,
+ forMarshaling->coverageModulationTableCount * sizeof(const float));
*ptr += forMarshaling->coverageModulationTableCount * sizeof(const float);
}
}
@@ -13449,17 +12187,13 @@
#endif
#ifdef VK_NV_shader_sm_builtins
void reservedmarshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -13470,17 +12204,13 @@
}
void reservedmarshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -13493,33 +12223,27 @@
#endif
#ifdef VK_EXT_image_drm_format_modifier
void reservedmarshal_VkDrmFormatModifierPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrmFormatModifierPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint64_t*)&forMarshaling->drmFormatModifier, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->drmFormatModifierPlaneCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->drmFormatModifierTilingFeatures, sizeof(VkFormatFeatureFlags));
+ memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->drmFormatModifierTilingFeatures,
+ sizeof(VkFormatFeatureFlags));
*ptr += sizeof(VkFormatFeatureFlags);
}
void reservedmarshal_VkDrmFormatModifierPropertiesListEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesListEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrmFormatModifierPropertiesListEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -13530,27 +12254,25 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pDrmFormatModifierProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->drmFormatModifierCount; ++i)
- {
- reservedmarshal_VkDrmFormatModifierPropertiesEXT(vkStream, rootType, (VkDrmFormatModifierPropertiesEXT*)(forMarshaling->pDrmFormatModifierProperties + i), ptr);
+ if (forMarshaling->pDrmFormatModifierProperties) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->drmFormatModifierCount; ++i) {
+ reservedmarshal_VkDrmFormatModifierPropertiesEXT(
+ vkStream, rootType,
+ (VkDrmFormatModifierPropertiesEXT*)(forMarshaling->pDrmFormatModifierProperties +
+ i),
+ ptr);
}
}
}
void reservedmarshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -13565,46 +12287,39 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pQueueFamilyIndices)
- {
- memcpy(*ptr, (const uint32_t*)forMarshaling->pQueueFamilyIndices, forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
+ if (forMarshaling->pQueueFamilyIndices) {
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pQueueFamilyIndices,
+ forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
*ptr += forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t);
}
}
void reservedmarshal_VkImageDrmFormatModifierListCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageDrmFormatModifierListCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageDrmFormatModifierListCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->drmFormatModifierCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const uint64_t*)forMarshaling->pDrmFormatModifiers, forMarshaling->drmFormatModifierCount * sizeof(const uint64_t));
+ memcpy(*ptr, (const uint64_t*)forMarshaling->pDrmFormatModifiers,
+ forMarshaling->drmFormatModifierCount * sizeof(const uint64_t));
*ptr += forMarshaling->drmFormatModifierCount * sizeof(const uint64_t);
}
void reservedmarshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageDrmFormatModifierExplicitCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageDrmFormatModifierExplicitCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -13612,24 +12327,21 @@
*ptr += sizeof(uint64_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->drmFormatModifierPlaneCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->drmFormatModifierPlaneCount; ++i)
- {
- reservedmarshal_VkSubresourceLayout(vkStream, rootType, (const VkSubresourceLayout*)(forMarshaling->pPlaneLayouts + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->drmFormatModifierPlaneCount; ++i) {
+ reservedmarshal_VkSubresourceLayout(
+ vkStream, rootType, (const VkSubresourceLayout*)(forMarshaling->pPlaneLayouts + i),
+ ptr);
}
}
void reservedmarshal_VkImageDrmFormatModifierPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageDrmFormatModifierPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageDrmFormatModifierPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -13638,33 +12350,27 @@
}
void reservedmarshal_VkDrmFormatModifierProperties2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrmFormatModifierProperties2EXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrmFormatModifierProperties2EXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint64_t*)&forMarshaling->drmFormatModifier, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->drmFormatModifierPlaneCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkFormatFeatureFlags2KHR*)&forMarshaling->drmFormatModifierTilingFeatures, sizeof(VkFormatFeatureFlags2KHR));
+ memcpy(*ptr, (VkFormatFeatureFlags2KHR*)&forMarshaling->drmFormatModifierTilingFeatures,
+ sizeof(VkFormatFeatureFlags2KHR));
*ptr += sizeof(VkFormatFeatureFlags2KHR);
}
void reservedmarshal_VkDrmFormatModifierPropertiesList2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesList2EXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrmFormatModifierPropertiesList2EXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -13675,11 +12381,13 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pDrmFormatModifierProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->drmFormatModifierCount; ++i)
- {
- reservedmarshal_VkDrmFormatModifierProperties2EXT(vkStream, rootType, (VkDrmFormatModifierProperties2EXT*)(forMarshaling->pDrmFormatModifierProperties + i), ptr);
+ if (forMarshaling->pDrmFormatModifierProperties) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->drmFormatModifierCount; ++i) {
+ reservedmarshal_VkDrmFormatModifierProperties2EXT(
+ vkStream, rootType,
+ (VkDrmFormatModifierProperties2EXT*)(forMarshaling->pDrmFormatModifierProperties +
+ i),
+ ptr);
}
}
}
@@ -13687,42 +12395,36 @@
#endif
#ifdef VK_EXT_validation_cache
void reservedmarshal_VkValidationCacheCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkValidationCacheCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkValidationCacheCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkValidationCacheCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkValidationCacheCreateFlagsEXT));
+ memcpy(*ptr, (VkValidationCacheCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkValidationCacheCreateFlagsEXT));
*ptr += sizeof(VkValidationCacheCreateFlagsEXT);
uint64_t cgen_var_0 = (uint64_t)forMarshaling->initialDataSize;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- memcpy(*ptr, (const void*)forMarshaling->pInitialData, forMarshaling->initialDataSize * sizeof(const uint8_t));
+ memcpy(*ptr, (const void*)forMarshaling->pInitialData,
+ forMarshaling->initialDataSize * sizeof(const uint8_t));
*ptr += forMarshaling->initialDataSize * sizeof(const uint8_t);
}
void reservedmarshal_VkShaderModuleValidationCacheCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkShaderModuleValidationCacheCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkShaderModuleValidationCacheCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -13738,32 +12440,26 @@
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_NV_shading_rate_image
-void reservedmarshal_VkShadingRatePaletteNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkShadingRatePaletteNV* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkShadingRatePaletteNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkShadingRatePaletteNV* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->shadingRatePaletteEntryCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const VkShadingRatePaletteEntryNV*)forMarshaling->pShadingRatePaletteEntries, forMarshaling->shadingRatePaletteEntryCount * sizeof(const VkShadingRatePaletteEntryNV));
+ memcpy(*ptr, (const VkShadingRatePaletteEntryNV*)forMarshaling->pShadingRatePaletteEntries,
+ forMarshaling->shadingRatePaletteEntryCount * sizeof(const VkShadingRatePaletteEntryNV));
*ptr += forMarshaling->shadingRatePaletteEntryCount * sizeof(const VkShadingRatePaletteEntryNV);
}
void reservedmarshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineViewportShadingRateImageStateCreateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineViewportShadingRateImageStateCreateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -13776,27 +12472,23 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pShadingRatePalettes)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
- {
- reservedmarshal_VkShadingRatePaletteNV(vkStream, rootType, (const VkShadingRatePaletteNV*)(forMarshaling->pShadingRatePalettes + i), ptr);
+ if (forMarshaling->pShadingRatePalettes) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i) {
+ reservedmarshal_VkShadingRatePaletteNV(
+ vkStream, rootType,
+ (const VkShadingRatePaletteNV*)(forMarshaling->pShadingRatePalettes + i), ptr);
}
}
}
void reservedmarshal_VkPhysicalDeviceShadingRateImageFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShadingRateImageFeaturesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShadingRateImageFeaturesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -13807,33 +12499,27 @@
}
void reservedmarshal_VkPhysicalDeviceShadingRateImagePropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShadingRateImagePropertiesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShadingRateImagePropertiesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->shadingRateTexelSize), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->shadingRateTexelSize), ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->shadingRatePaletteSize, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->shadingRateMaxCoarseSamples, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkCoarseSampleLocationNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCoarseSampleLocationNV* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkCoarseSampleLocationNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCoarseSampleLocationNV* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->pixelX, sizeof(uint32_t));
@@ -13844,69 +12530,64 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkCoarseSampleOrderCustomNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCoarseSampleOrderCustomNV* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkCoarseSampleOrderCustomNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkCoarseSampleOrderCustomNV* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- memcpy(*ptr, (VkShadingRatePaletteEntryNV*)&forMarshaling->shadingRate, sizeof(VkShadingRatePaletteEntryNV));
+ memcpy(*ptr, (VkShadingRatePaletteEntryNV*)&forMarshaling->shadingRate,
+ sizeof(VkShadingRatePaletteEntryNV));
*ptr += sizeof(VkShadingRatePaletteEntryNV);
memcpy(*ptr, (uint32_t*)&forMarshaling->sampleCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->sampleLocationCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->sampleLocationCount; ++i)
- {
- reservedmarshal_VkCoarseSampleLocationNV(vkStream, rootType, (const VkCoarseSampleLocationNV*)(forMarshaling->pSampleLocations + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->sampleLocationCount; ++i) {
+ reservedmarshal_VkCoarseSampleLocationNV(
+ vkStream, rootType,
+ (const VkCoarseSampleLocationNV*)(forMarshaling->pSampleLocations + i), ptr);
}
}
void reservedmarshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkCoarseSampleOrderTypeNV*)&forMarshaling->sampleOrderType, sizeof(VkCoarseSampleOrderTypeNV));
+ memcpy(*ptr, (VkCoarseSampleOrderTypeNV*)&forMarshaling->sampleOrderType,
+ sizeof(VkCoarseSampleOrderTypeNV));
*ptr += sizeof(VkCoarseSampleOrderTypeNV);
memcpy(*ptr, (uint32_t*)&forMarshaling->customSampleOrderCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->customSampleOrderCount; ++i)
- {
- reservedmarshal_VkCoarseSampleOrderCustomNV(vkStream, rootType, (const VkCoarseSampleOrderCustomNV*)(forMarshaling->pCustomSampleOrders + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->customSampleOrderCount; ++i) {
+ reservedmarshal_VkCoarseSampleOrderCustomNV(
+ vkStream, rootType,
+ (const VkCoarseSampleOrderCustomNV*)(forMarshaling->pCustomSampleOrders + i), ptr);
}
}
#endif
#ifdef VK_NV_ray_tracing
void reservedmarshal_VkRayTracingShaderGroupCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRayTracingShaderGroupCreateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRayTracingShaderGroupCreateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkRayTracingShaderGroupTypeKHR*)&forMarshaling->type, sizeof(VkRayTracingShaderGroupTypeKHR));
+ memcpy(*ptr, (VkRayTracingShaderGroupTypeKHR*)&forMarshaling->type,
+ sizeof(VkRayTracingShaderGroupTypeKHR));
*ptr += sizeof(VkRayTracingShaderGroupTypeKHR);
memcpy(*ptr, (uint32_t*)&forMarshaling->generalShader, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -13919,17 +12600,13 @@
}
void reservedmarshal_VkRayTracingPipelineCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRayTracingPipelineCreateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRayTracingPipelineCreateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -13937,15 +12614,17 @@
*ptr += sizeof(VkPipelineCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->stageCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i)
- {
- reservedmarshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i) {
+ reservedmarshal_VkPipelineShaderStageCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->groupCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->groupCount; ++i)
- {
- reservedmarshal_VkRayTracingShaderGroupCreateInfoNV(vkStream, rootType, (const VkRayTracingShaderGroupCreateInfoNV*)(forMarshaling->pGroups + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->groupCount; ++i) {
+ reservedmarshal_VkRayTracingShaderGroupCreateInfoNV(
+ vkStream, rootType,
+ (const VkRayTracingShaderGroupCreateInfoNV*)(forMarshaling->pGroups + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->maxRecursionDepth, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -13961,18 +12640,14 @@
*ptr += sizeof(int32_t);
}
-void reservedmarshal_VkGeometryTrianglesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeometryTrianglesNV* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkGeometryTrianglesNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeometryTrianglesNV* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -14006,18 +12681,13 @@
*ptr += sizeof(VkDeviceSize);
}
-void reservedmarshal_VkGeometryAABBNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeometryAABBNV* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkGeometryAABBNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeometryAABBNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -14033,101 +12703,86 @@
*ptr += sizeof(VkDeviceSize);
}
-void reservedmarshal_VkGeometryDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeometryDataNV* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkGeometryDataNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeometryDataNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- reservedmarshal_VkGeometryTrianglesNV(vkStream, rootType, (VkGeometryTrianglesNV*)(&forMarshaling->triangles), ptr);
- reservedmarshal_VkGeometryAABBNV(vkStream, rootType, (VkGeometryAABBNV*)(&forMarshaling->aabbs), ptr);
+ reservedmarshal_VkGeometryTrianglesNV(vkStream, rootType,
+ (VkGeometryTrianglesNV*)(&forMarshaling->triangles), ptr);
+ reservedmarshal_VkGeometryAABBNV(vkStream, rootType, (VkGeometryAABBNV*)(&forMarshaling->aabbs),
+ ptr);
}
-void reservedmarshal_VkGeometryNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeometryNV* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkGeometryNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeometryNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkGeometryTypeKHR*)&forMarshaling->geometryType, sizeof(VkGeometryTypeKHR));
*ptr += sizeof(VkGeometryTypeKHR);
- reservedmarshal_VkGeometryDataNV(vkStream, rootType, (VkGeometryDataNV*)(&forMarshaling->geometry), ptr);
+ reservedmarshal_VkGeometryDataNV(vkStream, rootType,
+ (VkGeometryDataNV*)(&forMarshaling->geometry), ptr);
memcpy(*ptr, (VkGeometryFlagsKHR*)&forMarshaling->flags, sizeof(VkGeometryFlagsKHR));
*ptr += sizeof(VkGeometryFlagsKHR);
}
void reservedmarshal_VkAccelerationStructureInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkAccelerationStructureTypeNV*)&forMarshaling->type, sizeof(VkAccelerationStructureTypeNV));
+ memcpy(*ptr, (VkAccelerationStructureTypeNV*)&forMarshaling->type,
+ sizeof(VkAccelerationStructureTypeNV));
*ptr += sizeof(VkAccelerationStructureTypeNV);
- memcpy(*ptr, (VkBuildAccelerationStructureFlagsNV*)&forMarshaling->flags, sizeof(VkBuildAccelerationStructureFlagsNV));
+ memcpy(*ptr, (VkBuildAccelerationStructureFlagsNV*)&forMarshaling->flags,
+ sizeof(VkBuildAccelerationStructureFlagsNV));
*ptr += sizeof(VkBuildAccelerationStructureFlagsNV);
memcpy(*ptr, (uint32_t*)&forMarshaling->instanceCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->geometryCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->geometryCount; ++i)
- {
- reservedmarshal_VkGeometryNV(vkStream, rootType, (const VkGeometryNV*)(forMarshaling->pGeometries + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->geometryCount; ++i) {
+ reservedmarshal_VkGeometryNV(vkStream, rootType,
+ (const VkGeometryNV*)(forMarshaling->pGeometries + i), ptr);
}
}
void reservedmarshal_VkAccelerationStructureCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureCreateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureCreateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->compactedSize, sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
- reservedmarshal_VkAccelerationStructureInfoNV(vkStream, rootType, (VkAccelerationStructureInfoNV*)(&forMarshaling->info), ptr);
+ reservedmarshal_VkAccelerationStructureInfoNV(
+ vkStream, rootType, (VkAccelerationStructureInfoNV*)(&forMarshaling->info), ptr);
}
void reservedmarshal_VkBindAccelerationStructureMemoryInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindAccelerationStructureMemoryInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindAccelerationStructureMemoryInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -14143,22 +12798,19 @@
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (uint32_t*)&forMarshaling->deviceIndexCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const uint32_t*)forMarshaling->pDeviceIndices, forMarshaling->deviceIndexCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pDeviceIndices,
+ forMarshaling->deviceIndexCount * sizeof(const uint32_t));
*ptr += forMarshaling->deviceIndexCount * sizeof(const uint32_t);
}
void reservedmarshal_VkWriteDescriptorSetAccelerationStructureNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWriteDescriptorSetAccelerationStructureNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWriteDescriptorSetAccelerationStructureNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -14169,16 +12821,13 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pAccelerationStructures)
- {
- if (forMarshaling->accelerationStructureCount)
- {
+ if (forMarshaling->pAccelerationStructures) {
+ if (forMarshaling->accelerationStructureCount) {
uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->accelerationStructureCount; ++k)
- {
- uint64_t tmpval = get_host_u64_VkAccelerationStructureNV(forMarshaling->pAccelerationStructures[k]);
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->accelerationStructureCount; ++k) {
+ uint64_t tmpval = get_host_u64_VkAccelerationStructureNV(
+ forMarshaling->pAccelerationStructures[k]);
memcpy(cgen_var_0_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
}
@@ -14188,21 +12837,18 @@
}
void reservedmarshal_VkAccelerationStructureMemoryRequirementsInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureMemoryRequirementsInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureMemoryRequirementsInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkAccelerationStructureMemoryRequirementsTypeNV*)&forMarshaling->type, sizeof(VkAccelerationStructureMemoryRequirementsTypeNV));
+ memcpy(*ptr, (VkAccelerationStructureMemoryRequirementsTypeNV*)&forMarshaling->type,
+ sizeof(VkAccelerationStructureMemoryRequirementsTypeNV));
*ptr += sizeof(VkAccelerationStructureMemoryRequirementsTypeNV);
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkAccelerationStructureNV((*&forMarshaling->accelerationStructure));
@@ -14211,17 +12857,13 @@
}
void reservedmarshal_VkPhysicalDeviceRayTracingPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingPropertiesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPropertiesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -14239,28 +12881,22 @@
*ptr += sizeof(uint64_t);
memcpy(*ptr, (uint64_t*)&forMarshaling->maxTriangleCount, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetAccelerationStructures, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetAccelerationStructures,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkTransformMatrixKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkTransformMatrixKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkTransformMatrixKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkTransformMatrixKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- memcpy(*ptr, (float*)forMarshaling->matrix, ((3)*(4)) * sizeof(float));
- *ptr += ((3)*(4)) * sizeof(float);
+ memcpy(*ptr, (float*)forMarshaling->matrix, ((3) * (4)) * sizeof(float));
+ *ptr += ((3) * (4)) * sizeof(float);
}
-void reservedmarshal_VkAabbPositionsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAabbPositionsKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkAabbPositionsKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAabbPositionsKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (float*)&forMarshaling->minX, sizeof(float));
@@ -14278,44 +12914,37 @@
}
void reservedmarshal_VkAccelerationStructureInstanceKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureInstanceKHR* forMarshaling,
- uint8_t** ptr)
-{
-
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureInstanceKHR* forMarshaling, uint8_t** ptr) {
typedef struct VkAccelerationStructureInstanceKHRWithoutBitFields {
- VkTransformMatrixKHR transform;
- uint32_t dwords[2];
- uint64_t accelerationStructureReference;
+ VkTransformMatrixKHR transform;
+ uint32_t dwords[2];
+ uint64_t accelerationStructureReference;
} VkAccelerationStructureInstanceKHRWithoutBitFields;
-
+
(void)vkStream;
- const VkAccelerationStructureInstanceKHRWithoutBitFields* forMarshaling_new = (const VkAccelerationStructureInstanceKHRWithoutBitFields*)(forMarshaling);
- reservedmarshal_VkTransformMatrixKHR(vkStream, rootType, (VkTransformMatrixKHR*)(&forMarshaling_new->transform), ptr);
+ const VkAccelerationStructureInstanceKHRWithoutBitFields* forMarshaling_new =
+ (const VkAccelerationStructureInstanceKHRWithoutBitFields*)(forMarshaling);
+ reservedmarshal_VkTransformMatrixKHR(
+ vkStream, rootType, (VkTransformMatrixKHR*)(&forMarshaling_new->transform), ptr);
for (uint32_t i = 0; i < 2; i++) {
memcpy(*ptr, (uint32_t*)&(forMarshaling_new->dwords[i]), sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
memcpy(*ptr, (uint64_t*)&forMarshaling_new->accelerationStructureReference, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
-
}
#endif
#ifdef VK_NV_representative_fragment_test
void reservedmarshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -14324,17 +12953,13 @@
}
void reservedmarshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -14345,17 +12970,13 @@
#endif
#ifdef VK_EXT_filter_cubic
void reservedmarshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceImageViewImageFormatInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceImageViewImageFormatInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -14364,17 +12985,13 @@
}
void reservedmarshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFilterCubicImageViewImageFormatPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFilterCubicImageViewImageFormatPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -14389,67 +13006,56 @@
#endif
#ifdef VK_EXT_global_priority
void reservedmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceQueueGlobalPriorityCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceQueueGlobalPriorityCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkQueueGlobalPriorityEXT*)&forMarshaling->globalPriority, sizeof(VkQueueGlobalPriorityEXT));
+ memcpy(*ptr, (VkQueueGlobalPriorityEXT*)&forMarshaling->globalPriority,
+ sizeof(VkQueueGlobalPriorityEXT));
*ptr += sizeof(VkQueueGlobalPriorityEXT);
}
#endif
#ifdef VK_EXT_external_memory_host
void reservedmarshal_VkImportMemoryHostPointerInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportMemoryHostPointerInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportMemoryHostPointerInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pHostPointer;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pHostPointer)
- {
+ if (forMarshaling->pHostPointer) {
memcpy(*ptr, (void*)forMarshaling->pHostPointer, sizeof(uint8_t));
*ptr += sizeof(uint8_t);
}
}
void reservedmarshal_VkMemoryHostPointerPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryHostPointerPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryHostPointerPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -14458,21 +13064,18 @@
}
void reservedmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDeviceSize*)&forMarshaling->minImportedHostPointerAlignment, sizeof(VkDeviceSize));
+ memcpy(*ptr, (VkDeviceSize*)&forMarshaling->minImportedHostPointerAlignment,
+ sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
}
@@ -14481,38 +13084,32 @@
#endif
#ifdef VK_AMD_pipeline_compiler_control
void reservedmarshal_VkPipelineCompilerControlCreateInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCompilerControlCreateInfoAMD* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCompilerControlCreateInfoAMD* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineCompilerControlFlagsAMD*)&forMarshaling->compilerControlFlags, sizeof(VkPipelineCompilerControlFlagsAMD));
+ memcpy(*ptr, (VkPipelineCompilerControlFlagsAMD*)&forMarshaling->compilerControlFlags,
+ sizeof(VkPipelineCompilerControlFlagsAMD));
*ptr += sizeof(VkPipelineCompilerControlFlagsAMD);
}
#endif
#ifdef VK_EXT_calibrated_timestamps
-void reservedmarshal_VkCalibratedTimestampInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCalibratedTimestampInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkCalibratedTimestampInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkCalibratedTimestampInfoEXT* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -14523,17 +13120,13 @@
#endif
#ifdef VK_AMD_shader_core_properties
void reservedmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderCorePropertiesAMD* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderCorePropertiesAMD* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -14569,77 +13162,67 @@
#endif
#ifdef VK_EXT_video_decode_h265
-void reservedmarshal_VkVideoDecodeH265ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265ProfileEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkVideoDecodeH265ProfileEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkVideoDecodeH265ProfileEXT* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (StdVideoH265ProfileIdc*)&forMarshaling->stdProfileIdc, sizeof(StdVideoH265ProfileIdc));
+ memcpy(*ptr, (StdVideoH265ProfileIdc*)&forMarshaling->stdProfileIdc,
+ sizeof(StdVideoH265ProfileIdc));
*ptr += sizeof(StdVideoH265ProfileIdc);
}
void reservedmarshal_VkVideoDecodeH265CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265CapabilitiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265CapabilitiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxLevel, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- reservedmarshal_VkExtensionProperties(vkStream, rootType, (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion), ptr);
+ reservedmarshal_VkExtensionProperties(
+ vkStream, rootType, (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion), ptr);
}
void reservedmarshal_VkVideoDecodeH265SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265SessionCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265SessionCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkVideoDecodeH265CreateFlagsEXT*)&forMarshaling->flags, sizeof(VkVideoDecodeH265CreateFlagsEXT));
+ memcpy(*ptr, (VkVideoDecodeH265CreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkVideoDecodeH265CreateFlagsEXT));
*ptr += sizeof(VkVideoDecodeH265CreateFlagsEXT);
- reservedmarshal_VkExtensionProperties(vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion), ptr);
+ reservedmarshal_VkExtensionProperties(
+ vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion),
+ ptr);
}
void reservedmarshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265SessionParametersAddInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265SessionParametersAddInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -14650,9 +13233,9 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pSpsStd)
- {
- memcpy(*ptr, (const StdVideoH265SequenceParameterSet*)forMarshaling->pSpsStd, forMarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
+ if (forMarshaling->pSpsStd) {
+ memcpy(*ptr, (const StdVideoH265SequenceParameterSet*)forMarshaling->pSpsStd,
+ forMarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
*ptr += forMarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->ppsStdCount, sizeof(uint32_t));
@@ -14662,25 +13245,21 @@
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pPpsStd)
- {
- memcpy(*ptr, (const StdVideoH265PictureParameterSet*)forMarshaling->pPpsStd, forMarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
+ if (forMarshaling->pPpsStd) {
+ memcpy(*ptr, (const StdVideoH265PictureParameterSet*)forMarshaling->pPpsStd,
+ forMarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
*ptr += forMarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet);
}
}
void reservedmarshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265SessionParametersCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265SessionParametersCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -14693,89 +13272,80 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pParametersAddInfo)
- {
- reservedmarshal_VkVideoDecodeH265SessionParametersAddInfoEXT(vkStream, rootType, (const VkVideoDecodeH265SessionParametersAddInfoEXT*)(forMarshaling->pParametersAddInfo), ptr);
+ if (forMarshaling->pParametersAddInfo) {
+ reservedmarshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ (const VkVideoDecodeH265SessionParametersAddInfoEXT*)(forMarshaling
+ ->pParametersAddInfo),
+ ptr);
}
}
void reservedmarshal_VkVideoDecodeH265PictureInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265PictureInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265PictureInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (StdVideoDecodeH265PictureInfo*)forMarshaling->pStdPictureInfo, sizeof(StdVideoDecodeH265PictureInfo));
+ memcpy(*ptr, (StdVideoDecodeH265PictureInfo*)forMarshaling->pStdPictureInfo,
+ sizeof(StdVideoDecodeH265PictureInfo));
*ptr += sizeof(StdVideoDecodeH265PictureInfo);
memcpy(*ptr, (uint32_t*)&forMarshaling->slicesCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const uint32_t*)forMarshaling->pSlicesDataOffsets, forMarshaling->slicesCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pSlicesDataOffsets,
+ forMarshaling->slicesCount * sizeof(const uint32_t));
*ptr += forMarshaling->slicesCount * sizeof(const uint32_t);
}
void reservedmarshal_VkVideoDecodeH265DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265DpbSlotInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265DpbSlotInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (const StdVideoDecodeH265ReferenceInfo*)forMarshaling->pStdReferenceInfo, sizeof(const StdVideoDecodeH265ReferenceInfo));
+ memcpy(*ptr, (const StdVideoDecodeH265ReferenceInfo*)forMarshaling->pStdReferenceInfo,
+ sizeof(const StdVideoDecodeH265ReferenceInfo));
*ptr += sizeof(const StdVideoDecodeH265ReferenceInfo);
}
#endif
#ifdef VK_AMD_memory_overallocation_behavior
void reservedmarshal_VkDeviceMemoryOverallocationCreateInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceMemoryOverallocationCreateInfoAMD* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceMemoryOverallocationCreateInfoAMD* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkMemoryOverallocationBehaviorAMD*)&forMarshaling->overallocationBehavior, sizeof(VkMemoryOverallocationBehaviorAMD));
+ memcpy(*ptr, (VkMemoryOverallocationBehaviorAMD*)&forMarshaling->overallocationBehavior,
+ sizeof(VkMemoryOverallocationBehaviorAMD));
*ptr += sizeof(VkMemoryOverallocationBehaviorAMD);
}
#endif
#ifdef VK_EXT_vertex_attribute_divisor
void reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -14784,11 +13354,8 @@
}
void reservedmarshal_VkVertexInputBindingDivisorDescriptionEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVertexInputBindingDivisorDescriptionEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVertexInputBindingDivisorDescriptionEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
@@ -14798,63 +13365,56 @@
}
void reservedmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineVertexInputDivisorStateCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineVertexInputDivisorStateCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->vertexBindingDivisorCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexBindingDivisorCount; ++i)
- {
- reservedmarshal_VkVertexInputBindingDivisorDescriptionEXT(vkStream, rootType, (const VkVertexInputBindingDivisorDescriptionEXT*)(forMarshaling->pVertexBindingDivisors + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->vertexBindingDivisorCount; ++i) {
+ reservedmarshal_VkVertexInputBindingDivisorDescriptionEXT(
+ vkStream, rootType,
+ (const VkVertexInputBindingDivisorDescriptionEXT*)(forMarshaling
+ ->pVertexBindingDivisors +
+ i),
+ ptr);
}
}
void reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->vertexAttributeInstanceRateDivisor, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->vertexAttributeInstanceRateZeroDivisor, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->vertexAttributeInstanceRateZeroDivisor,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
#endif
#ifdef VK_GGP_frame_token
-void reservedmarshal_VkPresentFrameTokenGGP(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentFrameTokenGGP* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPresentFrameTokenGGP(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentFrameTokenGGP* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -14865,40 +13425,38 @@
#endif
#ifdef VK_EXT_pipeline_creation_feedback
void reservedmarshal_VkPipelineCreationFeedbackEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCreationFeedbackEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCreationFeedbackEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- memcpy(*ptr, (VkPipelineCreationFeedbackFlagsEXT*)&forMarshaling->flags, sizeof(VkPipelineCreationFeedbackFlagsEXT));
+ memcpy(*ptr, (VkPipelineCreationFeedbackFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkPipelineCreationFeedbackFlagsEXT));
*ptr += sizeof(VkPipelineCreationFeedbackFlagsEXT);
memcpy(*ptr, (uint64_t*)&forMarshaling->duration, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
}
void reservedmarshal_VkPipelineCreationFeedbackCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCreationFeedbackCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCreationFeedbackCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkPipelineCreationFeedbackEXT(vkStream, rootType, (VkPipelineCreationFeedbackEXT*)(forMarshaling->pPipelineCreationFeedback), ptr);
+ reservedmarshal_VkPipelineCreationFeedbackEXT(
+ vkStream, rootType,
+ (VkPipelineCreationFeedbackEXT*)(forMarshaling->pPipelineCreationFeedback), ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->pipelineStageCreationFeedbackCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->pipelineStageCreationFeedbackCount; ++i)
- {
- reservedmarshal_VkPipelineCreationFeedbackEXT(vkStream, rootType, (VkPipelineCreationFeedbackEXT*)(forMarshaling->pPipelineStageCreationFeedbacks + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->pipelineStageCreationFeedbackCount; ++i) {
+ reservedmarshal_VkPipelineCreationFeedbackEXT(
+ vkStream, rootType,
+ (VkPipelineCreationFeedbackEXT*)(forMarshaling->pPipelineStageCreationFeedbacks + i),
+ ptr);
}
}
@@ -14907,17 +13465,13 @@
#endif
#ifdef VK_NV_compute_shader_derivatives
void reservedmarshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -14930,17 +13484,13 @@
#endif
#ifdef VK_NV_mesh_shader
void reservedmarshal_VkPhysicalDeviceMeshShaderFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMeshShaderFeaturesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMeshShaderFeaturesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -14951,17 +13501,13 @@
}
void reservedmarshal_VkPhysicalDeviceMeshShaderPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMeshShaderPropertiesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMeshShaderPropertiesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -14994,11 +13540,8 @@
}
void reservedmarshal_VkDrawMeshTasksIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrawMeshTasksIndirectCommandNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrawMeshTasksIndirectCommandNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->taskCount, sizeof(uint32_t));
@@ -15010,17 +13553,13 @@
#endif
#ifdef VK_NV_fragment_shader_barycentric
void reservedmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15031,17 +13570,13 @@
#endif
#ifdef VK_NV_shader_image_footprint
void reservedmarshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderImageFootprintFeaturesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderImageFootprintFeaturesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15052,17 +13587,13 @@
#endif
#ifdef VK_NV_scissor_exclusive
void reservedmarshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineViewportExclusiveScissorStateCreateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineViewportExclusiveScissorStateCreateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15073,27 +13604,22 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pExclusiveScissors)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->exclusiveScissorCount; ++i)
- {
- reservedmarshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pExclusiveScissors + i), ptr);
+ if (forMarshaling->pExclusiveScissors) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->exclusiveScissorCount; ++i) {
+ reservedmarshal_VkRect2D(vkStream, rootType,
+ (const VkRect2D*)(forMarshaling->pExclusiveScissors + i), ptr);
}
}
}
void reservedmarshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExclusiveScissorFeaturesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExclusiveScissorFeaturesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15104,36 +13630,28 @@
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
void reservedmarshal_VkQueueFamilyCheckpointPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueueFamilyCheckpointPropertiesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyCheckpointPropertiesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineStageFlags*)&forMarshaling->checkpointExecutionStageMask, sizeof(VkPipelineStageFlags));
+ memcpy(*ptr, (VkPipelineStageFlags*)&forMarshaling->checkpointExecutionStageMask,
+ sizeof(VkPipelineStageFlags));
*ptr += sizeof(VkPipelineStageFlags);
}
-void reservedmarshal_VkCheckpointDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCheckpointDataNV* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkCheckpointDataNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCheckpointDataNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15144,8 +13662,7 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pCheckpointMarker)
- {
+ if (forMarshaling->pCheckpointMarker) {
memcpy(*ptr, (void*)forMarshaling->pCheckpointMarker, sizeof(uint8_t));
*ptr += sizeof(uint8_t);
}
@@ -15154,17 +13671,13 @@
#endif
#ifdef VK_INTEL_shader_integer_functions2
void reservedmarshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15174,43 +13687,36 @@
#endif
#ifdef VK_INTEL_performance_query
-void reservedmarshal_VkPerformanceValueDataINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceValueDataINTEL* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPerformanceValueDataINTEL(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkPerformanceValueDataINTEL* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->value32, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkPerformanceValueINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceValueINTEL* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPerformanceValueINTEL(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceValueINTEL* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- memcpy(*ptr, (VkPerformanceValueTypeINTEL*)&forMarshaling->type, sizeof(VkPerformanceValueTypeINTEL));
+ memcpy(*ptr, (VkPerformanceValueTypeINTEL*)&forMarshaling->type,
+ sizeof(VkPerformanceValueTypeINTEL));
*ptr += sizeof(VkPerformanceValueTypeINTEL);
- reservedmarshal_VkPerformanceValueDataINTEL(vkStream, rootType, (VkPerformanceValueDataINTEL*)(&forMarshaling->data), ptr);
+ reservedmarshal_VkPerformanceValueDataINTEL(
+ vkStream, rootType, (VkPerformanceValueDataINTEL*)(&forMarshaling->data), ptr);
}
void reservedmarshal_VkInitializePerformanceApiInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkInitializePerformanceApiInfoINTEL* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkInitializePerformanceApiInfoINTEL* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15219,44 +13725,37 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pUserData)
- {
+ if (forMarshaling->pUserData) {
memcpy(*ptr, (void*)forMarshaling->pUserData, sizeof(uint8_t));
*ptr += sizeof(uint8_t);
}
}
void reservedmarshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueryPoolPerformanceQueryCreateInfoINTEL* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueryPoolPerformanceQueryCreateInfoINTEL* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkQueryPoolSamplingModeINTEL*)&forMarshaling->performanceCountersSampling, sizeof(VkQueryPoolSamplingModeINTEL));
+ memcpy(*ptr, (VkQueryPoolSamplingModeINTEL*)&forMarshaling->performanceCountersSampling,
+ sizeof(VkQueryPoolSamplingModeINTEL));
*ptr += sizeof(VkQueryPoolSamplingModeINTEL);
}
-void reservedmarshal_VkPerformanceMarkerInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceMarkerInfoINTEL* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkPerformanceMarkerInfoINTEL(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkPerformanceMarkerInfoINTEL* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15265,17 +13764,13 @@
}
void reservedmarshal_VkPerformanceStreamMarkerInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceStreamMarkerInfoINTEL* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceStreamMarkerInfoINTEL* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15284,21 +13779,18 @@
}
void reservedmarshal_VkPerformanceOverrideInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceOverrideInfoINTEL* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceOverrideInfoINTEL* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPerformanceOverrideTypeINTEL*)&forMarshaling->type, sizeof(VkPerformanceOverrideTypeINTEL));
+ memcpy(*ptr, (VkPerformanceOverrideTypeINTEL*)&forMarshaling->type,
+ sizeof(VkPerformanceOverrideTypeINTEL));
*ptr += sizeof(VkPerformanceOverrideTypeINTEL);
memcpy(*ptr, (VkBool32*)&forMarshaling->enable, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -15307,38 +13799,31 @@
}
void reservedmarshal_VkPerformanceConfigurationAcquireInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceConfigurationAcquireInfoINTEL* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceConfigurationAcquireInfoINTEL* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPerformanceConfigurationTypeINTEL*)&forMarshaling->type, sizeof(VkPerformanceConfigurationTypeINTEL));
+ memcpy(*ptr, (VkPerformanceConfigurationTypeINTEL*)&forMarshaling->type,
+ sizeof(VkPerformanceConfigurationTypeINTEL));
*ptr += sizeof(VkPerformanceConfigurationTypeINTEL);
}
#endif
#ifdef VK_EXT_pci_bus_info
void reservedmarshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePCIBusInfoPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePCIBusInfoPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15355,17 +13840,13 @@
#endif
#ifdef VK_AMD_display_native_hdr
void reservedmarshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayNativeHdrSurfaceCapabilitiesAMD* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayNativeHdrSurfaceCapabilitiesAMD* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15374,17 +13855,13 @@
}
void reservedmarshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSwapchainDisplayNativeHdrCreateInfoAMD* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSwapchainDisplayNativeHdrCreateInfoAMD* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15395,21 +13872,18 @@
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
void reservedmarshal_VkImagePipeSurfaceCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImagePipeSurfaceCreateInfoFUCHSIA* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImagePipeSurfaceCreateInfoFUCHSIA* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkImagePipeSurfaceCreateFlagsFUCHSIA*)&forMarshaling->flags, sizeof(VkImagePipeSurfaceCreateFlagsFUCHSIA));
+ memcpy(*ptr, (VkImagePipeSurfaceCreateFlagsFUCHSIA*)&forMarshaling->flags,
+ sizeof(VkImagePipeSurfaceCreateFlagsFUCHSIA));
*ptr += sizeof(VkImagePipeSurfaceCreateFlagsFUCHSIA);
memcpy(*ptr, (zx_handle_t*)&forMarshaling->imagePipeHandle, sizeof(zx_handle_t));
*ptr += sizeof(zx_handle_t);
@@ -15417,32 +13891,24 @@
#endif
#ifdef VK_EXT_metal_surface
-void reservedmarshal_VkMetalSurfaceCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMetalSurfaceCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
-
+void reservedmarshal_VkMetalSurfaceCreateInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkMetalSurfaceCreateInfoEXT* forMarshaling,
+ uint8_t** ptr) {
// This struct should never be marshaled / unmarshaled.
__builtin_trap();
-
}
#endif
#ifdef VK_EXT_fragment_density_map
void reservedmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15450,47 +13916,44 @@
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentDensityMapDynamic, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentDensityMapNonSubsampledImages, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentDensityMapNonSubsampledImages,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minFragmentDensityTexelSize), ptr);
- reservedmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxFragmentDensityTexelSize), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->minFragmentDensityTexelSize), ptr);
+ reservedmarshal_VkExtent2D(vkStream, rootType,
+ (VkExtent2D*)(&forMarshaling->maxFragmentDensityTexelSize), ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->fragmentDensityInvocations, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassFragmentDensityMapCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassFragmentDensityMapCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkAttachmentReference(vkStream, rootType, (VkAttachmentReference*)(&forMarshaling->fragmentDensityMapAttachment), ptr);
+ reservedmarshal_VkAttachmentReference(
+ vkStream, rootType, (VkAttachmentReference*)(&forMarshaling->fragmentDensityMapAttachment),
+ ptr);
}
#endif
@@ -15502,17 +13965,13 @@
#endif
#ifdef VK_EXT_subgroup_size_control
void reservedmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15523,17 +13982,13 @@
}
void reservedmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15543,22 +13998,19 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxComputeWorkgroupSubgroups, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->requiredSubgroupSizeStages, sizeof(VkShaderStageFlags));
+ memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->requiredSubgroupSizeStages,
+ sizeof(VkShaderStageFlags));
*ptr += sizeof(VkShaderStageFlags);
}
void reservedmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15569,21 +14021,18 @@
#endif
#ifdef VK_AMD_shader_core_properties2
void reservedmarshal_VkPhysicalDeviceShaderCoreProperties2AMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderCoreProperties2AMD* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderCoreProperties2AMD* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkShaderCorePropertiesFlagsAMD*)&forMarshaling->shaderCoreFeatures, sizeof(VkShaderCorePropertiesFlagsAMD));
+ memcpy(*ptr, (VkShaderCorePropertiesFlagsAMD*)&forMarshaling->shaderCoreFeatures,
+ sizeof(VkShaderCorePropertiesFlagsAMD));
*ptr += sizeof(VkShaderCorePropertiesFlagsAMD);
memcpy(*ptr, (uint32_t*)&forMarshaling->activeComputeUnitCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -15592,17 +14041,13 @@
#endif
#ifdef VK_AMD_device_coherent_memory
void reservedmarshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCoherentMemoryFeaturesAMD* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCoherentMemoryFeaturesAMD* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15613,17 +14058,13 @@
#endif
#ifdef VK_EXT_shader_image_atomic_int64
void reservedmarshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15636,40 +14077,34 @@
#endif
#ifdef VK_EXT_memory_budget
void reservedmarshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryBudgetPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryBudgetPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDeviceSize*)forMarshaling->heapBudget, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
+ memcpy(*ptr, (VkDeviceSize*)forMarshaling->heapBudget,
+ VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
*ptr += VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize);
- memcpy(*ptr, (VkDeviceSize*)forMarshaling->heapUsage, VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
+ memcpy(*ptr, (VkDeviceSize*)forMarshaling->heapUsage,
+ VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize));
*ptr += VK_MAX_MEMORY_HEAPS * sizeof(VkDeviceSize);
}
#endif
#ifdef VK_EXT_memory_priority
void reservedmarshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryPriorityFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryPriorityFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15678,17 +14113,13 @@
}
void reservedmarshal_VkMemoryPriorityAllocateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryPriorityAllocateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryPriorityAllocateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15699,17 +14130,14 @@
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
void reservedmarshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* forMarshaling,
- uint8_t** ptr)
-{
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15720,17 +14148,13 @@
#endif
#ifdef VK_EXT_buffer_device_address
void reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15743,17 +14167,13 @@
}
void reservedmarshal_VkBufferDeviceAddressCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferDeviceAddressCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferDeviceAddressCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15764,17 +14184,13 @@
#endif
#ifdef VK_EXT_tooling_info
void reservedmarshal_VkPhysicalDeviceToolPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceToolPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceToolPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15794,45 +14210,43 @@
#ifdef VK_EXT_separate_stencil_usage
#endif
#ifdef VK_EXT_validation_features
-void reservedmarshal_VkValidationFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkValidationFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkValidationFeaturesEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkValidationFeaturesEXT* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->enabledValidationFeatureCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const VkValidationFeatureEnableEXT*)forMarshaling->pEnabledValidationFeatures, forMarshaling->enabledValidationFeatureCount * sizeof(const VkValidationFeatureEnableEXT));
- *ptr += forMarshaling->enabledValidationFeatureCount * sizeof(const VkValidationFeatureEnableEXT);
+ memcpy(
+ *ptr, (const VkValidationFeatureEnableEXT*)forMarshaling->pEnabledValidationFeatures,
+ forMarshaling->enabledValidationFeatureCount * sizeof(const VkValidationFeatureEnableEXT));
+ *ptr +=
+ forMarshaling->enabledValidationFeatureCount * sizeof(const VkValidationFeatureEnableEXT);
memcpy(*ptr, (uint32_t*)&forMarshaling->disabledValidationFeatureCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const VkValidationFeatureDisableEXT*)forMarshaling->pDisabledValidationFeatures, forMarshaling->disabledValidationFeatureCount * sizeof(const VkValidationFeatureDisableEXT));
- *ptr += forMarshaling->disabledValidationFeatureCount * sizeof(const VkValidationFeatureDisableEXT);
+ memcpy(*ptr, (const VkValidationFeatureDisableEXT*)forMarshaling->pDisabledValidationFeatures,
+ forMarshaling->disabledValidationFeatureCount *
+ sizeof(const VkValidationFeatureDisableEXT));
+ *ptr +=
+ forMarshaling->disabledValidationFeatureCount * sizeof(const VkValidationFeatureDisableEXT);
}
#endif
#ifdef VK_NV_cooperative_matrix
void reservedmarshal_VkCooperativeMatrixPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCooperativeMatrixPropertiesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCooperativeMatrixPropertiesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15855,17 +14269,13 @@
}
void reservedmarshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCooperativeMatrixFeaturesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCooperativeMatrixFeaturesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15876,38 +14286,31 @@
}
void reservedmarshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCooperativeMatrixPropertiesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCooperativeMatrixPropertiesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->cooperativeMatrixSupportedStages, sizeof(VkShaderStageFlags));
+ memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->cooperativeMatrixSupportedStages,
+ sizeof(VkShaderStageFlags));
*ptr += sizeof(VkShaderStageFlags);
}
#endif
#ifdef VK_NV_coverage_reduction_mode
void reservedmarshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCoverageReductionModeFeaturesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCoverageReductionModeFeaturesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15916,46 +14319,43 @@
}
void reservedmarshal_VkPipelineCoverageReductionStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCoverageReductionStateCreateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCoverageReductionStateCreateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineCoverageReductionStateCreateFlagsNV*)&forMarshaling->flags, sizeof(VkPipelineCoverageReductionStateCreateFlagsNV));
+ memcpy(*ptr, (VkPipelineCoverageReductionStateCreateFlagsNV*)&forMarshaling->flags,
+ sizeof(VkPipelineCoverageReductionStateCreateFlagsNV));
*ptr += sizeof(VkPipelineCoverageReductionStateCreateFlagsNV);
- memcpy(*ptr, (VkCoverageReductionModeNV*)&forMarshaling->coverageReductionMode, sizeof(VkCoverageReductionModeNV));
+ memcpy(*ptr, (VkCoverageReductionModeNV*)&forMarshaling->coverageReductionMode,
+ sizeof(VkCoverageReductionModeNV));
*ptr += sizeof(VkCoverageReductionModeNV);
}
void reservedmarshal_VkFramebufferMixedSamplesCombinationNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFramebufferMixedSamplesCombinationNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFramebufferMixedSamplesCombinationNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkCoverageReductionModeNV*)&forMarshaling->coverageReductionMode, sizeof(VkCoverageReductionModeNV));
+ memcpy(*ptr, (VkCoverageReductionModeNV*)&forMarshaling->coverageReductionMode,
+ sizeof(VkCoverageReductionModeNV));
*ptr += sizeof(VkCoverageReductionModeNV);
- memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples, sizeof(VkSampleCountFlagBits));
+ memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples,
+ sizeof(VkSampleCountFlagBits));
*ptr += sizeof(VkSampleCountFlagBits);
- memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->depthStencilSamples, sizeof(VkSampleCountFlags));
+ memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->depthStencilSamples,
+ sizeof(VkSampleCountFlags));
*ptr += sizeof(VkSampleCountFlags);
memcpy(*ptr, (VkSampleCountFlags*)&forMarshaling->colorSamples, sizeof(VkSampleCountFlags));
*ptr += sizeof(VkSampleCountFlags);
@@ -15964,17 +14364,13 @@
#endif
#ifdef VK_EXT_fragment_shader_interlock
void reservedmarshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -15989,17 +14385,13 @@
#endif
#ifdef VK_EXT_ycbcr_image_arrays
void reservedmarshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -16010,99 +14402,83 @@
#endif
#ifdef VK_EXT_provoking_vertex
void reservedmarshal_VkPhysicalDeviceProvokingVertexFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceProvokingVertexFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceProvokingVertexFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->provokingVertexLast, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->transformFeedbackPreservesProvokingVertex, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->transformFeedbackPreservesProvokingVertex,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPhysicalDeviceProvokingVertexPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceProvokingVertexPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceProvokingVertexPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->provokingVertexModePerPipeline, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->transformFeedbackPreservesTriangleFanProvokingVertex, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->transformFeedbackPreservesTriangleFanProvokingVertex,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkProvokingVertexModeEXT*)&forMarshaling->provokingVertexMode, sizeof(VkProvokingVertexModeEXT));
+ memcpy(*ptr, (VkProvokingVertexModeEXT*)&forMarshaling->provokingVertexMode,
+ sizeof(VkProvokingVertexModeEXT));
*ptr += sizeof(VkProvokingVertexModeEXT);
}
#endif
#ifdef VK_EXT_full_screen_exclusive
void reservedmarshal_VkSurfaceFullScreenExclusiveInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceFullScreenExclusiveInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceFullScreenExclusiveInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkFullScreenExclusiveEXT*)&forMarshaling->fullScreenExclusive, sizeof(VkFullScreenExclusiveEXT));
+ memcpy(*ptr, (VkFullScreenExclusiveEXT*)&forMarshaling->fullScreenExclusive,
+ sizeof(VkFullScreenExclusiveEXT));
*ptr += sizeof(VkFullScreenExclusiveEXT);
}
void reservedmarshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceCapabilitiesFullScreenExclusiveEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceCapabilitiesFullScreenExclusiveEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -16111,17 +14487,13 @@
}
void reservedmarshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceFullScreenExclusiveWin32InfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceFullScreenExclusiveWin32InfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -16132,38 +14504,31 @@
#endif
#ifdef VK_EXT_headless_surface
void reservedmarshal_VkHeadlessSurfaceCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkHeadlessSurfaceCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkHeadlessSurfaceCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkHeadlessSurfaceCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkHeadlessSurfaceCreateFlagsEXT));
+ memcpy(*ptr, (VkHeadlessSurfaceCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkHeadlessSurfaceCreateFlagsEXT));
*ptr += sizeof(VkHeadlessSurfaceCreateFlagsEXT);
}
#endif
#ifdef VK_EXT_line_rasterization
void reservedmarshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -16182,17 +14547,13 @@
}
void reservedmarshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -16201,21 +14562,18 @@
}
void reservedmarshal_VkPipelineRasterizationLineStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationLineStateCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationLineStateCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkLineRasterizationModeEXT*)&forMarshaling->lineRasterizationMode, sizeof(VkLineRasterizationModeEXT));
+ memcpy(*ptr, (VkLineRasterizationModeEXT*)&forMarshaling->lineRasterizationMode,
+ sizeof(VkLineRasterizationModeEXT));
*ptr += sizeof(VkLineRasterizationModeEXT);
memcpy(*ptr, (VkBool32*)&forMarshaling->stippledLineEnable, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -16228,17 +14586,13 @@
#endif
#ifdef VK_EXT_shader_atomic_float
void reservedmarshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -16273,17 +14627,13 @@
#endif
#ifdef VK_EXT_index_type_uint8
void reservedmarshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -16294,17 +14644,13 @@
#endif
#ifdef VK_EXT_extended_dynamic_state
void reservedmarshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -16315,17 +14661,13 @@
#endif
#ifdef VK_EXT_shader_atomic_float2
void reservedmarshal_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -16358,17 +14700,13 @@
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
void reservedmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -16379,17 +14717,13 @@
#endif
#ifdef VK_NV_device_generated_commands
void reservedmarshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -16405,26 +14739,25 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxIndirectCommandsStreamStride, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->minSequencesCountBufferOffsetAlignment, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->minSequencesCountBufferOffsetAlignment,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->minSequencesIndexBufferOffsetAlignment, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->minSequencesIndexBufferOffsetAlignment,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->minIndirectCommandsBufferOffsetAlignment, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->minIndirectCommandsBufferOffsetAlignment,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
void reservedmarshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -16433,76 +14766,69 @@
}
void reservedmarshal_VkGraphicsShaderGroupCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGraphicsShaderGroupCreateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGraphicsShaderGroupCreateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->stageCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i)
- {
- reservedmarshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i) {
+ reservedmarshal_VkPipelineShaderStageCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i), ptr);
}
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pVertexInputState;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pVertexInputState)
- {
- reservedmarshal_VkPipelineVertexInputStateCreateInfo(vkStream, rootType, (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState), ptr);
+ if (forMarshaling->pVertexInputState) {
+ reservedmarshal_VkPipelineVertexInputStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState), ptr);
}
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pTessellationState;
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pTessellationState)
- {
- reservedmarshal_VkPipelineTessellationStateCreateInfo(vkStream, rootType, (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState), ptr);
+ if (forMarshaling->pTessellationState) {
+ reservedmarshal_VkPipelineTessellationStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState), ptr);
}
}
void reservedmarshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGraphicsPipelineShaderGroupsCreateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGraphicsPipelineShaderGroupsCreateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->groupCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->groupCount; ++i)
- {
- reservedmarshal_VkGraphicsShaderGroupCreateInfoNV(vkStream, rootType, (const VkGraphicsShaderGroupCreateInfoNV*)(forMarshaling->pGroups + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->groupCount; ++i) {
+ reservedmarshal_VkGraphicsShaderGroupCreateInfoNV(
+ vkStream, rootType,
+ (const VkGraphicsShaderGroupCreateInfoNV*)(forMarshaling->pGroups + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->pipelineCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- if (forMarshaling->pipelineCount)
- {
+ if (forMarshaling->pipelineCount) {
uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->pipelineCount; ++k)
- {
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->pipelineCount; ++k) {
uint64_t tmpval = get_host_u64_VkPipeline(forMarshaling->pPipelines[k]);
memcpy(cgen_var_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
@@ -16512,11 +14838,8 @@
}
void reservedmarshal_VkBindShaderGroupIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindShaderGroupIndirectCommandNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindShaderGroupIndirectCommandNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->groupIndex, sizeof(uint32_t));
@@ -16524,11 +14847,8 @@
}
void reservedmarshal_VkBindIndexBufferIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindIndexBufferIndirectCommandNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindIndexBufferIndirectCommandNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkDeviceAddress*)&forMarshaling->bufferAddress, sizeof(VkDeviceAddress));
@@ -16540,11 +14860,8 @@
}
void reservedmarshal_VkBindVertexBufferIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindVertexBufferIndirectCommandNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindVertexBufferIndirectCommandNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkDeviceAddress*)&forMarshaling->bufferAddress, sizeof(VkDeviceAddress));
@@ -16556,23 +14873,18 @@
}
void reservedmarshal_VkSetStateFlagsIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSetStateFlagsIndirectCommandNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSetStateFlagsIndirectCommandNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->data, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkIndirectCommandsStreamNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkIndirectCommandsStreamNV* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkIndirectCommandsStreamNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkIndirectCommandsStreamNV* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
uint64_t cgen_var_0;
@@ -16584,21 +14896,18 @@
}
void reservedmarshal_VkIndirectCommandsLayoutTokenNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkIndirectCommandsLayoutTokenNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkIndirectCommandsLayoutTokenNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkIndirectCommandsTokenTypeNV*)&forMarshaling->tokenType, sizeof(VkIndirectCommandsTokenTypeNV));
+ memcpy(*ptr, (VkIndirectCommandsTokenTypeNV*)&forMarshaling->tokenType,
+ sizeof(VkIndirectCommandsTokenTypeNV));
*ptr += sizeof(VkIndirectCommandsTokenTypeNV);
memcpy(*ptr, (uint32_t*)&forMarshaling->stream, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -16612,83 +14921,87 @@
*&cgen_var_0 = get_host_u64_VkPipelineLayout((*&forMarshaling->pushconstantPipelineLayout));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
- memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->pushconstantShaderStageFlags, sizeof(VkShaderStageFlags));
+ memcpy(*ptr, (VkShaderStageFlags*)&forMarshaling->pushconstantShaderStageFlags,
+ sizeof(VkShaderStageFlags));
*ptr += sizeof(VkShaderStageFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->pushconstantOffset, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->pushconstantSize, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkIndirectStateFlagsNV*)&forMarshaling->indirectStateFlags, sizeof(VkIndirectStateFlagsNV));
+ memcpy(*ptr, (VkIndirectStateFlagsNV*)&forMarshaling->indirectStateFlags,
+ sizeof(VkIndirectStateFlagsNV));
*ptr += sizeof(VkIndirectStateFlagsNV);
memcpy(*ptr, (uint32_t*)&forMarshaling->indexTypeCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const VkIndexType*)forMarshaling->pIndexTypes, forMarshaling->indexTypeCount * sizeof(const VkIndexType));
+ memcpy(*ptr, (const VkIndexType*)forMarshaling->pIndexTypes,
+ forMarshaling->indexTypeCount * sizeof(const VkIndexType));
*ptr += forMarshaling->indexTypeCount * sizeof(const VkIndexType);
- memcpy(*ptr, (const uint32_t*)forMarshaling->pIndexTypeValues, forMarshaling->indexTypeCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pIndexTypeValues,
+ forMarshaling->indexTypeCount * sizeof(const uint32_t));
*ptr += forMarshaling->indexTypeCount * sizeof(const uint32_t);
}
void reservedmarshal_VkIndirectCommandsLayoutCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkIndirectCommandsLayoutCreateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkIndirectCommandsLayoutCreateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkIndirectCommandsLayoutUsageFlagsNV*)&forMarshaling->flags, sizeof(VkIndirectCommandsLayoutUsageFlagsNV));
+ memcpy(*ptr, (VkIndirectCommandsLayoutUsageFlagsNV*)&forMarshaling->flags,
+ sizeof(VkIndirectCommandsLayoutUsageFlagsNV));
*ptr += sizeof(VkIndirectCommandsLayoutUsageFlagsNV);
- memcpy(*ptr, (VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ memcpy(*ptr, (VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
*ptr += sizeof(VkPipelineBindPoint);
memcpy(*ptr, (uint32_t*)&forMarshaling->tokenCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->tokenCount; ++i)
- {
- reservedmarshal_VkIndirectCommandsLayoutTokenNV(vkStream, rootType, (const VkIndirectCommandsLayoutTokenNV*)(forMarshaling->pTokens + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->tokenCount; ++i) {
+ reservedmarshal_VkIndirectCommandsLayoutTokenNV(
+ vkStream, rootType,
+ (const VkIndirectCommandsLayoutTokenNV*)(forMarshaling->pTokens + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->streamCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const uint32_t*)forMarshaling->pStreamStrides, forMarshaling->streamCount * sizeof(const uint32_t));
+ memcpy(*ptr, (const uint32_t*)forMarshaling->pStreamStrides,
+ forMarshaling->streamCount * sizeof(const uint32_t));
*ptr += forMarshaling->streamCount * sizeof(const uint32_t);
}
-void reservedmarshal_VkGeneratedCommandsInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeneratedCommandsInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkGeneratedCommandsInfoNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkGeneratedCommandsInfoNV* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ memcpy(*ptr, (VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
*ptr += sizeof(VkPipelineBindPoint);
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPipeline((*&forMarshaling->pipeline));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
uint64_t cgen_var_1;
- *&cgen_var_1 = get_host_u64_VkIndirectCommandsLayoutNV((*&forMarshaling->indirectCommandsLayout));
+ *&cgen_var_1 =
+ get_host_u64_VkIndirectCommandsLayoutNV((*&forMarshaling->indirectCommandsLayout));
memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
*ptr += 1 * 8;
memcpy(*ptr, (uint32_t*)&forMarshaling->streamCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->streamCount; ++i)
- {
- reservedmarshal_VkIndirectCommandsStreamNV(vkStream, rootType, (const VkIndirectCommandsStreamNV*)(forMarshaling->pStreams + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->streamCount; ++i) {
+ reservedmarshal_VkIndirectCommandsStreamNV(
+ vkStream, rootType, (const VkIndirectCommandsStreamNV*)(forMarshaling->pStreams + i),
+ ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->sequencesCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -16715,28 +15028,26 @@
}
void reservedmarshal_VkGeneratedCommandsMemoryRequirementsInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeneratedCommandsMemoryRequirementsInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeneratedCommandsMemoryRequirementsInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
+ memcpy(*ptr, (VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint,
+ sizeof(VkPipelineBindPoint));
*ptr += sizeof(VkPipelineBindPoint);
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkPipeline((*&forMarshaling->pipeline));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
uint64_t cgen_var_1;
- *&cgen_var_1 = get_host_u64_VkIndirectCommandsLayoutNV((*&forMarshaling->indirectCommandsLayout));
+ *&cgen_var_1 =
+ get_host_u64_VkIndirectCommandsLayoutNV((*&forMarshaling->indirectCommandsLayout));
memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
*ptr += 1 * 8;
memcpy(*ptr, (uint32_t*)&forMarshaling->maxSequencesCount, sizeof(uint32_t));
@@ -16746,17 +15057,13 @@
#endif
#ifdef VK_NV_inherited_viewport_scissor
void reservedmarshal_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -16765,17 +15072,13 @@
}
void reservedmarshal_VkCommandBufferInheritanceViewportScissorInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferInheritanceViewportScissorInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferInheritanceViewportScissorInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -16788,26 +15091,22 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pViewportDepths)
- {
- reservedmarshal_VkViewport(vkStream, rootType, (const VkViewport*)(forMarshaling->pViewportDepths), ptr);
+ if (forMarshaling->pViewportDepths) {
+ reservedmarshal_VkViewport(vkStream, rootType,
+ (const VkViewport*)(forMarshaling->pViewportDepths), ptr);
}
}
#endif
#ifdef VK_EXT_texel_buffer_alignment
void reservedmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -16816,67 +15115,61 @@
}
void reservedmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDeviceSize*)&forMarshaling->storageTexelBufferOffsetAlignmentBytes, sizeof(VkDeviceSize));
+ memcpy(*ptr, (VkDeviceSize*)&forMarshaling->storageTexelBufferOffsetAlignmentBytes,
+ sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
- memcpy(*ptr, (VkBool32*)&forMarshaling->storageTexelBufferOffsetSingleTexelAlignment, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->storageTexelBufferOffsetSingleTexelAlignment,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkDeviceSize*)&forMarshaling->uniformTexelBufferOffsetAlignmentBytes, sizeof(VkDeviceSize));
+ memcpy(*ptr, (VkDeviceSize*)&forMarshaling->uniformTexelBufferOffsetAlignmentBytes,
+ sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
- memcpy(*ptr, (VkBool32*)&forMarshaling->uniformTexelBufferOffsetSingleTexelAlignment, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->uniformTexelBufferOffsetSingleTexelAlignment,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
#endif
#ifdef VK_QCOM_render_pass_transform
void reservedmarshal_VkRenderPassTransformBeginInfoQCOM(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassTransformBeginInfoQCOM* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassTransformBeginInfoQCOM* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ memcpy(*ptr, (VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
*ptr += sizeof(VkSurfaceTransformFlagBitsKHR);
}
void reservedmarshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ memcpy(*ptr, (VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
*ptr += sizeof(VkSurfaceTransformFlagBitsKHR);
reservedmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->renderArea), ptr);
}
@@ -16884,17 +15177,13 @@
#endif
#ifdef VK_EXT_device_memory_report
void reservedmarshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -16903,23 +15192,21 @@
}
void reservedmarshal_VkDeviceMemoryReportCallbackDataEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceMemoryReportCallbackDataEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceMemoryReportCallbackDataEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDeviceMemoryReportFlagsEXT*)&forMarshaling->flags, sizeof(VkDeviceMemoryReportFlagsEXT));
+ memcpy(*ptr, (VkDeviceMemoryReportFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkDeviceMemoryReportFlagsEXT));
*ptr += sizeof(VkDeviceMemoryReportFlagsEXT);
- memcpy(*ptr, (VkDeviceMemoryReportEventTypeEXT*)&forMarshaling->type, sizeof(VkDeviceMemoryReportEventTypeEXT));
+ memcpy(*ptr, (VkDeviceMemoryReportEventTypeEXT*)&forMarshaling->type,
+ sizeof(VkDeviceMemoryReportEventTypeEXT));
*ptr += sizeof(VkDeviceMemoryReportEventTypeEXT);
memcpy(*ptr, (uint64_t*)&forMarshaling->memoryObjectId, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
@@ -16934,21 +15221,18 @@
}
void reservedmarshal_VkDeviceDeviceMemoryReportCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceDeviceMemoryReportCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceDeviceMemoryReportCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDeviceMemoryReportFlagsEXT*)&forMarshaling->flags, sizeof(VkDeviceMemoryReportFlagsEXT));
+ memcpy(*ptr, (VkDeviceMemoryReportFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkDeviceMemoryReportFlagsEXT));
*ptr += sizeof(VkDeviceMemoryReportFlagsEXT);
uint64_t cgen_var_0 = (uint64_t)forMarshaling->pfnUserCallback;
memcpy((*ptr), &cgen_var_0, 8);
@@ -16963,17 +15247,13 @@
#endif
#ifdef VK_EXT_robustness2
void reservedmarshal_VkPhysicalDeviceRobustness2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRobustness2FeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRobustness2FeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -16986,60 +15266,51 @@
}
void reservedmarshal_VkPhysicalDeviceRobustness2PropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRobustness2PropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRobustness2PropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDeviceSize*)&forMarshaling->robustStorageBufferAccessSizeAlignment, sizeof(VkDeviceSize));
+ memcpy(*ptr, (VkDeviceSize*)&forMarshaling->robustStorageBufferAccessSizeAlignment,
+ sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
- memcpy(*ptr, (VkDeviceSize*)&forMarshaling->robustUniformBufferAccessSizeAlignment, sizeof(VkDeviceSize));
+ memcpy(*ptr, (VkDeviceSize*)&forMarshaling->robustUniformBufferAccessSizeAlignment,
+ sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
}
#endif
#ifdef VK_EXT_custom_border_color
void reservedmarshal_VkSamplerCustomBorderColorCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerCustomBorderColorCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerCustomBorderColorCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkClearColorValue(vkStream, rootType, (VkClearColorValue*)(&forMarshaling->customBorderColor), ptr);
+ reservedmarshal_VkClearColorValue(vkStream, rootType,
+ (VkClearColorValue*)(&forMarshaling->customBorderColor), ptr);
memcpy(*ptr, (VkFormat*)&forMarshaling->format, sizeof(VkFormat));
*ptr += sizeof(VkFormat);
}
void reservedmarshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCustomBorderColorPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCustomBorderColorPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17048,17 +15319,13 @@
}
void reservedmarshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCustomBorderColorFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCustomBorderColorFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17073,17 +15340,13 @@
#endif
#ifdef VK_EXT_private_data
void reservedmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePrivateDataFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePrivateDataFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17092,17 +15355,13 @@
}
void reservedmarshal_VkDevicePrivateDataCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDevicePrivateDataCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDevicePrivateDataCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17111,38 +15370,31 @@
}
void reservedmarshal_VkPrivateDataSlotCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPrivateDataSlotCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPrivateDataSlotCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkPrivateDataSlotCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkPrivateDataSlotCreateFlagsEXT));
+ memcpy(*ptr, (VkPrivateDataSlotCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkPrivateDataSlotCreateFlagsEXT));
*ptr += sizeof(VkPrivateDataSlotCreateFlagsEXT);
}
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
void reservedmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17153,17 +15405,13 @@
#endif
#ifdef VK_NV_device_diagnostics_config
void reservedmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17172,21 +15420,18 @@
}
void reservedmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceDiagnosticsConfigCreateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceDiagnosticsConfigCreateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDeviceDiagnosticsConfigFlagsNV*)&forMarshaling->flags, sizeof(VkDeviceDiagnosticsConfigFlagsNV));
+ memcpy(*ptr, (VkDeviceDiagnosticsConfigFlagsNV*)&forMarshaling->flags,
+ sizeof(VkDeviceDiagnosticsConfigFlagsNV));
*ptr += sizeof(VkDeviceDiagnosticsConfigFlagsNV);
}
@@ -17195,17 +15440,13 @@
#endif
#ifdef VK_NV_fragment_shading_rate_enums
void reservedmarshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17218,55 +15459,48 @@
}
void reservedmarshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->maxFragmentShadingRateInvocationCount, sizeof(VkSampleCountFlagBits));
+ memcpy(*ptr, (VkSampleCountFlagBits*)&forMarshaling->maxFragmentShadingRateInvocationCount,
+ sizeof(VkSampleCountFlagBits));
*ptr += sizeof(VkSampleCountFlagBits);
}
void reservedmarshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkFragmentShadingRateTypeNV*)&forMarshaling->shadingRateType, sizeof(VkFragmentShadingRateTypeNV));
+ memcpy(*ptr, (VkFragmentShadingRateTypeNV*)&forMarshaling->shadingRateType,
+ sizeof(VkFragmentShadingRateTypeNV));
*ptr += sizeof(VkFragmentShadingRateTypeNV);
- memcpy(*ptr, (VkFragmentShadingRateNV*)&forMarshaling->shadingRate, sizeof(VkFragmentShadingRateNV));
+ memcpy(*ptr, (VkFragmentShadingRateNV*)&forMarshaling->shadingRate,
+ sizeof(VkFragmentShadingRateNV));
*ptr += sizeof(VkFragmentShadingRateNV);
- memcpy(*ptr, (VkFragmentShadingRateCombinerOpKHR*)forMarshaling->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
+ memcpy(*ptr, (VkFragmentShadingRateCombinerOpKHR*)forMarshaling->combinerOps,
+ 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
*ptr += 2 * sizeof(VkFragmentShadingRateCombinerOpKHR);
}
#endif
#ifdef VK_NV_ray_tracing_motion_blur
void reservedmarshal_VkDeviceOrHostAddressConstKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceOrHostAddressConstKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceOrHostAddressConstKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
@@ -17274,77 +15508,65 @@
}
void reservedmarshal_VkAccelerationStructureGeometryMotionTrianglesDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryMotionTrianglesDataNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureGeometryMotionTrianglesDataNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->vertexData), ptr);
+ reservedmarshal_VkDeviceOrHostAddressConstKHR(
+ vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->vertexData), ptr);
}
void reservedmarshal_VkAccelerationStructureMotionInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureMotionInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureMotionInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxInstances, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkAccelerationStructureMotionInfoFlagsNV*)&forMarshaling->flags, sizeof(VkAccelerationStructureMotionInfoFlagsNV));
+ memcpy(*ptr, (VkAccelerationStructureMotionInfoFlagsNV*)&forMarshaling->flags,
+ sizeof(VkAccelerationStructureMotionInfoFlagsNV));
*ptr += sizeof(VkAccelerationStructureMotionInfoFlagsNV);
}
void reservedmarshal_VkAccelerationStructureMatrixMotionInstanceNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureMatrixMotionInstanceNV* forMarshaling,
- uint8_t** ptr)
-{
-
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureMatrixMotionInstanceNV* forMarshaling, uint8_t** ptr) {
typedef struct VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields {
- VkTransformMatrixKHR transformT0;
- VkTransformMatrixKHR transformT1;
- uint32_t dwords[2];
- uint64_t accelerationStructureReference;
+ VkTransformMatrixKHR transformT0;
+ VkTransformMatrixKHR transformT1;
+ uint32_t dwords[2];
+ uint64_t accelerationStructureReference;
} VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields;
-
+
(void)vkStream;
- const VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields* forMarshaling_new = (const VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields*)(forMarshaling);
- reservedmarshal_VkTransformMatrixKHR(vkStream, rootType, (VkTransformMatrixKHR*)(&forMarshaling_new->transformT0), ptr);
- reservedmarshal_VkTransformMatrixKHR(vkStream, rootType, (VkTransformMatrixKHR*)(&forMarshaling_new->transformT1), ptr);
+ const VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields* forMarshaling_new =
+ (const VkAccelerationStructureMatrixMotionInstanceNVWithoutBitFields*)(forMarshaling);
+ reservedmarshal_VkTransformMatrixKHR(
+ vkStream, rootType, (VkTransformMatrixKHR*)(&forMarshaling_new->transformT0), ptr);
+ reservedmarshal_VkTransformMatrixKHR(
+ vkStream, rootType, (VkTransformMatrixKHR*)(&forMarshaling_new->transformT1), ptr);
for (uint32_t i = 0; i < 2; i++) {
memcpy(*ptr, (uint32_t*)&(forMarshaling_new->dwords[i]), sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
memcpy(*ptr, (uint64_t*)&forMarshaling_new->accelerationStructureReference, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
-
}
-void reservedmarshal_VkSRTDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSRTDataNV* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSRTDataNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSRTDataNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (float*)&forMarshaling->sx, sizeof(float));
@@ -17382,93 +15604,84 @@
}
void reservedmarshal_VkAccelerationStructureSRTMotionInstanceNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureSRTMotionInstanceNV* forMarshaling,
- uint8_t** ptr)
-{
-
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureSRTMotionInstanceNV* forMarshaling, uint8_t** ptr) {
typedef struct VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields {
- VkSRTDataNV transformT0;
- VkSRTDataNV transformT1;
- uint32_t dwords[2];
- uint64_t accelerationStructureReference;
+ VkSRTDataNV transformT0;
+ VkSRTDataNV transformT1;
+ uint32_t dwords[2];
+ uint64_t accelerationStructureReference;
} VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields;
-
+
(void)vkStream;
- const VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields* forMarshaling_new = (const VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields*)(forMarshaling);
- reservedmarshal_VkSRTDataNV(vkStream, rootType, (VkSRTDataNV*)(&forMarshaling_new->transformT0), ptr);
- reservedmarshal_VkSRTDataNV(vkStream, rootType, (VkSRTDataNV*)(&forMarshaling_new->transformT1), ptr);
+ const VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields* forMarshaling_new =
+ (const VkAccelerationStructureSRTMotionInstanceNVWithoutBitFields*)(forMarshaling);
+ reservedmarshal_VkSRTDataNV(vkStream, rootType, (VkSRTDataNV*)(&forMarshaling_new->transformT0),
+ ptr);
+ reservedmarshal_VkSRTDataNV(vkStream, rootType, (VkSRTDataNV*)(&forMarshaling_new->transformT1),
+ ptr);
for (uint32_t i = 0; i < 2; i++) {
memcpy(*ptr, (uint32_t*)&(forMarshaling_new->dwords[i]), sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
memcpy(*ptr, (uint64_t*)&forMarshaling_new->accelerationStructureReference, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
-
}
void reservedmarshal_VkAccelerationStructureMotionInstanceDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureMotionInstanceDataNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureMotionInstanceDataNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- reservedmarshal_VkAccelerationStructureInstanceKHR(vkStream, rootType, (VkAccelerationStructureInstanceKHR*)(&forMarshaling->staticInstance), ptr);
+ reservedmarshal_VkAccelerationStructureInstanceKHR(
+ vkStream, rootType, (VkAccelerationStructureInstanceKHR*)(&forMarshaling->staticInstance),
+ ptr);
}
void reservedmarshal_VkAccelerationStructureMotionInstanceNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureMotionInstanceNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureMotionInstanceNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- memcpy(*ptr, (VkAccelerationStructureMotionInstanceTypeNV*)&forMarshaling->type, sizeof(VkAccelerationStructureMotionInstanceTypeNV));
+ memcpy(*ptr, (VkAccelerationStructureMotionInstanceTypeNV*)&forMarshaling->type,
+ sizeof(VkAccelerationStructureMotionInstanceTypeNV));
*ptr += sizeof(VkAccelerationStructureMotionInstanceTypeNV);
- memcpy(*ptr, (VkAccelerationStructureMotionInstanceFlagsNV*)&forMarshaling->flags, sizeof(VkAccelerationStructureMotionInstanceFlagsNV));
+ memcpy(*ptr, (VkAccelerationStructureMotionInstanceFlagsNV*)&forMarshaling->flags,
+ sizeof(VkAccelerationStructureMotionInstanceFlagsNV));
*ptr += sizeof(VkAccelerationStructureMotionInstanceFlagsNV);
- reservedmarshal_VkAccelerationStructureMotionInstanceDataNV(vkStream, rootType, (VkAccelerationStructureMotionInstanceDataNV*)(&forMarshaling->data), ptr);
+ reservedmarshal_VkAccelerationStructureMotionInstanceDataNV(
+ vkStream, rootType, (VkAccelerationStructureMotionInstanceDataNV*)(&forMarshaling->data),
+ ptr);
}
void reservedmarshal_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->rayTracingMotionBlur, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->rayTracingMotionBlurPipelineTraceRaysIndirect, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->rayTracingMotionBlurPipelineTraceRaysIndirect,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
void reservedmarshal_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17479,17 +15692,13 @@
#endif
#ifdef VK_EXT_fragment_density_map2
void reservedmarshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17498,23 +15707,20 @@
}
void reservedmarshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->subsampledLoads, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->subsampledCoarseReconstructionEarlyAccess, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->subsampledCoarseReconstructionEarlyAccess,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxSubsampledArrayLayers, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -17525,38 +15731,31 @@
#endif
#ifdef VK_QCOM_rotated_copy_commands
void reservedmarshal_VkCopyCommandTransformInfoQCOM(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyCommandTransformInfoQCOM* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyCommandTransformInfoQCOM* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
+ memcpy(*ptr, (VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform,
+ sizeof(VkSurfaceTransformFlagBitsKHR));
*ptr += sizeof(VkSurfaceTransformFlagBitsKHR);
}
#endif
#ifdef VK_EXT_image_robustness
void reservedmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceImageRobustnessFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceImageRobustnessFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17567,17 +15766,13 @@
#endif
#ifdef VK_EXT_4444_formats
void reservedmarshal_VkPhysicalDevice4444FormatsFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevice4444FormatsFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevice4444FormatsFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17590,17 +15785,13 @@
#endif
#ifdef VK_EXT_rgba10x6_formats
void reservedmarshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17613,29 +15804,25 @@
#endif
#ifdef VK_EXT_directfb_surface
void reservedmarshal_VkDirectFBSurfaceCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDirectFBSurfaceCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDirectFBSurfaceCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkDirectFBSurfaceCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkDirectFBSurfaceCreateFlagsEXT));
+ memcpy(*ptr, (VkDirectFBSurfaceCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkDirectFBSurfaceCreateFlagsEXT));
*ptr += sizeof(VkDirectFBSurfaceCreateFlagsEXT);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->dfb;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->dfb)
- {
+ if (forMarshaling->dfb) {
memcpy(*ptr, (IDirectFB*)forMarshaling->dfb, sizeof(IDirectFB));
*ptr += sizeof(IDirectFB);
}
@@ -17644,8 +15831,7 @@
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->surface)
- {
+ if (forMarshaling->surface) {
memcpy(*ptr, (IDirectFBSurface*)forMarshaling->surface, sizeof(IDirectFBSurface));
*ptr += sizeof(IDirectFBSurface);
}
@@ -17654,17 +15840,13 @@
#endif
#ifdef VK_VALVE_mutable_descriptor_type
void reservedmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17673,56 +15855,49 @@
}
void reservedmarshal_VkMutableDescriptorTypeListVALVE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMutableDescriptorTypeListVALVE* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMutableDescriptorTypeListVALVE* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->descriptorTypeCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const VkDescriptorType*)forMarshaling->pDescriptorTypes, forMarshaling->descriptorTypeCount * sizeof(const VkDescriptorType));
+ memcpy(*ptr, (const VkDescriptorType*)forMarshaling->pDescriptorTypes,
+ forMarshaling->descriptorTypeCount * sizeof(const VkDescriptorType));
*ptr += forMarshaling->descriptorTypeCount * sizeof(const VkDescriptorType);
}
void reservedmarshal_VkMutableDescriptorTypeCreateInfoVALVE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMutableDescriptorTypeCreateInfoVALVE* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMutableDescriptorTypeCreateInfoVALVE* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->mutableDescriptorTypeListCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->mutableDescriptorTypeListCount; ++i)
- {
- reservedmarshal_VkMutableDescriptorTypeListVALVE(vkStream, rootType, (const VkMutableDescriptorTypeListVALVE*)(forMarshaling->pMutableDescriptorTypeLists + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->mutableDescriptorTypeListCount; ++i) {
+ reservedmarshal_VkMutableDescriptorTypeListVALVE(
+ vkStream, rootType,
+ (const VkMutableDescriptorTypeListVALVE*)(forMarshaling->pMutableDescriptorTypeLists +
+ i),
+ ptr);
}
}
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
void reservedmarshal_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17731,17 +15906,13 @@
}
void reservedmarshal_VkVertexInputBindingDescription2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVertexInputBindingDescription2EXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVertexInputBindingDescription2EXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17756,17 +15927,13 @@
}
void reservedmarshal_VkVertexInputAttributeDescription2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVertexInputAttributeDescription2EXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVertexInputAttributeDescription2EXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17783,17 +15950,13 @@
#endif
#ifdef VK_EXT_physical_device_drm
void reservedmarshal_VkPhysicalDeviceDrmPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDrmPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDrmPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17814,17 +15977,13 @@
#endif
#ifdef VK_EXT_primitive_topology_list_restart
void reservedmarshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17837,38 +15996,31 @@
#endif
#ifdef VK_FUCHSIA_external_memory
void reservedmarshal_VkImportMemoryZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportMemoryZirconHandleInfoFUCHSIA* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportMemoryZirconHandleInfoFUCHSIA* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
memcpy(*ptr, (zx_handle_t*)&forMarshaling->handle, sizeof(zx_handle_t));
*ptr += sizeof(zx_handle_t);
}
void reservedmarshal_VkMemoryZirconHandlePropertiesFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryZirconHandlePropertiesFUCHSIA* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryZirconHandlePropertiesFUCHSIA* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17877,17 +16029,13 @@
}
void reservedmarshal_VkMemoryGetZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryGetZirconHandleInfoFUCHSIA* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17895,24 +16043,21 @@
*&cgen_var_0 = get_host_u64_VkDeviceMemory((*&forMarshaling->memory));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
- memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
}
#endif
#ifdef VK_FUCHSIA_external_semaphore
void reservedmarshal_VkImportSemaphoreZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportSemaphoreZirconHandleInfoFUCHSIA* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17922,24 +16067,21 @@
*ptr += 1 * 8;
memcpy(*ptr, (VkSemaphoreImportFlags*)&forMarshaling->flags, sizeof(VkSemaphoreImportFlags));
*ptr += sizeof(VkSemaphoreImportFlags);
- memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
*ptr += sizeof(VkExternalSemaphoreHandleTypeFlagBits);
memcpy(*ptr, (zx_handle_t*)&forMarshaling->zirconHandle, sizeof(zx_handle_t));
*ptr += sizeof(zx_handle_t);
}
void reservedmarshal_VkSemaphoreGetZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreGetZirconHandleInfoFUCHSIA* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17947,24 +16089,21 @@
*&cgen_var_0 = get_host_u64_VkSemaphore((*&forMarshaling->semaphore));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
- memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalSemaphoreHandleTypeFlagBits));
*ptr += sizeof(VkExternalSemaphoreHandleTypeFlagBits);
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
void reservedmarshal_VkBufferCollectionCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCollectionCreateInfoFUCHSIA* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCollectionCreateInfoFUCHSIA* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17973,17 +16112,13 @@
}
void reservedmarshal_VkImportMemoryBufferCollectionFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportMemoryBufferCollectionFUCHSIA* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportMemoryBufferCollectionFUCHSIA* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -17996,17 +16131,13 @@
}
void reservedmarshal_VkBufferCollectionImageCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCollectionImageCreateInfoFUCHSIA* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCollectionImageCreateInfoFUCHSIA* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18019,17 +16150,13 @@
}
void reservedmarshal_VkBufferCollectionConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCollectionConstraintsInfoFUCHSIA* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCollectionConstraintsInfoFUCHSIA* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18046,38 +16173,35 @@
}
void reservedmarshal_VkBufferConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferConstraintsInfoFUCHSIA* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferConstraintsInfoFUCHSIA* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkBufferCreateInfo(vkStream, rootType, (VkBufferCreateInfo*)(&forMarshaling->createInfo), ptr);
- memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->requiredFormatFeatures, sizeof(VkFormatFeatureFlags));
+ reservedmarshal_VkBufferCreateInfo(vkStream, rootType,
+ (VkBufferCreateInfo*)(&forMarshaling->createInfo), ptr);
+ memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->requiredFormatFeatures,
+ sizeof(VkFormatFeatureFlags));
*ptr += sizeof(VkFormatFeatureFlags);
- reservedmarshal_VkBufferCollectionConstraintsInfoFUCHSIA(vkStream, rootType, (VkBufferCollectionConstraintsInfoFUCHSIA*)(&forMarshaling->bufferCollectionConstraints), ptr);
+ reservedmarshal_VkBufferCollectionConstraintsInfoFUCHSIA(
+ vkStream, rootType,
+ (VkBufferCollectionConstraintsInfoFUCHSIA*)(&forMarshaling->bufferCollectionConstraints),
+ ptr);
}
void reservedmarshal_VkBufferCollectionBufferCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCollectionBufferCreateInfoFUCHSIA* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCollectionBufferCreateInfoFUCHSIA* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18089,18 +16213,15 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkSysmemColorSpaceFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSysmemColorSpaceFUCHSIA* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkSysmemColorSpaceFUCHSIA(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkSysmemColorSpaceFUCHSIA* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18109,17 +16230,13 @@
}
void reservedmarshal_VkBufferCollectionPropertiesFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCollectionPropertiesFUCHSIA* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCollectionPropertiesFUCHSIA* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18131,87 +16248,94 @@
*ptr += sizeof(uint32_t);
memcpy(*ptr, (uint64_t*)&forMarshaling->sysmemPixelFormat, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
- memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->formatFeatures, sizeof(VkFormatFeatureFlags));
+ memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->formatFeatures,
+ sizeof(VkFormatFeatureFlags));
*ptr += sizeof(VkFormatFeatureFlags);
- reservedmarshal_VkSysmemColorSpaceFUCHSIA(vkStream, rootType, (VkSysmemColorSpaceFUCHSIA*)(&forMarshaling->sysmemColorSpaceIndex), ptr);
- reservedmarshal_VkComponentMapping(vkStream, rootType, (VkComponentMapping*)(&forMarshaling->samplerYcbcrConversionComponents), ptr);
- memcpy(*ptr, (VkSamplerYcbcrModelConversion*)&forMarshaling->suggestedYcbcrModel, sizeof(VkSamplerYcbcrModelConversion));
+ reservedmarshal_VkSysmemColorSpaceFUCHSIA(
+ vkStream, rootType, (VkSysmemColorSpaceFUCHSIA*)(&forMarshaling->sysmemColorSpaceIndex),
+ ptr);
+ reservedmarshal_VkComponentMapping(
+ vkStream, rootType, (VkComponentMapping*)(&forMarshaling->samplerYcbcrConversionComponents),
+ ptr);
+ memcpy(*ptr, (VkSamplerYcbcrModelConversion*)&forMarshaling->suggestedYcbcrModel,
+ sizeof(VkSamplerYcbcrModelConversion));
*ptr += sizeof(VkSamplerYcbcrModelConversion);
- memcpy(*ptr, (VkSamplerYcbcrRange*)&forMarshaling->suggestedYcbcrRange, sizeof(VkSamplerYcbcrRange));
+ memcpy(*ptr, (VkSamplerYcbcrRange*)&forMarshaling->suggestedYcbcrRange,
+ sizeof(VkSamplerYcbcrRange));
*ptr += sizeof(VkSamplerYcbcrRange);
- memcpy(*ptr, (VkChromaLocation*)&forMarshaling->suggestedXChromaOffset, sizeof(VkChromaLocation));
+ memcpy(*ptr, (VkChromaLocation*)&forMarshaling->suggestedXChromaOffset,
+ sizeof(VkChromaLocation));
*ptr += sizeof(VkChromaLocation);
- memcpy(*ptr, (VkChromaLocation*)&forMarshaling->suggestedYChromaOffset, sizeof(VkChromaLocation));
+ memcpy(*ptr, (VkChromaLocation*)&forMarshaling->suggestedYChromaOffset,
+ sizeof(VkChromaLocation));
*ptr += sizeof(VkChromaLocation);
}
void reservedmarshal_VkImageFormatConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageFormatConstraintsInfoFUCHSIA* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageFormatConstraintsInfoFUCHSIA* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkImageCreateInfo(vkStream, rootType, (VkImageCreateInfo*)(&forMarshaling->imageCreateInfo), ptr);
- memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->requiredFormatFeatures, sizeof(VkFormatFeatureFlags));
+ reservedmarshal_VkImageCreateInfo(vkStream, rootType,
+ (VkImageCreateInfo*)(&forMarshaling->imageCreateInfo), ptr);
+ memcpy(*ptr, (VkFormatFeatureFlags*)&forMarshaling->requiredFormatFeatures,
+ sizeof(VkFormatFeatureFlags));
*ptr += sizeof(VkFormatFeatureFlags);
- memcpy(*ptr, (VkImageFormatConstraintsFlagsFUCHSIA*)&forMarshaling->flags, sizeof(VkImageFormatConstraintsFlagsFUCHSIA));
+ memcpy(*ptr, (VkImageFormatConstraintsFlagsFUCHSIA*)&forMarshaling->flags,
+ sizeof(VkImageFormatConstraintsFlagsFUCHSIA));
*ptr += sizeof(VkImageFormatConstraintsFlagsFUCHSIA);
memcpy(*ptr, (uint64_t*)&forMarshaling->sysmemPixelFormat, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
memcpy(*ptr, (uint32_t*)&forMarshaling->colorSpaceCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- reservedmarshal_VkSysmemColorSpaceFUCHSIA(vkStream, rootType, (const VkSysmemColorSpaceFUCHSIA*)(forMarshaling->pColorSpaces), ptr);
+ reservedmarshal_VkSysmemColorSpaceFUCHSIA(
+ vkStream, rootType, (const VkSysmemColorSpaceFUCHSIA*)(forMarshaling->pColorSpaces), ptr);
}
void reservedmarshal_VkImageConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageConstraintsInfoFUCHSIA* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageConstraintsInfoFUCHSIA* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->formatConstraintsCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->formatConstraintsCount; ++i)
- {
- reservedmarshal_VkImageFormatConstraintsInfoFUCHSIA(vkStream, rootType, (const VkImageFormatConstraintsInfoFUCHSIA*)(forMarshaling->pFormatConstraints + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->formatConstraintsCount; ++i) {
+ reservedmarshal_VkImageFormatConstraintsInfoFUCHSIA(
+ vkStream, rootType,
+ (const VkImageFormatConstraintsInfoFUCHSIA*)(forMarshaling->pFormatConstraints + i),
+ ptr);
}
- reservedmarshal_VkBufferCollectionConstraintsInfoFUCHSIA(vkStream, rootType, (VkBufferCollectionConstraintsInfoFUCHSIA*)(&forMarshaling->bufferCollectionConstraints), ptr);
- memcpy(*ptr, (VkImageConstraintsInfoFlagsFUCHSIA*)&forMarshaling->flags, sizeof(VkImageConstraintsInfoFlagsFUCHSIA));
+ reservedmarshal_VkBufferCollectionConstraintsInfoFUCHSIA(
+ vkStream, rootType,
+ (VkBufferCollectionConstraintsInfoFUCHSIA*)(&forMarshaling->bufferCollectionConstraints),
+ ptr);
+ memcpy(*ptr, (VkImageConstraintsInfoFlagsFUCHSIA*)&forMarshaling->flags,
+ sizeof(VkImageConstraintsInfoFlagsFUCHSIA));
*ptr += sizeof(VkImageConstraintsInfoFlagsFUCHSIA);
}
#endif
#ifdef VK_HUAWEI_subpass_shading
void reservedmarshal_VkSubpassShadingPipelineCreateInfoHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassShadingPipelineCreateInfoHUAWEI* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassShadingPipelineCreateInfoHUAWEI* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18224,17 +16348,13 @@
}
void reservedmarshal_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18243,38 +16363,31 @@
}
void reservedmarshal_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxSubpassShadingWorkgroupSizeAspectRatio, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxSubpassShadingWorkgroupSizeAspectRatio,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
#endif
#ifdef VK_HUAWEI_invocation_mask
void reservedmarshal_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18285,17 +16398,13 @@
#endif
#ifdef VK_NV_external_memory_rdma
void reservedmarshal_VkMemoryGetRemoteAddressInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryGetRemoteAddressInfoNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryGetRemoteAddressInfoNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18303,22 +16412,19 @@
*&cgen_var_0 = get_host_u64_VkDeviceMemory((*&forMarshaling->memory));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
- memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
+ memcpy(*ptr, (VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
*ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
}
void reservedmarshal_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18329,17 +16435,13 @@
#endif
#ifdef VK_EXT_extended_dynamic_state2
void reservedmarshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18347,36 +16449,34 @@
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->extendedDynamicState2LogicOp, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->extendedDynamicState2PatchControlPoints, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->extendedDynamicState2PatchControlPoints,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
#endif
#ifdef VK_QNX_screen_surface
-void reservedmarshal_VkScreenSurfaceCreateInfoQNX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkScreenSurfaceCreateInfoQNX* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkScreenSurfaceCreateInfoQNX(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkScreenSurfaceCreateInfoQNX* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkScreenSurfaceCreateFlagsQNX*)&forMarshaling->flags, sizeof(VkScreenSurfaceCreateFlagsQNX));
+ memcpy(*ptr, (VkScreenSurfaceCreateFlagsQNX*)&forMarshaling->flags,
+ sizeof(VkScreenSurfaceCreateFlagsQNX));
*ptr += sizeof(VkScreenSurfaceCreateFlagsQNX);
// WARNING PTR CHECK
uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->context;
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->context)
- {
+ if (forMarshaling->context) {
memcpy(*ptr, (_screen_context*)forMarshaling->context, sizeof(_screen_context));
*ptr += sizeof(_screen_context);
}
@@ -18385,8 +16485,7 @@
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->window)
- {
+ if (forMarshaling->window) {
memcpy(*ptr, (_screen_window*)forMarshaling->window, sizeof(_screen_window));
*ptr += sizeof(_screen_window);
}
@@ -18395,17 +16494,13 @@
#endif
#ifdef VK_EXT_color_write_enable
void reservedmarshal_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceColorWriteEnableFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceColorWriteEnableFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18414,40 +16509,34 @@
}
void reservedmarshal_VkPipelineColorWriteCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineColorWriteCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineColorWriteCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (const VkBool32*)forMarshaling->pColorWriteEnables, forMarshaling->attachmentCount * sizeof(const VkBool32));
+ memcpy(*ptr, (const VkBool32*)forMarshaling->pColorWriteEnables,
+ forMarshaling->attachmentCount * sizeof(const VkBool32));
*ptr += forMarshaling->attachmentCount * sizeof(const VkBool32);
}
#endif
#ifdef VK_GOOGLE_gfxstream
-void reservedmarshal_VkImportColorBufferGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportColorBufferGOOGLE* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImportColorBufferGOOGLE(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkImportColorBufferGOOGLE* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18455,18 +16544,14 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkImportBufferGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportBufferGOOGLE* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkImportBufferGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportBufferGOOGLE* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18475,17 +16560,13 @@
}
void reservedmarshal_VkImportPhysicalAddressGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportPhysicalAddressGOOGLE* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportPhysicalAddressGOOGLE* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18504,17 +16585,13 @@
#endif
#ifdef VK_EXT_global_priority_query
void reservedmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18523,40 +16600,33 @@
}
void reservedmarshal_VkQueueFamilyGlobalPriorityPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueueFamilyGlobalPriorityPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyGlobalPriorityPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (uint32_t*)&forMarshaling->priorityCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (VkQueueGlobalPriorityEXT*)forMarshaling->priorities, VK_MAX_GLOBAL_PRIORITY_SIZE_EXT * sizeof(VkQueueGlobalPriorityEXT));
+ memcpy(*ptr, (VkQueueGlobalPriorityEXT*)forMarshaling->priorities,
+ VK_MAX_GLOBAL_PRIORITY_SIZE_EXT * sizeof(VkQueueGlobalPriorityEXT));
*ptr += VK_MAX_GLOBAL_PRIORITY_SIZE_EXT * sizeof(VkQueueGlobalPriorityEXT);
}
#endif
#ifdef VK_EXT_multi_draw
void reservedmarshal_VkPhysicalDeviceMultiDrawFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiDrawFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMultiDrawFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18565,17 +16635,13 @@
}
void reservedmarshal_VkPhysicalDeviceMultiDrawPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiDrawPropertiesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMultiDrawPropertiesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18583,12 +16649,8 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkMultiDrawInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMultiDrawInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkMultiDrawInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMultiDrawInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->firstVertex, sizeof(uint32_t));
@@ -18597,12 +16659,10 @@
*ptr += sizeof(uint32_t);
}
-void reservedmarshal_VkMultiDrawIndexedInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMultiDrawIndexedInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkMultiDrawIndexedInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkMultiDrawIndexedInfoEXT* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->firstIndex, sizeof(uint32_t));
@@ -18618,17 +16678,13 @@
#endif
#ifdef VK_EXT_border_color_swizzle
void reservedmarshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18639,21 +16695,18 @@
}
void reservedmarshal_VkSamplerBorderColorComponentMappingCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerBorderColorComponentMappingCreateInfoEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerBorderColorComponentMappingCreateInfoEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkComponentMapping(vkStream, rootType, (VkComponentMapping*)(&forMarshaling->components), ptr);
+ reservedmarshal_VkComponentMapping(vkStream, rootType,
+ (VkComponentMapping*)(&forMarshaling->components), ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->srgb, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
@@ -18661,17 +16714,13 @@
#endif
#ifdef VK_EXT_pageable_device_local_memory
void reservedmarshal_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18681,12 +16730,9 @@
#endif
#ifdef VK_KHR_acceleration_structure
-void reservedmarshal_VkDeviceOrHostAddressKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceOrHostAddressKHR* forMarshaling,
- uint8_t** ptr)
-{
+void reservedmarshal_VkDeviceOrHostAddressKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceOrHostAddressKHR* forMarshaling,
+ uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
@@ -18694,11 +16740,8 @@
}
void reservedmarshal_VkAccelerationStructureBuildRangeInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureBuildRangeInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureBuildRangeInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->primitiveCount, sizeof(uint32_t));
@@ -18712,133 +16755,124 @@
}
void reservedmarshal_VkAccelerationStructureGeometryTrianglesDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryTrianglesDataKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureGeometryTrianglesDataKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkFormat*)&forMarshaling->vertexFormat, sizeof(VkFormat));
*ptr += sizeof(VkFormat);
- reservedmarshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->vertexData), ptr);
+ reservedmarshal_VkDeviceOrHostAddressConstKHR(
+ vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->vertexData), ptr);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->vertexStride, sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (uint32_t*)&forMarshaling->maxVertex, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
memcpy(*ptr, (VkIndexType*)&forMarshaling->indexType, sizeof(VkIndexType));
*ptr += sizeof(VkIndexType);
- reservedmarshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->indexData), ptr);
- reservedmarshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->transformData), ptr);
+ reservedmarshal_VkDeviceOrHostAddressConstKHR(
+ vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->indexData), ptr);
+ reservedmarshal_VkDeviceOrHostAddressConstKHR(
+ vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->transformData), ptr);
}
void reservedmarshal_VkAccelerationStructureGeometryAabbsDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryAabbsDataKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureGeometryAabbsDataKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->data), ptr);
+ reservedmarshal_VkDeviceOrHostAddressConstKHR(
+ vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->data), ptr);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->stride, sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
}
void reservedmarshal_VkAccelerationStructureGeometryInstancesDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryInstancesDataKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureGeometryInstancesDataKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->arrayOfPointers, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- reservedmarshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->data), ptr);
+ reservedmarshal_VkDeviceOrHostAddressConstKHR(
+ vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->data), ptr);
}
void reservedmarshal_VkAccelerationStructureGeometryDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryDataKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureGeometryDataKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
- reservedmarshal_VkAccelerationStructureGeometryTrianglesDataKHR(vkStream, rootType, (VkAccelerationStructureGeometryTrianglesDataKHR*)(&forMarshaling->triangles), ptr);
+ reservedmarshal_VkAccelerationStructureGeometryTrianglesDataKHR(
+ vkStream, rootType,
+ (VkAccelerationStructureGeometryTrianglesDataKHR*)(&forMarshaling->triangles), ptr);
}
void reservedmarshal_VkAccelerationStructureGeometryKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureGeometryKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkGeometryTypeKHR*)&forMarshaling->geometryType, sizeof(VkGeometryTypeKHR));
*ptr += sizeof(VkGeometryTypeKHR);
- reservedmarshal_VkAccelerationStructureGeometryDataKHR(vkStream, rootType, (VkAccelerationStructureGeometryDataKHR*)(&forMarshaling->geometry), ptr);
+ reservedmarshal_VkAccelerationStructureGeometryDataKHR(
+ vkStream, rootType, (VkAccelerationStructureGeometryDataKHR*)(&forMarshaling->geometry),
+ ptr);
memcpy(*ptr, (VkGeometryFlagsKHR*)&forMarshaling->flags, sizeof(VkGeometryFlagsKHR));
*ptr += sizeof(VkGeometryFlagsKHR);
}
void reservedmarshal_VkAccelerationStructureBuildGeometryInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureBuildGeometryInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureBuildGeometryInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkAccelerationStructureTypeKHR*)&forMarshaling->type, sizeof(VkAccelerationStructureTypeKHR));
+ memcpy(*ptr, (VkAccelerationStructureTypeKHR*)&forMarshaling->type,
+ sizeof(VkAccelerationStructureTypeKHR));
*ptr += sizeof(VkAccelerationStructureTypeKHR);
- memcpy(*ptr, (VkBuildAccelerationStructureFlagsKHR*)&forMarshaling->flags, sizeof(VkBuildAccelerationStructureFlagsKHR));
+ memcpy(*ptr, (VkBuildAccelerationStructureFlagsKHR*)&forMarshaling->flags,
+ sizeof(VkBuildAccelerationStructureFlagsKHR));
*ptr += sizeof(VkBuildAccelerationStructureFlagsKHR);
- memcpy(*ptr, (VkBuildAccelerationStructureModeKHR*)&forMarshaling->mode, sizeof(VkBuildAccelerationStructureModeKHR));
+ memcpy(*ptr, (VkBuildAccelerationStructureModeKHR*)&forMarshaling->mode,
+ sizeof(VkBuildAccelerationStructureModeKHR));
*ptr += sizeof(VkBuildAccelerationStructureModeKHR);
uint64_t cgen_var_0;
- *&cgen_var_0 = get_host_u64_VkAccelerationStructureKHR((*&forMarshaling->srcAccelerationStructure));
+ *&cgen_var_0 =
+ get_host_u64_VkAccelerationStructureKHR((*&forMarshaling->srcAccelerationStructure));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
uint64_t cgen_var_1;
- *&cgen_var_1 = get_host_u64_VkAccelerationStructureKHR((*&forMarshaling->dstAccelerationStructure));
+ *&cgen_var_1 =
+ get_host_u64_VkAccelerationStructureKHR((*&forMarshaling->dstAccelerationStructure));
memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
*ptr += 1 * 8;
memcpy(*ptr, (uint32_t*)&forMarshaling->geometryCount, sizeof(uint32_t));
@@ -18848,32 +16882,30 @@
memcpy((*ptr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pGeometries)
- {
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->geometryCount; ++i)
- {
- reservedmarshal_VkAccelerationStructureGeometryKHR(vkStream, rootType, (const VkAccelerationStructureGeometryKHR*)(forMarshaling->pGeometries + i), ptr);
+ if (forMarshaling->pGeometries) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->geometryCount; ++i) {
+ reservedmarshal_VkAccelerationStructureGeometryKHR(
+ vkStream, rootType,
+ (const VkAccelerationStructureGeometryKHR*)(forMarshaling->pGeometries + i), ptr);
}
}
- reservedmarshal_VkDeviceOrHostAddressKHR(vkStream, rootType, (VkDeviceOrHostAddressKHR*)(&forMarshaling->scratchData), ptr);
+ reservedmarshal_VkDeviceOrHostAddressKHR(
+ vkStream, rootType, (VkDeviceOrHostAddressKHR*)(&forMarshaling->scratchData), ptr);
}
void reservedmarshal_VkAccelerationStructureCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureCreateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureCreateInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkAccelerationStructureCreateFlagsKHR*)&forMarshaling->createFlags, sizeof(VkAccelerationStructureCreateFlagsKHR));
+ memcpy(*ptr, (VkAccelerationStructureCreateFlagsKHR*)&forMarshaling->createFlags,
+ sizeof(VkAccelerationStructureCreateFlagsKHR));
*ptr += sizeof(VkAccelerationStructureCreateFlagsKHR);
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkBuffer((*&forMarshaling->buffer));
@@ -18883,24 +16915,21 @@
*ptr += sizeof(VkDeviceSize);
memcpy(*ptr, (VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
*ptr += sizeof(VkDeviceSize);
- memcpy(*ptr, (VkAccelerationStructureTypeKHR*)&forMarshaling->type, sizeof(VkAccelerationStructureTypeKHR));
+ memcpy(*ptr, (VkAccelerationStructureTypeKHR*)&forMarshaling->type,
+ sizeof(VkAccelerationStructureTypeKHR));
*ptr += sizeof(VkAccelerationStructureTypeKHR);
memcpy(*ptr, (VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
*ptr += sizeof(VkDeviceAddress);
}
void reservedmarshal_VkWriteDescriptorSetAccelerationStructureKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWriteDescriptorSetAccelerationStructureKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWriteDescriptorSetAccelerationStructureKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18911,16 +16940,13 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pAccelerationStructures)
- {
- if (forMarshaling->accelerationStructureCount)
- {
+ if (forMarshaling->pAccelerationStructures) {
+ if (forMarshaling->accelerationStructureCount) {
uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*ptr);
- if (forMarshaling)
- {
- for (uint32_t k = 0; k < forMarshaling->accelerationStructureCount; ++k)
- {
- uint64_t tmpval = get_host_u64_VkAccelerationStructureKHR(forMarshaling->pAccelerationStructures[k]);
+ if (forMarshaling) {
+ for (uint32_t k = 0; k < forMarshaling->accelerationStructureCount; ++k) {
+ uint64_t tmpval = get_host_u64_VkAccelerationStructureKHR(
+ forMarshaling->pAccelerationStructures[k]);
memcpy(cgen_var_0_0_ptr + k * 8, &tmpval, sizeof(uint64_t));
}
}
@@ -18930,17 +16956,13 @@
}
void reservedmarshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceAccelerationStructureFeaturesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceAccelerationStructureFeaturesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18952,22 +16974,19 @@
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->accelerationStructureHostCommands, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingAccelerationStructureUpdateAfterBind, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->descriptorBindingAccelerationStructureUpdateAfterBind,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
}
void reservedmarshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceAccelerationStructurePropertiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceAccelerationStructurePropertiesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -18977,70 +16996,66 @@
*ptr += sizeof(uint64_t);
memcpy(*ptr, (uint64_t*)&forMarshaling->maxPrimitiveCount, sizeof(uint64_t));
*ptr += sizeof(uint64_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorAccelerationStructures, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorAccelerationStructures,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindAccelerationStructures, sizeof(uint32_t));
+ memcpy(*ptr,
+ (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindAccelerationStructures,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetAccelerationStructures, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetAccelerationStructures,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindAccelerationStructures, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindAccelerationStructures,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- memcpy(*ptr, (uint32_t*)&forMarshaling->minAccelerationStructureScratchOffsetAlignment, sizeof(uint32_t));
+ memcpy(*ptr, (uint32_t*)&forMarshaling->minAccelerationStructureScratchOffsetAlignment,
+ sizeof(uint32_t));
*ptr += sizeof(uint32_t);
}
void reservedmarshal_VkAccelerationStructureDeviceAddressInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureDeviceAddressInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureDeviceAddressInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
uint64_t cgen_var_0;
- *&cgen_var_0 = get_host_u64_VkAccelerationStructureKHR((*&forMarshaling->accelerationStructure));
+ *&cgen_var_0 =
+ get_host_u64_VkAccelerationStructureKHR((*&forMarshaling->accelerationStructure));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
}
void reservedmarshal_VkAccelerationStructureVersionInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureVersionInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureVersionInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (const uint8_t*)forMarshaling->pVersionData, 2*VK_UUID_SIZE * sizeof(const uint8_t));
- *ptr += 2*VK_UUID_SIZE * sizeof(const uint8_t);
+ memcpy(*ptr, (const uint8_t*)forMarshaling->pVersionData,
+ 2 * VK_UUID_SIZE * sizeof(const uint8_t));
+ *ptr += 2 * VK_UUID_SIZE * sizeof(const uint8_t);
}
void reservedmarshal_VkCopyAccelerationStructureToMemoryInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyAccelerationStructureToMemoryInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyAccelerationStructureToMemoryInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -19048,47 +17063,43 @@
*&cgen_var_0 = get_host_u64_VkAccelerationStructureKHR((*&forMarshaling->src));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
- reservedmarshal_VkDeviceOrHostAddressKHR(vkStream, rootType, (VkDeviceOrHostAddressKHR*)(&forMarshaling->dst), ptr);
- memcpy(*ptr, (VkCopyAccelerationStructureModeKHR*)&forMarshaling->mode, sizeof(VkCopyAccelerationStructureModeKHR));
+ reservedmarshal_VkDeviceOrHostAddressKHR(vkStream, rootType,
+ (VkDeviceOrHostAddressKHR*)(&forMarshaling->dst), ptr);
+ memcpy(*ptr, (VkCopyAccelerationStructureModeKHR*)&forMarshaling->mode,
+ sizeof(VkCopyAccelerationStructureModeKHR));
*ptr += sizeof(VkCopyAccelerationStructureModeKHR);
}
void reservedmarshal_VkCopyMemoryToAccelerationStructureInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyMemoryToAccelerationStructureInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyMemoryToAccelerationStructureInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- reservedmarshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->src), ptr);
+ reservedmarshal_VkDeviceOrHostAddressConstKHR(
+ vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->src), ptr);
uint64_t cgen_var_0;
*&cgen_var_0 = get_host_u64_VkAccelerationStructureKHR((*&forMarshaling->dst));
memcpy(*ptr, (uint64_t*)&cgen_var_0, 1 * 8);
*ptr += 1 * 8;
- memcpy(*ptr, (VkCopyAccelerationStructureModeKHR*)&forMarshaling->mode, sizeof(VkCopyAccelerationStructureModeKHR));
+ memcpy(*ptr, (VkCopyAccelerationStructureModeKHR*)&forMarshaling->mode,
+ sizeof(VkCopyAccelerationStructureModeKHR));
*ptr += sizeof(VkCopyAccelerationStructureModeKHR);
}
void reservedmarshal_VkCopyAccelerationStructureInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyAccelerationStructureInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyAccelerationStructureInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -19100,22 +17111,19 @@
*&cgen_var_1 = get_host_u64_VkAccelerationStructureKHR((*&forMarshaling->dst));
memcpy(*ptr, (uint64_t*)&cgen_var_1, 1 * 8);
*ptr += 1 * 8;
- memcpy(*ptr, (VkCopyAccelerationStructureModeKHR*)&forMarshaling->mode, sizeof(VkCopyAccelerationStructureModeKHR));
+ memcpy(*ptr, (VkCopyAccelerationStructureModeKHR*)&forMarshaling->mode,
+ sizeof(VkCopyAccelerationStructureModeKHR));
*ptr += sizeof(VkCopyAccelerationStructureModeKHR);
}
void reservedmarshal_VkAccelerationStructureBuildSizesInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureBuildSizesInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureBuildSizesInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -19130,21 +17138,18 @@
#endif
#ifdef VK_KHR_ray_tracing_pipeline
void reservedmarshal_VkRayTracingShaderGroupCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRayTracingShaderGroupCreateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRayTracingShaderGroupCreateInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
- memcpy(*ptr, (VkRayTracingShaderGroupTypeKHR*)&forMarshaling->type, sizeof(VkRayTracingShaderGroupTypeKHR));
+ memcpy(*ptr, (VkRayTracingShaderGroupTypeKHR*)&forMarshaling->type,
+ sizeof(VkRayTracingShaderGroupTypeKHR));
*ptr += sizeof(VkRayTracingShaderGroupTypeKHR);
memcpy(*ptr, (uint32_t*)&forMarshaling->generalShader, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -19159,25 +17164,21 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pShaderGroupCaptureReplayHandle)
- {
- memcpy(*ptr, (const void*)forMarshaling->pShaderGroupCaptureReplayHandle, sizeof(const uint8_t));
+ if (forMarshaling->pShaderGroupCaptureReplayHandle) {
+ memcpy(*ptr, (const void*)forMarshaling->pShaderGroupCaptureReplayHandle,
+ sizeof(const uint8_t));
*ptr += sizeof(const uint8_t);
}
}
void reservedmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRayTracingPipelineInterfaceCreateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRayTracingPipelineInterfaceCreateInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -19188,17 +17189,13 @@
}
void reservedmarshal_VkRayTracingPipelineCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRayTracingPipelineCreateInfoKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRayTracingPipelineCreateInfoKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -19206,15 +17203,17 @@
*ptr += sizeof(VkPipelineCreateFlags);
memcpy(*ptr, (uint32_t*)&forMarshaling->stageCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i)
- {
- reservedmarshal_VkPipelineShaderStageCreateInfo(vkStream, rootType, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->stageCount; ++i) {
+ reservedmarshal_VkPipelineShaderStageCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->groupCount, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
- for (uint32_t i = 0; i < (uint32_t)forMarshaling->groupCount; ++i)
- {
- reservedmarshal_VkRayTracingShaderGroupCreateInfoKHR(vkStream, rootType, (const VkRayTracingShaderGroupCreateInfoKHR*)(forMarshaling->pGroups + i), ptr);
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->groupCount; ++i) {
+ reservedmarshal_VkRayTracingShaderGroupCreateInfoKHR(
+ vkStream, rootType,
+ (const VkRayTracingShaderGroupCreateInfoKHR*)(forMarshaling->pGroups + i), ptr);
}
memcpy(*ptr, (uint32_t*)&forMarshaling->maxPipelineRayRecursionDepth, sizeof(uint32_t));
*ptr += sizeof(uint32_t);
@@ -19223,27 +17222,31 @@
memcpy((*ptr), &cgen_var_0, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pLibraryInfo)
- {
- reservedmarshal_VkPipelineLibraryCreateInfoKHR(vkStream, rootType, (const VkPipelineLibraryCreateInfoKHR*)(forMarshaling->pLibraryInfo), ptr);
+ if (forMarshaling->pLibraryInfo) {
+ reservedmarshal_VkPipelineLibraryCreateInfoKHR(
+ vkStream, rootType,
+ (const VkPipelineLibraryCreateInfoKHR*)(forMarshaling->pLibraryInfo), ptr);
}
// WARNING PTR CHECK
uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pLibraryInterface;
memcpy((*ptr), &cgen_var_1, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pLibraryInterface)
- {
- reservedmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(vkStream, rootType, (const VkRayTracingPipelineInterfaceCreateInfoKHR*)(forMarshaling->pLibraryInterface), ptr);
+ if (forMarshaling->pLibraryInterface) {
+ reservedmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ vkStream, rootType,
+ (const VkRayTracingPipelineInterfaceCreateInfoKHR*)(forMarshaling->pLibraryInterface),
+ ptr);
}
// WARNING PTR CHECK
uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pDynamicState;
memcpy((*ptr), &cgen_var_2, 8);
android::base::Stream::toBe64((uint8_t*)(*ptr));
*ptr += 8;
- if (forMarshaling->pDynamicState)
- {
- reservedmarshal_VkPipelineDynamicStateCreateInfo(vkStream, rootType, (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState), ptr);
+ if (forMarshaling->pDynamicState) {
+ reservedmarshal_VkPipelineDynamicStateCreateInfo(
+ vkStream, rootType,
+ (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState), ptr);
}
uint64_t cgen_var_3;
*&cgen_var_3 = get_host_u64_VkPipelineLayout((*&forMarshaling->layout));
@@ -19258,25 +17261,23 @@
}
void reservedmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
memcpy(*ptr, (VkBool32*)&forMarshaling->rayTracingPipeline, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->rayTracingPipelineShaderGroupHandleCaptureReplay, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->rayTracingPipelineShaderGroupHandleCaptureReplay,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
- memcpy(*ptr, (VkBool32*)&forMarshaling->rayTracingPipelineShaderGroupHandleCaptureReplayMixed, sizeof(VkBool32));
+ memcpy(*ptr, (VkBool32*)&forMarshaling->rayTracingPipelineShaderGroupHandleCaptureReplayMixed,
+ sizeof(VkBool32));
*ptr += sizeof(VkBool32);
memcpy(*ptr, (VkBool32*)&forMarshaling->rayTracingPipelineTraceRaysIndirect, sizeof(VkBool32));
*ptr += sizeof(VkBool32);
@@ -19285,17 +17286,13 @@
}
void reservedmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -19318,11 +17315,8 @@
}
void reservedmarshal_VkStridedDeviceAddressRegionKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkStridedDeviceAddressRegionKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkStridedDeviceAddressRegionKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
@@ -19334,11 +17328,8 @@
}
void reservedmarshal_VkTraceRaysIndirectCommandKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkTraceRaysIndirectCommandKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkTraceRaysIndirectCommandKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (uint32_t*)&forMarshaling->width, sizeof(uint32_t));
@@ -19352,17 +17343,13 @@
#endif
#ifdef VK_KHR_ray_query
void reservedmarshal_VkPhysicalDeviceRayQueryFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRayQueryFeaturesKHR* forMarshaling,
- uint8_t** ptr)
-{
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRayQueryFeaturesKHR* forMarshaling, uint8_t** ptr) {
(void)vkStream;
(void)rootType;
memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
*ptr += sizeof(VkStructureType);
- if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM)
- {
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
rootType = forMarshaling->sType;
}
reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
@@ -19371,1559 +17358,2085 @@
}
#endif
-void reservedmarshal_extension_struct(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const void* structExtension,
- uint8_t** ptr)
-{
+void reservedmarshal_extension_struct(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const void* structExtension, uint8_t** ptr) {
VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension);
- uint32_t currExtSize = goldfish_vk_extension_struct_size_with_stream_features(vkStream->getFeatureBits(), rootType, structExtension);
- if (!currExtSize && structExtension)
- {
+ uint32_t currExtSize = goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, structExtension);
+ if (!currExtSize && structExtension) {
// unknown struct extension; skip and call on its pNext field
reservedmarshal_extension_struct(vkStream, rootType, (void*)structAccess->pNext, ptr);
return;
- }
- else
- {
+ } else {
// known or null extension struct
- memcpy(*ptr, &currExtSize, sizeof(uint32_t));;
- android::base::Stream::toBe32((uint8_t*)*ptr); *ptr += sizeof(uint32_t);
- if (!currExtSize)
- {
+ memcpy(*ptr, &currExtSize, sizeof(uint32_t));
+ ;
+ android::base::Stream::toBe32((uint8_t*)*ptr);
+ *ptr += sizeof(uint32_t);
+ if (!currExtSize) {
// exit if this was a null extension struct (size == 0 in this branch)
return;
}
}
- memcpy(*ptr, structExtension, sizeof(VkStructureType)); *ptr += sizeof(VkStructureType);
- if (!structExtension)
- {
+ memcpy(*ptr, structExtension, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (!structExtension) {
return;
}
uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension);
- switch(structType)
- {
+ switch (structType) {
#ifdef VK_VERSION_1_1
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
- {
- reservedmarshal_VkPhysicalDeviceSubgroupProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
+ reservedmarshal_VkPhysicalDeviceSubgroupProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
- {
- reservedmarshal_VkPhysicalDevice16BitStorageFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
+ reservedmarshal_VkPhysicalDevice16BitStorageFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
- {
- reservedmarshal_VkMemoryDedicatedRequirements(vkStream, rootType, reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
+ reservedmarshal_VkMemoryDedicatedRequirements(
+ vkStream, rootType,
+ reinterpret_cast<const VkMemoryDedicatedRequirements*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
- {
- reservedmarshal_VkMemoryDedicatedAllocateInfo(vkStream, rootType, reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: {
+ reservedmarshal_VkMemoryDedicatedAllocateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
- {
- reservedmarshal_VkMemoryAllocateFlagsInfo(vkStream, rootType, reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: {
+ reservedmarshal_VkMemoryAllocateFlagsInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
- {
- reservedmarshal_VkDeviceGroupRenderPassBeginInfo(vkStream, rootType, reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: {
+ reservedmarshal_VkDeviceGroupRenderPassBeginInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
- {
- reservedmarshal_VkDeviceGroupCommandBufferBeginInfo(vkStream, rootType, reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: {
+ reservedmarshal_VkDeviceGroupCommandBufferBeginInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
- {
- reservedmarshal_VkDeviceGroupSubmitInfo(vkStream, rootType, reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: {
+ reservedmarshal_VkDeviceGroupSubmitInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceGroupSubmitInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
- {
- reservedmarshal_VkDeviceGroupBindSparseInfo(vkStream, rootType, reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: {
+ reservedmarshal_VkDeviceGroupBindSparseInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
- {
- reservedmarshal_VkBindBufferMemoryDeviceGroupInfo(vkStream, rootType, reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: {
+ reservedmarshal_VkBindBufferMemoryDeviceGroupInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
- {
- reservedmarshal_VkBindImageMemoryDeviceGroupInfo(vkStream, rootType, reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: {
+ reservedmarshal_VkBindImageMemoryDeviceGroupInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
- {
- reservedmarshal_VkDeviceGroupDeviceCreateInfo(vkStream, rootType, reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: {
+ reservedmarshal_VkDeviceGroupDeviceCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
- {
- reservedmarshal_VkPhysicalDeviceFeatures2(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
+ reservedmarshal_VkPhysicalDeviceFeatures2(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFeatures2*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
- {
- reservedmarshal_VkPhysicalDevicePointClippingProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: {
+ reservedmarshal_VkPhysicalDevicePointClippingProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
- {
- reservedmarshal_VkRenderPassInputAttachmentAspectCreateInfo(vkStream, rootType, reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: {
+ reservedmarshal_VkRenderPassInputAttachmentAspectCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
- {
- reservedmarshal_VkImageViewUsageCreateInfo(vkStream, rootType, reinterpret_cast<const VkImageViewUsageCreateInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: {
+ reservedmarshal_VkImageViewUsageCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkImageViewUsageCreateInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
- {
- reservedmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(vkStream, rootType, reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: {
+ reservedmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
- {
- reservedmarshal_VkRenderPassMultiviewCreateInfo(vkStream, rootType, reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: {
+ reservedmarshal_VkRenderPassMultiviewCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
- {
- reservedmarshal_VkPhysicalDeviceMultiviewFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceMultiviewFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
- {
- reservedmarshal_VkPhysicalDeviceMultiviewProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: {
+ reservedmarshal_VkPhysicalDeviceMultiviewProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
- {
- reservedmarshal_VkPhysicalDeviceVariablePointersFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceVariablePointersFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
- {
- reservedmarshal_VkPhysicalDeviceProtectedMemoryFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceProtectedMemoryFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
- {
- reservedmarshal_VkPhysicalDeviceProtectedMemoryProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: {
+ reservedmarshal_VkPhysicalDeviceProtectedMemoryProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
- {
- reservedmarshal_VkProtectedSubmitInfo(vkStream, rootType, reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: {
+ reservedmarshal_VkProtectedSubmitInfo(
+ vkStream, rootType, reinterpret_cast<const VkProtectedSubmitInfo*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
- {
- reservedmarshal_VkSamplerYcbcrConversionInfo(vkStream, rootType, reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: {
+ reservedmarshal_VkSamplerYcbcrConversionInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
- {
- reservedmarshal_VkBindImagePlaneMemoryInfo(vkStream, rootType, reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: {
+ reservedmarshal_VkBindImagePlaneMemoryInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
- {
- reservedmarshal_VkImagePlaneMemoryRequirementsInfo(vkStream, rootType, reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: {
+ reservedmarshal_VkImagePlaneMemoryRequirementsInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
- {
- reservedmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
- {
- reservedmarshal_VkSamplerYcbcrConversionImageFormatProperties(vkStream, rootType, reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: {
+ reservedmarshal_VkSamplerYcbcrConversionImageFormatProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
- {
- reservedmarshal_VkPhysicalDeviceExternalImageFormatInfo(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: {
+ reservedmarshal_VkPhysicalDeviceExternalImageFormatInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
- {
- reservedmarshal_VkExternalImageFormatProperties(vkStream, rootType, reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: {
+ reservedmarshal_VkExternalImageFormatProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkExternalImageFormatProperties*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
- {
- reservedmarshal_VkPhysicalDeviceIDProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: {
+ reservedmarshal_VkPhysicalDeviceIDProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceIDProperties*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
- {
- reservedmarshal_VkExternalMemoryImageCreateInfo(vkStream, rootType, reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: {
+ reservedmarshal_VkExternalMemoryImageCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
- {
- reservedmarshal_VkExternalMemoryBufferCreateInfo(vkStream, rootType, reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: {
+ reservedmarshal_VkExternalMemoryBufferCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
- {
- reservedmarshal_VkExportMemoryAllocateInfo(vkStream, rootType, reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: {
+ reservedmarshal_VkExportMemoryAllocateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkExportMemoryAllocateInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
- {
- reservedmarshal_VkExportFenceCreateInfo(vkStream, rootType, reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: {
+ reservedmarshal_VkExportFenceCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkExportFenceCreateInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
- {
- reservedmarshal_VkExportSemaphoreCreateInfo(vkStream, rootType, reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: {
+ reservedmarshal_VkExportSemaphoreCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkExportSemaphoreCreateInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
- {
- reservedmarshal_VkPhysicalDeviceMaintenance3Properties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: {
+ reservedmarshal_VkPhysicalDeviceMaintenance3Properties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
- {
- reservedmarshal_VkPhysicalDeviceShaderDrawParametersFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceShaderDrawParametersFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_VERSION_1_2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
- {
- reservedmarshal_VkPhysicalDeviceVulkan11Features(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceVulkan11Features(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkan11Features*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
- {
- reservedmarshal_VkPhysicalDeviceVulkan11Properties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: {
+ reservedmarshal_VkPhysicalDeviceVulkan11Properties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkan11Properties*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
- {
- reservedmarshal_VkPhysicalDeviceVulkan12Features(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceVulkan12Features(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkan12Features*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
- {
- reservedmarshal_VkPhysicalDeviceVulkan12Properties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: {
+ reservedmarshal_VkPhysicalDeviceVulkan12Properties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkan12Properties*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
- {
- reservedmarshal_VkImageFormatListCreateInfo(vkStream, rootType, reinterpret_cast<const VkImageFormatListCreateInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: {
+ reservedmarshal_VkImageFormatListCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkImageFormatListCreateInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
- {
- reservedmarshal_VkPhysicalDevice8BitStorageFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: {
+ reservedmarshal_VkPhysicalDevice8BitStorageFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
- {
- reservedmarshal_VkPhysicalDeviceDriverProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: {
+ reservedmarshal_VkPhysicalDeviceDriverProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDriverProperties*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
- {
- reservedmarshal_VkPhysicalDeviceShaderAtomicInt64Features(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceShaderAtomicInt64Features(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
- {
- reservedmarshal_VkPhysicalDeviceShaderFloat16Int8Features(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceShaderFloat16Int8Features(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
- {
- reservedmarshal_VkPhysicalDeviceFloatControlsProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: {
+ reservedmarshal_VkPhysicalDeviceFloatControlsProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
- {
- reservedmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(vkStream, rootType, reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: {
+ reservedmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
- {
- reservedmarshal_VkPhysicalDeviceDescriptorIndexingFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceDescriptorIndexingFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
- {
- reservedmarshal_VkPhysicalDeviceDescriptorIndexingProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: {
+ reservedmarshal_VkPhysicalDeviceDescriptorIndexingProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
- {
- reservedmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(vkStream, rootType, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: {
+ reservedmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
- {
- reservedmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(vkStream, rootType, reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: {
+ reservedmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(
+ vkStream, rootType,
+ reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
- {
- reservedmarshal_VkSubpassDescriptionDepthStencilResolve(vkStream, rootType, reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: {
+ reservedmarshal_VkSubpassDescriptionDepthStencilResolve(
+ vkStream, rootType,
+ reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
- {
- reservedmarshal_VkPhysicalDeviceDepthStencilResolveProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: {
+ reservedmarshal_VkPhysicalDeviceDepthStencilResolveProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
- {
- reservedmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
- {
- reservedmarshal_VkImageStencilUsageCreateInfo(vkStream, rootType, reinterpret_cast<const VkImageStencilUsageCreateInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: {
+ reservedmarshal_VkImageStencilUsageCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkImageStencilUsageCreateInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
- {
- reservedmarshal_VkSamplerReductionModeCreateInfo(vkStream, rootType, reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: {
+ reservedmarshal_VkSamplerReductionModeCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
- {
- reservedmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: {
+ reservedmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
- {
- reservedmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
- {
- reservedmarshal_VkPhysicalDeviceImagelessFramebufferFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceImagelessFramebufferFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
- {
- reservedmarshal_VkFramebufferAttachmentsCreateInfo(vkStream, rootType, reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: {
+ reservedmarshal_VkFramebufferAttachmentsCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkFramebufferAttachmentsCreateInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
- {
- reservedmarshal_VkRenderPassAttachmentBeginInfo(vkStream, rootType, reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: {
+ reservedmarshal_VkRenderPassAttachmentBeginInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderPassAttachmentBeginInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
- {
- reservedmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
- {
- reservedmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
- {
- reservedmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
- {
- reservedmarshal_VkAttachmentReferenceStencilLayout(vkStream, rootType, reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: {
+ reservedmarshal_VkAttachmentReferenceStencilLayout(
+ vkStream, rootType,
+ reinterpret_cast<const VkAttachmentReferenceStencilLayout*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
- {
- reservedmarshal_VkAttachmentDescriptionStencilLayout(vkStream, rootType, reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: {
+ reservedmarshal_VkAttachmentDescriptionStencilLayout(
+ vkStream, rootType,
+ reinterpret_cast<const VkAttachmentDescriptionStencilLayout*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
- {
- reservedmarshal_VkPhysicalDeviceHostQueryResetFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceHostQueryResetFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
- {
- reservedmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
- {
- reservedmarshal_VkPhysicalDeviceTimelineSemaphoreProperties(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: {
+ reservedmarshal_VkPhysicalDeviceTimelineSemaphoreProperties(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
- {
- reservedmarshal_VkSemaphoreTypeCreateInfo(vkStream, rootType, reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: {
+ reservedmarshal_VkSemaphoreTypeCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkSemaphoreTypeCreateInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
- {
- reservedmarshal_VkTimelineSemaphoreSubmitInfo(vkStream, rootType, reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: {
+ reservedmarshal_VkTimelineSemaphoreSubmitInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkTimelineSemaphoreSubmitInfo*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
- {
- reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: {
+ reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
- {
- reservedmarshal_VkBufferOpaqueCaptureAddressCreateInfo(vkStream, rootType, reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: {
+ reservedmarshal_VkBufferOpaqueCaptureAddressCreateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
- {
- reservedmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo(vkStream, rootType, reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: {
+ reservedmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo(
+ vkStream, rootType,
+ reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_swapchain
- case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
- {
- reservedmarshal_VkImageSwapchainCreateInfoKHR(vkStream, rootType, reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
+ reservedmarshal_VkImageSwapchainCreateInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
- {
- reservedmarshal_VkBindImageMemorySwapchainInfoKHR(vkStream, rootType, reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: {
+ reservedmarshal_VkBindImageMemorySwapchainInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
- {
- reservedmarshal_VkDeviceGroupPresentInfoKHR(vkStream, rootType, reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: {
+ reservedmarshal_VkDeviceGroupPresentInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
- {
- reservedmarshal_VkDeviceGroupSwapchainCreateInfoKHR(vkStream, rootType, reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: {
+ reservedmarshal_VkDeviceGroupSwapchainCreateInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_KHR_display_swapchain
- case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
- {
- reservedmarshal_VkDisplayPresentInfoKHR(vkStream, rootType, reinterpret_cast<const VkDisplayPresentInfoKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: {
+ reservedmarshal_VkDisplayPresentInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkDisplayPresentInfoKHR*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_KHR_video_queue
- case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR:
- {
- reservedmarshal_VkVideoQueueFamilyProperties2KHR(vkStream, rootType, reinterpret_cast<const VkVideoQueueFamilyProperties2KHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: {
+ reservedmarshal_VkVideoQueueFamilyProperties2KHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoQueueFamilyProperties2KHR*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR:
- {
- reservedmarshal_VkVideoProfileKHR(vkStream, rootType, reinterpret_cast<const VkVideoProfileKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR: {
+ reservedmarshal_VkVideoProfileKHR(
+ vkStream, rootType, reinterpret_cast<const VkVideoProfileKHR*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR:
- {
- reservedmarshal_VkVideoProfilesKHR(vkStream, rootType, reinterpret_cast<const VkVideoProfilesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR: {
+ reservedmarshal_VkVideoProfilesKHR(
+ vkStream, rootType, reinterpret_cast<const VkVideoProfilesKHR*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_dynamic_rendering
- case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR:
- {
- reservedmarshal_VkPipelineRenderingCreateInfoKHR(vkStream, rootType, reinterpret_cast<const VkPipelineRenderingCreateInfoKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: {
+ reservedmarshal_VkPipelineRenderingCreateInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRenderingCreateInfoKHR*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR:
- {
- reservedmarshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: {
+ reservedmarshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR:
- {
- reservedmarshal_VkCommandBufferInheritanceRenderingInfoKHR(vkStream, rootType, reinterpret_cast<const VkCommandBufferInheritanceRenderingInfoKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: {
+ reservedmarshal_VkCommandBufferInheritanceRenderingInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkCommandBufferInheritanceRenderingInfoKHR*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
- {
- reservedmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(vkStream, rootType, reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
+ reservedmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
- {
- reservedmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(vkStream, rootType, reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
+ reservedmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
- {
- reservedmarshal_VkAttachmentSampleCountInfoAMD(vkStream, rootType, reinterpret_cast<const VkAttachmentSampleCountInfoAMD*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
+ reservedmarshal_VkAttachmentSampleCountInfoAMD(
+ vkStream, rootType,
+ reinterpret_cast<const VkAttachmentSampleCountInfoAMD*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
- {
- reservedmarshal_VkMultiviewPerViewAttributesInfoNVX(vkStream, rootType, reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
+ reservedmarshal_VkMultiviewPerViewAttributesInfoNVX(
+ vkStream, rootType,
+ reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_KHR_external_memory_win32
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
- {
- reservedmarshal_VkImportMemoryWin32HandleInfoKHR(vkStream, rootType, reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
+ reservedmarshal_VkImportMemoryWin32HandleInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
- {
- reservedmarshal_VkExportMemoryWin32HandleInfoKHR(vkStream, rootType, reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
+ reservedmarshal_VkExportMemoryWin32HandleInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_KHR_external_memory_fd
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
- {
- reservedmarshal_VkImportMemoryFdInfoKHR(vkStream, rootType, reinterpret_cast<const VkImportMemoryFdInfoKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: {
+ reservedmarshal_VkImportMemoryFdInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportMemoryFdInfoKHR*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_KHR_win32_keyed_mutex
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
- {
- reservedmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(vkStream, rootType, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: {
+ reservedmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_external_semaphore_win32
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
- {
- reservedmarshal_VkExportSemaphoreWin32HandleInfoKHR(vkStream, rootType, reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: {
+ reservedmarshal_VkExportSemaphoreWin32HandleInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
- {
- reservedmarshal_VkD3D12FenceSubmitInfoKHR(vkStream, rootType, reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: {
+ reservedmarshal_VkD3D12FenceSubmitInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_KHR_push_descriptor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
- {
- reservedmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: {
+ reservedmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_incremental_present
- case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
- {
- reservedmarshal_VkPresentRegionsKHR(vkStream, rootType, reinterpret_cast<const VkPresentRegionsKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: {
+ reservedmarshal_VkPresentRegionsKHR(
+ vkStream, rootType, reinterpret_cast<const VkPresentRegionsKHR*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_shared_presentable_image
- case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
- {
- reservedmarshal_VkSharedPresentSurfaceCapabilitiesKHR(vkStream, rootType, reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
+ reservedmarshal_VkSharedPresentSurfaceCapabilitiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_external_fence_win32
- case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
- {
- reservedmarshal_VkExportFenceWin32HandleInfoKHR(vkStream, rootType, reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: {
+ reservedmarshal_VkExportFenceWin32HandleInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_KHR_performance_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
- {
- reservedmarshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: {
+ reservedmarshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
- {
- reservedmarshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: {
+ reservedmarshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
- {
- reservedmarshal_VkQueryPoolPerformanceCreateInfoKHR(vkStream, rootType, reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: {
+ reservedmarshal_VkQueryPoolPerformanceCreateInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
- {
- reservedmarshal_VkPerformanceQuerySubmitInfoKHR(vkStream, rootType, reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: {
+ reservedmarshal_VkPerformanceQuerySubmitInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_KHR_portability_subset
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
- {
- reservedmarshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
+ reservedmarshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
- {
- reservedmarshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
+ reservedmarshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_shader_clock
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
- {
- reservedmarshal_VkPhysicalDeviceShaderClockFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
+ reservedmarshal_VkPhysicalDeviceShaderClockFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_shader_terminate_invocation
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR:
- {
- reservedmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: {
+ reservedmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_fragment_shading_rate
- case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
- {
- reservedmarshal_VkFragmentShadingRateAttachmentInfoKHR(vkStream, rootType, reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
+ reservedmarshal_VkFragmentShadingRateAttachmentInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
- {
- reservedmarshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(vkStream, rootType, reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: {
+ reservedmarshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
- {
- reservedmarshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: {
+ reservedmarshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
- {
- reservedmarshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: {
+ reservedmarshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_surface_protected_capabilities
- case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
- {
- reservedmarshal_VkSurfaceProtectedCapabilitiesKHR(vkStream, rootType, reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: {
+ reservedmarshal_VkSurfaceProtectedCapabilitiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_KHR_present_wait
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
- {
- reservedmarshal_VkPhysicalDevicePresentWaitFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: {
+ reservedmarshal_VkPhysicalDevicePresentWaitFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
- {
- reservedmarshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: {
+ reservedmarshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_shader_integer_dot_product
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR:
- {
- reservedmarshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: {
+ reservedmarshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR:
- {
- reservedmarshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: {
+ reservedmarshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_present_id
- case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
- {
- reservedmarshal_VkPresentIdKHR(vkStream, rootType, reinterpret_cast<const VkPresentIdKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: {
+ reservedmarshal_VkPresentIdKHR(
+ vkStream, rootType, reinterpret_cast<const VkPresentIdKHR*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
- {
- reservedmarshal_VkPhysicalDevicePresentIdFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: {
+ reservedmarshal_VkPhysicalDevicePresentIdFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_video_encode_queue
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
- {
- reservedmarshal_VkVideoEncodeRateControlInfoKHR(vkStream, rootType, reinterpret_cast<const VkVideoEncodeRateControlInfoKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
+ reservedmarshal_VkVideoEncodeRateControlInfoKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeRateControlInfoKHR*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_KHR_synchronization2
- case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR:
- {
- reservedmarshal_VkMemoryBarrier2KHR(vkStream, rootType, reinterpret_cast<const VkMemoryBarrier2KHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: {
+ reservedmarshal_VkMemoryBarrier2KHR(
+ vkStream, rootType, reinterpret_cast<const VkMemoryBarrier2KHR*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR:
- {
- reservedmarshal_VkPhysicalDeviceSynchronization2FeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSynchronization2FeaturesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: {
+ reservedmarshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSynchronization2FeaturesKHR*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
- {
- reservedmarshal_VkQueueFamilyCheckpointProperties2NV(vkStream, rootType, reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
+ reservedmarshal_VkQueueFamilyCheckpointProperties2NV(
+ vkStream, rootType,
+ reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
- {
- reservedmarshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
+ reservedmarshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<
+ const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR:
- {
- reservedmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: {
+ reservedmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
- {
- reservedmarshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
+ reservedmarshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_format_feature_flags2
- case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR:
- {
- reservedmarshal_VkFormatProperties3KHR(vkStream, rootType, reinterpret_cast<const VkFormatProperties3KHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: {
+ reservedmarshal_VkFormatProperties3KHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkFormatProperties3KHR*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_KHR_maintenance4
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR:
- {
- reservedmarshal_VkPhysicalDeviceMaintenance4FeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: {
+ reservedmarshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR:
- {
- reservedmarshal_VkPhysicalDeviceMaintenance4PropertiesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: {
+ reservedmarshal_VkPhysicalDeviceMaintenance4PropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_ANDROID_native_buffer
- case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
- {
- reservedmarshal_VkNativeBufferANDROID(vkStream, rootType, reinterpret_cast<const VkNativeBufferANDROID*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
+ reservedmarshal_VkNativeBufferANDROID(
+ vkStream, rootType, reinterpret_cast<const VkNativeBufferANDROID*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_debug_report
- case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
- {
- reservedmarshal_VkDebugReportCallbackCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: {
+ reservedmarshal_VkDebugReportCallbackCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_AMD_rasterization_order
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
- {
- reservedmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(vkStream, rootType, reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: {
+ reservedmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_dedicated_allocation
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
- {
- reservedmarshal_VkDedicatedAllocationImageCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: {
+ reservedmarshal_VkDedicatedAllocationImageCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
- {
- reservedmarshal_VkDedicatedAllocationBufferCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: {
+ reservedmarshal_VkDedicatedAllocationBufferCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
- {
- reservedmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(vkStream, rootType, reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: {
+ reservedmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_transform_feedback
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: {
+ reservedmarshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
- {
- reservedmarshal_VkPipelineRasterizationStateStreamCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: {
+ reservedmarshal_VkPipelineRasterizationStateStreamCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_video_encode_h264
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT:
- {
- reservedmarshal_VkVideoEncodeH264CapabilitiesEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH264CapabilitiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
+ reservedmarshal_VkVideoEncodeH264CapabilitiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH264CapabilitiesEXT*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT:
- {
- reservedmarshal_VkVideoEncodeH264SessionCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: {
+ reservedmarshal_VkVideoEncodeH264SessionCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- reservedmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ reservedmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- reservedmarshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ reservedmarshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT:
- {
- reservedmarshal_VkVideoEncodeH264VclFrameInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH264VclFrameInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
+ reservedmarshal_VkVideoEncodeH264VclFrameInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH264VclFrameInfoEXT*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT:
- {
- reservedmarshal_VkVideoEncodeH264EmitPictureParametersEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: {
+ reservedmarshal_VkVideoEncodeH264EmitPictureParametersEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT:
- {
- reservedmarshal_VkVideoEncodeH264ProfileEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH264ProfileEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT: {
+ reservedmarshal_VkVideoEncodeH264ProfileEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH264ProfileEXT*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_EXT_video_encode_h265
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT:
- {
- reservedmarshal_VkVideoEncodeH265CapabilitiesEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH265CapabilitiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
+ reservedmarshal_VkVideoEncodeH265CapabilitiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH265CapabilitiesEXT*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT:
- {
- reservedmarshal_VkVideoEncodeH265SessionCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: {
+ reservedmarshal_VkVideoEncodeH265SessionCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- reservedmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ reservedmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- reservedmarshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ reservedmarshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT:
- {
- reservedmarshal_VkVideoEncodeH265VclFrameInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH265VclFrameInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
+ reservedmarshal_VkVideoEncodeH265VclFrameInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH265VclFrameInfoEXT*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT:
- {
- reservedmarshal_VkVideoEncodeH265EmitPictureParametersEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: {
+ reservedmarshal_VkVideoEncodeH265EmitPictureParametersEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT:
- {
- reservedmarshal_VkVideoEncodeH265ProfileEXT(vkStream, rootType, reinterpret_cast<const VkVideoEncodeH265ProfileEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT: {
+ reservedmarshal_VkVideoEncodeH265ProfileEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoEncodeH265ProfileEXT*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_EXT_video_decode_h264
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT:
- {
- reservedmarshal_VkVideoDecodeH264ProfileEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH264ProfileEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT: {
+ reservedmarshal_VkVideoDecodeH264ProfileEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH264ProfileEXT*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT:
- {
- reservedmarshal_VkVideoDecodeH264CapabilitiesEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH264CapabilitiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: {
+ reservedmarshal_VkVideoDecodeH264CapabilitiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH264CapabilitiesEXT*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT:
- {
- reservedmarshal_VkVideoDecodeH264SessionCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: {
+ reservedmarshal_VkVideoDecodeH264SessionCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- reservedmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ reservedmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- reservedmarshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ reservedmarshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT:
- {
- reservedmarshal_VkVideoDecodeH264PictureInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH264PictureInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: {
+ reservedmarshal_VkVideoDecodeH264PictureInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH264PictureInfoEXT*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT:
- {
- reservedmarshal_VkVideoDecodeH264MvcEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH264MvcEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT: {
+ reservedmarshal_VkVideoDecodeH264MvcEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH264MvcEXT*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT:
- {
- reservedmarshal_VkVideoDecodeH264DpbSlotInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: {
+ reservedmarshal_VkVideoDecodeH264DpbSlotInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_AMD_texture_gather_bias_lod
- case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
- {
- reservedmarshal_VkTextureLODGatherFormatPropertiesAMD(vkStream, rootType, reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
+ reservedmarshal_VkTextureLODGatherFormatPropertiesAMD(
+ vkStream, rootType,
+ reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_corner_sampled_image
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
- {
- reservedmarshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: {
+ reservedmarshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_external_memory
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
- {
- reservedmarshal_VkExternalMemoryImageCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: {
+ reservedmarshal_VkExternalMemoryImageCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
- {
- reservedmarshal_VkExportMemoryAllocateInfoNV(vkStream, rootType, reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: {
+ reservedmarshal_VkExportMemoryAllocateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_NV_external_memory_win32
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
- {
- reservedmarshal_VkImportMemoryWin32HandleInfoNV(vkStream, rootType, reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
+ reservedmarshal_VkImportMemoryWin32HandleInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
- {
- reservedmarshal_VkExportMemoryWin32HandleInfoNV(vkStream, rootType, reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
+ reservedmarshal_VkExportMemoryWin32HandleInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_NV_win32_keyed_mutex
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
- {
- reservedmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(vkStream, rootType, reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: {
+ reservedmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_validation_flags
- case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
- {
- reservedmarshal_VkValidationFlagsEXT(vkStream, rootType, reinterpret_cast<const VkValidationFlagsEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: {
+ reservedmarshal_VkValidationFlagsEXT(
+ vkStream, rootType, reinterpret_cast<const VkValidationFlagsEXT*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_astc_decode_mode
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
- {
- reservedmarshal_VkImageViewASTCDecodeModeEXT(vkStream, rootType, reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
+ reservedmarshal_VkImageViewASTCDecodeModeEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_conditional_rendering
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
- {
- reservedmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(vkStream, rootType, reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: {
+ reservedmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_clip_space_w_scaling
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
- {
- reservedmarshal_VkPipelineViewportWScalingStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: {
+ reservedmarshal_VkPipelineViewportWScalingStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_display_control
- case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
- {
- reservedmarshal_VkSwapchainCounterCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: {
+ reservedmarshal_VkSwapchainCounterCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_GOOGLE_display_timing
- case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
- {
- reservedmarshal_VkPresentTimesInfoGOOGLE(vkStream, rootType, reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: {
+ reservedmarshal_VkPresentTimesInfoGOOGLE(
+ vkStream, rootType,
+ reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_NVX_multiview_per_view_attributes
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
- {
- reservedmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: {
+ reservedmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_viewport_swizzle
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
- {
- reservedmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: {
+ reservedmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_discard_rectangles
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: {
+ reservedmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
- {
- reservedmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: {
+ reservedmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_conservative_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: {
+ reservedmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
- {
- reservedmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: {
+ reservedmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_depth_clip_enable
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
- {
- reservedmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ reservedmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_debug_utils
- case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
- {
- reservedmarshal_VkDebugUtilsMessengerCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
+ reservedmarshal_VkDebugUtilsMessengerCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
- {
- reservedmarshal_VkAndroidHardwareBufferUsageANDROID(vkStream, rootType, reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: {
+ reservedmarshal_VkAndroidHardwareBufferUsageANDROID(
+ vkStream, rootType,
+ reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
- {
- reservedmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(vkStream, rootType, reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: {
+ reservedmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
+ vkStream, rootType,
+ reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
- {
- reservedmarshal_VkImportAndroidHardwareBufferInfoANDROID(vkStream, rootType, reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: {
+ reservedmarshal_VkImportAndroidHardwareBufferInfoANDROID(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
- {
- reservedmarshal_VkExternalFormatANDROID(vkStream, rootType, reinterpret_cast<const VkExternalFormatANDROID*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: {
+ reservedmarshal_VkExternalFormatANDROID(
+ vkStream, rootType,
+ reinterpret_cast<const VkExternalFormatANDROID*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
- {
- reservedmarshal_VkAndroidHardwareBufferFormatProperties2ANDROID(vkStream, rootType, reinterpret_cast<const VkAndroidHardwareBufferFormatProperties2ANDROID*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: {
+ reservedmarshal_VkAndroidHardwareBufferFormatProperties2ANDROID(
+ vkStream, rootType,
+ reinterpret_cast<const VkAndroidHardwareBufferFormatProperties2ANDROID*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_inline_uniform_block
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
+ reservedmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT:
- {
- reservedmarshal_VkWriteDescriptorSetInlineUniformBlockEXT(vkStream, rootType, reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
+ reservedmarshal_VkWriteDescriptorSetInlineUniformBlockEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT:
- {
- reservedmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
+ reservedmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_sample_locations
- case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
- {
- reservedmarshal_VkSampleLocationsInfoEXT(vkStream, rootType, reinterpret_cast<const VkSampleLocationsInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
+ reservedmarshal_VkSampleLocationsInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkSampleLocationsInfoEXT*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
- {
- reservedmarshal_VkRenderPassSampleLocationsBeginInfoEXT(vkStream, rootType, reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: {
+ reservedmarshal_VkRenderPassSampleLocationsBeginInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
- {
- reservedmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: {
+ reservedmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: {
+ reservedmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_blend_operation_advanced
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: {
+ reservedmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
- {
- reservedmarshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: {
+ reservedmarshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_fragment_coverage_to_color
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
- {
- reservedmarshal_VkPipelineCoverageToColorStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: {
+ reservedmarshal_VkPipelineCoverageToColorStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_framebuffer_mixed_samples
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
- {
- reservedmarshal_VkPipelineCoverageModulationStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: {
+ reservedmarshal_VkPipelineCoverageModulationStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_shader_sm_builtins
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
- {
- reservedmarshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: {
+ reservedmarshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
- {
- reservedmarshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: {
+ reservedmarshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_image_drm_format_modifier
- case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
- {
- reservedmarshal_VkDrmFormatModifierPropertiesListEXT(vkStream, rootType, reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: {
+ reservedmarshal_VkDrmFormatModifierPropertiesListEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
- {
- reservedmarshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: {
+ reservedmarshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
- {
- reservedmarshal_VkImageDrmFormatModifierListCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: {
+ reservedmarshal_VkImageDrmFormatModifierListCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
- {
- reservedmarshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: {
+ reservedmarshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
- {
- reservedmarshal_VkDrmFormatModifierPropertiesList2EXT(vkStream, rootType, reinterpret_cast<const VkDrmFormatModifierPropertiesList2EXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: {
+ reservedmarshal_VkDrmFormatModifierPropertiesList2EXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkDrmFormatModifierPropertiesList2EXT*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_validation_cache
- case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
- {
- reservedmarshal_VkShaderModuleValidationCacheCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: {
+ reservedmarshal_VkShaderModuleValidationCacheCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_shading_rate_image
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
- {
- reservedmarshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: {
+ reservedmarshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
- {
- reservedmarshal_VkPhysicalDeviceShadingRateImageFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: {
+ reservedmarshal_VkPhysicalDeviceShadingRateImageFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
- {
- reservedmarshal_VkPhysicalDeviceShadingRateImagePropertiesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: {
+ reservedmarshal_VkPhysicalDeviceShadingRateImagePropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
- {
- reservedmarshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: {
+ reservedmarshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_ray_tracing
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
- {
- reservedmarshal_VkWriteDescriptorSetAccelerationStructureNV(vkStream, rootType, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: {
+ reservedmarshal_VkWriteDescriptorSetAccelerationStructureNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
- {
- reservedmarshal_VkPhysicalDeviceRayTracingPropertiesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: {
+ reservedmarshal_VkPhysicalDeviceRayTracingPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_representative_fragment_test
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
- {
- reservedmarshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: {
+ reservedmarshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
- {
- reservedmarshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: {
+ reservedmarshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_filter_cubic
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
- {
- reservedmarshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: {
+ reservedmarshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
- {
- reservedmarshal_VkFilterCubicImageViewImageFormatPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: {
+ reservedmarshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_global_priority
- case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
- {
- reservedmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
+ reservedmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_external_memory_host
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
- {
- reservedmarshal_VkImportMemoryHostPointerInfoEXT(vkStream, rootType, reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
+ reservedmarshal_VkImportMemoryHostPointerInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: {
+ reservedmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_AMD_pipeline_compiler_control
- case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
- {
- reservedmarshal_VkPipelineCompilerControlCreateInfoAMD(vkStream, rootType, reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: {
+ reservedmarshal_VkPipelineCompilerControlCreateInfoAMD(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_AMD_shader_core_properties
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
- {
- reservedmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: {
+ reservedmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_video_decode_h265
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT:
- {
- reservedmarshal_VkVideoDecodeH265ProfileEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH265ProfileEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT: {
+ reservedmarshal_VkVideoDecodeH265ProfileEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH265ProfileEXT*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT:
- {
- reservedmarshal_VkVideoDecodeH265CapabilitiesEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH265CapabilitiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: {
+ reservedmarshal_VkVideoDecodeH265CapabilitiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH265CapabilitiesEXT*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT:
- {
- reservedmarshal_VkVideoDecodeH265SessionCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: {
+ reservedmarshal_VkVideoDecodeH265SessionCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- reservedmarshal_VkVideoDecodeH265SessionParametersAddInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ reservedmarshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- reservedmarshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ reservedmarshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT:
- {
- reservedmarshal_VkVideoDecodeH265PictureInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH265PictureInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: {
+ reservedmarshal_VkVideoDecodeH265PictureInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH265PictureInfoEXT*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT:
- {
- reservedmarshal_VkVideoDecodeH265DpbSlotInfoEXT(vkStream, rootType, reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: {
+ reservedmarshal_VkVideoDecodeH265DpbSlotInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_AMD_memory_overallocation_behavior
- case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
- {
- reservedmarshal_VkDeviceMemoryOverallocationCreateInfoAMD(vkStream, rootType, reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
+ reservedmarshal_VkDeviceMemoryOverallocationCreateInfoAMD(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_vertex_attribute_divisor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
+ reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
- {
- reservedmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: {
+ reservedmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_GGP_frame_token
- case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
- {
- reservedmarshal_VkPresentFrameTokenGGP(vkStream, rootType, reinterpret_cast<const VkPresentFrameTokenGGP*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: {
+ reservedmarshal_VkPresentFrameTokenGGP(
+ vkStream, rootType,
+ reinterpret_cast<const VkPresentFrameTokenGGP*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_EXT_pipeline_creation_feedback
- case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT:
- {
- reservedmarshal_VkPipelineCreationFeedbackCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
+ reservedmarshal_VkPipelineCreationFeedbackCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_compute_shader_derivatives
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
- {
- reservedmarshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
+ reservedmarshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_mesh_shader
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
- {
- reservedmarshal_VkPhysicalDeviceMeshShaderFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: {
+ reservedmarshal_VkPhysicalDeviceMeshShaderFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
- {
- reservedmarshal_VkPhysicalDeviceMeshShaderPropertiesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: {
+ reservedmarshal_VkPhysicalDeviceMeshShaderPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_fragment_shader_barycentric
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV:
- {
- reservedmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
+ reservedmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_shader_image_footprint
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
- {
- reservedmarshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
+ reservedmarshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_scissor_exclusive
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
- {
- reservedmarshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: {
+ reservedmarshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
- {
- reservedmarshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: {
+ reservedmarshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
- {
- reservedmarshal_VkQueueFamilyCheckpointPropertiesNV(vkStream, rootType, reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: {
+ reservedmarshal_VkQueueFamilyCheckpointPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_INTEL_shader_integer_functions2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
- {
- reservedmarshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: {
+ reservedmarshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_INTEL_performance_query
- case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
- {
- reservedmarshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(vkStream, rootType, reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: {
+ reservedmarshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(
+ vkStream, rootType,
+ reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_pci_bus_info
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
- {
- reservedmarshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: {
+ reservedmarshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_AMD_display_native_hdr
- case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
- {
- reservedmarshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(vkStream, rootType, reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: {
+ reservedmarshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
+ vkStream, rootType,
+ reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
- {
- reservedmarshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(vkStream, rootType, reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: {
+ reservedmarshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(
+ vkStream, rootType,
+ reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_fragment_density_map
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
- {
- reservedmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
+ reservedmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
- {
- reservedmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: {
+ reservedmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
- reservedmarshal_VkImportColorBufferGOOGLE(vkStream, rootType, reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
+ reservedmarshal_VkImportColorBufferGOOGLE(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension), ptr);
break;
}
- default:
- {
- reservedmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension), ptr);
+ default: {
+ reservedmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
}
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2:
- {
- reservedmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: {
+ reservedmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
- reservedmarshal_VkImportPhysicalAddressGOOGLE(vkStream, rootType, reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
+ reservedmarshal_VkImportPhysicalAddressGOOGLE(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension),
+ ptr);
break;
}
- default:
- {
- reservedmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension), ptr);
+ default: {
+ reservedmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
+ structExtension),
+ ptr);
break;
}
}
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
- {
- switch(rootType)
- {
- case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
- {
- reservedmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: {
+ switch (rootType) {
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: {
+ reservedmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2:
- {
- reservedmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: {
+ reservedmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
- {
- reservedmarshal_VkImportBufferGOOGLE(vkStream, rootType, reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: {
+ reservedmarshal_VkImportBufferGOOGLE(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension), ptr);
break;
}
- default:
- {
- reservedmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension), ptr);
+ default: {
+ reservedmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
}
@@ -20931,628 +19444,876 @@
}
#endif
#ifdef VK_EXT_subgroup_size_control
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: {
+ reservedmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:
- {
- reservedmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: {
+ reservedmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_AMD_shader_core_properties2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
- {
- reservedmarshal_VkPhysicalDeviceShaderCoreProperties2AMD(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
+ reservedmarshal_VkPhysicalDeviceShaderCoreProperties2AMD(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_AMD_device_coherent_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
- {
- reservedmarshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: {
+ reservedmarshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_shader_image_atomic_int64
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_memory_budget
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: {
+ reservedmarshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_memory_priority
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
- {
- reservedmarshal_VkMemoryPriorityAllocateInfoEXT(vkStream, rootType, reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: {
+ reservedmarshal_VkMemoryPriorityAllocateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
- {
- reservedmarshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: {
+ reservedmarshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_buffer_device_address
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
- {
- reservedmarshal_VkBufferDeviceAddressCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: {
+ reservedmarshal_VkBufferDeviceAddressCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_EXT_validation_features
- case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
- {
- reservedmarshal_VkValidationFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkValidationFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: {
+ reservedmarshal_VkValidationFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkValidationFeaturesEXT*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_NV_cooperative_matrix
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
- {
- reservedmarshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: {
+ reservedmarshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
- {
- reservedmarshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: {
+ reservedmarshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_coverage_reduction_mode
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
- {
- reservedmarshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: {
+ reservedmarshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
- {
- reservedmarshal_VkPipelineCoverageReductionStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: {
+ reservedmarshal_VkPipelineCoverageReductionStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_fragment_shader_interlock
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_ycbcr_image_arrays
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_provoking_vertex
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceProvokingVertexFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceProvokingVertexFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceProvokingVertexPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: {
+ reservedmarshal_VkPhysicalDeviceProvokingVertexPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
- {
- reservedmarshal_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: {
+ reservedmarshal_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_full_screen_exclusive
- case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
- {
- reservedmarshal_VkSurfaceFullScreenExclusiveInfoEXT(vkStream, rootType, reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: {
+ reservedmarshal_VkSurfaceFullScreenExclusiveInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
- {
- reservedmarshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(vkStream, rootType, reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: {
+ reservedmarshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
- {
- reservedmarshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(vkStream, rootType, reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: {
+ reservedmarshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_line_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: {
+ reservedmarshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
- {
- reservedmarshal_VkPipelineRasterizationLineStateCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: {
+ reservedmarshal_VkPipelineRasterizationLineStateCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_shader_atomic_float
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_index_type_uint8
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_shader_atomic_float2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_device_generated_commands
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
- {
- reservedmarshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: {
+ reservedmarshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
- {
- reservedmarshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: {
+ reservedmarshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
- {
- reservedmarshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: {
+ reservedmarshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_inherited_viewport_scissor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
- {
- reservedmarshal_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: {
+ reservedmarshal_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
- {
- reservedmarshal_VkCommandBufferInheritanceViewportScissorInfoNV(vkStream, rootType, reinterpret_cast<const VkCommandBufferInheritanceViewportScissorInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: {
+ reservedmarshal_VkCommandBufferInheritanceViewportScissorInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkCommandBufferInheritanceViewportScissorInfoNV*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_texel_buffer_alignment
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
+ reservedmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_QCOM_render_pass_transform
- case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
- {
- reservedmarshal_VkRenderPassTransformBeginInfoQCOM(vkStream, rootType, reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
+ reservedmarshal_VkRenderPassTransformBeginInfoQCOM(
+ vkStream, rootType,
+ reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
- {
- reservedmarshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(vkStream, rootType, reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: {
+ reservedmarshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
+ vkStream, rootType,
+ reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_device_memory_report
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
- {
- reservedmarshal_VkDeviceDeviceMemoryReportCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: {
+ reservedmarshal_VkDeviceDeviceMemoryReportCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_robustness2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceRobustness2FeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceRobustness2FeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceRobustness2PropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: {
+ reservedmarshal_VkPhysicalDeviceRobustness2PropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_custom_border_color
- case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
- {
- reservedmarshal_VkSamplerCustomBorderColorCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: {
+ reservedmarshal_VkSamplerCustomBorderColorCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: {
+ reservedmarshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_private_data
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
- {
- reservedmarshal_VkDevicePrivateDataCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkDevicePrivateDataCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: {
+ reservedmarshal_VkDevicePrivateDataCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkDevicePrivateDataCreateInfoEXT*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_device_diagnostics_config
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
- {
- reservedmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: {
+ reservedmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
- {
- reservedmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: {
+ reservedmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_fragment_shading_rate_enums
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
- {
- reservedmarshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
+ reservedmarshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
- {
- reservedmarshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: {
+ reservedmarshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
- {
- reservedmarshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(vkStream, rootType, reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: {
+ reservedmarshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_ray_tracing_motion_blur
- case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
- {
- reservedmarshal_VkAccelerationStructureGeometryMotionTrianglesDataNV(vkStream, rootType, reinterpret_cast<const VkAccelerationStructureGeometryMotionTrianglesDataNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: {
+ reservedmarshal_VkAccelerationStructureGeometryMotionTrianglesDataNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkAccelerationStructureGeometryMotionTrianglesDataNV*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
- {
- reservedmarshal_VkAccelerationStructureMotionInfoNV(vkStream, rootType, reinterpret_cast<const VkAccelerationStructureMotionInfoNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: {
+ reservedmarshal_VkAccelerationStructureMotionInfoNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkAccelerationStructureMotionInfoNV*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
- {
- reservedmarshal_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: {
+ reservedmarshal_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_fragment_density_map2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: {
+ reservedmarshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_QCOM_rotated_copy_commands
- case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
- {
- reservedmarshal_VkCopyCommandTransformInfoQCOM(vkStream, rootType, reinterpret_cast<const VkCopyCommandTransformInfoQCOM*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: {
+ reservedmarshal_VkCopyCommandTransformInfoQCOM(
+ vkStream, rootType,
+ reinterpret_cast<const VkCopyCommandTransformInfoQCOM*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_EXT_image_robustness
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_4444_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDevice4444FormatsFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDevice4444FormatsFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_rgba10x6_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_VALVE_mutable_descriptor_type
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE:
- {
- reservedmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: {
+ reservedmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE:
- {
- reservedmarshal_VkMutableDescriptorTypeCreateInfoVALVE(vkStream, rootType, reinterpret_cast<const VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: {
+ reservedmarshal_VkMutableDescriptorTypeCreateInfoVALVE(
+ vkStream, rootType,
+ reinterpret_cast<const VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_physical_device_drm
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceDrmPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceDrmPropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: {
+ reservedmarshal_VkPhysicalDeviceDrmPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceDrmPropertiesEXT*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_EXT_primitive_topology_list_restart
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_FUCHSIA_external_memory
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
- {
- reservedmarshal_VkImportMemoryZirconHandleInfoFUCHSIA(vkStream, rootType, reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: {
+ reservedmarshal_VkImportMemoryZirconHandleInfoFUCHSIA(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
- {
- reservedmarshal_VkImportMemoryBufferCollectionFUCHSIA(vkStream, rootType, reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIA*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: {
+ reservedmarshal_VkImportMemoryBufferCollectionFUCHSIA(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIA*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
- {
- reservedmarshal_VkBufferCollectionImageCreateInfoFUCHSIA(vkStream, rootType, reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIA*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: {
+ reservedmarshal_VkBufferCollectionImageCreateInfoFUCHSIA(
+ vkStream, rootType,
+ reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIA*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
- {
- reservedmarshal_VkBufferCollectionBufferCreateInfoFUCHSIA(vkStream, rootType, reinterpret_cast<const VkBufferCollectionBufferCreateInfoFUCHSIA*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: {
+ reservedmarshal_VkBufferCollectionBufferCreateInfoFUCHSIA(
+ vkStream, rootType,
+ reinterpret_cast<const VkBufferCollectionBufferCreateInfoFUCHSIA*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_HUAWEI_subpass_shading
- case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
- {
- reservedmarshal_VkSubpassShadingPipelineCreateInfoHUAWEI(vkStream, rootType, reinterpret_cast<const VkSubpassShadingPipelineCreateInfoHUAWEI*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: {
+ reservedmarshal_VkSubpassShadingPipelineCreateInfoHUAWEI(
+ vkStream, rootType,
+ reinterpret_cast<const VkSubpassShadingPipelineCreateInfoHUAWEI*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
- {
- reservedmarshal_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: {
+ reservedmarshal_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
- {
- reservedmarshal_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: {
+ reservedmarshal_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_HUAWEI_invocation_mask
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
- {
- reservedmarshal_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: {
+ reservedmarshal_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_NV_external_memory_rdma
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
- {
- reservedmarshal_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: {
+ reservedmarshal_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_extended_dynamic_state2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_color_write_enable
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceColorWriteEnableFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
- {
- reservedmarshal_VkPipelineColorWriteCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkPipelineColorWriteCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: {
+ reservedmarshal_VkPipelineColorWriteCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPipelineColorWriteCreateInfoEXT*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_GOOGLE_gfxstream
- case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
- {
- reservedmarshal_VkImportColorBufferGOOGLE(vkStream, rootType, reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
+ reservedmarshal_VkImportColorBufferGOOGLE(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportColorBufferGOOGLE*>(structExtension), ptr);
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
- {
- reservedmarshal_VkImportBufferGOOGLE(vkStream, rootType, reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE: {
+ reservedmarshal_VkImportBufferGOOGLE(
+ vkStream, rootType, reinterpret_cast<const VkImportBufferGOOGLE*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
- {
- reservedmarshal_VkImportPhysicalAddressGOOGLE(vkStream, rootType, reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE: {
+ reservedmarshal_VkImportPhysicalAddressGOOGLE(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportPhysicalAddressGOOGLE*>(structExtension), ptr);
break;
}
#endif
#ifdef VK_EXT_global_priority_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT:
- {
- reservedmarshal_VkQueueFamilyGlobalPriorityPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: {
+ reservedmarshal_VkQueueFamilyGlobalPriorityPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_multi_draw
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceMultiDrawFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceMultiDrawFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT*>(structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceMultiDrawPropertiesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceMultiDrawPropertiesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: {
+ reservedmarshal_VkPhysicalDeviceMultiDrawPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceMultiDrawPropertiesEXT*>(structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_border_color_swizzle
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
- {
- reservedmarshal_VkSamplerBorderColorComponentMappingCreateInfoEXT(vkStream, rootType, reinterpret_cast<const VkSamplerBorderColorComponentMappingCreateInfoEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: {
+ reservedmarshal_VkSamplerBorderColorComponentMappingCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkSamplerBorderColorComponentMappingCreateInfoEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_EXT_pageable_device_local_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
- {
- reservedmarshal_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(vkStream, rootType, reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: {
+ reservedmarshal_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_acceleration_structure
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
- {
- reservedmarshal_VkWriteDescriptorSetAccelerationStructureKHR(vkStream, rootType, reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
+ reservedmarshal_VkWriteDescriptorSetAccelerationStructureKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
- {
- reservedmarshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: {
+ reservedmarshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
- {
- reservedmarshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: {
+ reservedmarshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
- {
- reservedmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
+ reservedmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
+ structExtension),
+ ptr);
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
- {
- reservedmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: {
+ reservedmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(
+ structExtension),
+ ptr);
break;
}
#endif
#ifdef VK_KHR_ray_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
- {
- reservedmarshal_VkPhysicalDeviceRayQueryFeaturesKHR(vkStream, rootType, reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension), ptr);
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: {
+ reservedmarshal_VkPhysicalDeviceRayQueryFeaturesKHR(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension), ptr);
break;
}
#endif
- default:
- {
+ default: {
// fatal; the switch is only taken if the extension struct is known
abort();
}
}
}
-
-} // namespace goldfish_vk
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h b/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h
index b724bd1..a1ed9ad 100644
--- a/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h
+++ b/system/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h
@@ -14,25 +14,28 @@
// limitations under the License.
// Autogenerated module goldfish_vk_reserved_marshaling_guest
-// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal -o ../qemu/android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+//
+// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
+// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
-// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
-
+//
+// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
+// $CEREAL_OUTPUT_DIR
+//
#pragma once
-
#include <vulkan/vulkan.h>
-
-#include "vk_platform_compat.h"
-
+#include "VulkanStreamGuest.h"
#include "goldfish_vk_marshaling_guest.h"
#include "goldfish_vk_private_defs.h"
-#include "VulkanStreamGuest.h"
+#include "vk_platform_compat.h"
+#include "vulkan_gfxstream.h"
// Stuff we are not going to use but if included,
// will cause compile errors. These are Android Vulkan
@@ -41,1757 +44,1203 @@
#undef VK_KHR_android_surface
#undef VK_ANDROID_external_memory_android_hardware_buffer
-
namespace goldfish_vk {
-
#ifdef VK_VERSION_1_0
-void reservedmarshal_VkExtent2D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExtent2D* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkExtent2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExtent2D* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkExtent3D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExtent3D* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkExtent3D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExtent3D* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkOffset2D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkOffset2D* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkOffset2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkOffset2D* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkOffset3D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkOffset3D* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkOffset3D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkOffset3D* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkRect2D(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRect2D* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkRect2D(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRect2D* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkBaseInStructure(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBaseInStructure* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkBaseInStructure(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBaseInStructure* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkBaseOutStructure(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBaseOutStructure* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkBaseOutStructure(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBaseOutStructure* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkBufferMemoryBarrier(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferMemoryBarrier* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkBufferMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferMemoryBarrier* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkDispatchIndirectCommand(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDispatchIndirectCommand* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDispatchIndirectCommand(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDispatchIndirectCommand* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkDrawIndexedIndirectCommand(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrawIndexedIndirectCommand* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDrawIndexedIndirectCommand(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDrawIndexedIndirectCommand* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkDrawIndirectCommand(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrawIndirectCommand* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDrawIndirectCommand(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrawIndirectCommand* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkImageSubresourceRange(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageSubresourceRange* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImageSubresourceRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSubresourceRange* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkImageMemoryBarrier(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageMemoryBarrier* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImageMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageMemoryBarrier* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkMemoryBarrier(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryBarrier* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkMemoryBarrier(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryBarrier* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineCacheHeaderVersionOne(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCacheHeaderVersionOne* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCacheHeaderVersionOne* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkAllocationCallbacks(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAllocationCallbacks* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkAllocationCallbacks(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAllocationCallbacks* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkApplicationInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkApplicationInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkApplicationInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkApplicationInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFormatProperties* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkFormatProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFormatProperties* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageFormatProperties* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImageFormatProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageFormatProperties* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkInstanceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkInstanceCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkInstanceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkInstanceCreateInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkMemoryHeap(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryHeap* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkMemoryHeap(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryHeap* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkMemoryType(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryType* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkMemoryType(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryType* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkPhysicalDeviceFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFeatures* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPhysicalDeviceFeatures(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFeatures* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkPhysicalDeviceLimits(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceLimits* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPhysicalDeviceLimits(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceLimits* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceMemoryProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryProperties* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryProperties* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceSparseProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSparseProperties* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSparseProperties* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkPhysicalDeviceProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceProperties* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPhysicalDeviceProperties(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkPhysicalDeviceProperties* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkQueueFamilyProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueueFamilyProperties* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkQueueFamilyProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyProperties* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkDeviceQueueCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceQueueCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDeviceQueueCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceQueueCreateInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkDeviceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDeviceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceCreateInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkExtensionProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExtensionProperties* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkExtensionProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExtensionProperties* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkLayerProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkLayerProperties* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkLayerProperties(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkLayerProperties* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubmitInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubmitInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkMappedMemoryRange(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMappedMemoryRange* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkMappedMemoryRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMappedMemoryRange* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkMemoryAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryAllocateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkMemoryAllocateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryAllocateInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkMemoryRequirements(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryRequirements* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkMemoryRequirements(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryRequirements* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkSparseMemoryBind(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseMemoryBind* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSparseMemoryBind(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseMemoryBind* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkSparseBufferMemoryBindInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseBufferMemoryBindInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSparseBufferMemoryBindInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkSparseBufferMemoryBindInfo* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkSparseImageOpaqueMemoryBindInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageOpaqueMemoryBindInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageOpaqueMemoryBindInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkImageSubresource(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageSubresource* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImageSubresource(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSubresource* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkSparseImageMemoryBind(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageMemoryBind* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSparseImageMemoryBind(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageMemoryBind* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkSparseImageMemoryBindInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageMemoryBindInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSparseImageMemoryBindInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkSparseImageMemoryBindInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkBindSparseInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindSparseInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkBindSparseInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindSparseInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkSparseImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageFormatProperties* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageFormatProperties* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkSparseImageMemoryRequirements(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageMemoryRequirements* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageMemoryRequirements* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkFenceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFenceCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkFenceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFenceCreateInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkSemaphoreCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSemaphoreCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreCreateInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkEventCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkEventCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkEventCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkEventCreateInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkQueryPoolCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueryPoolCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkQueryPoolCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueryPoolCreateInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkBufferCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkBufferCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCreateInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkBufferViewCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferViewCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkBufferViewCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferViewCreateInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkImageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImageCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageCreateInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkSubresourceLayout(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubresourceLayout* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSubresourceLayout(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubresourceLayout* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkComponentMapping(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkComponentMapping* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkComponentMapping(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkComponentMapping* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkImageViewCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageViewCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImageViewCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageViewCreateInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkShaderModuleCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkShaderModuleCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkShaderModuleCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkShaderModuleCreateInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkPipelineCacheCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCacheCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPipelineCacheCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkPipelineCacheCreateInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkSpecializationMapEntry(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSpecializationMapEntry* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSpecializationMapEntry(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSpecializationMapEntry* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkSpecializationInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSpecializationInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSpecializationInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSpecializationInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineShaderStageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineShaderStageCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineShaderStageCreateInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkComputePipelineCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkComputePipelineCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkComputePipelineCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkComputePipelineCreateInfo* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkVertexInputBindingDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVertexInputBindingDescription* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVertexInputBindingDescription* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVertexInputAttributeDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVertexInputAttributeDescription* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVertexInputAttributeDescription* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineVertexInputStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineVertexInputStateCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineVertexInputStateCreateInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineInputAssemblyStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineInputAssemblyStateCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineInputAssemblyStateCreateInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineTessellationStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineTessellationStateCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineTessellationStateCreateInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkViewport(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkViewport* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkViewport(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkViewport* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineViewportStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineViewportStateCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineViewportStateCreateInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineRasterizationStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationStateCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationStateCreateInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineMultisampleStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineMultisampleStateCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineMultisampleStateCreateInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkStencilOpState(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkStencilOpState* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkStencilOpState(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkStencilOpState* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineDepthStencilStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineDepthStencilStateCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineDepthStencilStateCreateInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineColorBlendAttachmentState(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineColorBlendAttachmentState* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineColorBlendAttachmentState* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineColorBlendStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineColorBlendStateCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineColorBlendStateCreateInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineDynamicStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineDynamicStateCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineDynamicStateCreateInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkGraphicsPipelineCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGraphicsPipelineCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkGraphicsPipelineCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkGraphicsPipelineCreateInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkPushConstantRange(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPushConstantRange* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPushConstantRange(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPushConstantRange* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkPipelineLayoutCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineLayoutCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPipelineLayoutCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkPipelineLayoutCreateInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkSamplerCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSamplerCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerCreateInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkCopyDescriptorSet(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyDescriptorSet* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkCopyDescriptorSet(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyDescriptorSet* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkDescriptorBufferInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorBufferInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDescriptorBufferInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorBufferInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkDescriptorImageInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorImageInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDescriptorImageInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorImageInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkDescriptorPoolSize(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorPoolSize* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDescriptorPoolSize(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorPoolSize* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkDescriptorPoolCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorPoolCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDescriptorPoolCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDescriptorPoolCreateInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkDescriptorSetAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetAllocateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDescriptorSetAllocateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDescriptorSetAllocateInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkDescriptorSetLayoutBinding(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetLayoutBinding* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDescriptorSetLayoutBinding(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDescriptorSetLayoutBinding* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkDescriptorSetLayoutCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetLayoutCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorSetLayoutCreateInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkWriteDescriptorSet(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWriteDescriptorSet* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkWriteDescriptorSet(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWriteDescriptorSet* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkAttachmentDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentDescription* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkAttachmentDescription(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentDescription* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkAttachmentReference(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentReference* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkAttachmentReference(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentReference* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkFramebufferCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFramebufferCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkFramebufferCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFramebufferCreateInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkSubpassDescription(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassDescription* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSubpassDescription(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassDescription* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkSubpassDependency(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassDependency* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSubpassDependency(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassDependency* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkRenderPassCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkRenderPassCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassCreateInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkCommandPoolCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandPoolCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkCommandPoolCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandPoolCreateInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkCommandBufferAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferAllocateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkCommandBufferAllocateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkCommandBufferAllocateInfo* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkCommandBufferInheritanceInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferInheritanceInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferInheritanceInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkCommandBufferBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferBeginInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkCommandBufferBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferBeginInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkBufferCopy(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCopy* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkBufferCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCopy* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkImageSubresourceLayers(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageSubresourceLayers* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImageSubresourceLayers(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSubresourceLayers* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkBufferImageCopy(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferImageCopy* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkBufferImageCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferImageCopy* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkClearColorValue(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkClearColorValue* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkClearColorValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkClearColorValue* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkClearDepthStencilValue(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkClearDepthStencilValue* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkClearDepthStencilValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkClearDepthStencilValue* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkClearValue(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkClearValue* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkClearValue(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkClearValue* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkClearAttachment(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkClearAttachment* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkClearAttachment(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkClearAttachment* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkClearRect(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkClearRect* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkClearRect(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkClearRect* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkImageBlit(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageBlit* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImageBlit(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageBlit* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkImageCopy(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageCopy* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImageCopy(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageCopy* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkImageResolve(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageResolve* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImageResolve(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageResolve* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkRenderPassBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassBeginInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkRenderPassBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassBeginInfo* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_VERSION_1_1
void reservedmarshal_VkPhysicalDeviceSubgroupProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSubgroupProperties* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSubgroupProperties* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkBindBufferMemoryInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindBufferMemoryInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkBindBufferMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindBufferMemoryInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkBindImageMemoryInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindImageMemoryInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkBindImageMemoryInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindImageMemoryInfo* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkPhysicalDevice16BitStorageFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevice16BitStorageFeatures* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevice16BitStorageFeatures* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkMemoryDedicatedRequirements(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryDedicatedRequirements* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryDedicatedRequirements* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkMemoryDedicatedAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryDedicatedAllocateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryDedicatedAllocateInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkMemoryAllocateFlagsInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryAllocateFlagsInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkMemoryAllocateFlagsInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkMemoryAllocateFlagsInfo* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkDeviceGroupRenderPassBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupRenderPassBeginInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupRenderPassBeginInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDeviceGroupCommandBufferBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupCommandBufferBeginInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupCommandBufferBeginInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkDeviceGroupSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupSubmitInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDeviceGroupSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupSubmitInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkDeviceGroupBindSparseInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupBindSparseInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDeviceGroupBindSparseInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDeviceGroupBindSparseInfo* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkBindBufferMemoryDeviceGroupInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindBufferMemoryDeviceGroupInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindBufferMemoryDeviceGroupInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkBindImageMemoryDeviceGroupInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindImageMemoryDeviceGroupInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindImageMemoryDeviceGroupInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceGroupProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceGroupProperties* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceGroupProperties* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDeviceGroupDeviceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupDeviceCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupDeviceCreateInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkBufferMemoryRequirementsInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferMemoryRequirementsInfo2* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferMemoryRequirementsInfo2* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkImageMemoryRequirementsInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageMemoryRequirementsInfo2* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageMemoryRequirementsInfo2* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkImageSparseMemoryRequirementsInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageSparseMemoryRequirementsInfo2* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSparseMemoryRequirementsInfo2* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkMemoryRequirements2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryRequirements2* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkMemoryRequirements2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryRequirements2* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkSparseImageMemoryRequirements2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageMemoryRequirements2* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageMemoryRequirements2* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkPhysicalDeviceFeatures2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFeatures2* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPhysicalDeviceFeatures2(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkPhysicalDeviceFeatures2* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkPhysicalDeviceProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceProperties2* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPhysicalDeviceProperties2(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkPhysicalDeviceProperties2* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkFormatProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFormatProperties2* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkFormatProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFormatProperties2* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkImageFormatProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageFormatProperties2* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImageFormatProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageFormatProperties2* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceImageFormatInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceImageFormatInfo2* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceImageFormatInfo2* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkQueueFamilyProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueueFamilyProperties2* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkQueueFamilyProperties2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyProperties2* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceMemoryProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryProperties2* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryProperties2* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkSparseImageFormatProperties2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSparseImageFormatProperties2* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSparseImageFormatProperties2* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceSparseImageFormatInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSparseImageFormatInfo2* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSparseImageFormatInfo2* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDevicePointClippingProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePointClippingProperties* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePointClippingProperties* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkInputAttachmentAspectReference(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkInputAttachmentAspectReference* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkInputAttachmentAspectReference* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkRenderPassInputAttachmentAspectCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassInputAttachmentAspectCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassInputAttachmentAspectCreateInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkImageViewUsageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageViewUsageCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImageViewUsageCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkImageViewUsageCreateInfo* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkPipelineTessellationDomainOriginStateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineTessellationDomainOriginStateCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineTessellationDomainOriginStateCreateInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkRenderPassMultiviewCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassMultiviewCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassMultiviewCreateInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceMultiviewFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiviewFeatures* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMultiviewFeatures* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceMultiviewProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiviewProperties* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMultiviewProperties* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceVariablePointersFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVariablePointersFeatures* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVariablePointersFeatures* forMarshaling, uint8_t** ptr);
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceVariablePointersFeatures, reservedmarshal_VkPhysicalDeviceVariablePointerFeatures)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceVariablePointersFeatures,
+ reservedmarshal_VkPhysicalDeviceVariablePointerFeatures)
void reservedmarshal_VkPhysicalDeviceProtectedMemoryFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceProtectedMemoryFeatures* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceProtectedMemoryFeatures* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceProtectedMemoryProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceProtectedMemoryProperties* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceProtectedMemoryProperties* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkDeviceQueueInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceQueueInfo2* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDeviceQueueInfo2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceQueueInfo2* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkProtectedSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkProtectedSubmitInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkProtectedSubmitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkProtectedSubmitInfo* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkSamplerYcbcrConversionCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerYcbcrConversionCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerYcbcrConversionCreateInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkSamplerYcbcrConversionInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerYcbcrConversionInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSamplerYcbcrConversionInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkSamplerYcbcrConversionInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkBindImagePlaneMemoryInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindImagePlaneMemoryInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkBindImagePlaneMemoryInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkBindImagePlaneMemoryInfo* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkImagePlaneMemoryRequirementsInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImagePlaneMemoryRequirementsInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImagePlaneMemoryRequirementsInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSamplerYcbcrConversionFeatures* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSamplerYcbcrConversionFeatures* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkSamplerYcbcrConversionImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerYcbcrConversionImageFormatProperties* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerYcbcrConversionImageFormatProperties* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDescriptorUpdateTemplateEntry(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorUpdateTemplateEntry* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorUpdateTemplateEntry* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDescriptorUpdateTemplateCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorUpdateTemplateCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorUpdateTemplateCreateInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkExternalMemoryProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalMemoryProperties* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkExternalMemoryProperties(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkExternalMemoryProperties* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceExternalImageFormatInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalImageFormatInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExternalImageFormatInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkExternalImageFormatProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalImageFormatProperties* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalImageFormatProperties* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceExternalBufferInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalBufferInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExternalBufferInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkExternalBufferProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalBufferProperties* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkExternalBufferProperties(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkExternalBufferProperties* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkPhysicalDeviceIDProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceIDProperties* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPhysicalDeviceIDProperties(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkPhysicalDeviceIDProperties* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkExternalMemoryImageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalMemoryImageCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalMemoryImageCreateInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkExternalMemoryBufferCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalMemoryBufferCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalMemoryBufferCreateInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkExportMemoryAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportMemoryAllocateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkExportMemoryAllocateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkExportMemoryAllocateInfo* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceExternalFenceInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalFenceInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExternalFenceInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkExternalFenceProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalFenceProperties* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkExternalFenceProperties(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkExternalFenceProperties* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkExportFenceCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportFenceCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkExportFenceCreateInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportFenceCreateInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkExportSemaphoreCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportSemaphoreCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkExportSemaphoreCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkExportSemaphoreCreateInfo* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceExternalSemaphoreInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalSemaphoreInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExternalSemaphoreInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkExternalSemaphoreProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalSemaphoreProperties* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalSemaphoreProperties* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceMaintenance3Properties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMaintenance3Properties* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance3Properties* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkDescriptorSetLayoutSupport(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetLayoutSupport* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDescriptorSetLayoutSupport(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDescriptorSetLayoutSupport* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceShaderDrawParametersFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderDrawParametersFeatures* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderDrawParametersFeatures* forMarshaling, uint8_t** ptr);
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceShaderDrawParametersFeatures, reservedmarshal_VkPhysicalDeviceShaderDrawParameterFeatures)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceShaderDrawParametersFeatures,
+ reservedmarshal_VkPhysicalDeviceShaderDrawParameterFeatures)
#endif
#ifdef VK_VERSION_1_2
void reservedmarshal_VkPhysicalDeviceVulkan11Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan11Features* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan11Features* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceVulkan11Properties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan11Properties* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan11Properties* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceVulkan12Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan12Features* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan12Features* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkConformanceVersion(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkConformanceVersion* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkConformanceVersion(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkConformanceVersion* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceVulkan12Properties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkan12Properties* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVulkan12Properties* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkImageFormatListCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageFormatListCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImageFormatListCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkImageFormatListCreateInfo* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkAttachmentDescription2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentDescription2* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkAttachmentDescription2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentDescription2* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkAttachmentReference2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentReference2* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkAttachmentReference2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentReference2* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkSubpassDescription2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassDescription2* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSubpassDescription2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassDescription2* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkSubpassDependency2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassDependency2* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSubpassDependency2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassDependency2* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkRenderPassCreateInfo2(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassCreateInfo2* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkRenderPassCreateInfo2(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassCreateInfo2* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkSubpassBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassBeginInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSubpassBeginInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassBeginInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkSubpassEndInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassEndInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSubpassEndInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassEndInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDevice8BitStorageFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevice8BitStorageFeatures* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevice8BitStorageFeatures* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceDriverProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDriverProperties* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDriverProperties* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceShaderAtomicInt64Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderAtomicInt64Features* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderAtomicInt64Features* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceShaderFloat16Int8Features(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderFloat16Int8Features* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderFloat16Int8Features* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceFloatControlsProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFloatControlsProperties* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFloatControlsProperties* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetLayoutBindingFlagsCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorSetLayoutBindingFlagsCreateInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceDescriptorIndexingFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDescriptorIndexingFeatures* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDescriptorIndexingFeatures* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceDescriptorIndexingProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDescriptorIndexingProperties* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDescriptorIndexingProperties* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetVariableDescriptorCountAllocateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorSetVariableDescriptorCountAllocateInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorSetVariableDescriptorCountLayoutSupport* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorSetVariableDescriptorCountLayoutSupport* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkSubpassDescriptionDepthStencilResolve(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassDescriptionDepthStencilResolve* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassDescriptionDepthStencilResolve* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceDepthStencilResolveProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDepthStencilResolveProperties* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDepthStencilResolveProperties* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceScalarBlockLayoutFeatures* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceScalarBlockLayoutFeatures* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkImageStencilUsageCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageStencilUsageCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageStencilUsageCreateInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkSamplerReductionModeCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerReductionModeCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerReductionModeCreateInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSamplerFilterMinmaxProperties* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSamplerFilterMinmaxProperties* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVulkanMemoryModelFeatures* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVulkanMemoryModelFeatures* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceImagelessFramebufferFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceImagelessFramebufferFeatures* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceImagelessFramebufferFeatures* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkFramebufferAttachmentImageInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFramebufferAttachmentImageInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFramebufferAttachmentImageInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkFramebufferAttachmentsCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFramebufferAttachmentsCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFramebufferAttachmentsCreateInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkRenderPassAttachmentBeginInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassAttachmentBeginInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassAttachmentBeginInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAttachmentReferenceStencilLayout(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentReferenceStencilLayout* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentReferenceStencilLayout* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAttachmentDescriptionStencilLayout(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentDescriptionStencilLayout* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentDescriptionStencilLayout* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceHostQueryResetFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceHostQueryResetFeatures* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceHostQueryResetFeatures* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTimelineSemaphoreFeatures* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTimelineSemaphoreFeatures* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceTimelineSemaphoreProperties(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTimelineSemaphoreProperties* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTimelineSemaphoreProperties* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkSemaphoreTypeCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreTypeCreateInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSemaphoreTypeCreateInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkSemaphoreTypeCreateInfo* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkTimelineSemaphoreSubmitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkTimelineSemaphoreSubmitInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkTimelineSemaphoreSubmitInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkSemaphoreWaitInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreWaitInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSemaphoreWaitInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreWaitInfo* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkSemaphoreSignalInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreSignalInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSemaphoreSignalInfo(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreSignalInfo* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceBufferDeviceAddressFeatures* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceBufferDeviceAddressFeatures* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkBufferDeviceAddressInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferDeviceAddressInfo* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkBufferDeviceAddressInfo(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkBufferDeviceAddressInfo* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkBufferOpaqueCaptureAddressCreateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferOpaqueCaptureAddressCreateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferOpaqueCaptureAddressCreateInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryOpaqueCaptureAddressAllocateInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryOpaqueCaptureAddressAllocateInfo* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceMemoryOpaqueCaptureAddressInfo* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceMemoryOpaqueCaptureAddressInfo* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_surface
-void reservedmarshal_VkSurfaceCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceCapabilitiesKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSurfaceCapabilitiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceCapabilitiesKHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkSurfaceFormatKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceFormatKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSurfaceFormatKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceFormatKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_swapchain
-void reservedmarshal_VkSwapchainCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSwapchainCreateInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSwapchainCreateInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSwapchainCreateInfoKHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkPresentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPresentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkImageSwapchainCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageSwapchainCreateInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageSwapchainCreateInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkBindImageMemorySwapchainInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindImageMemorySwapchainInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindImageMemorySwapchainInfoKHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkAcquireNextImageInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAcquireNextImageInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkAcquireNextImageInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkAcquireNextImageInfoKHR* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkDeviceGroupPresentCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupPresentCapabilitiesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupPresentCapabilitiesKHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkDeviceGroupPresentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupPresentInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDeviceGroupPresentInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDeviceGroupPresentInfoKHR* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkDeviceGroupSwapchainCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceGroupSwapchainCreateInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceGroupSwapchainCreateInfoKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_display
-void reservedmarshal_VkDisplayModeParametersKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayModeParametersKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDisplayModeParametersKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDisplayModeParametersKHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkDisplayModeCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayModeCreateInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDisplayModeCreateInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDisplayModeCreateInfoKHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkDisplayModePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayModePropertiesKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDisplayModePropertiesKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDisplayModePropertiesKHR* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkDisplayPlaneCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPlaneCapabilitiesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPlaneCapabilitiesKHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkDisplayPlanePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPlanePropertiesKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDisplayPlanePropertiesKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDisplayPlanePropertiesKHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkDisplayPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPropertiesKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDisplayPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPropertiesKHR* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkDisplaySurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplaySurfaceCreateInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplaySurfaceCreateInfoKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_display_swapchain
-void reservedmarshal_VkDisplayPresentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPresentInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDisplayPresentInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPresentInfoKHR* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_KHR_xlib_surface
-void reservedmarshal_VkXlibSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkXlibSurfaceCreateInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkXlibSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkXlibSurfaceCreateInfoKHR* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_KHR_xcb_surface
-void reservedmarshal_VkXcbSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkXcbSurfaceCreateInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkXcbSurfaceCreateInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkXcbSurfaceCreateInfoKHR* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_KHR_wayland_surface
void reservedmarshal_VkWaylandSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWaylandSurfaceCreateInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWaylandSurfaceCreateInfoKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_android_surface
void reservedmarshal_VkAndroidSurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAndroidSurfaceCreateInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAndroidSurfaceCreateInfoKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_win32_surface
-void reservedmarshal_VkWin32SurfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWin32SurfaceCreateInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkWin32SurfaceCreateInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkWin32SurfaceCreateInfoKHR* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_KHR_sampler_mirror_clamp_to_edge
#endif
#ifdef VK_KHR_video_queue
void reservedmarshal_VkVideoQueueFamilyProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoQueueFamilyProperties2KHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoQueueFamilyProperties2KHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkVideoProfileKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoProfileKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkVideoProfileKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoProfileKHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkVideoProfilesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoProfilesKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkVideoProfilesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoProfilesKHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkVideoCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoCapabilitiesKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkVideoCapabilitiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoCapabilitiesKHR* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceVideoFormatInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVideoFormatInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVideoFormatInfoKHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkVideoFormatPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoFormatPropertiesKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkVideoFormatPropertiesKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkVideoFormatPropertiesKHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkVideoPictureResourceKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoPictureResourceKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkVideoPictureResourceKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkVideoPictureResourceKHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkVideoReferenceSlotKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoReferenceSlotKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkVideoReferenceSlotKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoReferenceSlotKHR* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkVideoGetMemoryPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoGetMemoryPropertiesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoGetMemoryPropertiesKHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkVideoBindMemoryKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoBindMemoryKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkVideoBindMemoryKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoBindMemoryKHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkVideoSessionCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoSessionCreateInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkVideoSessionCreateInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkVideoSessionCreateInfoKHR* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkVideoSessionParametersCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoSessionParametersCreateInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoSessionParametersCreateInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoSessionParametersUpdateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoSessionParametersUpdateInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoSessionParametersUpdateInfoKHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkVideoBeginCodingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoBeginCodingInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkVideoBeginCodingInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkVideoBeginCodingInfoKHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkVideoEndCodingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEndCodingInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkVideoEndCodingInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEndCodingInfoKHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkVideoCodingControlInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoCodingControlInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkVideoCodingControlInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkVideoCodingControlInfoKHR* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_KHR_video_decode_queue
-void reservedmarshal_VkVideoDecodeInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkVideoDecodeInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeInfoKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_dynamic_rendering
-void reservedmarshal_VkRenderingAttachmentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderingAttachmentInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkRenderingAttachmentInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkRenderingAttachmentInfoKHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkRenderingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderingInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkRenderingInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineRenderingCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRenderingCreateInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRenderingCreateInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDynamicRenderingFeaturesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDynamicRenderingFeaturesKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkCommandBufferInheritanceRenderingInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferInheritanceRenderingInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferInheritanceRenderingInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderingFragmentShadingRateAttachmentInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingFragmentShadingRateAttachmentInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderingFragmentDensityMapAttachmentInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderingFragmentDensityMapAttachmentInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAttachmentSampleCountInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentSampleCountInfoAMD* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentSampleCountInfoAMD* forMarshaling, uint8_t** ptr);
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkAttachmentSampleCountInfoAMD, reservedmarshal_VkAttachmentSampleCountInfoNV)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkAttachmentSampleCountInfoAMD,
+ reservedmarshal_VkAttachmentSampleCountInfoNV)
void reservedmarshal_VkMultiviewPerViewAttributesInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMultiviewPerViewAttributesInfoNVX* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMultiviewPerViewAttributesInfoNVX* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_multiview
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkRenderPassMultiviewCreateInfo, reservedmarshal_VkRenderPassMultiviewCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkRenderPassMultiviewCreateInfo,
+ reservedmarshal_VkRenderPassMultiviewCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceMultiviewFeatures, reservedmarshal_VkPhysicalDeviceMultiviewFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceMultiviewFeatures,
+ reservedmarshal_VkPhysicalDeviceMultiviewFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceMultiviewProperties, reservedmarshal_VkPhysicalDeviceMultiviewPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceMultiviewProperties,
+ reservedmarshal_VkPhysicalDeviceMultiviewPropertiesKHR)
#endif
#ifdef VK_KHR_get_physical_device_properties2
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceFeatures2, reservedmarshal_VkPhysicalDeviceFeatures2KHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceFeatures2,
+ reservedmarshal_VkPhysicalDeviceFeatures2KHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceProperties2, reservedmarshal_VkPhysicalDeviceProperties2KHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceProperties2,
+ reservedmarshal_VkPhysicalDeviceProperties2KHR)
DEFINE_ALIAS_FUNCTION(reservedmarshal_VkFormatProperties2, reservedmarshal_VkFormatProperties2KHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkImageFormatProperties2, reservedmarshal_VkImageFormatProperties2KHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkImageFormatProperties2,
+ reservedmarshal_VkImageFormatProperties2KHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceImageFormatInfo2, reservedmarshal_VkPhysicalDeviceImageFormatInfo2KHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceImageFormatInfo2,
+ reservedmarshal_VkPhysicalDeviceImageFormatInfo2KHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkQueueFamilyProperties2, reservedmarshal_VkQueueFamilyProperties2KHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkQueueFamilyProperties2,
+ reservedmarshal_VkQueueFamilyProperties2KHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceMemoryProperties2, reservedmarshal_VkPhysicalDeviceMemoryProperties2KHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceMemoryProperties2,
+ reservedmarshal_VkPhysicalDeviceMemoryProperties2KHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSparseImageFormatProperties2, reservedmarshal_VkSparseImageFormatProperties2KHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSparseImageFormatProperties2,
+ reservedmarshal_VkSparseImageFormatProperties2KHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceSparseImageFormatInfo2, reservedmarshal_VkPhysicalDeviceSparseImageFormatInfo2KHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceSparseImageFormatInfo2,
+ reservedmarshal_VkPhysicalDeviceSparseImageFormatInfo2KHR)
#endif
#ifdef VK_KHR_device_group
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkMemoryAllocateFlagsInfo, reservedmarshal_VkMemoryAllocateFlagsInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkMemoryAllocateFlagsInfo,
+ reservedmarshal_VkMemoryAllocateFlagsInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDeviceGroupRenderPassBeginInfo, reservedmarshal_VkDeviceGroupRenderPassBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDeviceGroupRenderPassBeginInfo,
+ reservedmarshal_VkDeviceGroupRenderPassBeginInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDeviceGroupCommandBufferBeginInfo, reservedmarshal_VkDeviceGroupCommandBufferBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDeviceGroupCommandBufferBeginInfo,
+ reservedmarshal_VkDeviceGroupCommandBufferBeginInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDeviceGroupSubmitInfo, reservedmarshal_VkDeviceGroupSubmitInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDeviceGroupSubmitInfo,
+ reservedmarshal_VkDeviceGroupSubmitInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDeviceGroupBindSparseInfo, reservedmarshal_VkDeviceGroupBindSparseInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDeviceGroupBindSparseInfo,
+ reservedmarshal_VkDeviceGroupBindSparseInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkBindBufferMemoryDeviceGroupInfo, reservedmarshal_VkBindBufferMemoryDeviceGroupInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkBindBufferMemoryDeviceGroupInfo,
+ reservedmarshal_VkBindBufferMemoryDeviceGroupInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkBindImageMemoryDeviceGroupInfo, reservedmarshal_VkBindImageMemoryDeviceGroupInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkBindImageMemoryDeviceGroupInfo,
+ reservedmarshal_VkBindImageMemoryDeviceGroupInfoKHR)
#endif
#ifdef VK_KHR_shader_draw_parameters
@@ -1799,199 +1248,188 @@
#ifdef VK_KHR_maintenance1
#endif
#ifdef VK_KHR_device_group_creation
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceGroupProperties, reservedmarshal_VkPhysicalDeviceGroupPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceGroupProperties,
+ reservedmarshal_VkPhysicalDeviceGroupPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDeviceGroupDeviceCreateInfo, reservedmarshal_VkDeviceGroupDeviceCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDeviceGroupDeviceCreateInfo,
+ reservedmarshal_VkDeviceGroupDeviceCreateInfoKHR)
#endif
#ifdef VK_KHR_external_memory_capabilities
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkExternalMemoryProperties, reservedmarshal_VkExternalMemoryPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkExternalMemoryProperties,
+ reservedmarshal_VkExternalMemoryPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceExternalImageFormatInfo, reservedmarshal_VkPhysicalDeviceExternalImageFormatInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceExternalImageFormatInfo,
+ reservedmarshal_VkPhysicalDeviceExternalImageFormatInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkExternalImageFormatProperties, reservedmarshal_VkExternalImageFormatPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkExternalImageFormatProperties,
+ reservedmarshal_VkExternalImageFormatPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceExternalBufferInfo, reservedmarshal_VkPhysicalDeviceExternalBufferInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceExternalBufferInfo,
+ reservedmarshal_VkPhysicalDeviceExternalBufferInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkExternalBufferProperties, reservedmarshal_VkExternalBufferPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkExternalBufferProperties,
+ reservedmarshal_VkExternalBufferPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceIDProperties, reservedmarshal_VkPhysicalDeviceIDPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceIDProperties,
+ reservedmarshal_VkPhysicalDeviceIDPropertiesKHR)
#endif
#ifdef VK_KHR_external_memory
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkExternalMemoryImageCreateInfo, reservedmarshal_VkExternalMemoryImageCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkExternalMemoryImageCreateInfo,
+ reservedmarshal_VkExternalMemoryImageCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkExternalMemoryBufferCreateInfo, reservedmarshal_VkExternalMemoryBufferCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkExternalMemoryBufferCreateInfo,
+ reservedmarshal_VkExternalMemoryBufferCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkExportMemoryAllocateInfo, reservedmarshal_VkExportMemoryAllocateInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkExportMemoryAllocateInfo,
+ reservedmarshal_VkExportMemoryAllocateInfoKHR)
#endif
#ifdef VK_KHR_external_memory_win32
void reservedmarshal_VkImportMemoryWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportMemoryWin32HandleInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportMemoryWin32HandleInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkExportMemoryWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportMemoryWin32HandleInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportMemoryWin32HandleInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkMemoryWin32HandlePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryWin32HandlePropertiesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryWin32HandlePropertiesKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkMemoryGetWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryGetWin32HandleInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryGetWin32HandleInfoKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_external_memory_fd
-void reservedmarshal_VkImportMemoryFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportMemoryFdInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImportMemoryFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportMemoryFdInfoKHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkMemoryFdPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryFdPropertiesKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkMemoryFdPropertiesKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryFdPropertiesKHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkMemoryGetFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryGetFdInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkMemoryGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryGetFdInfoKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_win32_keyed_mutex
void reservedmarshal_VkWin32KeyedMutexAcquireReleaseInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWin32KeyedMutexAcquireReleaseInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWin32KeyedMutexAcquireReleaseInfoKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_external_semaphore_capabilities
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceExternalSemaphoreInfo, reservedmarshal_VkPhysicalDeviceExternalSemaphoreInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceExternalSemaphoreInfo,
+ reservedmarshal_VkPhysicalDeviceExternalSemaphoreInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkExternalSemaphoreProperties, reservedmarshal_VkExternalSemaphorePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkExternalSemaphoreProperties,
+ reservedmarshal_VkExternalSemaphorePropertiesKHR)
#endif
#ifdef VK_KHR_external_semaphore
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkExportSemaphoreCreateInfo, reservedmarshal_VkExportSemaphoreCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkExportSemaphoreCreateInfo,
+ reservedmarshal_VkExportSemaphoreCreateInfoKHR)
#endif
#ifdef VK_KHR_external_semaphore_win32
void reservedmarshal_VkImportSemaphoreWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportSemaphoreWin32HandleInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportSemaphoreWin32HandleInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkExportSemaphoreWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportSemaphoreWin32HandleInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportSemaphoreWin32HandleInfoKHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkD3D12FenceSubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkD3D12FenceSubmitInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkD3D12FenceSubmitInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkD3D12FenceSubmitInfoKHR* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkSemaphoreGetWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreGetWin32HandleInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreGetWin32HandleInfoKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_external_semaphore_fd
-void reservedmarshal_VkImportSemaphoreFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportSemaphoreFdInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImportSemaphoreFdInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkImportSemaphoreFdInfoKHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkSemaphoreGetFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreGetFdInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSemaphoreGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreGetFdInfoKHR* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_KHR_push_descriptor
void reservedmarshal_VkPhysicalDevicePushDescriptorPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePushDescriptorPropertiesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePushDescriptorPropertiesKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_shader_float16_int8
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceShaderFloat16Int8Features, reservedmarshal_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceShaderFloat16Int8Features,
+ reservedmarshal_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceShaderFloat16Int8Features, reservedmarshal_VkPhysicalDeviceFloat16Int8FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceShaderFloat16Int8Features,
+ reservedmarshal_VkPhysicalDeviceFloat16Int8FeaturesKHR)
#endif
#ifdef VK_KHR_16bit_storage
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDevice16BitStorageFeatures, reservedmarshal_VkPhysicalDevice16BitStorageFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDevice16BitStorageFeatures,
+ reservedmarshal_VkPhysicalDevice16BitStorageFeaturesKHR)
#endif
#ifdef VK_KHR_incremental_present
-void reservedmarshal_VkRectLayerKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRectLayerKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkRectLayerKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRectLayerKHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkPresentRegionKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentRegionKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPresentRegionKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentRegionKHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkPresentRegionsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentRegionsKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPresentRegionsKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentRegionsKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_descriptor_update_template
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDescriptorUpdateTemplateEntry, reservedmarshal_VkDescriptorUpdateTemplateEntryKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDescriptorUpdateTemplateEntry,
+ reservedmarshal_VkDescriptorUpdateTemplateEntryKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDescriptorUpdateTemplateCreateInfo, reservedmarshal_VkDescriptorUpdateTemplateCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDescriptorUpdateTemplateCreateInfo,
+ reservedmarshal_VkDescriptorUpdateTemplateCreateInfoKHR)
#endif
#ifdef VK_KHR_imageless_framebuffer
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceImagelessFramebufferFeatures, reservedmarshal_VkPhysicalDeviceImagelessFramebufferFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceImagelessFramebufferFeatures,
+ reservedmarshal_VkPhysicalDeviceImagelessFramebufferFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkFramebufferAttachmentsCreateInfo, reservedmarshal_VkFramebufferAttachmentsCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkFramebufferAttachmentsCreateInfo,
+ reservedmarshal_VkFramebufferAttachmentsCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkFramebufferAttachmentImageInfo, reservedmarshal_VkFramebufferAttachmentImageInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkFramebufferAttachmentImageInfo,
+ reservedmarshal_VkFramebufferAttachmentImageInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkRenderPassAttachmentBeginInfo, reservedmarshal_VkRenderPassAttachmentBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkRenderPassAttachmentBeginInfo,
+ reservedmarshal_VkRenderPassAttachmentBeginInfoKHR)
#endif
#ifdef VK_KHR_create_renderpass2
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkRenderPassCreateInfo2, reservedmarshal_VkRenderPassCreateInfo2KHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkRenderPassCreateInfo2,
+ reservedmarshal_VkRenderPassCreateInfo2KHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkAttachmentDescription2, reservedmarshal_VkAttachmentDescription2KHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkAttachmentDescription2,
+ reservedmarshal_VkAttachmentDescription2KHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkAttachmentReference2, reservedmarshal_VkAttachmentReference2KHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkAttachmentReference2,
+ reservedmarshal_VkAttachmentReference2KHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSubpassDescription2, reservedmarshal_VkSubpassDescription2KHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSubpassDescription2,
+ reservedmarshal_VkSubpassDescription2KHR)
DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSubpassDependency2, reservedmarshal_VkSubpassDependency2KHR)
@@ -2002,180 +1440,150 @@
#endif
#ifdef VK_KHR_shared_presentable_image
void reservedmarshal_VkSharedPresentSurfaceCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSharedPresentSurfaceCapabilitiesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSharedPresentSurfaceCapabilitiesKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_external_fence_capabilities
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceExternalFenceInfo, reservedmarshal_VkPhysicalDeviceExternalFenceInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceExternalFenceInfo,
+ reservedmarshal_VkPhysicalDeviceExternalFenceInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkExternalFenceProperties, reservedmarshal_VkExternalFencePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkExternalFenceProperties,
+ reservedmarshal_VkExternalFencePropertiesKHR)
#endif
#ifdef VK_KHR_external_fence
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkExportFenceCreateInfo, reservedmarshal_VkExportFenceCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkExportFenceCreateInfo,
+ reservedmarshal_VkExportFenceCreateInfoKHR)
#endif
#ifdef VK_KHR_external_fence_win32
void reservedmarshal_VkImportFenceWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportFenceWin32HandleInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportFenceWin32HandleInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkExportFenceWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportFenceWin32HandleInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportFenceWin32HandleInfoKHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkFenceGetWin32HandleInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFenceGetWin32HandleInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkFenceGetWin32HandleInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkFenceGetWin32HandleInfoKHR* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_KHR_external_fence_fd
-void reservedmarshal_VkImportFenceFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportFenceFdInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImportFenceFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportFenceFdInfoKHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkFenceGetFdInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFenceGetFdInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkFenceGetFdInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFenceGetFdInfoKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_performance_query
void reservedmarshal_VkPhysicalDevicePerformanceQueryFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePerformanceQueryFeaturesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePerformanceQueryFeaturesKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDevicePerformanceQueryPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePerformanceQueryPropertiesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePerformanceQueryPropertiesKHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkPerformanceCounterKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceCounterKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPerformanceCounterKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceCounterKHR* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkPerformanceCounterDescriptionKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceCounterDescriptionKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceCounterDescriptionKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkQueryPoolPerformanceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueryPoolPerformanceCreateInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueryPoolPerformanceCreateInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPerformanceCounterResultKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceCounterResultKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceCounterResultKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAcquireProfilingLockInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAcquireProfilingLockInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAcquireProfilingLockInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPerformanceQuerySubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceQuerySubmitInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceQuerySubmitInfoKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_maintenance2
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDevicePointClippingProperties, reservedmarshal_VkPhysicalDevicePointClippingPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDevicePointClippingProperties,
+ reservedmarshal_VkPhysicalDevicePointClippingPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkRenderPassInputAttachmentAspectCreateInfo, reservedmarshal_VkRenderPassInputAttachmentAspectCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkRenderPassInputAttachmentAspectCreateInfo,
+ reservedmarshal_VkRenderPassInputAttachmentAspectCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkInputAttachmentAspectReference, reservedmarshal_VkInputAttachmentAspectReferenceKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkInputAttachmentAspectReference,
+ reservedmarshal_VkInputAttachmentAspectReferenceKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkImageViewUsageCreateInfo, reservedmarshal_VkImageViewUsageCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkImageViewUsageCreateInfo,
+ reservedmarshal_VkImageViewUsageCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPipelineTessellationDomainOriginStateCreateInfo, reservedmarshal_VkPipelineTessellationDomainOriginStateCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPipelineTessellationDomainOriginStateCreateInfo,
+ reservedmarshal_VkPipelineTessellationDomainOriginStateCreateInfoKHR)
#endif
#ifdef VK_KHR_get_surface_capabilities2
void reservedmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSurfaceInfo2KHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSurfaceInfo2KHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkSurfaceCapabilities2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceCapabilities2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSurfaceCapabilities2KHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkSurfaceCapabilities2KHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkSurfaceFormat2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceFormat2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSurfaceFormat2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceFormat2KHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_variable_pointers
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceVariablePointersFeatures, reservedmarshal_VkPhysicalDeviceVariablePointerFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceVariablePointersFeatures,
+ reservedmarshal_VkPhysicalDeviceVariablePointerFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceVariablePointersFeatures, reservedmarshal_VkPhysicalDeviceVariablePointersFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceVariablePointersFeatures,
+ reservedmarshal_VkPhysicalDeviceVariablePointersFeaturesKHR)
#endif
#ifdef VK_KHR_get_display_properties2
-void reservedmarshal_VkDisplayProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayProperties2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDisplayProperties2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayProperties2KHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkDisplayPlaneProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPlaneProperties2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDisplayPlaneProperties2KHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDisplayPlaneProperties2KHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkDisplayModeProperties2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayModeProperties2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDisplayModeProperties2KHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDisplayModeProperties2KHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkDisplayPlaneInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPlaneInfo2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDisplayPlaneInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPlaneInfo2KHR* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkDisplayPlaneCapabilities2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPlaneCapabilities2KHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPlaneCapabilities2KHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_dedicated_allocation
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkMemoryDedicatedRequirements, reservedmarshal_VkMemoryDedicatedRequirementsKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkMemoryDedicatedRequirements,
+ reservedmarshal_VkMemoryDedicatedRequirementsKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkMemoryDedicatedAllocateInfo, reservedmarshal_VkMemoryDedicatedAllocateInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkMemoryDedicatedAllocateInfo,
+ reservedmarshal_VkMemoryDedicatedAllocateInfoKHR)
#endif
#ifdef VK_KHR_storage_buffer_storage_class
@@ -2183,501 +1591,419 @@
#ifdef VK_KHR_relaxed_block_layout
#endif
#ifdef VK_KHR_get_memory_requirements2
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkBufferMemoryRequirementsInfo2, reservedmarshal_VkBufferMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkBufferMemoryRequirementsInfo2,
+ reservedmarshal_VkBufferMemoryRequirementsInfo2KHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkImageMemoryRequirementsInfo2, reservedmarshal_VkImageMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkImageMemoryRequirementsInfo2,
+ reservedmarshal_VkImageMemoryRequirementsInfo2KHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkImageSparseMemoryRequirementsInfo2, reservedmarshal_VkImageSparseMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkImageSparseMemoryRequirementsInfo2,
+ reservedmarshal_VkImageSparseMemoryRequirementsInfo2KHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkMemoryRequirements2, reservedmarshal_VkMemoryRequirements2KHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkMemoryRequirements2,
+ reservedmarshal_VkMemoryRequirements2KHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSparseImageMemoryRequirements2, reservedmarshal_VkSparseImageMemoryRequirements2KHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSparseImageMemoryRequirements2,
+ reservedmarshal_VkSparseImageMemoryRequirements2KHR)
#endif
#ifdef VK_KHR_image_format_list
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkImageFormatListCreateInfo, reservedmarshal_VkImageFormatListCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkImageFormatListCreateInfo,
+ reservedmarshal_VkImageFormatListCreateInfoKHR)
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSamplerYcbcrConversionCreateInfo, reservedmarshal_VkSamplerYcbcrConversionCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSamplerYcbcrConversionCreateInfo,
+ reservedmarshal_VkSamplerYcbcrConversionCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSamplerYcbcrConversionInfo, reservedmarshal_VkSamplerYcbcrConversionInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSamplerYcbcrConversionInfo,
+ reservedmarshal_VkSamplerYcbcrConversionInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkBindImagePlaneMemoryInfo, reservedmarshal_VkBindImagePlaneMemoryInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkBindImagePlaneMemoryInfo,
+ reservedmarshal_VkBindImagePlaneMemoryInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkImagePlaneMemoryRequirementsInfo, reservedmarshal_VkImagePlaneMemoryRequirementsInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkImagePlaneMemoryRequirementsInfo,
+ reservedmarshal_VkImagePlaneMemoryRequirementsInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures, reservedmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeatures,
+ reservedmarshal_VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSamplerYcbcrConversionImageFormatProperties, reservedmarshal_VkSamplerYcbcrConversionImageFormatPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSamplerYcbcrConversionImageFormatProperties,
+ reservedmarshal_VkSamplerYcbcrConversionImageFormatPropertiesKHR)
#endif
#ifdef VK_KHR_bind_memory2
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkBindBufferMemoryInfo, reservedmarshal_VkBindBufferMemoryInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkBindBufferMemoryInfo,
+ reservedmarshal_VkBindBufferMemoryInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkBindImageMemoryInfo, reservedmarshal_VkBindImageMemoryInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkBindImageMemoryInfo,
+ reservedmarshal_VkBindImageMemoryInfoKHR)
#endif
#ifdef VK_KHR_portability_subset
void reservedmarshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePortabilitySubsetFeaturesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePortabilitySubsetFeaturesKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePortabilitySubsetPropertiesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePortabilitySubsetPropertiesKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_maintenance3
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceMaintenance3Properties, reservedmarshal_VkPhysicalDeviceMaintenance3PropertiesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceMaintenance3Properties,
+ reservedmarshal_VkPhysicalDeviceMaintenance3PropertiesKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDescriptorSetLayoutSupport, reservedmarshal_VkDescriptorSetLayoutSupportKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDescriptorSetLayoutSupport,
+ reservedmarshal_VkDescriptorSetLayoutSupportKHR)
#endif
#ifdef VK_KHR_draw_indirect_count
#endif
#ifdef VK_KHR_shader_subgroup_extended_types
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, reservedmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures,
+ reservedmarshal_VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)
#endif
#ifdef VK_KHR_8bit_storage
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDevice8BitStorageFeatures, reservedmarshal_VkPhysicalDevice8BitStorageFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDevice8BitStorageFeatures,
+ reservedmarshal_VkPhysicalDevice8BitStorageFeaturesKHR)
#endif
#ifdef VK_KHR_shader_atomic_int64
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceShaderAtomicInt64Features, reservedmarshal_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceShaderAtomicInt64Features,
+ reservedmarshal_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR)
#endif
#ifdef VK_KHR_shader_clock
void reservedmarshal_VkPhysicalDeviceShaderClockFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderClockFeaturesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderClockFeaturesKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_driver_properties
DEFINE_ALIAS_FUNCTION(reservedmarshal_VkConformanceVersion, reservedmarshal_VkConformanceVersionKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceDriverProperties, reservedmarshal_VkPhysicalDeviceDriverPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceDriverProperties,
+ reservedmarshal_VkPhysicalDeviceDriverPropertiesKHR)
#endif
#ifdef VK_KHR_shader_float_controls
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceFloatControlsProperties, reservedmarshal_VkPhysicalDeviceFloatControlsPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceFloatControlsProperties,
+ reservedmarshal_VkPhysicalDeviceFloatControlsPropertiesKHR)
#endif
#ifdef VK_KHR_depth_stencil_resolve
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSubpassDescriptionDepthStencilResolve, reservedmarshal_VkSubpassDescriptionDepthStencilResolveKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSubpassDescriptionDepthStencilResolve,
+ reservedmarshal_VkSubpassDescriptionDepthStencilResolveKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceDepthStencilResolveProperties, reservedmarshal_VkPhysicalDeviceDepthStencilResolvePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceDepthStencilResolveProperties,
+ reservedmarshal_VkPhysicalDeviceDepthStencilResolvePropertiesKHR)
#endif
#ifdef VK_KHR_swapchain_mutable_format
#endif
#ifdef VK_KHR_timeline_semaphore
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures, reservedmarshal_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceTimelineSemaphoreFeatures,
+ reservedmarshal_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceTimelineSemaphoreProperties, reservedmarshal_VkPhysicalDeviceTimelineSemaphorePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceTimelineSemaphoreProperties,
+ reservedmarshal_VkPhysicalDeviceTimelineSemaphorePropertiesKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSemaphoreTypeCreateInfo, reservedmarshal_VkSemaphoreTypeCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSemaphoreTypeCreateInfo,
+ reservedmarshal_VkSemaphoreTypeCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkTimelineSemaphoreSubmitInfo, reservedmarshal_VkTimelineSemaphoreSubmitInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkTimelineSemaphoreSubmitInfo,
+ reservedmarshal_VkTimelineSemaphoreSubmitInfoKHR)
DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSemaphoreWaitInfo, reservedmarshal_VkSemaphoreWaitInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSemaphoreSignalInfo, reservedmarshal_VkSemaphoreSignalInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSemaphoreSignalInfo,
+ reservedmarshal_VkSemaphoreSignalInfoKHR)
#endif
#ifdef VK_KHR_vulkan_memory_model
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures, reservedmarshal_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures,
+ reservedmarshal_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR)
#endif
#ifdef VK_KHR_shader_terminate_invocation
void reservedmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_fragment_shading_rate
void reservedmarshal_VkFragmentShadingRateAttachmentInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFragmentShadingRateAttachmentInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFragmentShadingRateAttachmentInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineFragmentShadingRateStateCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineFragmentShadingRateStateCreateInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineFragmentShadingRateStateCreateInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceFragmentShadingRateKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRateKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_spirv_1_4
#endif
#ifdef VK_KHR_surface_protected_capabilities
void reservedmarshal_VkSurfaceProtectedCapabilitiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceProtectedCapabilitiesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceProtectedCapabilitiesKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_separate_depth_stencil_layouts
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, reservedmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures,
+ reservedmarshal_VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkAttachmentReferenceStencilLayout, reservedmarshal_VkAttachmentReferenceStencilLayoutKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkAttachmentReferenceStencilLayout,
+ reservedmarshal_VkAttachmentReferenceStencilLayoutKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkAttachmentDescriptionStencilLayout, reservedmarshal_VkAttachmentDescriptionStencilLayoutKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkAttachmentDescriptionStencilLayout,
+ reservedmarshal_VkAttachmentDescriptionStencilLayoutKHR)
#endif
#ifdef VK_KHR_present_wait
void reservedmarshal_VkPhysicalDevicePresentWaitFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePresentWaitFeaturesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePresentWaitFeaturesKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_uniform_buffer_standard_layout
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures, reservedmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeatures,
+ reservedmarshal_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)
#endif
#ifdef VK_KHR_buffer_device_address
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures, reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeatures,
+ reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkBufferDeviceAddressInfo, reservedmarshal_VkBufferDeviceAddressInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkBufferDeviceAddressInfo,
+ reservedmarshal_VkBufferDeviceAddressInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkBufferOpaqueCaptureAddressCreateInfo, reservedmarshal_VkBufferOpaqueCaptureAddressCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkBufferOpaqueCaptureAddressCreateInfo,
+ reservedmarshal_VkBufferOpaqueCaptureAddressCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo, reservedmarshal_VkMemoryOpaqueCaptureAddressAllocateInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkMemoryOpaqueCaptureAddressAllocateInfo,
+ reservedmarshal_VkMemoryOpaqueCaptureAddressAllocateInfoKHR)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo, reservedmarshal_VkDeviceMemoryOpaqueCaptureAddressInfoKHR)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo,
+ reservedmarshal_VkDeviceMemoryOpaqueCaptureAddressInfoKHR)
#endif
#ifdef VK_KHR_deferred_host_operations
#endif
#ifdef VK_KHR_pipeline_executable_properties
void reservedmarshal_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkPipelineInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPipelineInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineExecutablePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineExecutablePropertiesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineExecutablePropertiesKHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkPipelineExecutableInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineExecutableInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPipelineExecutableInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkPipelineExecutableInfoKHR* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkPipelineExecutableStatisticValueKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineExecutableStatisticValueKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineExecutableStatisticValueKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineExecutableStatisticKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineExecutableStatisticKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineExecutableStatisticKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineExecutableInternalRepresentationKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineExecutableInternalRepresentationKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineExecutableInternalRepresentationKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_shader_integer_dot_product
void reservedmarshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_pipeline_library
void reservedmarshal_VkPipelineLibraryCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineLibraryCreateInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineLibraryCreateInfoKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_shader_non_semantic_info
#endif
#ifdef VK_KHR_present_id
-void reservedmarshal_VkPresentIdKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentIdKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPresentIdKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentIdKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDevicePresentIdFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePresentIdFeaturesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePresentIdFeaturesKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_video_encode_queue
-void reservedmarshal_VkVideoEncodeInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkVideoEncodeInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoEncodeRateControlInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeRateControlInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeRateControlInfoKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_synchronization2
-void reservedmarshal_VkMemoryBarrier2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryBarrier2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkMemoryBarrier2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryBarrier2KHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkBufferMemoryBarrier2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferMemoryBarrier2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkBufferMemoryBarrier2KHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkBufferMemoryBarrier2KHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkImageMemoryBarrier2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageMemoryBarrier2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImageMemoryBarrier2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageMemoryBarrier2KHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkDependencyInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDependencyInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDependencyInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDependencyInfoKHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkSemaphoreSubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreSubmitInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSemaphoreSubmitInfoKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreSubmitInfoKHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkCommandBufferSubmitInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferSubmitInfoKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkCommandBufferSubmitInfoKHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkCommandBufferSubmitInfoKHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkSubmitInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubmitInfo2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSubmitInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubmitInfo2KHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSynchronization2FeaturesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSynchronization2FeaturesKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkQueueFamilyCheckpointProperties2NV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueueFamilyCheckpointProperties2NV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyCheckpointProperties2NV* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkCheckpointData2NV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCheckpointData2NV* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkCheckpointData2NV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCheckpointData2NV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
void reservedmarshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* forMarshaling,
uint8_t** ptr);
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
void reservedmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
void reservedmarshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_copy_commands2
-void reservedmarshal_VkBufferCopy2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCopy2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkBufferCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCopy2KHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkCopyBufferInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyBufferInfo2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkCopyBufferInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyBufferInfo2KHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkImageCopy2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageCopy2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImageCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageCopy2KHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkCopyImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyImageInfo2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkCopyImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyImageInfo2KHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkBufferImageCopy2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferImageCopy2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkBufferImageCopy2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferImageCopy2KHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkCopyBufferToImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyBufferToImageInfo2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkCopyBufferToImageInfo2KHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkCopyBufferToImageInfo2KHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkCopyImageToBufferInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyImageToBufferInfo2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkCopyImageToBufferInfo2KHR(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkCopyImageToBufferInfo2KHR* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkImageBlit2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageBlit2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImageBlit2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageBlit2KHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkBlitImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBlitImageInfo2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkBlitImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBlitImageInfo2KHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkImageResolve2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageResolve2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImageResolve2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageResolve2KHR* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkResolveImageInfo2KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkResolveImageInfo2KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkResolveImageInfo2KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkResolveImageInfo2KHR* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_KHR_format_feature_flags2
-void reservedmarshal_VkFormatProperties3KHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFormatProperties3KHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkFormatProperties3KHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFormatProperties3KHR* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_KHR_maintenance4
void reservedmarshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMaintenance4FeaturesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance4FeaturesKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceMaintenance4PropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMaintenance4PropertiesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMaintenance4PropertiesKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDeviceBufferMemoryRequirementsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceBufferMemoryRequirementsKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceBufferMemoryRequirementsKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDeviceImageMemoryRequirementsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceImageMemoryRequirementsKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceImageMemoryRequirementsKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_ANDROID_native_buffer
-void reservedmarshal_VkNativeBufferANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkNativeBufferANDROID* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkNativeBufferANDROID(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkNativeBufferANDROID* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_EXT_debug_report
void reservedmarshal_VkDebugReportCallbackCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugReportCallbackCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugReportCallbackCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_glsl_shader
@@ -2688,10 +2014,8 @@
#endif
#ifdef VK_AMD_rasterization_order
void reservedmarshal_VkPipelineRasterizationStateRasterizationOrderAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationStateRasterizationOrderAMD* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationStateRasterizationOrderAMD* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_AMD_shader_trinary_minmax
@@ -2700,98 +2024,71 @@
#endif
#ifdef VK_EXT_debug_marker
void reservedmarshal_VkDebugMarkerObjectNameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugMarkerObjectNameInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugMarkerObjectNameInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDebugMarkerObjectTagInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugMarkerObjectTagInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugMarkerObjectTagInfoEXT* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkDebugMarkerMarkerInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugMarkerMarkerInfoEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDebugMarkerMarkerInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDebugMarkerMarkerInfoEXT* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_AMD_gcn_shader
#endif
#ifdef VK_NV_dedicated_allocation
void reservedmarshal_VkDedicatedAllocationImageCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDedicatedAllocationImageCreateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDedicatedAllocationImageCreateInfoNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDedicatedAllocationBufferCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDedicatedAllocationBufferCreateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDedicatedAllocationBufferCreateInfoNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDedicatedAllocationMemoryAllocateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDedicatedAllocationMemoryAllocateInfoNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_transform_feedback
void reservedmarshal_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTransformFeedbackFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTransformFeedbackFeaturesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTransformFeedbackPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTransformFeedbackPropertiesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineRasterizationStateStreamCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationStateStreamCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationStateStreamCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NVX_binary_import
-void reservedmarshal_VkCuModuleCreateInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCuModuleCreateInfoNVX* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkCuModuleCreateInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCuModuleCreateInfoNVX* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkCuFunctionCreateInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCuFunctionCreateInfoNVX* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkCuFunctionCreateInfoNVX(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkCuFunctionCreateInfoNVX* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkCuLaunchInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCuLaunchInfoNVX* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkCuLaunchInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCuLaunchInfoNVX* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NVX_image_view_handle
-void reservedmarshal_VkImageViewHandleInfoNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageViewHandleInfoNVX* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImageViewHandleInfoNVX(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageViewHandleInfoNVX* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkImageViewAddressPropertiesNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageViewAddressPropertiesNVX* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageViewAddressPropertiesNVX* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_AMD_draw_indirect_count
@@ -2804,272 +2101,196 @@
#endif
#ifdef VK_EXT_video_encode_h264
void reservedmarshal_VkVideoEncodeH264CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264CapabilitiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264CapabilitiesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoEncodeH264SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264SessionCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264SessionCreateInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264SessionParametersAddInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264SessionParametersAddInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264SessionParametersCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264SessionParametersCreateInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264DpbSlotInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264DpbSlotInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoEncodeH264NaluSliceEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264NaluSliceEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264NaluSliceEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoEncodeH264VclFrameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264VclFrameInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264VclFrameInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoEncodeH264EmitPictureParametersEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264EmitPictureParametersEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH264EmitPictureParametersEXT* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkVideoEncodeH264ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH264ProfileEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkVideoEncodeH264ProfileEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkVideoEncodeH264ProfileEXT* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_EXT_video_encode_h265
void reservedmarshal_VkVideoEncodeH265CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265CapabilitiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265CapabilitiesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoEncodeH265SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265SessionCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265SessionCreateInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265SessionParametersAddInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265SessionParametersAddInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265SessionParametersCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265SessionParametersCreateInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265DpbSlotInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265DpbSlotInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoEncodeH265ReferenceListsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265ReferenceListsEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265ReferenceListsEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoEncodeH265NaluSliceEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265NaluSliceEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265NaluSliceEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoEncodeH265VclFrameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265VclFrameInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265VclFrameInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoEncodeH265EmitPictureParametersEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265EmitPictureParametersEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoEncodeH265EmitPictureParametersEXT* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkVideoEncodeH265ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoEncodeH265ProfileEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkVideoEncodeH265ProfileEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkVideoEncodeH265ProfileEXT* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_EXT_video_decode_h264
-void reservedmarshal_VkVideoDecodeH264ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264ProfileEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkVideoDecodeH264ProfileEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkVideoDecodeH264ProfileEXT* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkVideoDecodeH264CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264CapabilitiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264CapabilitiesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoDecodeH264SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264SessionCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264SessionCreateInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264SessionParametersAddInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264SessionParametersAddInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264SessionParametersCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264SessionParametersCreateInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoDecodeH264PictureInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264PictureInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264PictureInfoEXT* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkVideoDecodeH264MvcEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264MvcEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkVideoDecodeH264MvcEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264MvcEXT* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkVideoDecodeH264DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH264DpbSlotInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH264DpbSlotInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_AMD_texture_gather_bias_lod
void reservedmarshal_VkTextureLODGatherFormatPropertiesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkTextureLODGatherFormatPropertiesAMD* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkTextureLODGatherFormatPropertiesAMD* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_AMD_shader_info
-void reservedmarshal_VkShaderResourceUsageAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkShaderResourceUsageAMD* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkShaderResourceUsageAMD(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkShaderResourceUsageAMD* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkShaderStatisticsInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkShaderStatisticsInfoAMD* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkShaderStatisticsInfoAMD(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkShaderStatisticsInfoAMD* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_AMD_shader_image_load_store_lod
#endif
#ifdef VK_GGP_stream_descriptor_surface
void reservedmarshal_VkStreamDescriptorSurfaceCreateInfoGGP(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkStreamDescriptorSurfaceCreateInfoGGP* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkStreamDescriptorSurfaceCreateInfoGGP* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_corner_sampled_image
void reservedmarshal_VkPhysicalDeviceCornerSampledImageFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCornerSampledImageFeaturesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCornerSampledImageFeaturesNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_IMG_format_pvrtc
#endif
#ifdef VK_NV_external_memory_capabilities
void reservedmarshal_VkExternalImageFormatPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalImageFormatPropertiesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalImageFormatPropertiesNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_external_memory
void reservedmarshal_VkExternalMemoryImageCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalMemoryImageCreateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalMemoryImageCreateInfoNV* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkExportMemoryAllocateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportMemoryAllocateInfoNV* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkExportMemoryAllocateInfoNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkExportMemoryAllocateInfoNV* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_NV_external_memory_win32
void reservedmarshal_VkImportMemoryWin32HandleInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportMemoryWin32HandleInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportMemoryWin32HandleInfoNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkExportMemoryWin32HandleInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExportMemoryWin32HandleInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExportMemoryWin32HandleInfoNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_win32_keyed_mutex
void reservedmarshal_VkWin32KeyedMutexAcquireReleaseInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWin32KeyedMutexAcquireReleaseInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWin32KeyedMutexAcquireReleaseInfoNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_validation_flags
-void reservedmarshal_VkValidationFlagsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkValidationFlagsEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkValidationFlagsEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkValidationFlagsEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NN_vi_surface
-void reservedmarshal_VkViSurfaceCreateInfoNN(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkViSurfaceCreateInfoNN* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkViSurfaceCreateInfoNN(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkViSurfaceCreateInfoNN* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_EXT_shader_subgroup_ballot
@@ -3078,58 +2299,42 @@
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
void reservedmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_astc_decode_mode
-void reservedmarshal_VkImageViewASTCDecodeModeEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageViewASTCDecodeModeEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImageViewASTCDecodeModeEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkImageViewASTCDecodeModeEXT* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceASTCDecodeFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceASTCDecodeFeaturesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_conditional_rendering
void reservedmarshal_VkConditionalRenderingBeginInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkConditionalRenderingBeginInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkConditionalRenderingBeginInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceConditionalRenderingFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceConditionalRenderingFeaturesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferInheritanceConditionalRenderingInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferInheritanceConditionalRenderingInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_clip_space_w_scaling
-void reservedmarshal_VkViewportWScalingNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkViewportWScalingNV* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkViewportWScalingNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkViewportWScalingNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineViewportWScalingStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineViewportWScalingStateCreateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineViewportWScalingStateCreateInfoNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_direct_mode_display
@@ -3137,63 +2342,45 @@
#ifdef VK_EXT_acquire_xlib_display
#endif
#ifdef VK_EXT_display_surface_counter
-void reservedmarshal_VkSurfaceCapabilities2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceCapabilities2EXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSurfaceCapabilities2EXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkSurfaceCapabilities2EXT* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_EXT_display_control
-void reservedmarshal_VkDisplayPowerInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayPowerInfoEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDisplayPowerInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayPowerInfoEXT* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkDeviceEventInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceEventInfoEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDeviceEventInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceEventInfoEXT* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkDisplayEventInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayEventInfoEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDisplayEventInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayEventInfoEXT* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkSwapchainCounterCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSwapchainCounterCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSwapchainCounterCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_GOOGLE_display_timing
-void reservedmarshal_VkRefreshCycleDurationGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRefreshCycleDurationGOOGLE* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkRefreshCycleDurationGOOGLE(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkRefreshCycleDurationGOOGLE* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkPastPresentationTimingGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPastPresentationTimingGOOGLE* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPastPresentationTimingGOOGLE* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkPresentTimeGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentTimeGOOGLE* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPresentTimeGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentTimeGOOGLE* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkPresentTimesInfoGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentTimesInfoGOOGLE* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPresentTimesInfoGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentTimesInfoGOOGLE* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_NV_sample_mask_override_coverage
@@ -3204,98 +2391,71 @@
#endif
#ifdef VK_NVX_multiview_per_view_attributes
void reservedmarshal_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_viewport_swizzle
-void reservedmarshal_VkViewportSwizzleNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkViewportSwizzleNV* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkViewportSwizzleNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkViewportSwizzleNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineViewportSwizzleStateCreateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineViewportSwizzleStateCreateInfoNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_discard_rectangles
void reservedmarshal_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDiscardRectanglePropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDiscardRectanglePropertiesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineDiscardRectangleStateCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineDiscardRectangleStateCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_conservative_rasterization
void reservedmarshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineRasterizationConservativeStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationConservativeStateCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationConservativeStateCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_depth_clip_enable
void reservedmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
-void reservedmarshal_VkXYColorEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkXYColorEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkXYColorEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkXYColorEXT* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkHdrMetadataEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkHdrMetadataEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkHdrMetadataEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkHdrMetadataEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_MVK_ios_surface
-void reservedmarshal_VkIOSSurfaceCreateInfoMVK(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkIOSSurfaceCreateInfoMVK* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkIOSSurfaceCreateInfoMVK(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkIOSSurfaceCreateInfoMVK* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_MVK_macos_surface
-void reservedmarshal_VkMacOSSurfaceCreateInfoMVK(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMacOSSurfaceCreateInfoMVK* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkMacOSSurfaceCreateInfoMVK(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkMacOSSurfaceCreateInfoMVK* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_MVK_moltenvk
@@ -3305,85 +2465,63 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
-void reservedmarshal_VkDebugUtilsLabelEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugUtilsLabelEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDebugUtilsLabelEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugUtilsLabelEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDebugUtilsObjectNameInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugUtilsObjectNameInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugUtilsObjectNameInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDebugUtilsMessengerCallbackDataEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugUtilsMessengerCallbackDataEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugUtilsMessengerCallbackDataEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDebugUtilsMessengerCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugUtilsMessengerCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDebugUtilsMessengerCreateInfoEXT* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkDebugUtilsObjectTagInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDebugUtilsObjectTagInfoEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDebugUtilsObjectTagInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkDebugUtilsObjectTagInfoEXT* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
void reservedmarshal_VkAndroidHardwareBufferUsageANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAndroidHardwareBufferUsageANDROID* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAndroidHardwareBufferUsageANDROID* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAndroidHardwareBufferPropertiesANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAndroidHardwareBufferPropertiesANDROID* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAndroidHardwareBufferPropertiesANDROID* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAndroidHardwareBufferFormatPropertiesANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAndroidHardwareBufferFormatPropertiesANDROID* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAndroidHardwareBufferFormatPropertiesANDROID* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkImportAndroidHardwareBufferInfoANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportAndroidHardwareBufferInfoANDROID* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportAndroidHardwareBufferInfoANDROID* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryGetAndroidHardwareBufferInfoANDROID* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryGetAndroidHardwareBufferInfoANDROID* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkExternalFormatANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkExternalFormatANDROID* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkExternalFormatANDROID(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkExternalFormatANDROID* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkAndroidHardwareBufferFormatProperties2ANDROID(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAndroidHardwareBufferFormatProperties2ANDROID* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAndroidHardwareBufferFormatProperties2ANDROID* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_sampler_filter_minmax
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSamplerReductionModeCreateInfo, reservedmarshal_VkSamplerReductionModeCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkSamplerReductionModeCreateInfo,
+ reservedmarshal_VkSamplerReductionModeCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties, reservedmarshal_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties,
+ reservedmarshal_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT)
#endif
#ifdef VK_AMD_gpu_shader_int16
@@ -3394,734 +2532,535 @@
#endif
#ifdef VK_EXT_inline_uniform_block
void reservedmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkWriteDescriptorSetInlineUniformBlockEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWriteDescriptorSetInlineUniformBlockEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWriteDescriptorSetInlineUniformBlockEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
-void reservedmarshal_VkSampleLocationEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSampleLocationEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSampleLocationEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSampleLocationEXT* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkSampleLocationsInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSampleLocationsInfoEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSampleLocationsInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSampleLocationsInfoEXT* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkAttachmentSampleLocationsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAttachmentSampleLocationsEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAttachmentSampleLocationsEXT* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkSubpassSampleLocationsEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassSampleLocationsEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSubpassSampleLocationsEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkSubpassSampleLocationsEXT* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkRenderPassSampleLocationsBeginInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassSampleLocationsBeginInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassSampleLocationsBeginInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineSampleLocationsStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineSampleLocationsStateCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineSampleLocationsStateCreateInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceSampleLocationsPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSampleLocationsPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSampleLocationsPropertiesEXT* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkMultisamplePropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMultisamplePropertiesEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkMultisamplePropertiesEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkMultisamplePropertiesEXT* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_EXT_blend_operation_advanced
void reservedmarshal_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineColorBlendAdvancedStateCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineColorBlendAdvancedStateCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_fragment_coverage_to_color
void reservedmarshal_VkPipelineCoverageToColorStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCoverageToColorStateCreateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCoverageToColorStateCreateInfoNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_framebuffer_mixed_samples
void reservedmarshal_VkPipelineCoverageModulationStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCoverageModulationStateCreateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCoverageModulationStateCreateInfoNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_fill_rectangle
#endif
#ifdef VK_NV_shader_sm_builtins
void reservedmarshal_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_post_depth_coverage
#endif
#ifdef VK_EXT_image_drm_format_modifier
void reservedmarshal_VkDrmFormatModifierPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrmFormatModifierPropertiesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDrmFormatModifierPropertiesListEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesListEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrmFormatModifierPropertiesListEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkImageDrmFormatModifierListCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageDrmFormatModifierListCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageDrmFormatModifierListCreateInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkImageDrmFormatModifierExplicitCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageDrmFormatModifierExplicitCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageDrmFormatModifierExplicitCreateInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkImageDrmFormatModifierPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageDrmFormatModifierPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageDrmFormatModifierPropertiesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDrmFormatModifierProperties2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrmFormatModifierProperties2EXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrmFormatModifierProperties2EXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDrmFormatModifierPropertiesList2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrmFormatModifierPropertiesList2EXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrmFormatModifierPropertiesList2EXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_validation_cache
void reservedmarshal_VkValidationCacheCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkValidationCacheCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkValidationCacheCreateInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkShaderModuleValidationCacheCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkShaderModuleValidationCacheCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkShaderModuleValidationCacheCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_descriptor_indexing
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo, reservedmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfo,
+ reservedmarshal_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceDescriptorIndexingFeatures, reservedmarshal_VkPhysicalDeviceDescriptorIndexingFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceDescriptorIndexingFeatures,
+ reservedmarshal_VkPhysicalDeviceDescriptorIndexingFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceDescriptorIndexingProperties, reservedmarshal_VkPhysicalDeviceDescriptorIndexingPropertiesEXT)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceDescriptorIndexingProperties,
+ reservedmarshal_VkPhysicalDeviceDescriptorIndexingPropertiesEXT)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo, reservedmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfo,
+ reservedmarshal_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport, reservedmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupport,
+ reservedmarshal_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT)
#endif
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_NV_shading_rate_image
-void reservedmarshal_VkShadingRatePaletteNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkShadingRatePaletteNV* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkShadingRatePaletteNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkShadingRatePaletteNV* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkPipelineViewportShadingRateImageStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineViewportShadingRateImageStateCreateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineViewportShadingRateImageStateCreateInfoNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceShadingRateImageFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShadingRateImageFeaturesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShadingRateImageFeaturesNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceShadingRateImagePropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShadingRateImagePropertiesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShadingRateImagePropertiesNV* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkCoarseSampleLocationNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCoarseSampleLocationNV* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkCoarseSampleLocationNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCoarseSampleLocationNV* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkCoarseSampleOrderCustomNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCoarseSampleOrderCustomNV* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkCoarseSampleOrderCustomNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkCoarseSampleOrderCustomNV* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_ray_tracing
void reservedmarshal_VkRayTracingShaderGroupCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRayTracingShaderGroupCreateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRayTracingShaderGroupCreateInfoNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkRayTracingPipelineCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRayTracingPipelineCreateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRayTracingPipelineCreateInfoNV* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkGeometryTrianglesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeometryTrianglesNV* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkGeometryTrianglesNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeometryTrianglesNV* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkGeometryAABBNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeometryAABBNV* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkGeometryAABBNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeometryAABBNV* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkGeometryDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeometryDataNV* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkGeometryDataNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeometryDataNV* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkGeometryNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeometryNV* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkGeometryNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeometryNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureInfoNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureCreateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureCreateInfoNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkBindAccelerationStructureMemoryInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindAccelerationStructureMemoryInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindAccelerationStructureMemoryInfoNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkWriteDescriptorSetAccelerationStructureNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWriteDescriptorSetAccelerationStructureNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWriteDescriptorSetAccelerationStructureNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureMemoryRequirementsInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureMemoryRequirementsInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureMemoryRequirementsInfoNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceRayTracingPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingPropertiesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPropertiesNV* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkTransformMatrixKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkTransformMatrixKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkTransformMatrixKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkTransformMatrixKHR* forMarshaling, uint8_t** ptr);
DEFINE_ALIAS_FUNCTION(reservedmarshal_VkTransformMatrixKHR, reservedmarshal_VkTransformMatrixNV)
-void reservedmarshal_VkAabbPositionsKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAabbPositionsKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkAabbPositionsKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAabbPositionsKHR* forMarshaling, uint8_t** ptr);
DEFINE_ALIAS_FUNCTION(reservedmarshal_VkAabbPositionsKHR, reservedmarshal_VkAabbPositionsNV)
void reservedmarshal_VkAccelerationStructureInstanceKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureInstanceKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureInstanceKHR* forMarshaling, uint8_t** ptr);
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkAccelerationStructureInstanceKHR, reservedmarshal_VkAccelerationStructureInstanceNV)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkAccelerationStructureInstanceKHR,
+ reservedmarshal_VkAccelerationStructureInstanceNV)
#endif
#ifdef VK_NV_representative_fragment_test
void reservedmarshal_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_filter_cubic
void reservedmarshal_VkPhysicalDeviceImageViewImageFormatInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceImageViewImageFormatInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceImageViewImageFormatInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFilterCubicImageViewImageFormatPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFilterCubicImageViewImageFormatPropertiesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_QCOM_render_pass_shader_resolve
#endif
#ifdef VK_EXT_global_priority
void reservedmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceQueueGlobalPriorityCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceQueueGlobalPriorityCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_external_memory_host
void reservedmarshal_VkImportMemoryHostPointerInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportMemoryHostPointerInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportMemoryHostPointerInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkMemoryHostPointerPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryHostPointerPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryHostPointerPropertiesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_AMD_buffer_marker
#endif
#ifdef VK_AMD_pipeline_compiler_control
void reservedmarshal_VkPipelineCompilerControlCreateInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCompilerControlCreateInfoAMD* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCompilerControlCreateInfoAMD* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_calibrated_timestamps
-void reservedmarshal_VkCalibratedTimestampInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCalibratedTimestampInfoEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkCalibratedTimestampInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkCalibratedTimestampInfoEXT* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_AMD_shader_core_properties
void reservedmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderCorePropertiesAMD* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderCorePropertiesAMD* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_video_decode_h265
-void reservedmarshal_VkVideoDecodeH265ProfileEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265ProfileEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkVideoDecodeH265ProfileEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkVideoDecodeH265ProfileEXT* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkVideoDecodeH265CapabilitiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265CapabilitiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265CapabilitiesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoDecodeH265SessionCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265SessionCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265SessionCreateInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265SessionParametersAddInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265SessionParametersAddInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265SessionParametersCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265SessionParametersCreateInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoDecodeH265PictureInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265PictureInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265PictureInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVideoDecodeH265DpbSlotInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVideoDecodeH265DpbSlotInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVideoDecodeH265DpbSlotInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_AMD_memory_overallocation_behavior
void reservedmarshal_VkDeviceMemoryOverallocationCreateInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceMemoryOverallocationCreateInfoAMD* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceMemoryOverallocationCreateInfoAMD* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_vertex_attribute_divisor
void reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVertexInputBindingDivisorDescriptionEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVertexInputBindingDivisorDescriptionEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVertexInputBindingDivisorDescriptionEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineVertexInputDivisorStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineVertexInputDivisorStateCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineVertexInputDivisorStateCreateInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_GGP_frame_token
-void reservedmarshal_VkPresentFrameTokenGGP(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPresentFrameTokenGGP* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPresentFrameTokenGGP(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPresentFrameTokenGGP* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_EXT_pipeline_creation_feedback
void reservedmarshal_VkPipelineCreationFeedbackEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCreationFeedbackEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCreationFeedbackEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineCreationFeedbackCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCreationFeedbackCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCreationFeedbackCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_shader_subgroup_partitioned
#endif
#ifdef VK_NV_compute_shader_derivatives
void reservedmarshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_mesh_shader
void reservedmarshal_VkPhysicalDeviceMeshShaderFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMeshShaderFeaturesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMeshShaderFeaturesNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceMeshShaderPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMeshShaderPropertiesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMeshShaderPropertiesNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDrawMeshTasksIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDrawMeshTasksIndirectCommandNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDrawMeshTasksIndirectCommandNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_fragment_shader_barycentric
void reservedmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_shader_image_footprint
void reservedmarshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderImageFootprintFeaturesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderImageFootprintFeaturesNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_scissor_exclusive
void reservedmarshal_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineViewportExclusiveScissorStateCreateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineViewportExclusiveScissorStateCreateInfoNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExclusiveScissorFeaturesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExclusiveScissorFeaturesNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
void reservedmarshal_VkQueueFamilyCheckpointPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueueFamilyCheckpointPropertiesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyCheckpointPropertiesNV* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkCheckpointDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCheckpointDataNV* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkCheckpointDataNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCheckpointDataNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_INTEL_shader_integer_functions2
void reservedmarshal_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_INTEL_performance_query
-void reservedmarshal_VkPerformanceValueDataINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceValueDataINTEL* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPerformanceValueDataINTEL(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkPerformanceValueDataINTEL* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkPerformanceValueINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceValueINTEL* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPerformanceValueINTEL(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceValueINTEL* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkInitializePerformanceApiInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkInitializePerformanceApiInfoINTEL* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkInitializePerformanceApiInfoINTEL* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkQueryPoolPerformanceQueryCreateInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueryPoolPerformanceQueryCreateInfoINTEL* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueryPoolPerformanceQueryCreateInfoINTEL* forMarshaling, uint8_t** ptr);
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkQueryPoolPerformanceQueryCreateInfoINTEL, reservedmarshal_VkQueryPoolCreateInfoINTEL)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkQueryPoolPerformanceQueryCreateInfoINTEL,
+ reservedmarshal_VkQueryPoolCreateInfoINTEL)
-void reservedmarshal_VkPerformanceMarkerInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceMarkerInfoINTEL* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkPerformanceMarkerInfoINTEL(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkPerformanceMarkerInfoINTEL* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkPerformanceStreamMarkerInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceStreamMarkerInfoINTEL* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceStreamMarkerInfoINTEL* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPerformanceOverrideInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceOverrideInfoINTEL* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceOverrideInfoINTEL* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPerformanceConfigurationAcquireInfoINTEL(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPerformanceConfigurationAcquireInfoINTEL* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPerformanceConfigurationAcquireInfoINTEL* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_pci_bus_info
void reservedmarshal_VkPhysicalDevicePCIBusInfoPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePCIBusInfoPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePCIBusInfoPropertiesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_AMD_display_native_hdr
void reservedmarshal_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDisplayNativeHdrSurfaceCapabilitiesAMD* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDisplayNativeHdrSurfaceCapabilitiesAMD* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkSwapchainDisplayNativeHdrCreateInfoAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSwapchainDisplayNativeHdrCreateInfoAMD* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSwapchainDisplayNativeHdrCreateInfoAMD* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
void reservedmarshal_VkImagePipeSurfaceCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImagePipeSurfaceCreateInfoFUCHSIA* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImagePipeSurfaceCreateInfoFUCHSIA* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_metal_surface
-void reservedmarshal_VkMetalSurfaceCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMetalSurfaceCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkMetalSurfaceCreateInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkMetalSurfaceCreateInfoEXT* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_EXT_fragment_density_map
void reservedmarshal_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassFragmentDensityMapCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassFragmentDensityMapCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_scalar_block_layout
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures, reservedmarshal_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures,
+ reservedmarshal_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT)
#endif
#ifdef VK_GOOGLE_hlsl_functionality1
@@ -4130,1117 +3069,802 @@
#endif
#ifdef VK_EXT_subgroup_size_control
void reservedmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_AMD_shader_core_properties2
void reservedmarshal_VkPhysicalDeviceShaderCoreProperties2AMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderCoreProperties2AMD* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderCoreProperties2AMD* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_AMD_device_coherent_memory
void reservedmarshal_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCoherentMemoryFeaturesAMD* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCoherentMemoryFeaturesAMD* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_shader_image_atomic_int64
void reservedmarshal_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_memory_budget
void reservedmarshal_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryBudgetPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryBudgetPropertiesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_memory_priority
void reservedmarshal_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMemoryPriorityFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMemoryPriorityFeaturesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkMemoryPriorityAllocateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryPriorityAllocateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryPriorityAllocateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
void reservedmarshal_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_buffer_device_address
void reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* forMarshaling, uint8_t** ptr);
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, reservedmarshal_VkPhysicalDeviceBufferAddressFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT,
+ reservedmarshal_VkPhysicalDeviceBufferAddressFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkBufferDeviceAddressInfo, reservedmarshal_VkBufferDeviceAddressInfoEXT)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkBufferDeviceAddressInfo,
+ reservedmarshal_VkBufferDeviceAddressInfoEXT)
void reservedmarshal_VkBufferDeviceAddressCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferDeviceAddressCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferDeviceAddressCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_tooling_info
void reservedmarshal_VkPhysicalDeviceToolPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceToolPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceToolPropertiesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_separate_stencil_usage
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkImageStencilUsageCreateInfo, reservedmarshal_VkImageStencilUsageCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkImageStencilUsageCreateInfo,
+ reservedmarshal_VkImageStencilUsageCreateInfoEXT)
#endif
#ifdef VK_EXT_validation_features
-void reservedmarshal_VkValidationFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkValidationFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkValidationFeaturesEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkValidationFeaturesEXT* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_NV_cooperative_matrix
void reservedmarshal_VkCooperativeMatrixPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCooperativeMatrixPropertiesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCooperativeMatrixPropertiesNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCooperativeMatrixFeaturesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCooperativeMatrixFeaturesNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCooperativeMatrixPropertiesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCooperativeMatrixPropertiesNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_coverage_reduction_mode
void reservedmarshal_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCoverageReductionModeFeaturesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCoverageReductionModeFeaturesNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineCoverageReductionStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineCoverageReductionStateCreateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineCoverageReductionStateCreateInfoNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkFramebufferMixedSamplesCombinationNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkFramebufferMixedSamplesCombinationNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkFramebufferMixedSamplesCombinationNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_fragment_shader_interlock
void reservedmarshal_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_ycbcr_image_arrays
void reservedmarshal_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_provoking_vertex
void reservedmarshal_VkPhysicalDeviceProvokingVertexFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceProvokingVertexFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceProvokingVertexFeaturesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceProvokingVertexPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceProvokingVertexPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceProvokingVertexPropertiesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_full_screen_exclusive
void reservedmarshal_VkSurfaceFullScreenExclusiveInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceFullScreenExclusiveInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceFullScreenExclusiveInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceCapabilitiesFullScreenExclusiveEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceCapabilitiesFullScreenExclusiveEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkSurfaceFullScreenExclusiveWin32InfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSurfaceFullScreenExclusiveWin32InfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSurfaceFullScreenExclusiveWin32InfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_headless_surface
void reservedmarshal_VkHeadlessSurfaceCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkHeadlessSurfaceCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkHeadlessSurfaceCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_line_rasterization
void reservedmarshal_VkPhysicalDeviceLineRasterizationFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationFeaturesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceLineRasterizationPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceLineRasterizationPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceLineRasterizationPropertiesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineRasterizationLineStateCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineRasterizationLineStateCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineRasterizationLineStateCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_shader_atomic_float
void reservedmarshal_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_host_query_reset
-DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceHostQueryResetFeatures, reservedmarshal_VkPhysicalDeviceHostQueryResetFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(reservedmarshal_VkPhysicalDeviceHostQueryResetFeatures,
+ reservedmarshal_VkPhysicalDeviceHostQueryResetFeaturesEXT)
#endif
#ifdef VK_EXT_index_type_uint8
void reservedmarshal_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_extended_dynamic_state
void reservedmarshal_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_shader_atomic_float2
void reservedmarshal_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
void reservedmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_device_generated_commands
void reservedmarshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkGraphicsShaderGroupCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGraphicsShaderGroupCreateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGraphicsShaderGroupCreateInfoNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkGraphicsPipelineShaderGroupsCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGraphicsPipelineShaderGroupsCreateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGraphicsPipelineShaderGroupsCreateInfoNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkBindShaderGroupIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindShaderGroupIndirectCommandNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindShaderGroupIndirectCommandNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkBindIndexBufferIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindIndexBufferIndirectCommandNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindIndexBufferIndirectCommandNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkBindVertexBufferIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBindVertexBufferIndirectCommandNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBindVertexBufferIndirectCommandNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkSetStateFlagsIndirectCommandNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSetStateFlagsIndirectCommandNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSetStateFlagsIndirectCommandNV* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkIndirectCommandsStreamNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkIndirectCommandsStreamNV* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkIndirectCommandsStreamNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkIndirectCommandsStreamNV* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkIndirectCommandsLayoutTokenNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkIndirectCommandsLayoutTokenNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkIndirectCommandsLayoutTokenNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkIndirectCommandsLayoutCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkIndirectCommandsLayoutCreateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkIndirectCommandsLayoutCreateInfoNV* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkGeneratedCommandsInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeneratedCommandsInfoNV* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkGeneratedCommandsInfoNV(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkGeneratedCommandsInfoNV* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkGeneratedCommandsMemoryRequirementsInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkGeneratedCommandsMemoryRequirementsInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkGeneratedCommandsMemoryRequirementsInfoNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_inherited_viewport_scissor
void reservedmarshal_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkCommandBufferInheritanceViewportScissorInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferInheritanceViewportScissorInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferInheritanceViewportScissorInfoNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_texel_buffer_alignment
void reservedmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_QCOM_render_pass_transform
void reservedmarshal_VkRenderPassTransformBeginInfoQCOM(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRenderPassTransformBeginInfoQCOM* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRenderPassTransformBeginInfoQCOM* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_device_memory_report
void reservedmarshal_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDeviceMemoryReportCallbackDataEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceMemoryReportCallbackDataEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceMemoryReportCallbackDataEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDeviceDeviceMemoryReportCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceDeviceMemoryReportCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceDeviceMemoryReportCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_acquire_drm_display
#endif
#ifdef VK_EXT_robustness2
void reservedmarshal_VkPhysicalDeviceRobustness2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRobustness2FeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRobustness2FeaturesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceRobustness2PropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRobustness2PropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRobustness2PropertiesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_custom_border_color
void reservedmarshal_VkSamplerCustomBorderColorCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerCustomBorderColorCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerCustomBorderColorCreateInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCustomBorderColorPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCustomBorderColorPropertiesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceCustomBorderColorFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceCustomBorderColorFeaturesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_GOOGLE_user_type
#endif
#ifdef VK_EXT_private_data
void reservedmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePrivateDataFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePrivateDataFeaturesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDevicePrivateDataCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDevicePrivateDataCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDevicePrivateDataCreateInfoEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPrivateDataSlotCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPrivateDataSlotCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPrivateDataSlotCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
void reservedmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_device_diagnostics_config
void reservedmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceDiagnosticsConfigCreateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceDiagnosticsConfigCreateInfoNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_QCOM_render_pass_store_ops
#endif
#ifdef VK_NV_fragment_shading_rate_enums
void reservedmarshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_ray_tracing_motion_blur
void reservedmarshal_VkDeviceOrHostAddressConstKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceOrHostAddressConstKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceOrHostAddressConstKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureGeometryMotionTrianglesDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryMotionTrianglesDataNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureGeometryMotionTrianglesDataNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureMotionInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureMotionInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureMotionInfoNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureMatrixMotionInstanceNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureMatrixMotionInstanceNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureMatrixMotionInstanceNV* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkSRTDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSRTDataNV* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSRTDataNV(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSRTDataNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureSRTMotionInstanceNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureSRTMotionInstanceNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureSRTMotionInstanceNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureMotionInstanceDataNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureMotionInstanceDataNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureMotionInstanceDataNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureMotionInstanceNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureMotionInstanceNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureMotionInstanceNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
void reservedmarshal_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_fragment_density_map2
void reservedmarshal_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_QCOM_rotated_copy_commands
void reservedmarshal_VkCopyCommandTransformInfoQCOM(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyCommandTransformInfoQCOM* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyCommandTransformInfoQCOM* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_image_robustness
void reservedmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceImageRobustnessFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceImageRobustnessFeaturesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_4444_formats
void reservedmarshal_VkPhysicalDevice4444FormatsFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevice4444FormatsFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevice4444FormatsFeaturesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_rgba10x6_formats
void reservedmarshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_acquire_winrt_display
#endif
#ifdef VK_EXT_directfb_surface
void reservedmarshal_VkDirectFBSurfaceCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDirectFBSurfaceCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDirectFBSurfaceCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_VALVE_mutable_descriptor_type
void reservedmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkMutableDescriptorTypeListVALVE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMutableDescriptorTypeListVALVE* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMutableDescriptorTypeListVALVE* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkMutableDescriptorTypeCreateInfoVALVE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMutableDescriptorTypeCreateInfoVALVE* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMutableDescriptorTypeCreateInfoVALVE* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
void reservedmarshal_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVertexInputBindingDescription2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVertexInputBindingDescription2EXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVertexInputBindingDescription2EXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkVertexInputAttributeDescription2EXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkVertexInputAttributeDescription2EXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkVertexInputAttributeDescription2EXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_physical_device_drm
void reservedmarshal_VkPhysicalDeviceDrmPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceDrmPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceDrmPropertiesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_primitive_topology_list_restart
void reservedmarshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_FUCHSIA_external_memory
void reservedmarshal_VkImportMemoryZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportMemoryZirconHandleInfoFUCHSIA* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportMemoryZirconHandleInfoFUCHSIA* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkMemoryZirconHandlePropertiesFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryZirconHandlePropertiesFUCHSIA* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryZirconHandlePropertiesFUCHSIA* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkMemoryGetZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryGetZirconHandleInfoFUCHSIA* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryGetZirconHandleInfoFUCHSIA* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_FUCHSIA_external_semaphore
void reservedmarshal_VkImportSemaphoreZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportSemaphoreZirconHandleInfoFUCHSIA* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkSemaphoreGetZirconHandleInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSemaphoreGetZirconHandleInfoFUCHSIA* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_FUCHSIA_buffer_collection
void reservedmarshal_VkBufferCollectionCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCollectionCreateInfoFUCHSIA* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCollectionCreateInfoFUCHSIA* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkImportMemoryBufferCollectionFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportMemoryBufferCollectionFUCHSIA* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportMemoryBufferCollectionFUCHSIA* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkBufferCollectionImageCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCollectionImageCreateInfoFUCHSIA* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCollectionImageCreateInfoFUCHSIA* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkBufferCollectionConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCollectionConstraintsInfoFUCHSIA* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCollectionConstraintsInfoFUCHSIA* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkBufferConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferConstraintsInfoFUCHSIA* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferConstraintsInfoFUCHSIA* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkBufferCollectionBufferCreateInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCollectionBufferCreateInfoFUCHSIA* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCollectionBufferCreateInfoFUCHSIA* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkSysmemColorSpaceFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSysmemColorSpaceFUCHSIA* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkSysmemColorSpaceFUCHSIA(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkSysmemColorSpaceFUCHSIA* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkBufferCollectionPropertiesFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkBufferCollectionPropertiesFUCHSIA* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkBufferCollectionPropertiesFUCHSIA* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkImageFormatConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageFormatConstraintsInfoFUCHSIA* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageFormatConstraintsInfoFUCHSIA* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkImageConstraintsInfoFUCHSIA(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImageConstraintsInfoFUCHSIA* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImageConstraintsInfoFUCHSIA* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_HUAWEI_subpass_shading
void reservedmarshal_VkSubpassShadingPipelineCreateInfoHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSubpassShadingPipelineCreateInfoHUAWEI* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSubpassShadingPipelineCreateInfoHUAWEI* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_HUAWEI_invocation_mask
void reservedmarshal_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_NV_external_memory_rdma
void reservedmarshal_VkMemoryGetRemoteAddressInfoNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMemoryGetRemoteAddressInfoNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMemoryGetRemoteAddressInfoNV* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_extended_dynamic_state2
void reservedmarshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_QNX_screen_surface
-void reservedmarshal_VkScreenSurfaceCreateInfoQNX(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkScreenSurfaceCreateInfoQNX* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkScreenSurfaceCreateInfoQNX(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkScreenSurfaceCreateInfoQNX* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_EXT_color_write_enable
void reservedmarshal_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceColorWriteEnableFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceColorWriteEnableFeaturesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPipelineColorWriteCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPipelineColorWriteCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPipelineColorWriteCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_GOOGLE_gfxstream
-void reservedmarshal_VkImportColorBufferGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportColorBufferGOOGLE* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImportColorBufferGOOGLE(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkImportColorBufferGOOGLE* forMarshaling,
+ uint8_t** ptr);
-void reservedmarshal_VkImportBufferGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportBufferGOOGLE* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkImportBufferGOOGLE(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportBufferGOOGLE* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkImportPhysicalAddressGOOGLE(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkImportPhysicalAddressGOOGLE* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkImportPhysicalAddressGOOGLE* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_global_priority_query
void reservedmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkQueueFamilyGlobalPriorityPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkQueueFamilyGlobalPriorityPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkQueueFamilyGlobalPriorityPropertiesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_multi_draw
void reservedmarshal_VkPhysicalDeviceMultiDrawFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiDrawFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMultiDrawFeaturesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceMultiDrawPropertiesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceMultiDrawPropertiesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceMultiDrawPropertiesEXT* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkMultiDrawInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMultiDrawInfoEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkMultiDrawInfoEXT(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkMultiDrawInfoEXT* forMarshaling, uint8_t** ptr);
-void reservedmarshal_VkMultiDrawIndexedInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkMultiDrawIndexedInfoEXT* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkMultiDrawIndexedInfoEXT(VulkanStreamGuest* vkStream,
+ VkStructureType rootType,
+ const VkMultiDrawIndexedInfoEXT* forMarshaling,
+ uint8_t** ptr);
#endif
#ifdef VK_EXT_load_store_op_none
#endif
#ifdef VK_EXT_border_color_swizzle
void reservedmarshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkSamplerBorderColorComponentMappingCreateInfoEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkSamplerBorderColorComponentMappingCreateInfoEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkSamplerBorderColorComponentMappingCreateInfoEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_EXT_pageable_device_local_memory
void reservedmarshal_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_acceleration_structure
-void reservedmarshal_VkDeviceOrHostAddressKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkDeviceOrHostAddressKHR* forMarshaling,
- uint8_t** ptr);
+void reservedmarshal_VkDeviceOrHostAddressKHR(VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkDeviceOrHostAddressKHR* forMarshaling,
+ uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureBuildRangeInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureBuildRangeInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureBuildRangeInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureGeometryTrianglesDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryTrianglesDataKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureGeometryTrianglesDataKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureGeometryAabbsDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryAabbsDataKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureGeometryAabbsDataKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureGeometryInstancesDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryInstancesDataKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureGeometryInstancesDataKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureGeometryDataKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryDataKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureGeometryDataKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureGeometryKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureGeometryKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureGeometryKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureBuildGeometryInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureBuildGeometryInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureBuildGeometryInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureCreateInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureCreateInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkWriteDescriptorSetAccelerationStructureKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkWriteDescriptorSetAccelerationStructureKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkWriteDescriptorSetAccelerationStructureKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceAccelerationStructureFeaturesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceAccelerationStructureFeaturesKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceAccelerationStructurePropertiesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceAccelerationStructurePropertiesKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureDeviceAddressInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureDeviceAddressInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureDeviceAddressInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureVersionInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureVersionInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureVersionInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkCopyAccelerationStructureToMemoryInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyAccelerationStructureToMemoryInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyAccelerationStructureToMemoryInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkCopyMemoryToAccelerationStructureInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyMemoryToAccelerationStructureInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyMemoryToAccelerationStructureInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkCopyAccelerationStructureInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkCopyAccelerationStructureInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkCopyAccelerationStructureInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkAccelerationStructureBuildSizesInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkAccelerationStructureBuildSizesInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkAccelerationStructureBuildSizesInfoKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_ray_tracing_pipeline
void reservedmarshal_VkRayTracingShaderGroupCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRayTracingShaderGroupCreateInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRayTracingShaderGroupCreateInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkRayTracingPipelineInterfaceCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRayTracingPipelineInterfaceCreateInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRayTracingPipelineInterfaceCreateInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkRayTracingPipelineCreateInfoKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkRayTracingPipelineCreateInfoKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkRayTracingPipelineCreateInfoKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkStridedDeviceAddressRegionKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkStridedDeviceAddressRegionKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkStridedDeviceAddressRegionKHR* forMarshaling, uint8_t** ptr);
void reservedmarshal_VkTraceRaysIndirectCommandKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkTraceRaysIndirectCommandKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkTraceRaysIndirectCommandKHR* forMarshaling, uint8_t** ptr);
#endif
#ifdef VK_KHR_ray_query
void reservedmarshal_VkPhysicalDeviceRayQueryFeaturesKHR(
- VulkanStreamGuest* vkStream,
- VkStructureType rootType,
- const VkPhysicalDeviceRayQueryFeaturesKHR* forMarshaling,
- uint8_t** ptr);
+ VulkanStreamGuest* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceRayQueryFeaturesKHR* forMarshaling, uint8_t** ptr);
#endif
-} // namespace goldfish_vk
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_transform_guest.cpp b/system/vulkan_enc/goldfish_vk_transform_guest.cpp
index c3a690c..3a3aa43 100644
--- a/system/vulkan_enc/goldfish_vk_transform_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_transform_guest.cpp
@@ -14,1641 +14,1303 @@
// limitations under the License.
// Autogenerated module goldfish_vk_transform_guest
-// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal -o ../qemu/android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+//
+// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
+// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
-// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
+//
+// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
+// $CEREAL_OUTPUT_DIR
+//
#include "goldfish_vk_transform_guest.h"
-
-#include "goldfish_vk_extension_structs_guest.h"
-#include "goldfish_vk_private_defs.h"
-
#include <cstring>
#include "ResourceTracker.h"
-
+#include "goldfish_vk_extension_structs_guest.h"
+#include "goldfish_vk_private_defs.h"
namespace goldfish_vk {
-void transform_tohost_extension_struct(
- ResourceTracker* resourceTracker,
- void* structExtension_out);
+void transform_tohost_extension_struct(ResourceTracker* resourceTracker, void* structExtension_out);
-void transform_fromhost_extension_struct(
- ResourceTracker* resourceTracker,
- void* structExtension_out);
+void transform_fromhost_extension_struct(ResourceTracker* resourceTracker,
+ void* structExtension_out);
#ifdef VK_VERSION_1_0
-void transform_tohost_VkExtent2D(
- ResourceTracker* resourceTracker,
- VkExtent2D* toTransform)
-{
+void transform_tohost_VkExtent2D(ResourceTracker* resourceTracker, VkExtent2D* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkExtent2D(
- ResourceTracker* resourceTracker,
- VkExtent2D* toTransform)
-{
+void transform_fromhost_VkExtent2D(ResourceTracker* resourceTracker, VkExtent2D* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkExtent3D(
- ResourceTracker* resourceTracker,
- VkExtent3D* toTransform)
-{
+void transform_tohost_VkExtent3D(ResourceTracker* resourceTracker, VkExtent3D* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkExtent3D(
- ResourceTracker* resourceTracker,
- VkExtent3D* toTransform)
-{
+void transform_fromhost_VkExtent3D(ResourceTracker* resourceTracker, VkExtent3D* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkOffset2D(
- ResourceTracker* resourceTracker,
- VkOffset2D* toTransform)
-{
+void transform_tohost_VkOffset2D(ResourceTracker* resourceTracker, VkOffset2D* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkOffset2D(
- ResourceTracker* resourceTracker,
- VkOffset2D* toTransform)
-{
+void transform_fromhost_VkOffset2D(ResourceTracker* resourceTracker, VkOffset2D* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkOffset3D(
- ResourceTracker* resourceTracker,
- VkOffset3D* toTransform)
-{
+void transform_tohost_VkOffset3D(ResourceTracker* resourceTracker, VkOffset3D* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkOffset3D(
- ResourceTracker* resourceTracker,
- VkOffset3D* toTransform)
-{
+void transform_fromhost_VkOffset3D(ResourceTracker* resourceTracker, VkOffset3D* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkRect2D(
- ResourceTracker* resourceTracker,
- VkRect2D* toTransform)
-{
+void transform_tohost_VkRect2D(ResourceTracker* resourceTracker, VkRect2D* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_tohost_VkOffset2D(resourceTracker, (VkOffset2D*)(&toTransform->offset));
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->extent));
}
-void transform_fromhost_VkRect2D(
- ResourceTracker* resourceTracker,
- VkRect2D* toTransform)
-{
+void transform_fromhost_VkRect2D(ResourceTracker* resourceTracker, VkRect2D* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_fromhost_VkOffset2D(resourceTracker, (VkOffset2D*)(&toTransform->offset));
transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->extent));
}
-void transform_tohost_VkBaseInStructure(
- ResourceTracker* resourceTracker,
- VkBaseInStructure* toTransform)
-{
+void transform_tohost_VkBaseInStructure(ResourceTracker* resourceTracker,
+ VkBaseInStructure* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkBaseInStructure(
- ResourceTracker* resourceTracker,
- VkBaseInStructure* toTransform)
-{
+void transform_fromhost_VkBaseInStructure(ResourceTracker* resourceTracker,
+ VkBaseInStructure* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkBaseOutStructure(
- ResourceTracker* resourceTracker,
- VkBaseOutStructure* toTransform)
-{
+void transform_tohost_VkBaseOutStructure(ResourceTracker* resourceTracker,
+ VkBaseOutStructure* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkBaseOutStructure(
- ResourceTracker* resourceTracker,
- VkBaseOutStructure* toTransform)
-{
+void transform_fromhost_VkBaseOutStructure(ResourceTracker* resourceTracker,
+ VkBaseOutStructure* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkBufferMemoryBarrier(
- ResourceTracker* resourceTracker,
- VkBufferMemoryBarrier* toTransform)
-{
+void transform_tohost_VkBufferMemoryBarrier(ResourceTracker* resourceTracker,
+ VkBufferMemoryBarrier* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkBufferMemoryBarrier(
- ResourceTracker* resourceTracker,
- VkBufferMemoryBarrier* toTransform)
-{
+void transform_fromhost_VkBufferMemoryBarrier(ResourceTracker* resourceTracker,
+ VkBufferMemoryBarrier* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkDispatchIndirectCommand(
- ResourceTracker* resourceTracker,
- VkDispatchIndirectCommand* toTransform)
-{
+void transform_tohost_VkDispatchIndirectCommand(ResourceTracker* resourceTracker,
+ VkDispatchIndirectCommand* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkDispatchIndirectCommand(
- ResourceTracker* resourceTracker,
- VkDispatchIndirectCommand* toTransform)
-{
+void transform_fromhost_VkDispatchIndirectCommand(ResourceTracker* resourceTracker,
+ VkDispatchIndirectCommand* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkDrawIndexedIndirectCommand(
- ResourceTracker* resourceTracker,
- VkDrawIndexedIndirectCommand* toTransform)
-{
+void transform_tohost_VkDrawIndexedIndirectCommand(ResourceTracker* resourceTracker,
+ VkDrawIndexedIndirectCommand* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkDrawIndexedIndirectCommand(
- ResourceTracker* resourceTracker,
- VkDrawIndexedIndirectCommand* toTransform)
-{
+void transform_fromhost_VkDrawIndexedIndirectCommand(ResourceTracker* resourceTracker,
+ VkDrawIndexedIndirectCommand* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkDrawIndirectCommand(
- ResourceTracker* resourceTracker,
- VkDrawIndirectCommand* toTransform)
-{
+void transform_tohost_VkDrawIndirectCommand(ResourceTracker* resourceTracker,
+ VkDrawIndirectCommand* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkDrawIndirectCommand(
- ResourceTracker* resourceTracker,
- VkDrawIndirectCommand* toTransform)
-{
+void transform_fromhost_VkDrawIndirectCommand(ResourceTracker* resourceTracker,
+ VkDrawIndirectCommand* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkImageSubresourceRange(
- ResourceTracker* resourceTracker,
- VkImageSubresourceRange* toTransform)
-{
+void transform_tohost_VkImageSubresourceRange(ResourceTracker* resourceTracker,
+ VkImageSubresourceRange* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkImageSubresourceRange(
- ResourceTracker* resourceTracker,
- VkImageSubresourceRange* toTransform)
-{
+void transform_fromhost_VkImageSubresourceRange(ResourceTracker* resourceTracker,
+ VkImageSubresourceRange* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkImageMemoryBarrier(
- ResourceTracker* resourceTracker,
- VkImageMemoryBarrier* toTransform)
-{
+void transform_tohost_VkImageMemoryBarrier(ResourceTracker* resourceTracker,
+ VkImageMemoryBarrier* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkImageSubresourceRange(resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
+ transform_tohost_VkImageSubresourceRange(
+ resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
}
-void transform_fromhost_VkImageMemoryBarrier(
- ResourceTracker* resourceTracker,
- VkImageMemoryBarrier* toTransform)
-{
+void transform_fromhost_VkImageMemoryBarrier(ResourceTracker* resourceTracker,
+ VkImageMemoryBarrier* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkImageSubresourceRange(resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
+ transform_fromhost_VkImageSubresourceRange(
+ resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
}
-void transform_tohost_VkMemoryBarrier(
- ResourceTracker* resourceTracker,
- VkMemoryBarrier* toTransform)
-{
+void transform_tohost_VkMemoryBarrier(ResourceTracker* resourceTracker,
+ VkMemoryBarrier* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkMemoryBarrier(
- ResourceTracker* resourceTracker,
- VkMemoryBarrier* toTransform)
-{
+void transform_fromhost_VkMemoryBarrier(ResourceTracker* resourceTracker,
+ VkMemoryBarrier* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPipelineCacheHeaderVersionOne(
- ResourceTracker* resourceTracker,
- VkPipelineCacheHeaderVersionOne* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineCacheHeaderVersionOne* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_fromhost_VkPipelineCacheHeaderVersionOne(
- ResourceTracker* resourceTracker,
- VkPipelineCacheHeaderVersionOne* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineCacheHeaderVersionOne* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkAllocationCallbacks(
- ResourceTracker* resourceTracker,
- VkAllocationCallbacks* toTransform)
-{
+void transform_tohost_VkAllocationCallbacks(ResourceTracker* resourceTracker,
+ VkAllocationCallbacks* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkAllocationCallbacks(
- ResourceTracker* resourceTracker,
- VkAllocationCallbacks* toTransform)
-{
+void transform_fromhost_VkAllocationCallbacks(ResourceTracker* resourceTracker,
+ VkAllocationCallbacks* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkApplicationInfo(
- ResourceTracker* resourceTracker,
- VkApplicationInfo* toTransform)
-{
+void transform_tohost_VkApplicationInfo(ResourceTracker* resourceTracker,
+ VkApplicationInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkApplicationInfo(
- ResourceTracker* resourceTracker,
- VkApplicationInfo* toTransform)
-{
+void transform_fromhost_VkApplicationInfo(ResourceTracker* resourceTracker,
+ VkApplicationInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkFormatProperties(
- ResourceTracker* resourceTracker,
- VkFormatProperties* toTransform)
-{
+void transform_tohost_VkFormatProperties(ResourceTracker* resourceTracker,
+ VkFormatProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkFormatProperties(
- ResourceTracker* resourceTracker,
- VkFormatProperties* toTransform)
-{
+void transform_fromhost_VkFormatProperties(ResourceTracker* resourceTracker,
+ VkFormatProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkImageFormatProperties(
- ResourceTracker* resourceTracker,
- VkImageFormatProperties* toTransform)
-{
+void transform_tohost_VkImageFormatProperties(ResourceTracker* resourceTracker,
+ VkImageFormatProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->maxExtent));
}
-void transform_fromhost_VkImageFormatProperties(
- ResourceTracker* resourceTracker,
- VkImageFormatProperties* toTransform)
-{
+void transform_fromhost_VkImageFormatProperties(ResourceTracker* resourceTracker,
+ VkImageFormatProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->maxExtent));
}
-void transform_tohost_VkInstanceCreateInfo(
- ResourceTracker* resourceTracker,
- VkInstanceCreateInfo* toTransform)
-{
+void transform_tohost_VkInstanceCreateInfo(ResourceTracker* resourceTracker,
+ VkInstanceCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pApplicationInfo)
- {
- transform_tohost_VkApplicationInfo(resourceTracker, (VkApplicationInfo*)(toTransform->pApplicationInfo));
+ if (toTransform->pApplicationInfo) {
+ transform_tohost_VkApplicationInfo(resourceTracker,
+ (VkApplicationInfo*)(toTransform->pApplicationInfo));
}
}
-void transform_fromhost_VkInstanceCreateInfo(
- ResourceTracker* resourceTracker,
- VkInstanceCreateInfo* toTransform)
-{
+void transform_fromhost_VkInstanceCreateInfo(ResourceTracker* resourceTracker,
+ VkInstanceCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pApplicationInfo)
- {
- transform_fromhost_VkApplicationInfo(resourceTracker, (VkApplicationInfo*)(toTransform->pApplicationInfo));
+ if (toTransform->pApplicationInfo) {
+ transform_fromhost_VkApplicationInfo(resourceTracker,
+ (VkApplicationInfo*)(toTransform->pApplicationInfo));
}
}
-void transform_tohost_VkMemoryHeap(
- ResourceTracker* resourceTracker,
- VkMemoryHeap* toTransform)
-{
+void transform_tohost_VkMemoryHeap(ResourceTracker* resourceTracker, VkMemoryHeap* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkMemoryHeap(
- ResourceTracker* resourceTracker,
- VkMemoryHeap* toTransform)
-{
+void transform_fromhost_VkMemoryHeap(ResourceTracker* resourceTracker, VkMemoryHeap* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkMemoryType(
- ResourceTracker* resourceTracker,
- VkMemoryType* toTransform)
-{
+void transform_tohost_VkMemoryType(ResourceTracker* resourceTracker, VkMemoryType* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkMemoryType(
- ResourceTracker* resourceTracker,
- VkMemoryType* toTransform)
-{
+void transform_fromhost_VkMemoryType(ResourceTracker* resourceTracker, VkMemoryType* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkPhysicalDeviceFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFeatures* toTransform)
-{
+void transform_tohost_VkPhysicalDeviceFeatures(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkPhysicalDeviceFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFeatures* toTransform)
-{
+void transform_fromhost_VkPhysicalDeviceFeatures(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkPhysicalDeviceLimits(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceLimits* toTransform)
-{
+void transform_tohost_VkPhysicalDeviceLimits(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceLimits* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkPhysicalDeviceLimits(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceLimits* toTransform)
-{
+void transform_fromhost_VkPhysicalDeviceLimits(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceLimits* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkPhysicalDeviceMemoryProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMemoryProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMemoryProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i)
- {
- transform_tohost_VkMemoryType(resourceTracker, (VkMemoryType*)(toTransform->memoryTypes + i));
+ for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i) {
+ transform_tohost_VkMemoryType(resourceTracker,
+ (VkMemoryType*)(toTransform->memoryTypes + i));
}
- for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i)
- {
- transform_tohost_VkMemoryHeap(resourceTracker, (VkMemoryHeap*)(toTransform->memoryHeaps + i));
+ for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i) {
+ transform_tohost_VkMemoryHeap(resourceTracker,
+ (VkMemoryHeap*)(toTransform->memoryHeaps + i));
}
}
void transform_fromhost_VkPhysicalDeviceMemoryProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMemoryProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMemoryProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i)
- {
- transform_fromhost_VkMemoryType(resourceTracker, (VkMemoryType*)(toTransform->memoryTypes + i));
+ for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_TYPES; ++i) {
+ transform_fromhost_VkMemoryType(resourceTracker,
+ (VkMemoryType*)(toTransform->memoryTypes + i));
}
- for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i)
- {
- transform_fromhost_VkMemoryHeap(resourceTracker, (VkMemoryHeap*)(toTransform->memoryHeaps + i));
+ for (uint32_t i = 0; i < (uint32_t)VK_MAX_MEMORY_HEAPS; ++i) {
+ transform_fromhost_VkMemoryHeap(resourceTracker,
+ (VkMemoryHeap*)(toTransform->memoryHeaps + i));
}
}
void transform_tohost_VkPhysicalDeviceSparseProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSparseProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSparseProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_fromhost_VkPhysicalDeviceSparseProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSparseProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSparseProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkPhysicalDeviceProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProperties* toTransform)
-{
+void transform_tohost_VkPhysicalDeviceProperties(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_tohost_VkPhysicalDeviceLimits(resourceTracker, (VkPhysicalDeviceLimits*)(&toTransform->limits));
- transform_tohost_VkPhysicalDeviceSparseProperties(resourceTracker, (VkPhysicalDeviceSparseProperties*)(&toTransform->sparseProperties));
+ transform_tohost_VkPhysicalDeviceLimits(resourceTracker,
+ (VkPhysicalDeviceLimits*)(&toTransform->limits));
+ transform_tohost_VkPhysicalDeviceSparseProperties(
+ resourceTracker, (VkPhysicalDeviceSparseProperties*)(&toTransform->sparseProperties));
}
-void transform_fromhost_VkPhysicalDeviceProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProperties* toTransform)
-{
+void transform_fromhost_VkPhysicalDeviceProperties(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_fromhost_VkPhysicalDeviceLimits(resourceTracker, (VkPhysicalDeviceLimits*)(&toTransform->limits));
- transform_fromhost_VkPhysicalDeviceSparseProperties(resourceTracker, (VkPhysicalDeviceSparseProperties*)(&toTransform->sparseProperties));
+ transform_fromhost_VkPhysicalDeviceLimits(resourceTracker,
+ (VkPhysicalDeviceLimits*)(&toTransform->limits));
+ transform_fromhost_VkPhysicalDeviceSparseProperties(
+ resourceTracker, (VkPhysicalDeviceSparseProperties*)(&toTransform->sparseProperties));
}
-void transform_tohost_VkQueueFamilyProperties(
- ResourceTracker* resourceTracker,
- VkQueueFamilyProperties* toTransform)
-{
+void transform_tohost_VkQueueFamilyProperties(ResourceTracker* resourceTracker,
+ VkQueueFamilyProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->minImageTransferGranularity));
+ transform_tohost_VkExtent3D(resourceTracker,
+ (VkExtent3D*)(&toTransform->minImageTransferGranularity));
}
-void transform_fromhost_VkQueueFamilyProperties(
- ResourceTracker* resourceTracker,
- VkQueueFamilyProperties* toTransform)
-{
+void transform_fromhost_VkQueueFamilyProperties(ResourceTracker* resourceTracker,
+ VkQueueFamilyProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->minImageTransferGranularity));
+ transform_fromhost_VkExtent3D(resourceTracker,
+ (VkExtent3D*)(&toTransform->minImageTransferGranularity));
}
-void transform_tohost_VkDeviceQueueCreateInfo(
- ResourceTracker* resourceTracker,
- VkDeviceQueueCreateInfo* toTransform)
-{
+void transform_tohost_VkDeviceQueueCreateInfo(ResourceTracker* resourceTracker,
+ VkDeviceQueueCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkDeviceQueueCreateInfo(
- ResourceTracker* resourceTracker,
- VkDeviceQueueCreateInfo* toTransform)
-{
+void transform_fromhost_VkDeviceQueueCreateInfo(ResourceTracker* resourceTracker,
+ VkDeviceQueueCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkDeviceCreateInfo(
- ResourceTracker* resourceTracker,
- VkDeviceCreateInfo* toTransform)
-{
+void transform_tohost_VkDeviceCreateInfo(ResourceTracker* resourceTracker,
+ VkDeviceCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pQueueCreateInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->queueCreateInfoCount; ++i)
- {
- transform_tohost_VkDeviceQueueCreateInfo(resourceTracker, (VkDeviceQueueCreateInfo*)(toTransform->pQueueCreateInfos + i));
+ if (toTransform) {
+ if (toTransform->pQueueCreateInfos) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->queueCreateInfoCount; ++i) {
+ transform_tohost_VkDeviceQueueCreateInfo(
+ resourceTracker,
+ (VkDeviceQueueCreateInfo*)(toTransform->pQueueCreateInfos + i));
}
}
}
- if (toTransform->pEnabledFeatures)
- {
- transform_tohost_VkPhysicalDeviceFeatures(resourceTracker, (VkPhysicalDeviceFeatures*)(toTransform->pEnabledFeatures));
+ if (toTransform->pEnabledFeatures) {
+ transform_tohost_VkPhysicalDeviceFeatures(
+ resourceTracker, (VkPhysicalDeviceFeatures*)(toTransform->pEnabledFeatures));
}
}
-void transform_fromhost_VkDeviceCreateInfo(
- ResourceTracker* resourceTracker,
- VkDeviceCreateInfo* toTransform)
-{
+void transform_fromhost_VkDeviceCreateInfo(ResourceTracker* resourceTracker,
+ VkDeviceCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pQueueCreateInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->queueCreateInfoCount; ++i)
- {
- transform_fromhost_VkDeviceQueueCreateInfo(resourceTracker, (VkDeviceQueueCreateInfo*)(toTransform->pQueueCreateInfos + i));
+ if (toTransform) {
+ if (toTransform->pQueueCreateInfos) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->queueCreateInfoCount; ++i) {
+ transform_fromhost_VkDeviceQueueCreateInfo(
+ resourceTracker,
+ (VkDeviceQueueCreateInfo*)(toTransform->pQueueCreateInfos + i));
}
}
}
- if (toTransform->pEnabledFeatures)
- {
- transform_fromhost_VkPhysicalDeviceFeatures(resourceTracker, (VkPhysicalDeviceFeatures*)(toTransform->pEnabledFeatures));
+ if (toTransform->pEnabledFeatures) {
+ transform_fromhost_VkPhysicalDeviceFeatures(
+ resourceTracker, (VkPhysicalDeviceFeatures*)(toTransform->pEnabledFeatures));
}
}
-void transform_tohost_VkExtensionProperties(
- ResourceTracker* resourceTracker,
- VkExtensionProperties* toTransform)
-{
+void transform_tohost_VkExtensionProperties(ResourceTracker* resourceTracker,
+ VkExtensionProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkExtensionProperties(
- ResourceTracker* resourceTracker,
- VkExtensionProperties* toTransform)
-{
+void transform_fromhost_VkExtensionProperties(ResourceTracker* resourceTracker,
+ VkExtensionProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkLayerProperties(
- ResourceTracker* resourceTracker,
- VkLayerProperties* toTransform)
-{
+void transform_tohost_VkLayerProperties(ResourceTracker* resourceTracker,
+ VkLayerProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkLayerProperties(
- ResourceTracker* resourceTracker,
- VkLayerProperties* toTransform)
-{
+void transform_fromhost_VkLayerProperties(ResourceTracker* resourceTracker,
+ VkLayerProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkSubmitInfo(
- ResourceTracker* resourceTracker,
- VkSubmitInfo* toTransform)
-{
+void transform_tohost_VkSubmitInfo(ResourceTracker* resourceTracker, VkSubmitInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkSubmitInfo(
- ResourceTracker* resourceTracker,
- VkSubmitInfo* toTransform)
-{
+void transform_fromhost_VkSubmitInfo(ResourceTracker* resourceTracker, VkSubmitInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkMappedMemoryRange(
- ResourceTracker* resourceTracker,
- VkMappedMemoryRange* toTransform)
-{
+void transform_tohost_VkMappedMemoryRange(ResourceTracker* resourceTracker,
+ VkMappedMemoryRange* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->offset, 1, (VkDeviceSize*)&toTransform->size, 1, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->offset, 1,
+ (VkDeviceSize*)&toTransform->size, 1, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkMappedMemoryRange(
- ResourceTracker* resourceTracker,
- VkMappedMemoryRange* toTransform)
-{
+void transform_fromhost_VkMappedMemoryRange(ResourceTracker* resourceTracker,
+ VkMappedMemoryRange* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_fromhost((VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->offset, 1, (VkDeviceSize*)&toTransform->size, 1, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_fromhost(
+ (VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->offset, 1,
+ (VkDeviceSize*)&toTransform->size, 1, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkMemoryAllocateInfo(
- ResourceTracker* resourceTracker,
- VkMemoryAllocateInfo* toTransform)
-{
+void transform_tohost_VkMemoryAllocateInfo(ResourceTracker* resourceTracker,
+ VkMemoryAllocateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeIndex, 1, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0,
+ (uint32_t*)&toTransform->memoryTypeIndex, 1, (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkMemoryAllocateInfo(
- ResourceTracker* resourceTracker,
- VkMemoryAllocateInfo* toTransform)
-{
+void transform_fromhost_VkMemoryAllocateInfo(ResourceTracker* resourceTracker,
+ VkMemoryAllocateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_fromhost((VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeIndex, 1, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_fromhost(
+ (VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0,
+ (uint32_t*)&toTransform->memoryTypeIndex, 1, (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkMemoryRequirements(
- ResourceTracker* resourceTracker,
- VkMemoryRequirements* toTransform)
-{
+void transform_tohost_VkMemoryRequirements(ResourceTracker* resourceTracker,
+ VkMemoryRequirements* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
+ resourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0,
+ (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
}
-void transform_fromhost_VkMemoryRequirements(
- ResourceTracker* resourceTracker,
- VkMemoryRequirements* toTransform)
-{
+void transform_fromhost_VkMemoryRequirements(ResourceTracker* resourceTracker,
+ VkMemoryRequirements* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_fromhost((VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
+ resourceTracker->deviceMemoryTransform_fromhost(
+ (VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0,
+ (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
}
-void transform_tohost_VkSparseMemoryBind(
- ResourceTracker* resourceTracker,
- VkSparseMemoryBind* toTransform)
-{
+void transform_tohost_VkSparseMemoryBind(ResourceTracker* resourceTracker,
+ VkSparseMemoryBind* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->memoryOffset, 1, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ resourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->memoryOffset, 1,
+ (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
}
-void transform_fromhost_VkSparseMemoryBind(
- ResourceTracker* resourceTracker,
- VkSparseMemoryBind* toTransform)
-{
+void transform_fromhost_VkSparseMemoryBind(ResourceTracker* resourceTracker,
+ VkSparseMemoryBind* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_fromhost((VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->memoryOffset, 1, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ resourceTracker->deviceMemoryTransform_fromhost(
+ (VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->memoryOffset, 1,
+ (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
}
-void transform_tohost_VkSparseBufferMemoryBindInfo(
- ResourceTracker* resourceTracker,
- VkSparseBufferMemoryBindInfo* toTransform)
-{
+void transform_tohost_VkSparseBufferMemoryBindInfo(ResourceTracker* resourceTracker,
+ VkSparseBufferMemoryBindInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform)
- {
- if (toTransform->pBinds)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->bindCount; ++i)
- {
- transform_tohost_VkSparseMemoryBind(resourceTracker, (VkSparseMemoryBind*)(toTransform->pBinds + i));
+ if (toTransform) {
+ if (toTransform->pBinds) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->bindCount; ++i) {
+ transform_tohost_VkSparseMemoryBind(resourceTracker,
+ (VkSparseMemoryBind*)(toTransform->pBinds + i));
}
}
}
}
-void transform_fromhost_VkSparseBufferMemoryBindInfo(
- ResourceTracker* resourceTracker,
- VkSparseBufferMemoryBindInfo* toTransform)
-{
+void transform_fromhost_VkSparseBufferMemoryBindInfo(ResourceTracker* resourceTracker,
+ VkSparseBufferMemoryBindInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform)
- {
- if (toTransform->pBinds)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->bindCount; ++i)
- {
- transform_fromhost_VkSparseMemoryBind(resourceTracker, (VkSparseMemoryBind*)(toTransform->pBinds + i));
+ if (toTransform) {
+ if (toTransform->pBinds) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->bindCount; ++i) {
+ transform_fromhost_VkSparseMemoryBind(
+ resourceTracker, (VkSparseMemoryBind*)(toTransform->pBinds + i));
}
}
}
}
void transform_tohost_VkSparseImageOpaqueMemoryBindInfo(
- ResourceTracker* resourceTracker,
- VkSparseImageOpaqueMemoryBindInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSparseImageOpaqueMemoryBindInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform)
- {
- if (toTransform->pBinds)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->bindCount; ++i)
- {
- transform_tohost_VkSparseMemoryBind(resourceTracker, (VkSparseMemoryBind*)(toTransform->pBinds + i));
+ if (toTransform) {
+ if (toTransform->pBinds) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->bindCount; ++i) {
+ transform_tohost_VkSparseMemoryBind(resourceTracker,
+ (VkSparseMemoryBind*)(toTransform->pBinds + i));
}
}
}
}
void transform_fromhost_VkSparseImageOpaqueMemoryBindInfo(
- ResourceTracker* resourceTracker,
- VkSparseImageOpaqueMemoryBindInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSparseImageOpaqueMemoryBindInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform)
- {
- if (toTransform->pBinds)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->bindCount; ++i)
- {
- transform_fromhost_VkSparseMemoryBind(resourceTracker, (VkSparseMemoryBind*)(toTransform->pBinds + i));
+ if (toTransform) {
+ if (toTransform->pBinds) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->bindCount; ++i) {
+ transform_fromhost_VkSparseMemoryBind(
+ resourceTracker, (VkSparseMemoryBind*)(toTransform->pBinds + i));
}
}
}
}
-void transform_tohost_VkImageSubresource(
- ResourceTracker* resourceTracker,
- VkImageSubresource* toTransform)
-{
+void transform_tohost_VkImageSubresource(ResourceTracker* resourceTracker,
+ VkImageSubresource* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkImageSubresource(
- ResourceTracker* resourceTracker,
- VkImageSubresource* toTransform)
-{
+void transform_fromhost_VkImageSubresource(ResourceTracker* resourceTracker,
+ VkImageSubresource* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkSparseImageMemoryBind(
- ResourceTracker* resourceTracker,
- VkSparseImageMemoryBind* toTransform)
-{
+void transform_tohost_VkSparseImageMemoryBind(ResourceTracker* resourceTracker,
+ VkSparseImageMemoryBind* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->memoryOffset, 1, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- transform_tohost_VkImageSubresource(resourceTracker, (VkImageSubresource*)(&toTransform->subresource));
+ resourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->memoryOffset, 1,
+ (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ transform_tohost_VkImageSubresource(resourceTracker,
+ (VkImageSubresource*)(&toTransform->subresource));
transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->offset));
transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->extent));
}
-void transform_fromhost_VkSparseImageMemoryBind(
- ResourceTracker* resourceTracker,
- VkSparseImageMemoryBind* toTransform)
-{
+void transform_fromhost_VkSparseImageMemoryBind(ResourceTracker* resourceTracker,
+ VkSparseImageMemoryBind* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_fromhost((VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->memoryOffset, 1, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- transform_fromhost_VkImageSubresource(resourceTracker, (VkImageSubresource*)(&toTransform->subresource));
+ resourceTracker->deviceMemoryTransform_fromhost(
+ (VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->memoryOffset, 1,
+ (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ transform_fromhost_VkImageSubresource(resourceTracker,
+ (VkImageSubresource*)(&toTransform->subresource));
transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->offset));
transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->extent));
}
-void transform_tohost_VkSparseImageMemoryBindInfo(
- ResourceTracker* resourceTracker,
- VkSparseImageMemoryBindInfo* toTransform)
-{
+void transform_tohost_VkSparseImageMemoryBindInfo(ResourceTracker* resourceTracker,
+ VkSparseImageMemoryBindInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform)
- {
- if (toTransform->pBinds)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->bindCount; ++i)
- {
- transform_tohost_VkSparseImageMemoryBind(resourceTracker, (VkSparseImageMemoryBind*)(toTransform->pBinds + i));
+ if (toTransform) {
+ if (toTransform->pBinds) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->bindCount; ++i) {
+ transform_tohost_VkSparseImageMemoryBind(
+ resourceTracker, (VkSparseImageMemoryBind*)(toTransform->pBinds + i));
}
}
}
}
-void transform_fromhost_VkSparseImageMemoryBindInfo(
- ResourceTracker* resourceTracker,
- VkSparseImageMemoryBindInfo* toTransform)
-{
+void transform_fromhost_VkSparseImageMemoryBindInfo(ResourceTracker* resourceTracker,
+ VkSparseImageMemoryBindInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform)
- {
- if (toTransform->pBinds)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->bindCount; ++i)
- {
- transform_fromhost_VkSparseImageMemoryBind(resourceTracker, (VkSparseImageMemoryBind*)(toTransform->pBinds + i));
+ if (toTransform) {
+ if (toTransform->pBinds) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->bindCount; ++i) {
+ transform_fromhost_VkSparseImageMemoryBind(
+ resourceTracker, (VkSparseImageMemoryBind*)(toTransform->pBinds + i));
}
}
}
}
-void transform_tohost_VkBindSparseInfo(
- ResourceTracker* resourceTracker,
- VkBindSparseInfo* toTransform)
-{
+void transform_tohost_VkBindSparseInfo(ResourceTracker* resourceTracker,
+ VkBindSparseInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pBufferBinds)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->bufferBindCount; ++i)
- {
- transform_tohost_VkSparseBufferMemoryBindInfo(resourceTracker, (VkSparseBufferMemoryBindInfo*)(toTransform->pBufferBinds + i));
+ if (toTransform) {
+ if (toTransform->pBufferBinds) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->bufferBindCount; ++i) {
+ transform_tohost_VkSparseBufferMemoryBindInfo(
+ resourceTracker,
+ (VkSparseBufferMemoryBindInfo*)(toTransform->pBufferBinds + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pImageOpaqueBinds)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->imageOpaqueBindCount; ++i)
- {
- transform_tohost_VkSparseImageOpaqueMemoryBindInfo(resourceTracker, (VkSparseImageOpaqueMemoryBindInfo*)(toTransform->pImageOpaqueBinds + i));
+ if (toTransform) {
+ if (toTransform->pImageOpaqueBinds) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->imageOpaqueBindCount; ++i) {
+ transform_tohost_VkSparseImageOpaqueMemoryBindInfo(
+ resourceTracker,
+ (VkSparseImageOpaqueMemoryBindInfo*)(toTransform->pImageOpaqueBinds + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pImageBinds)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->imageBindCount; ++i)
- {
- transform_tohost_VkSparseImageMemoryBindInfo(resourceTracker, (VkSparseImageMemoryBindInfo*)(toTransform->pImageBinds + i));
+ if (toTransform) {
+ if (toTransform->pImageBinds) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->imageBindCount; ++i) {
+ transform_tohost_VkSparseImageMemoryBindInfo(
+ resourceTracker, (VkSparseImageMemoryBindInfo*)(toTransform->pImageBinds + i));
}
}
}
}
-void transform_fromhost_VkBindSparseInfo(
- ResourceTracker* resourceTracker,
- VkBindSparseInfo* toTransform)
-{
+void transform_fromhost_VkBindSparseInfo(ResourceTracker* resourceTracker,
+ VkBindSparseInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pBufferBinds)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->bufferBindCount; ++i)
- {
- transform_fromhost_VkSparseBufferMemoryBindInfo(resourceTracker, (VkSparseBufferMemoryBindInfo*)(toTransform->pBufferBinds + i));
+ if (toTransform) {
+ if (toTransform->pBufferBinds) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->bufferBindCount; ++i) {
+ transform_fromhost_VkSparseBufferMemoryBindInfo(
+ resourceTracker,
+ (VkSparseBufferMemoryBindInfo*)(toTransform->pBufferBinds + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pImageOpaqueBinds)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->imageOpaqueBindCount; ++i)
- {
- transform_fromhost_VkSparseImageOpaqueMemoryBindInfo(resourceTracker, (VkSparseImageOpaqueMemoryBindInfo*)(toTransform->pImageOpaqueBinds + i));
+ if (toTransform) {
+ if (toTransform->pImageOpaqueBinds) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->imageOpaqueBindCount; ++i) {
+ transform_fromhost_VkSparseImageOpaqueMemoryBindInfo(
+ resourceTracker,
+ (VkSparseImageOpaqueMemoryBindInfo*)(toTransform->pImageOpaqueBinds + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pImageBinds)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->imageBindCount; ++i)
- {
- transform_fromhost_VkSparseImageMemoryBindInfo(resourceTracker, (VkSparseImageMemoryBindInfo*)(toTransform->pImageBinds + i));
+ if (toTransform) {
+ if (toTransform->pImageBinds) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->imageBindCount; ++i) {
+ transform_fromhost_VkSparseImageMemoryBindInfo(
+ resourceTracker, (VkSparseImageMemoryBindInfo*)(toTransform->pImageBinds + i));
}
}
}
}
-void transform_tohost_VkSparseImageFormatProperties(
- ResourceTracker* resourceTracker,
- VkSparseImageFormatProperties* toTransform)
-{
+void transform_tohost_VkSparseImageFormatProperties(ResourceTracker* resourceTracker,
+ VkSparseImageFormatProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageGranularity));
}
-void transform_fromhost_VkSparseImageFormatProperties(
- ResourceTracker* resourceTracker,
- VkSparseImageFormatProperties* toTransform)
-{
+void transform_fromhost_VkSparseImageFormatProperties(ResourceTracker* resourceTracker,
+ VkSparseImageFormatProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageGranularity));
}
void transform_tohost_VkSparseImageMemoryRequirements(
- ResourceTracker* resourceTracker,
- VkSparseImageMemoryRequirements* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSparseImageMemoryRequirements* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_tohost_VkSparseImageFormatProperties(resourceTracker, (VkSparseImageFormatProperties*)(&toTransform->formatProperties));
+ transform_tohost_VkSparseImageFormatProperties(
+ resourceTracker, (VkSparseImageFormatProperties*)(&toTransform->formatProperties));
}
void transform_fromhost_VkSparseImageMemoryRequirements(
- ResourceTracker* resourceTracker,
- VkSparseImageMemoryRequirements* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSparseImageMemoryRequirements* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_fromhost_VkSparseImageFormatProperties(resourceTracker, (VkSparseImageFormatProperties*)(&toTransform->formatProperties));
+ transform_fromhost_VkSparseImageFormatProperties(
+ resourceTracker, (VkSparseImageFormatProperties*)(&toTransform->formatProperties));
}
-void transform_tohost_VkFenceCreateInfo(
- ResourceTracker* resourceTracker,
- VkFenceCreateInfo* toTransform)
-{
+void transform_tohost_VkFenceCreateInfo(ResourceTracker* resourceTracker,
+ VkFenceCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkFenceCreateInfo(
- ResourceTracker* resourceTracker,
- VkFenceCreateInfo* toTransform)
-{
+void transform_fromhost_VkFenceCreateInfo(ResourceTracker* resourceTracker,
+ VkFenceCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkSemaphoreCreateInfo(
- ResourceTracker* resourceTracker,
- VkSemaphoreCreateInfo* toTransform)
-{
+void transform_tohost_VkSemaphoreCreateInfo(ResourceTracker* resourceTracker,
+ VkSemaphoreCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkSemaphoreCreateInfo(
- ResourceTracker* resourceTracker,
- VkSemaphoreCreateInfo* toTransform)
-{
+void transform_fromhost_VkSemaphoreCreateInfo(ResourceTracker* resourceTracker,
+ VkSemaphoreCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkEventCreateInfo(
- ResourceTracker* resourceTracker,
- VkEventCreateInfo* toTransform)
-{
+void transform_tohost_VkEventCreateInfo(ResourceTracker* resourceTracker,
+ VkEventCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkEventCreateInfo(
- ResourceTracker* resourceTracker,
- VkEventCreateInfo* toTransform)
-{
+void transform_fromhost_VkEventCreateInfo(ResourceTracker* resourceTracker,
+ VkEventCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkQueryPoolCreateInfo(
- ResourceTracker* resourceTracker,
- VkQueryPoolCreateInfo* toTransform)
-{
+void transform_tohost_VkQueryPoolCreateInfo(ResourceTracker* resourceTracker,
+ VkQueryPoolCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkQueryPoolCreateInfo(
- ResourceTracker* resourceTracker,
- VkQueryPoolCreateInfo* toTransform)
-{
+void transform_fromhost_VkQueryPoolCreateInfo(ResourceTracker* resourceTracker,
+ VkQueryPoolCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkBufferCreateInfo(
- ResourceTracker* resourceTracker,
- VkBufferCreateInfo* toTransform)
-{
+void transform_tohost_VkBufferCreateInfo(ResourceTracker* resourceTracker,
+ VkBufferCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkBufferCreateInfo(
- ResourceTracker* resourceTracker,
- VkBufferCreateInfo* toTransform)
-{
+void transform_fromhost_VkBufferCreateInfo(ResourceTracker* resourceTracker,
+ VkBufferCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkBufferViewCreateInfo(
- ResourceTracker* resourceTracker,
- VkBufferViewCreateInfo* toTransform)
-{
+void transform_tohost_VkBufferViewCreateInfo(ResourceTracker* resourceTracker,
+ VkBufferViewCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkBufferViewCreateInfo(
- ResourceTracker* resourceTracker,
- VkBufferViewCreateInfo* toTransform)
-{
+void transform_fromhost_VkBufferViewCreateInfo(ResourceTracker* resourceTracker,
+ VkBufferViewCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkImageCreateInfo(
- ResourceTracker* resourceTracker,
- VkImageCreateInfo* toTransform)
-{
+void transform_tohost_VkImageCreateInfo(ResourceTracker* resourceTracker,
+ VkImageCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->extent));
}
-void transform_fromhost_VkImageCreateInfo(
- ResourceTracker* resourceTracker,
- VkImageCreateInfo* toTransform)
-{
+void transform_fromhost_VkImageCreateInfo(ResourceTracker* resourceTracker,
+ VkImageCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->extent));
}
-void transform_tohost_VkSubresourceLayout(
- ResourceTracker* resourceTracker,
- VkSubresourceLayout* toTransform)
-{
+void transform_tohost_VkSubresourceLayout(ResourceTracker* resourceTracker,
+ VkSubresourceLayout* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkSubresourceLayout(
- ResourceTracker* resourceTracker,
- VkSubresourceLayout* toTransform)
-{
+void transform_fromhost_VkSubresourceLayout(ResourceTracker* resourceTracker,
+ VkSubresourceLayout* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkComponentMapping(
- ResourceTracker* resourceTracker,
- VkComponentMapping* toTransform)
-{
+void transform_tohost_VkComponentMapping(ResourceTracker* resourceTracker,
+ VkComponentMapping* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkComponentMapping(
- ResourceTracker* resourceTracker,
- VkComponentMapping* toTransform)
-{
+void transform_fromhost_VkComponentMapping(ResourceTracker* resourceTracker,
+ VkComponentMapping* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkImageViewCreateInfo(
- ResourceTracker* resourceTracker,
- VkImageViewCreateInfo* toTransform)
-{
+void transform_tohost_VkImageViewCreateInfo(ResourceTracker* resourceTracker,
+ VkImageViewCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkComponentMapping(resourceTracker, (VkComponentMapping*)(&toTransform->components));
- transform_tohost_VkImageSubresourceRange(resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
+ transform_tohost_VkComponentMapping(resourceTracker,
+ (VkComponentMapping*)(&toTransform->components));
+ transform_tohost_VkImageSubresourceRange(
+ resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
}
-void transform_fromhost_VkImageViewCreateInfo(
- ResourceTracker* resourceTracker,
- VkImageViewCreateInfo* toTransform)
-{
+void transform_fromhost_VkImageViewCreateInfo(ResourceTracker* resourceTracker,
+ VkImageViewCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkComponentMapping(resourceTracker, (VkComponentMapping*)(&toTransform->components));
- transform_fromhost_VkImageSubresourceRange(resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
+ transform_fromhost_VkComponentMapping(resourceTracker,
+ (VkComponentMapping*)(&toTransform->components));
+ transform_fromhost_VkImageSubresourceRange(
+ resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
}
-void transform_tohost_VkShaderModuleCreateInfo(
- ResourceTracker* resourceTracker,
- VkShaderModuleCreateInfo* toTransform)
-{
+void transform_tohost_VkShaderModuleCreateInfo(ResourceTracker* resourceTracker,
+ VkShaderModuleCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkShaderModuleCreateInfo(
- ResourceTracker* resourceTracker,
- VkShaderModuleCreateInfo* toTransform)
-{
+void transform_fromhost_VkShaderModuleCreateInfo(ResourceTracker* resourceTracker,
+ VkShaderModuleCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkPipelineCacheCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineCacheCreateInfo* toTransform)
-{
+void transform_tohost_VkPipelineCacheCreateInfo(ResourceTracker* resourceTracker,
+ VkPipelineCacheCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkPipelineCacheCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineCacheCreateInfo* toTransform)
-{
+void transform_fromhost_VkPipelineCacheCreateInfo(ResourceTracker* resourceTracker,
+ VkPipelineCacheCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkSpecializationMapEntry(
- ResourceTracker* resourceTracker,
- VkSpecializationMapEntry* toTransform)
-{
+void transform_tohost_VkSpecializationMapEntry(ResourceTracker* resourceTracker,
+ VkSpecializationMapEntry* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkSpecializationMapEntry(
- ResourceTracker* resourceTracker,
- VkSpecializationMapEntry* toTransform)
-{
+void transform_fromhost_VkSpecializationMapEntry(ResourceTracker* resourceTracker,
+ VkSpecializationMapEntry* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkSpecializationInfo(
- ResourceTracker* resourceTracker,
- VkSpecializationInfo* toTransform)
-{
+void transform_tohost_VkSpecializationInfo(ResourceTracker* resourceTracker,
+ VkSpecializationInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform)
- {
- if (toTransform->pMapEntries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->mapEntryCount; ++i)
- {
- transform_tohost_VkSpecializationMapEntry(resourceTracker, (VkSpecializationMapEntry*)(toTransform->pMapEntries + i));
+ if (toTransform) {
+ if (toTransform->pMapEntries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->mapEntryCount; ++i) {
+ transform_tohost_VkSpecializationMapEntry(
+ resourceTracker, (VkSpecializationMapEntry*)(toTransform->pMapEntries + i));
}
}
}
}
-void transform_fromhost_VkSpecializationInfo(
- ResourceTracker* resourceTracker,
- VkSpecializationInfo* toTransform)
-{
+void transform_fromhost_VkSpecializationInfo(ResourceTracker* resourceTracker,
+ VkSpecializationInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform)
- {
- if (toTransform->pMapEntries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->mapEntryCount; ++i)
- {
- transform_fromhost_VkSpecializationMapEntry(resourceTracker, (VkSpecializationMapEntry*)(toTransform->pMapEntries + i));
+ if (toTransform) {
+ if (toTransform->pMapEntries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->mapEntryCount; ++i) {
+ transform_fromhost_VkSpecializationMapEntry(
+ resourceTracker, (VkSpecializationMapEntry*)(toTransform->pMapEntries + i));
}
}
}
}
void transform_tohost_VkPipelineShaderStageCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineShaderStageCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineShaderStageCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pSpecializationInfo)
- {
- transform_tohost_VkSpecializationInfo(resourceTracker, (VkSpecializationInfo*)(toTransform->pSpecializationInfo));
+ if (toTransform->pSpecializationInfo) {
+ transform_tohost_VkSpecializationInfo(
+ resourceTracker, (VkSpecializationInfo*)(toTransform->pSpecializationInfo));
}
}
void transform_fromhost_VkPipelineShaderStageCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineShaderStageCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineShaderStageCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pSpecializationInfo)
- {
- transform_fromhost_VkSpecializationInfo(resourceTracker, (VkSpecializationInfo*)(toTransform->pSpecializationInfo));
+ if (toTransform->pSpecializationInfo) {
+ transform_fromhost_VkSpecializationInfo(
+ resourceTracker, (VkSpecializationInfo*)(toTransform->pSpecializationInfo));
}
}
-void transform_tohost_VkComputePipelineCreateInfo(
- ResourceTracker* resourceTracker,
- VkComputePipelineCreateInfo* toTransform)
-{
+void transform_tohost_VkComputePipelineCreateInfo(ResourceTracker* resourceTracker,
+ VkComputePipelineCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkPipelineShaderStageCreateInfo(resourceTracker, (VkPipelineShaderStageCreateInfo*)(&toTransform->stage));
+ transform_tohost_VkPipelineShaderStageCreateInfo(
+ resourceTracker, (VkPipelineShaderStageCreateInfo*)(&toTransform->stage));
}
-void transform_fromhost_VkComputePipelineCreateInfo(
- ResourceTracker* resourceTracker,
- VkComputePipelineCreateInfo* toTransform)
-{
+void transform_fromhost_VkComputePipelineCreateInfo(ResourceTracker* resourceTracker,
+ VkComputePipelineCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkPipelineShaderStageCreateInfo(resourceTracker, (VkPipelineShaderStageCreateInfo*)(&toTransform->stage));
+ transform_fromhost_VkPipelineShaderStageCreateInfo(
+ resourceTracker, (VkPipelineShaderStageCreateInfo*)(&toTransform->stage));
}
void transform_tohost_VkVertexInputBindingDescription(
- ResourceTracker* resourceTracker,
- VkVertexInputBindingDescription* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVertexInputBindingDescription* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_fromhost_VkVertexInputBindingDescription(
- ResourceTracker* resourceTracker,
- VkVertexInputBindingDescription* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVertexInputBindingDescription* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkVertexInputAttributeDescription(
- ResourceTracker* resourceTracker,
- VkVertexInputAttributeDescription* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVertexInputAttributeDescription* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_fromhost_VkVertexInputAttributeDescription(
- ResourceTracker* resourceTracker,
- VkVertexInputAttributeDescription* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVertexInputAttributeDescription* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkPipelineVertexInputStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineVertexInputStateCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineVertexInputStateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pVertexBindingDescriptions)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->vertexBindingDescriptionCount; ++i)
- {
- transform_tohost_VkVertexInputBindingDescription(resourceTracker, (VkVertexInputBindingDescription*)(toTransform->pVertexBindingDescriptions + i));
+ if (toTransform) {
+ if (toTransform->pVertexBindingDescriptions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->vertexBindingDescriptionCount; ++i) {
+ transform_tohost_VkVertexInputBindingDescription(
+ resourceTracker,
+ (VkVertexInputBindingDescription*)(toTransform->pVertexBindingDescriptions +
+ i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pVertexAttributeDescriptions)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->vertexAttributeDescriptionCount; ++i)
- {
- transform_tohost_VkVertexInputAttributeDescription(resourceTracker, (VkVertexInputAttributeDescription*)(toTransform->pVertexAttributeDescriptions + i));
+ if (toTransform) {
+ if (toTransform->pVertexAttributeDescriptions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->vertexAttributeDescriptionCount; ++i) {
+ transform_tohost_VkVertexInputAttributeDescription(
+ resourceTracker,
+ (VkVertexInputAttributeDescription*)(toTransform->pVertexAttributeDescriptions +
+ i));
}
}
}
}
void transform_fromhost_VkPipelineVertexInputStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineVertexInputStateCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineVertexInputStateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pVertexBindingDescriptions)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->vertexBindingDescriptionCount; ++i)
- {
- transform_fromhost_VkVertexInputBindingDescription(resourceTracker, (VkVertexInputBindingDescription*)(toTransform->pVertexBindingDescriptions + i));
+ if (toTransform) {
+ if (toTransform->pVertexBindingDescriptions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->vertexBindingDescriptionCount; ++i) {
+ transform_fromhost_VkVertexInputBindingDescription(
+ resourceTracker,
+ (VkVertexInputBindingDescription*)(toTransform->pVertexBindingDescriptions +
+ i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pVertexAttributeDescriptions)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->vertexAttributeDescriptionCount; ++i)
- {
- transform_fromhost_VkVertexInputAttributeDescription(resourceTracker, (VkVertexInputAttributeDescription*)(toTransform->pVertexAttributeDescriptions + i));
+ if (toTransform) {
+ if (toTransform->pVertexAttributeDescriptions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->vertexAttributeDescriptionCount; ++i) {
+ transform_fromhost_VkVertexInputAttributeDescription(
+ resourceTracker,
+ (VkVertexInputAttributeDescription*)(toTransform->pVertexAttributeDescriptions +
+ i));
}
}
}
}
void transform_tohost_VkPipelineInputAssemblyStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineInputAssemblyStateCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineInputAssemblyStateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineInputAssemblyStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineInputAssemblyStateCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineInputAssemblyStateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPipelineTessellationStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineTessellationStateCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineTessellationStateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineTessellationStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineTessellationStateCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineTessellationStateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkViewport(
- ResourceTracker* resourceTracker,
- VkViewport* toTransform)
-{
+void transform_tohost_VkViewport(ResourceTracker* resourceTracker, VkViewport* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkViewport(
- ResourceTracker* resourceTracker,
- VkViewport* toTransform)
-{
+void transform_fromhost_VkViewport(ResourceTracker* resourceTracker, VkViewport* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkPipelineViewportStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineViewportStateCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineViewportStateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pViewports)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->viewportCount; ++i)
- {
- transform_tohost_VkViewport(resourceTracker, (VkViewport*)(toTransform->pViewports + i));
+ if (toTransform) {
+ if (toTransform->pViewports) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->viewportCount; ++i) {
+ transform_tohost_VkViewport(resourceTracker,
+ (VkViewport*)(toTransform->pViewports + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pScissors)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->scissorCount; ++i)
- {
+ if (toTransform) {
+ if (toTransform->pScissors) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->scissorCount; ++i) {
transform_tohost_VkRect2D(resourceTracker, (VkRect2D*)(toTransform->pScissors + i));
}
}
@@ -1656,109 +1318,83 @@
}
void transform_fromhost_VkPipelineViewportStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineViewportStateCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineViewportStateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pViewports)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->viewportCount; ++i)
- {
- transform_fromhost_VkViewport(resourceTracker, (VkViewport*)(toTransform->pViewports + i));
+ if (toTransform) {
+ if (toTransform->pViewports) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->viewportCount; ++i) {
+ transform_fromhost_VkViewport(resourceTracker,
+ (VkViewport*)(toTransform->pViewports + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pScissors)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->scissorCount; ++i)
- {
- transform_fromhost_VkRect2D(resourceTracker, (VkRect2D*)(toTransform->pScissors + i));
+ if (toTransform) {
+ if (toTransform->pScissors) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->scissorCount; ++i) {
+ transform_fromhost_VkRect2D(resourceTracker,
+ (VkRect2D*)(toTransform->pScissors + i));
}
}
}
}
void transform_tohost_VkPipelineRasterizationStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineRasterizationStateCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineRasterizationStateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineRasterizationStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineRasterizationStateCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineRasterizationStateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPipelineMultisampleStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineMultisampleStateCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineMultisampleStateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineMultisampleStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineMultisampleStateCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineMultisampleStateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkStencilOpState(
- ResourceTracker* resourceTracker,
- VkStencilOpState* toTransform)
-{
+void transform_tohost_VkStencilOpState(ResourceTracker* resourceTracker,
+ VkStencilOpState* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkStencilOpState(
- ResourceTracker* resourceTracker,
- VkStencilOpState* toTransform)
-{
+void transform_fromhost_VkStencilOpState(ResourceTracker* resourceTracker,
+ VkStencilOpState* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkPipelineDepthStencilStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineDepthStencilStateCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineDepthStencilStateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_tohost_VkStencilOpState(resourceTracker, (VkStencilOpState*)(&toTransform->front));
@@ -1766,13 +1402,10 @@
}
void transform_fromhost_VkPipelineDepthStencilStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineDepthStencilStateCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineDepthStencilStateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_fromhost_VkStencilOpState(resourceTracker, (VkStencilOpState*)(&toTransform->front));
@@ -1780,1168 +1413,945 @@
}
void transform_tohost_VkPipelineColorBlendAttachmentState(
- ResourceTracker* resourceTracker,
- VkPipelineColorBlendAttachmentState* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineColorBlendAttachmentState* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_fromhost_VkPipelineColorBlendAttachmentState(
- ResourceTracker* resourceTracker,
- VkPipelineColorBlendAttachmentState* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineColorBlendAttachmentState* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkPipelineColorBlendStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineColorBlendStateCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineColorBlendStateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->attachmentCount; ++i)
- {
- transform_tohost_VkPipelineColorBlendAttachmentState(resourceTracker, (VkPipelineColorBlendAttachmentState*)(toTransform->pAttachments + i));
+ if (toTransform) {
+ if (toTransform->pAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->attachmentCount; ++i) {
+ transform_tohost_VkPipelineColorBlendAttachmentState(
+ resourceTracker,
+ (VkPipelineColorBlendAttachmentState*)(toTransform->pAttachments + i));
}
}
}
}
void transform_fromhost_VkPipelineColorBlendStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineColorBlendStateCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineColorBlendStateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->attachmentCount; ++i)
- {
- transform_fromhost_VkPipelineColorBlendAttachmentState(resourceTracker, (VkPipelineColorBlendAttachmentState*)(toTransform->pAttachments + i));
+ if (toTransform) {
+ if (toTransform->pAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->attachmentCount; ++i) {
+ transform_fromhost_VkPipelineColorBlendAttachmentState(
+ resourceTracker,
+ (VkPipelineColorBlendAttachmentState*)(toTransform->pAttachments + i));
}
}
}
}
void transform_tohost_VkPipelineDynamicStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineDynamicStateCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineDynamicStateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineDynamicStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineDynamicStateCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineDynamicStateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkGraphicsPipelineCreateInfo(
- ResourceTracker* resourceTracker,
- VkGraphicsPipelineCreateInfo* toTransform)
-{
+void transform_tohost_VkGraphicsPipelineCreateInfo(ResourceTracker* resourceTracker,
+ VkGraphicsPipelineCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pStages)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->stageCount; ++i)
- {
- transform_tohost_VkPipelineShaderStageCreateInfo(resourceTracker, (VkPipelineShaderStageCreateInfo*)(toTransform->pStages + i));
+ if (toTransform) {
+ if (toTransform->pStages) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->stageCount; ++i) {
+ transform_tohost_VkPipelineShaderStageCreateInfo(
+ resourceTracker, (VkPipelineShaderStageCreateInfo*)(toTransform->pStages + i));
}
}
}
- if (toTransform->pVertexInputState)
- {
- transform_tohost_VkPipelineVertexInputStateCreateInfo(resourceTracker, (VkPipelineVertexInputStateCreateInfo*)(toTransform->pVertexInputState));
+ if (toTransform->pVertexInputState) {
+ transform_tohost_VkPipelineVertexInputStateCreateInfo(
+ resourceTracker,
+ (VkPipelineVertexInputStateCreateInfo*)(toTransform->pVertexInputState));
}
- if (toTransform->pInputAssemblyState)
- {
- transform_tohost_VkPipelineInputAssemblyStateCreateInfo(resourceTracker, (VkPipelineInputAssemblyStateCreateInfo*)(toTransform->pInputAssemblyState));
+ if (toTransform->pInputAssemblyState) {
+ transform_tohost_VkPipelineInputAssemblyStateCreateInfo(
+ resourceTracker,
+ (VkPipelineInputAssemblyStateCreateInfo*)(toTransform->pInputAssemblyState));
}
- if (toTransform->pTessellationState)
- {
- transform_tohost_VkPipelineTessellationStateCreateInfo(resourceTracker, (VkPipelineTessellationStateCreateInfo*)(toTransform->pTessellationState));
+ if (toTransform->pTessellationState) {
+ transform_tohost_VkPipelineTessellationStateCreateInfo(
+ resourceTracker,
+ (VkPipelineTessellationStateCreateInfo*)(toTransform->pTessellationState));
}
- if (toTransform->pViewportState)
- {
- transform_tohost_VkPipelineViewportStateCreateInfo(resourceTracker, (VkPipelineViewportStateCreateInfo*)(toTransform->pViewportState));
+ if (toTransform->pViewportState) {
+ transform_tohost_VkPipelineViewportStateCreateInfo(
+ resourceTracker, (VkPipelineViewportStateCreateInfo*)(toTransform->pViewportState));
}
- if (toTransform->pRasterizationState)
- {
- transform_tohost_VkPipelineRasterizationStateCreateInfo(resourceTracker, (VkPipelineRasterizationStateCreateInfo*)(toTransform->pRasterizationState));
+ if (toTransform->pRasterizationState) {
+ transform_tohost_VkPipelineRasterizationStateCreateInfo(
+ resourceTracker,
+ (VkPipelineRasterizationStateCreateInfo*)(toTransform->pRasterizationState));
}
- if (toTransform->pMultisampleState)
- {
- transform_tohost_VkPipelineMultisampleStateCreateInfo(resourceTracker, (VkPipelineMultisampleStateCreateInfo*)(toTransform->pMultisampleState));
+ if (toTransform->pMultisampleState) {
+ transform_tohost_VkPipelineMultisampleStateCreateInfo(
+ resourceTracker,
+ (VkPipelineMultisampleStateCreateInfo*)(toTransform->pMultisampleState));
}
- if (toTransform->pDepthStencilState)
- {
- transform_tohost_VkPipelineDepthStencilStateCreateInfo(resourceTracker, (VkPipelineDepthStencilStateCreateInfo*)(toTransform->pDepthStencilState));
+ if (toTransform->pDepthStencilState) {
+ transform_tohost_VkPipelineDepthStencilStateCreateInfo(
+ resourceTracker,
+ (VkPipelineDepthStencilStateCreateInfo*)(toTransform->pDepthStencilState));
}
- if (toTransform->pColorBlendState)
- {
- transform_tohost_VkPipelineColorBlendStateCreateInfo(resourceTracker, (VkPipelineColorBlendStateCreateInfo*)(toTransform->pColorBlendState));
+ if (toTransform->pColorBlendState) {
+ transform_tohost_VkPipelineColorBlendStateCreateInfo(
+ resourceTracker, (VkPipelineColorBlendStateCreateInfo*)(toTransform->pColorBlendState));
}
- if (toTransform->pDynamicState)
- {
- transform_tohost_VkPipelineDynamicStateCreateInfo(resourceTracker, (VkPipelineDynamicStateCreateInfo*)(toTransform->pDynamicState));
+ if (toTransform->pDynamicState) {
+ transform_tohost_VkPipelineDynamicStateCreateInfo(
+ resourceTracker, (VkPipelineDynamicStateCreateInfo*)(toTransform->pDynamicState));
}
}
-void transform_fromhost_VkGraphicsPipelineCreateInfo(
- ResourceTracker* resourceTracker,
- VkGraphicsPipelineCreateInfo* toTransform)
-{
+void transform_fromhost_VkGraphicsPipelineCreateInfo(ResourceTracker* resourceTracker,
+ VkGraphicsPipelineCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pStages)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->stageCount; ++i)
- {
- transform_fromhost_VkPipelineShaderStageCreateInfo(resourceTracker, (VkPipelineShaderStageCreateInfo*)(toTransform->pStages + i));
+ if (toTransform) {
+ if (toTransform->pStages) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->stageCount; ++i) {
+ transform_fromhost_VkPipelineShaderStageCreateInfo(
+ resourceTracker, (VkPipelineShaderStageCreateInfo*)(toTransform->pStages + i));
}
}
}
- if (toTransform->pVertexInputState)
- {
- transform_fromhost_VkPipelineVertexInputStateCreateInfo(resourceTracker, (VkPipelineVertexInputStateCreateInfo*)(toTransform->pVertexInputState));
+ if (toTransform->pVertexInputState) {
+ transform_fromhost_VkPipelineVertexInputStateCreateInfo(
+ resourceTracker,
+ (VkPipelineVertexInputStateCreateInfo*)(toTransform->pVertexInputState));
}
- if (toTransform->pInputAssemblyState)
- {
- transform_fromhost_VkPipelineInputAssemblyStateCreateInfo(resourceTracker, (VkPipelineInputAssemblyStateCreateInfo*)(toTransform->pInputAssemblyState));
+ if (toTransform->pInputAssemblyState) {
+ transform_fromhost_VkPipelineInputAssemblyStateCreateInfo(
+ resourceTracker,
+ (VkPipelineInputAssemblyStateCreateInfo*)(toTransform->pInputAssemblyState));
}
- if (toTransform->pTessellationState)
- {
- transform_fromhost_VkPipelineTessellationStateCreateInfo(resourceTracker, (VkPipelineTessellationStateCreateInfo*)(toTransform->pTessellationState));
+ if (toTransform->pTessellationState) {
+ transform_fromhost_VkPipelineTessellationStateCreateInfo(
+ resourceTracker,
+ (VkPipelineTessellationStateCreateInfo*)(toTransform->pTessellationState));
}
- if (toTransform->pViewportState)
- {
- transform_fromhost_VkPipelineViewportStateCreateInfo(resourceTracker, (VkPipelineViewportStateCreateInfo*)(toTransform->pViewportState));
+ if (toTransform->pViewportState) {
+ transform_fromhost_VkPipelineViewportStateCreateInfo(
+ resourceTracker, (VkPipelineViewportStateCreateInfo*)(toTransform->pViewportState));
}
- if (toTransform->pRasterizationState)
- {
- transform_fromhost_VkPipelineRasterizationStateCreateInfo(resourceTracker, (VkPipelineRasterizationStateCreateInfo*)(toTransform->pRasterizationState));
+ if (toTransform->pRasterizationState) {
+ transform_fromhost_VkPipelineRasterizationStateCreateInfo(
+ resourceTracker,
+ (VkPipelineRasterizationStateCreateInfo*)(toTransform->pRasterizationState));
}
- if (toTransform->pMultisampleState)
- {
- transform_fromhost_VkPipelineMultisampleStateCreateInfo(resourceTracker, (VkPipelineMultisampleStateCreateInfo*)(toTransform->pMultisampleState));
+ if (toTransform->pMultisampleState) {
+ transform_fromhost_VkPipelineMultisampleStateCreateInfo(
+ resourceTracker,
+ (VkPipelineMultisampleStateCreateInfo*)(toTransform->pMultisampleState));
}
- if (toTransform->pDepthStencilState)
- {
- transform_fromhost_VkPipelineDepthStencilStateCreateInfo(resourceTracker, (VkPipelineDepthStencilStateCreateInfo*)(toTransform->pDepthStencilState));
+ if (toTransform->pDepthStencilState) {
+ transform_fromhost_VkPipelineDepthStencilStateCreateInfo(
+ resourceTracker,
+ (VkPipelineDepthStencilStateCreateInfo*)(toTransform->pDepthStencilState));
}
- if (toTransform->pColorBlendState)
- {
- transform_fromhost_VkPipelineColorBlendStateCreateInfo(resourceTracker, (VkPipelineColorBlendStateCreateInfo*)(toTransform->pColorBlendState));
+ if (toTransform->pColorBlendState) {
+ transform_fromhost_VkPipelineColorBlendStateCreateInfo(
+ resourceTracker, (VkPipelineColorBlendStateCreateInfo*)(toTransform->pColorBlendState));
}
- if (toTransform->pDynamicState)
- {
- transform_fromhost_VkPipelineDynamicStateCreateInfo(resourceTracker, (VkPipelineDynamicStateCreateInfo*)(toTransform->pDynamicState));
+ if (toTransform->pDynamicState) {
+ transform_fromhost_VkPipelineDynamicStateCreateInfo(
+ resourceTracker, (VkPipelineDynamicStateCreateInfo*)(toTransform->pDynamicState));
}
}
-void transform_tohost_VkPushConstantRange(
- ResourceTracker* resourceTracker,
- VkPushConstantRange* toTransform)
-{
+void transform_tohost_VkPushConstantRange(ResourceTracker* resourceTracker,
+ VkPushConstantRange* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkPushConstantRange(
- ResourceTracker* resourceTracker,
- VkPushConstantRange* toTransform)
-{
+void transform_fromhost_VkPushConstantRange(ResourceTracker* resourceTracker,
+ VkPushConstantRange* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkPipelineLayoutCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineLayoutCreateInfo* toTransform)
-{
+void transform_tohost_VkPipelineLayoutCreateInfo(ResourceTracker* resourceTracker,
+ VkPipelineLayoutCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pPushConstantRanges)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->pushConstantRangeCount; ++i)
- {
- transform_tohost_VkPushConstantRange(resourceTracker, (VkPushConstantRange*)(toTransform->pPushConstantRanges + i));
+ if (toTransform) {
+ if (toTransform->pPushConstantRanges) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->pushConstantRangeCount; ++i) {
+ transform_tohost_VkPushConstantRange(
+ resourceTracker, (VkPushConstantRange*)(toTransform->pPushConstantRanges + i));
}
}
}
}
-void transform_fromhost_VkPipelineLayoutCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineLayoutCreateInfo* toTransform)
-{
+void transform_fromhost_VkPipelineLayoutCreateInfo(ResourceTracker* resourceTracker,
+ VkPipelineLayoutCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pPushConstantRanges)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->pushConstantRangeCount; ++i)
- {
- transform_fromhost_VkPushConstantRange(resourceTracker, (VkPushConstantRange*)(toTransform->pPushConstantRanges + i));
+ if (toTransform) {
+ if (toTransform->pPushConstantRanges) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->pushConstantRangeCount; ++i) {
+ transform_fromhost_VkPushConstantRange(
+ resourceTracker, (VkPushConstantRange*)(toTransform->pPushConstantRanges + i));
}
}
}
}
-void transform_tohost_VkSamplerCreateInfo(
- ResourceTracker* resourceTracker,
- VkSamplerCreateInfo* toTransform)
-{
+void transform_tohost_VkSamplerCreateInfo(ResourceTracker* resourceTracker,
+ VkSamplerCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkSamplerCreateInfo(
- ResourceTracker* resourceTracker,
- VkSamplerCreateInfo* toTransform)
-{
+void transform_fromhost_VkSamplerCreateInfo(ResourceTracker* resourceTracker,
+ VkSamplerCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkCopyDescriptorSet(
- ResourceTracker* resourceTracker,
- VkCopyDescriptorSet* toTransform)
-{
+void transform_tohost_VkCopyDescriptorSet(ResourceTracker* resourceTracker,
+ VkCopyDescriptorSet* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkCopyDescriptorSet(
- ResourceTracker* resourceTracker,
- VkCopyDescriptorSet* toTransform)
-{
+void transform_fromhost_VkCopyDescriptorSet(ResourceTracker* resourceTracker,
+ VkCopyDescriptorSet* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkDescriptorBufferInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorBufferInfo* toTransform)
-{
+void transform_tohost_VkDescriptorBufferInfo(ResourceTracker* resourceTracker,
+ VkDescriptorBufferInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkDescriptorBufferInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorBufferInfo* toTransform)
-{
+void transform_fromhost_VkDescriptorBufferInfo(ResourceTracker* resourceTracker,
+ VkDescriptorBufferInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkDescriptorImageInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorImageInfo* toTransform)
-{
+void transform_tohost_VkDescriptorImageInfo(ResourceTracker* resourceTracker,
+ VkDescriptorImageInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkDescriptorImageInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorImageInfo* toTransform)
-{
+void transform_fromhost_VkDescriptorImageInfo(ResourceTracker* resourceTracker,
+ VkDescriptorImageInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkDescriptorPoolSize(
- ResourceTracker* resourceTracker,
- VkDescriptorPoolSize* toTransform)
-{
+void transform_tohost_VkDescriptorPoolSize(ResourceTracker* resourceTracker,
+ VkDescriptorPoolSize* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkDescriptorPoolSize(
- ResourceTracker* resourceTracker,
- VkDescriptorPoolSize* toTransform)
-{
+void transform_fromhost_VkDescriptorPoolSize(ResourceTracker* resourceTracker,
+ VkDescriptorPoolSize* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkDescriptorPoolCreateInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorPoolCreateInfo* toTransform)
-{
+void transform_tohost_VkDescriptorPoolCreateInfo(ResourceTracker* resourceTracker,
+ VkDescriptorPoolCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pPoolSizes)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->poolSizeCount; ++i)
- {
- transform_tohost_VkDescriptorPoolSize(resourceTracker, (VkDescriptorPoolSize*)(toTransform->pPoolSizes + i));
+ if (toTransform) {
+ if (toTransform->pPoolSizes) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->poolSizeCount; ++i) {
+ transform_tohost_VkDescriptorPoolSize(
+ resourceTracker, (VkDescriptorPoolSize*)(toTransform->pPoolSizes + i));
}
}
}
}
-void transform_fromhost_VkDescriptorPoolCreateInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorPoolCreateInfo* toTransform)
-{
+void transform_fromhost_VkDescriptorPoolCreateInfo(ResourceTracker* resourceTracker,
+ VkDescriptorPoolCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pPoolSizes)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->poolSizeCount; ++i)
- {
- transform_fromhost_VkDescriptorPoolSize(resourceTracker, (VkDescriptorPoolSize*)(toTransform->pPoolSizes + i));
+ if (toTransform) {
+ if (toTransform->pPoolSizes) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->poolSizeCount; ++i) {
+ transform_fromhost_VkDescriptorPoolSize(
+ resourceTracker, (VkDescriptorPoolSize*)(toTransform->pPoolSizes + i));
}
}
}
}
-void transform_tohost_VkDescriptorSetAllocateInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorSetAllocateInfo* toTransform)
-{
+void transform_tohost_VkDescriptorSetAllocateInfo(ResourceTracker* resourceTracker,
+ VkDescriptorSetAllocateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkDescriptorSetAllocateInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorSetAllocateInfo* toTransform)
-{
+void transform_fromhost_VkDescriptorSetAllocateInfo(ResourceTracker* resourceTracker,
+ VkDescriptorSetAllocateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkDescriptorSetLayoutBinding(
- ResourceTracker* resourceTracker,
- VkDescriptorSetLayoutBinding* toTransform)
-{
+void transform_tohost_VkDescriptorSetLayoutBinding(ResourceTracker* resourceTracker,
+ VkDescriptorSetLayoutBinding* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkDescriptorSetLayoutBinding(
- ResourceTracker* resourceTracker,
- VkDescriptorSetLayoutBinding* toTransform)
-{
+void transform_fromhost_VkDescriptorSetLayoutBinding(ResourceTracker* resourceTracker,
+ VkDescriptorSetLayoutBinding* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkDescriptorSetLayoutCreateInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorSetLayoutCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDescriptorSetLayoutCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pBindings)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->bindingCount; ++i)
- {
- transform_tohost_VkDescriptorSetLayoutBinding(resourceTracker, (VkDescriptorSetLayoutBinding*)(toTransform->pBindings + i));
+ if (toTransform) {
+ if (toTransform->pBindings) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->bindingCount; ++i) {
+ transform_tohost_VkDescriptorSetLayoutBinding(
+ resourceTracker, (VkDescriptorSetLayoutBinding*)(toTransform->pBindings + i));
}
}
}
}
void transform_fromhost_VkDescriptorSetLayoutCreateInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorSetLayoutCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDescriptorSetLayoutCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pBindings)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->bindingCount; ++i)
- {
- transform_fromhost_VkDescriptorSetLayoutBinding(resourceTracker, (VkDescriptorSetLayoutBinding*)(toTransform->pBindings + i));
+ if (toTransform) {
+ if (toTransform->pBindings) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->bindingCount; ++i) {
+ transform_fromhost_VkDescriptorSetLayoutBinding(
+ resourceTracker, (VkDescriptorSetLayoutBinding*)(toTransform->pBindings + i));
}
}
}
}
-void transform_tohost_VkWriteDescriptorSet(
- ResourceTracker* resourceTracker,
- VkWriteDescriptorSet* toTransform)
-{
+void transform_tohost_VkWriteDescriptorSet(ResourceTracker* resourceTracker,
+ VkWriteDescriptorSet* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pImageInfo)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->descriptorCount; ++i)
- {
- transform_tohost_VkDescriptorImageInfo(resourceTracker, (VkDescriptorImageInfo*)(toTransform->pImageInfo + i));
+ if (toTransform) {
+ if (toTransform->pImageInfo) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->descriptorCount; ++i) {
+ transform_tohost_VkDescriptorImageInfo(
+ resourceTracker, (VkDescriptorImageInfo*)(toTransform->pImageInfo + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pBufferInfo)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->descriptorCount; ++i)
- {
- transform_tohost_VkDescriptorBufferInfo(resourceTracker, (VkDescriptorBufferInfo*)(toTransform->pBufferInfo + i));
+ if (toTransform) {
+ if (toTransform->pBufferInfo) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->descriptorCount; ++i) {
+ transform_tohost_VkDescriptorBufferInfo(
+ resourceTracker, (VkDescriptorBufferInfo*)(toTransform->pBufferInfo + i));
}
}
}
}
-void transform_fromhost_VkWriteDescriptorSet(
- ResourceTracker* resourceTracker,
- VkWriteDescriptorSet* toTransform)
-{
+void transform_fromhost_VkWriteDescriptorSet(ResourceTracker* resourceTracker,
+ VkWriteDescriptorSet* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pImageInfo)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->descriptorCount; ++i)
- {
- transform_fromhost_VkDescriptorImageInfo(resourceTracker, (VkDescriptorImageInfo*)(toTransform->pImageInfo + i));
+ if (toTransform) {
+ if (toTransform->pImageInfo) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->descriptorCount; ++i) {
+ transform_fromhost_VkDescriptorImageInfo(
+ resourceTracker, (VkDescriptorImageInfo*)(toTransform->pImageInfo + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pBufferInfo)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->descriptorCount; ++i)
- {
- transform_fromhost_VkDescriptorBufferInfo(resourceTracker, (VkDescriptorBufferInfo*)(toTransform->pBufferInfo + i));
+ if (toTransform) {
+ if (toTransform->pBufferInfo) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->descriptorCount; ++i) {
+ transform_fromhost_VkDescriptorBufferInfo(
+ resourceTracker, (VkDescriptorBufferInfo*)(toTransform->pBufferInfo + i));
}
}
}
}
-void transform_tohost_VkAttachmentDescription(
- ResourceTracker* resourceTracker,
- VkAttachmentDescription* toTransform)
-{
+void transform_tohost_VkAttachmentDescription(ResourceTracker* resourceTracker,
+ VkAttachmentDescription* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkAttachmentDescription(
- ResourceTracker* resourceTracker,
- VkAttachmentDescription* toTransform)
-{
+void transform_fromhost_VkAttachmentDescription(ResourceTracker* resourceTracker,
+ VkAttachmentDescription* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkAttachmentReference(
- ResourceTracker* resourceTracker,
- VkAttachmentReference* toTransform)
-{
+void transform_tohost_VkAttachmentReference(ResourceTracker* resourceTracker,
+ VkAttachmentReference* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkAttachmentReference(
- ResourceTracker* resourceTracker,
- VkAttachmentReference* toTransform)
-{
+void transform_fromhost_VkAttachmentReference(ResourceTracker* resourceTracker,
+ VkAttachmentReference* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkFramebufferCreateInfo(
- ResourceTracker* resourceTracker,
- VkFramebufferCreateInfo* toTransform)
-{
+void transform_tohost_VkFramebufferCreateInfo(ResourceTracker* resourceTracker,
+ VkFramebufferCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkFramebufferCreateInfo(
- ResourceTracker* resourceTracker,
- VkFramebufferCreateInfo* toTransform)
-{
+void transform_fromhost_VkFramebufferCreateInfo(ResourceTracker* resourceTracker,
+ VkFramebufferCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkSubpassDescription(
- ResourceTracker* resourceTracker,
- VkSubpassDescription* toTransform)
-{
+void transform_tohost_VkSubpassDescription(ResourceTracker* resourceTracker,
+ VkSubpassDescription* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform)
- {
- if (toTransform->pInputAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->inputAttachmentCount; ++i)
- {
- transform_tohost_VkAttachmentReference(resourceTracker, (VkAttachmentReference*)(toTransform->pInputAttachments + i));
+ if (toTransform) {
+ if (toTransform->pInputAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->inputAttachmentCount; ++i) {
+ transform_tohost_VkAttachmentReference(
+ resourceTracker, (VkAttachmentReference*)(toTransform->pInputAttachments + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pColorAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i)
- {
- transform_tohost_VkAttachmentReference(resourceTracker, (VkAttachmentReference*)(toTransform->pColorAttachments + i));
+ if (toTransform) {
+ if (toTransform->pColorAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i) {
+ transform_tohost_VkAttachmentReference(
+ resourceTracker, (VkAttachmentReference*)(toTransform->pColorAttachments + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pResolveAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i)
- {
- transform_tohost_VkAttachmentReference(resourceTracker, (VkAttachmentReference*)(toTransform->pResolveAttachments + i));
+ if (toTransform) {
+ if (toTransform->pResolveAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i) {
+ transform_tohost_VkAttachmentReference(
+ resourceTracker,
+ (VkAttachmentReference*)(toTransform->pResolveAttachments + i));
}
}
}
- if (toTransform->pDepthStencilAttachment)
- {
- transform_tohost_VkAttachmentReference(resourceTracker, (VkAttachmentReference*)(toTransform->pDepthStencilAttachment));
+ if (toTransform->pDepthStencilAttachment) {
+ transform_tohost_VkAttachmentReference(
+ resourceTracker, (VkAttachmentReference*)(toTransform->pDepthStencilAttachment));
}
}
-void transform_fromhost_VkSubpassDescription(
- ResourceTracker* resourceTracker,
- VkSubpassDescription* toTransform)
-{
+void transform_fromhost_VkSubpassDescription(ResourceTracker* resourceTracker,
+ VkSubpassDescription* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform)
- {
- if (toTransform->pInputAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->inputAttachmentCount; ++i)
- {
- transform_fromhost_VkAttachmentReference(resourceTracker, (VkAttachmentReference*)(toTransform->pInputAttachments + i));
+ if (toTransform) {
+ if (toTransform->pInputAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->inputAttachmentCount; ++i) {
+ transform_fromhost_VkAttachmentReference(
+ resourceTracker, (VkAttachmentReference*)(toTransform->pInputAttachments + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pColorAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i)
- {
- transform_fromhost_VkAttachmentReference(resourceTracker, (VkAttachmentReference*)(toTransform->pColorAttachments + i));
+ if (toTransform) {
+ if (toTransform->pColorAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i) {
+ transform_fromhost_VkAttachmentReference(
+ resourceTracker, (VkAttachmentReference*)(toTransform->pColorAttachments + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pResolveAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i)
- {
- transform_fromhost_VkAttachmentReference(resourceTracker, (VkAttachmentReference*)(toTransform->pResolveAttachments + i));
+ if (toTransform) {
+ if (toTransform->pResolveAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i) {
+ transform_fromhost_VkAttachmentReference(
+ resourceTracker,
+ (VkAttachmentReference*)(toTransform->pResolveAttachments + i));
}
}
}
- if (toTransform->pDepthStencilAttachment)
- {
- transform_fromhost_VkAttachmentReference(resourceTracker, (VkAttachmentReference*)(toTransform->pDepthStencilAttachment));
+ if (toTransform->pDepthStencilAttachment) {
+ transform_fromhost_VkAttachmentReference(
+ resourceTracker, (VkAttachmentReference*)(toTransform->pDepthStencilAttachment));
}
}
-void transform_tohost_VkSubpassDependency(
- ResourceTracker* resourceTracker,
- VkSubpassDependency* toTransform)
-{
+void transform_tohost_VkSubpassDependency(ResourceTracker* resourceTracker,
+ VkSubpassDependency* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkSubpassDependency(
- ResourceTracker* resourceTracker,
- VkSubpassDependency* toTransform)
-{
+void transform_fromhost_VkSubpassDependency(ResourceTracker* resourceTracker,
+ VkSubpassDependency* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkRenderPassCreateInfo(
- ResourceTracker* resourceTracker,
- VkRenderPassCreateInfo* toTransform)
-{
+void transform_tohost_VkRenderPassCreateInfo(ResourceTracker* resourceTracker,
+ VkRenderPassCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->attachmentCount; ++i)
- {
- transform_tohost_VkAttachmentDescription(resourceTracker, (VkAttachmentDescription*)(toTransform->pAttachments + i));
+ if (toTransform) {
+ if (toTransform->pAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->attachmentCount; ++i) {
+ transform_tohost_VkAttachmentDescription(
+ resourceTracker, (VkAttachmentDescription*)(toTransform->pAttachments + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pSubpasses)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->subpassCount; ++i)
- {
- transform_tohost_VkSubpassDescription(resourceTracker, (VkSubpassDescription*)(toTransform->pSubpasses + i));
+ if (toTransform) {
+ if (toTransform->pSubpasses) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->subpassCount; ++i) {
+ transform_tohost_VkSubpassDescription(
+ resourceTracker, (VkSubpassDescription*)(toTransform->pSubpasses + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pDependencies)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->dependencyCount; ++i)
- {
- transform_tohost_VkSubpassDependency(resourceTracker, (VkSubpassDependency*)(toTransform->pDependencies + i));
+ if (toTransform) {
+ if (toTransform->pDependencies) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->dependencyCount; ++i) {
+ transform_tohost_VkSubpassDependency(
+ resourceTracker, (VkSubpassDependency*)(toTransform->pDependencies + i));
}
}
}
}
-void transform_fromhost_VkRenderPassCreateInfo(
- ResourceTracker* resourceTracker,
- VkRenderPassCreateInfo* toTransform)
-{
+void transform_fromhost_VkRenderPassCreateInfo(ResourceTracker* resourceTracker,
+ VkRenderPassCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->attachmentCount; ++i)
- {
- transform_fromhost_VkAttachmentDescription(resourceTracker, (VkAttachmentDescription*)(toTransform->pAttachments + i));
+ if (toTransform) {
+ if (toTransform->pAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->attachmentCount; ++i) {
+ transform_fromhost_VkAttachmentDescription(
+ resourceTracker, (VkAttachmentDescription*)(toTransform->pAttachments + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pSubpasses)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->subpassCount; ++i)
- {
- transform_fromhost_VkSubpassDescription(resourceTracker, (VkSubpassDescription*)(toTransform->pSubpasses + i));
+ if (toTransform) {
+ if (toTransform->pSubpasses) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->subpassCount; ++i) {
+ transform_fromhost_VkSubpassDescription(
+ resourceTracker, (VkSubpassDescription*)(toTransform->pSubpasses + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pDependencies)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->dependencyCount; ++i)
- {
- transform_fromhost_VkSubpassDependency(resourceTracker, (VkSubpassDependency*)(toTransform->pDependencies + i));
+ if (toTransform) {
+ if (toTransform->pDependencies) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->dependencyCount; ++i) {
+ transform_fromhost_VkSubpassDependency(
+ resourceTracker, (VkSubpassDependency*)(toTransform->pDependencies + i));
}
}
}
}
-void transform_tohost_VkCommandPoolCreateInfo(
- ResourceTracker* resourceTracker,
- VkCommandPoolCreateInfo* toTransform)
-{
+void transform_tohost_VkCommandPoolCreateInfo(ResourceTracker* resourceTracker,
+ VkCommandPoolCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkCommandPoolCreateInfo(
- ResourceTracker* resourceTracker,
- VkCommandPoolCreateInfo* toTransform)
-{
+void transform_fromhost_VkCommandPoolCreateInfo(ResourceTracker* resourceTracker,
+ VkCommandPoolCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkCommandBufferAllocateInfo(
- ResourceTracker* resourceTracker,
- VkCommandBufferAllocateInfo* toTransform)
-{
+void transform_tohost_VkCommandBufferAllocateInfo(ResourceTracker* resourceTracker,
+ VkCommandBufferAllocateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkCommandBufferAllocateInfo(
- ResourceTracker* resourceTracker,
- VkCommandBufferAllocateInfo* toTransform)
-{
+void transform_fromhost_VkCommandBufferAllocateInfo(ResourceTracker* resourceTracker,
+ VkCommandBufferAllocateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkCommandBufferInheritanceInfo(
- ResourceTracker* resourceTracker,
- VkCommandBufferInheritanceInfo* toTransform)
-{
+void transform_tohost_VkCommandBufferInheritanceInfo(ResourceTracker* resourceTracker,
+ VkCommandBufferInheritanceInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkCommandBufferInheritanceInfo(
- ResourceTracker* resourceTracker,
- VkCommandBufferInheritanceInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkCommandBufferInheritanceInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkCommandBufferBeginInfo(
- ResourceTracker* resourceTracker,
- VkCommandBufferBeginInfo* toTransform)
-{
+void transform_tohost_VkCommandBufferBeginInfo(ResourceTracker* resourceTracker,
+ VkCommandBufferBeginInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pInheritanceInfo)
- {
- transform_tohost_VkCommandBufferInheritanceInfo(resourceTracker, (VkCommandBufferInheritanceInfo*)(toTransform->pInheritanceInfo));
+ if (toTransform->pInheritanceInfo) {
+ transform_tohost_VkCommandBufferInheritanceInfo(
+ resourceTracker, (VkCommandBufferInheritanceInfo*)(toTransform->pInheritanceInfo));
}
}
-void transform_fromhost_VkCommandBufferBeginInfo(
- ResourceTracker* resourceTracker,
- VkCommandBufferBeginInfo* toTransform)
-{
+void transform_fromhost_VkCommandBufferBeginInfo(ResourceTracker* resourceTracker,
+ VkCommandBufferBeginInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pInheritanceInfo)
- {
- transform_fromhost_VkCommandBufferInheritanceInfo(resourceTracker, (VkCommandBufferInheritanceInfo*)(toTransform->pInheritanceInfo));
+ if (toTransform->pInheritanceInfo) {
+ transform_fromhost_VkCommandBufferInheritanceInfo(
+ resourceTracker, (VkCommandBufferInheritanceInfo*)(toTransform->pInheritanceInfo));
}
}
-void transform_tohost_VkBufferCopy(
- ResourceTracker* resourceTracker,
- VkBufferCopy* toTransform)
-{
+void transform_tohost_VkBufferCopy(ResourceTracker* resourceTracker, VkBufferCopy* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkBufferCopy(
- ResourceTracker* resourceTracker,
- VkBufferCopy* toTransform)
-{
+void transform_fromhost_VkBufferCopy(ResourceTracker* resourceTracker, VkBufferCopy* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkImageSubresourceLayers(
- ResourceTracker* resourceTracker,
- VkImageSubresourceLayers* toTransform)
-{
+void transform_tohost_VkImageSubresourceLayers(ResourceTracker* resourceTracker,
+ VkImageSubresourceLayers* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkImageSubresourceLayers(
- ResourceTracker* resourceTracker,
- VkImageSubresourceLayers* toTransform)
-{
+void transform_fromhost_VkImageSubresourceLayers(ResourceTracker* resourceTracker,
+ VkImageSubresourceLayers* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkBufferImageCopy(
- ResourceTracker* resourceTracker,
- VkBufferImageCopy* toTransform)
-{
+void transform_tohost_VkBufferImageCopy(ResourceTracker* resourceTracker,
+ VkBufferImageCopy* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_tohost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
+ transform_tohost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
}
-void transform_fromhost_VkBufferImageCopy(
- ResourceTracker* resourceTracker,
- VkBufferImageCopy* toTransform)
-{
+void transform_fromhost_VkBufferImageCopy(ResourceTracker* resourceTracker,
+ VkBufferImageCopy* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_fromhost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
+ transform_fromhost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
}
-void transform_tohost_VkClearColorValue(
- ResourceTracker* resourceTracker,
- VkClearColorValue* toTransform)
-{
+void transform_tohost_VkClearColorValue(ResourceTracker* resourceTracker,
+ VkClearColorValue* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkClearColorValue(
- ResourceTracker* resourceTracker,
- VkClearColorValue* toTransform)
-{
+void transform_fromhost_VkClearColorValue(ResourceTracker* resourceTracker,
+ VkClearColorValue* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkClearDepthStencilValue(
- ResourceTracker* resourceTracker,
- VkClearDepthStencilValue* toTransform)
-{
+void transform_tohost_VkClearDepthStencilValue(ResourceTracker* resourceTracker,
+ VkClearDepthStencilValue* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkClearDepthStencilValue(
- ResourceTracker* resourceTracker,
- VkClearDepthStencilValue* toTransform)
-{
+void transform_fromhost_VkClearDepthStencilValue(ResourceTracker* resourceTracker,
+ VkClearDepthStencilValue* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkClearValue(
- ResourceTracker* resourceTracker,
- VkClearValue* toTransform)
-{
+void transform_tohost_VkClearValue(ResourceTracker* resourceTracker, VkClearValue* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_tohost_VkClearColorValue(resourceTracker, (VkClearColorValue*)(&toTransform->color));
- transform_tohost_VkClearDepthStencilValue(resourceTracker, (VkClearDepthStencilValue*)(&toTransform->depthStencil));
+ transform_tohost_VkClearDepthStencilValue(
+ resourceTracker, (VkClearDepthStencilValue*)(&toTransform->depthStencil));
}
-void transform_fromhost_VkClearValue(
- ResourceTracker* resourceTracker,
- VkClearValue* toTransform)
-{
+void transform_fromhost_VkClearValue(ResourceTracker* resourceTracker, VkClearValue* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_fromhost_VkClearColorValue(resourceTracker, (VkClearColorValue*)(&toTransform->color));
- transform_fromhost_VkClearDepthStencilValue(resourceTracker, (VkClearDepthStencilValue*)(&toTransform->depthStencil));
+ transform_fromhost_VkClearColorValue(resourceTracker,
+ (VkClearColorValue*)(&toTransform->color));
+ transform_fromhost_VkClearDepthStencilValue(
+ resourceTracker, (VkClearDepthStencilValue*)(&toTransform->depthStencil));
}
-void transform_tohost_VkClearAttachment(
- ResourceTracker* resourceTracker,
- VkClearAttachment* toTransform)
-{
+void transform_tohost_VkClearAttachment(ResourceTracker* resourceTracker,
+ VkClearAttachment* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_tohost_VkClearValue(resourceTracker, (VkClearValue*)(&toTransform->clearValue));
}
-void transform_fromhost_VkClearAttachment(
- ResourceTracker* resourceTracker,
- VkClearAttachment* toTransform)
-{
+void transform_fromhost_VkClearAttachment(ResourceTracker* resourceTracker,
+ VkClearAttachment* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_fromhost_VkClearValue(resourceTracker, (VkClearValue*)(&toTransform->clearValue));
}
-void transform_tohost_VkClearRect(
- ResourceTracker* resourceTracker,
- VkClearRect* toTransform)
-{
+void transform_tohost_VkClearRect(ResourceTracker* resourceTracker, VkClearRect* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_tohost_VkRect2D(resourceTracker, (VkRect2D*)(&toTransform->rect));
}
-void transform_fromhost_VkClearRect(
- ResourceTracker* resourceTracker,
- VkClearRect* toTransform)
-{
+void transform_fromhost_VkClearRect(ResourceTracker* resourceTracker, VkClearRect* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_fromhost_VkRect2D(resourceTracker, (VkRect2D*)(&toTransform->rect));
}
-void transform_tohost_VkImageBlit(
- ResourceTracker* resourceTracker,
- VkImageBlit* toTransform)
-{
+void transform_tohost_VkImageBlit(ResourceTracker* resourceTracker, VkImageBlit* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_tohost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ transform_tohost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(toTransform->srcOffsets + i));
}
- transform_tohost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ transform_tohost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(toTransform->dstOffsets + i));
}
}
-void transform_fromhost_VkImageBlit(
- ResourceTracker* resourceTracker,
- VkImageBlit* toTransform)
-{
+void transform_fromhost_VkImageBlit(ResourceTracker* resourceTracker, VkImageBlit* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_fromhost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ transform_fromhost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(toTransform->srcOffsets + i));
}
- transform_fromhost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ transform_fromhost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(toTransform->dstOffsets + i));
}
}
-void transform_tohost_VkImageCopy(
- ResourceTracker* resourceTracker,
- VkImageCopy* toTransform)
-{
+void transform_tohost_VkImageCopy(ResourceTracker* resourceTracker, VkImageCopy* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_tohost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
+ transform_tohost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->srcOffset));
- transform_tohost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
+ transform_tohost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->dstOffset));
transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->extent));
}
-void transform_fromhost_VkImageCopy(
- ResourceTracker* resourceTracker,
- VkImageCopy* toTransform)
-{
+void transform_fromhost_VkImageCopy(ResourceTracker* resourceTracker, VkImageCopy* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_fromhost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
+ transform_fromhost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->srcOffset));
- transform_fromhost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
+ transform_fromhost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->dstOffset));
transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->extent));
}
-void transform_tohost_VkImageResolve(
- ResourceTracker* resourceTracker,
- VkImageResolve* toTransform)
-{
+void transform_tohost_VkImageResolve(ResourceTracker* resourceTracker,
+ VkImageResolve* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_tohost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
+ transform_tohost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->srcOffset));
- transform_tohost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
+ transform_tohost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->dstOffset));
transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->extent));
}
-void transform_fromhost_VkImageResolve(
- ResourceTracker* resourceTracker,
- VkImageResolve* toTransform)
-{
+void transform_fromhost_VkImageResolve(ResourceTracker* resourceTracker,
+ VkImageResolve* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_fromhost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
+ transform_fromhost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->srcOffset));
- transform_fromhost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
+ transform_fromhost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->dstOffset));
transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->extent));
}
-void transform_tohost_VkRenderPassBeginInfo(
- ResourceTracker* resourceTracker,
- VkRenderPassBeginInfo* toTransform)
-{
+void transform_tohost_VkRenderPassBeginInfo(ResourceTracker* resourceTracker,
+ VkRenderPassBeginInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_tohost_VkRect2D(resourceTracker, (VkRect2D*)(&toTransform->renderArea));
- if (toTransform)
- {
- if (toTransform->pClearValues)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->clearValueCount; ++i)
- {
- transform_tohost_VkClearValue(resourceTracker, (VkClearValue*)(toTransform->pClearValues + i));
+ if (toTransform) {
+ if (toTransform->pClearValues) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->clearValueCount; ++i) {
+ transform_tohost_VkClearValue(resourceTracker,
+ (VkClearValue*)(toTransform->pClearValues + i));
}
}
}
}
-void transform_fromhost_VkRenderPassBeginInfo(
- ResourceTracker* resourceTracker,
- VkRenderPassBeginInfo* toTransform)
-{
+void transform_fromhost_VkRenderPassBeginInfo(ResourceTracker* resourceTracker,
+ VkRenderPassBeginInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_fromhost_VkRect2D(resourceTracker, (VkRect2D*)(&toTransform->renderArea));
- if (toTransform)
- {
- if (toTransform->pClearValues)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->clearValueCount; ++i)
- {
- transform_fromhost_VkClearValue(resourceTracker, (VkClearValue*)(toTransform->pClearValues + i));
+ if (toTransform) {
+ if (toTransform->pClearValues) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->clearValueCount; ++i) {
+ transform_fromhost_VkClearValue(resourceTracker,
+ (VkClearValue*)(toTransform->pClearValues + i));
}
}
}
@@ -2950,1721 +2360,1345 @@
#endif
#ifdef VK_VERSION_1_1
void transform_tohost_VkPhysicalDeviceSubgroupProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSubgroupProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSubgroupProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceSubgroupProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSubgroupProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSubgroupProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkBindBufferMemoryInfo(
- ResourceTracker* resourceTracker,
- VkBindBufferMemoryInfo* toTransform)
-{
+void transform_tohost_VkBindBufferMemoryInfo(ResourceTracker* resourceTracker,
+ VkBindBufferMemoryInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->memoryOffset, 1, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->memoryOffset, 1,
+ (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkBindBufferMemoryInfo(
- ResourceTracker* resourceTracker,
- VkBindBufferMemoryInfo* toTransform)
-{
+void transform_fromhost_VkBindBufferMemoryInfo(ResourceTracker* resourceTracker,
+ VkBindBufferMemoryInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_fromhost((VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->memoryOffset, 1, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_fromhost(
+ (VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->memoryOffset, 1,
+ (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkBindImageMemoryInfo(
- ResourceTracker* resourceTracker,
- VkBindImageMemoryInfo* toTransform)
-{
+void transform_tohost_VkBindImageMemoryInfo(ResourceTracker* resourceTracker,
+ VkBindImageMemoryInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->memoryOffset, 1, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->memoryOffset, 1,
+ (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkBindImageMemoryInfo(
- ResourceTracker* resourceTracker,
- VkBindImageMemoryInfo* toTransform)
-{
+void transform_fromhost_VkBindImageMemoryInfo(ResourceTracker* resourceTracker,
+ VkBindImageMemoryInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_fromhost((VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->memoryOffset, 1, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_fromhost(
+ (VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->memoryOffset, 1,
+ (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDevice16BitStorageFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDevice16BitStorageFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevice16BitStorageFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDevice16BitStorageFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDevice16BitStorageFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevice16BitStorageFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkMemoryDedicatedRequirements(
- ResourceTracker* resourceTracker,
- VkMemoryDedicatedRequirements* toTransform)
-{
+void transform_tohost_VkMemoryDedicatedRequirements(ResourceTracker* resourceTracker,
+ VkMemoryDedicatedRequirements* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkMemoryDedicatedRequirements(
- ResourceTracker* resourceTracker,
- VkMemoryDedicatedRequirements* toTransform)
-{
+void transform_fromhost_VkMemoryDedicatedRequirements(ResourceTracker* resourceTracker,
+ VkMemoryDedicatedRequirements* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkMemoryDedicatedAllocateInfo(
- ResourceTracker* resourceTracker,
- VkMemoryDedicatedAllocateInfo* toTransform)
-{
+void transform_tohost_VkMemoryDedicatedAllocateInfo(ResourceTracker* resourceTracker,
+ VkMemoryDedicatedAllocateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkMemoryDedicatedAllocateInfo(
- ResourceTracker* resourceTracker,
- VkMemoryDedicatedAllocateInfo* toTransform)
-{
+void transform_fromhost_VkMemoryDedicatedAllocateInfo(ResourceTracker* resourceTracker,
+ VkMemoryDedicatedAllocateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkMemoryAllocateFlagsInfo(
- ResourceTracker* resourceTracker,
- VkMemoryAllocateFlagsInfo* toTransform)
-{
+void transform_tohost_VkMemoryAllocateFlagsInfo(ResourceTracker* resourceTracker,
+ VkMemoryAllocateFlagsInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkMemoryAllocateFlagsInfo(
- ResourceTracker* resourceTracker,
- VkMemoryAllocateFlagsInfo* toTransform)
-{
+void transform_fromhost_VkMemoryAllocateFlagsInfo(ResourceTracker* resourceTracker,
+ VkMemoryAllocateFlagsInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkDeviceGroupRenderPassBeginInfo(
- ResourceTracker* resourceTracker,
- VkDeviceGroupRenderPassBeginInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceGroupRenderPassBeginInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pDeviceRenderAreas)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->deviceRenderAreaCount; ++i)
- {
- transform_tohost_VkRect2D(resourceTracker, (VkRect2D*)(toTransform->pDeviceRenderAreas + i));
+ if (toTransform) {
+ if (toTransform->pDeviceRenderAreas) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->deviceRenderAreaCount; ++i) {
+ transform_tohost_VkRect2D(resourceTracker,
+ (VkRect2D*)(toTransform->pDeviceRenderAreas + i));
}
}
}
}
void transform_fromhost_VkDeviceGroupRenderPassBeginInfo(
- ResourceTracker* resourceTracker,
- VkDeviceGroupRenderPassBeginInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceGroupRenderPassBeginInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pDeviceRenderAreas)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->deviceRenderAreaCount; ++i)
- {
- transform_fromhost_VkRect2D(resourceTracker, (VkRect2D*)(toTransform->pDeviceRenderAreas + i));
+ if (toTransform) {
+ if (toTransform->pDeviceRenderAreas) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->deviceRenderAreaCount; ++i) {
+ transform_fromhost_VkRect2D(resourceTracker,
+ (VkRect2D*)(toTransform->pDeviceRenderAreas + i));
}
}
}
}
void transform_tohost_VkDeviceGroupCommandBufferBeginInfo(
- ResourceTracker* resourceTracker,
- VkDeviceGroupCommandBufferBeginInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceGroupCommandBufferBeginInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDeviceGroupCommandBufferBeginInfo(
- ResourceTracker* resourceTracker,
- VkDeviceGroupCommandBufferBeginInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceGroupCommandBufferBeginInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkDeviceGroupSubmitInfo(
- ResourceTracker* resourceTracker,
- VkDeviceGroupSubmitInfo* toTransform)
-{
+void transform_tohost_VkDeviceGroupSubmitInfo(ResourceTracker* resourceTracker,
+ VkDeviceGroupSubmitInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkDeviceGroupSubmitInfo(
- ResourceTracker* resourceTracker,
- VkDeviceGroupSubmitInfo* toTransform)
-{
+void transform_fromhost_VkDeviceGroupSubmitInfo(ResourceTracker* resourceTracker,
+ VkDeviceGroupSubmitInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkDeviceGroupBindSparseInfo(
- ResourceTracker* resourceTracker,
- VkDeviceGroupBindSparseInfo* toTransform)
-{
+void transform_tohost_VkDeviceGroupBindSparseInfo(ResourceTracker* resourceTracker,
+ VkDeviceGroupBindSparseInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkDeviceGroupBindSparseInfo(
- ResourceTracker* resourceTracker,
- VkDeviceGroupBindSparseInfo* toTransform)
-{
+void transform_fromhost_VkDeviceGroupBindSparseInfo(ResourceTracker* resourceTracker,
+ VkDeviceGroupBindSparseInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkBindBufferMemoryDeviceGroupInfo(
- ResourceTracker* resourceTracker,
- VkBindBufferMemoryDeviceGroupInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBindBufferMemoryDeviceGroupInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkBindBufferMemoryDeviceGroupInfo(
- ResourceTracker* resourceTracker,
- VkBindBufferMemoryDeviceGroupInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBindBufferMemoryDeviceGroupInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkBindImageMemoryDeviceGroupInfo(
- ResourceTracker* resourceTracker,
- VkBindImageMemoryDeviceGroupInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBindImageMemoryDeviceGroupInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pSplitInstanceBindRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->splitInstanceBindRegionCount; ++i)
- {
- transform_tohost_VkRect2D(resourceTracker, (VkRect2D*)(toTransform->pSplitInstanceBindRegions + i));
+ if (toTransform) {
+ if (toTransform->pSplitInstanceBindRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->splitInstanceBindRegionCount; ++i) {
+ transform_tohost_VkRect2D(resourceTracker,
+ (VkRect2D*)(toTransform->pSplitInstanceBindRegions + i));
}
}
}
}
void transform_fromhost_VkBindImageMemoryDeviceGroupInfo(
- ResourceTracker* resourceTracker,
- VkBindImageMemoryDeviceGroupInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBindImageMemoryDeviceGroupInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pSplitInstanceBindRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->splitInstanceBindRegionCount; ++i)
- {
- transform_fromhost_VkRect2D(resourceTracker, (VkRect2D*)(toTransform->pSplitInstanceBindRegions + i));
+ if (toTransform) {
+ if (toTransform->pSplitInstanceBindRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->splitInstanceBindRegionCount; ++i) {
+ transform_fromhost_VkRect2D(
+ resourceTracker, (VkRect2D*)(toTransform->pSplitInstanceBindRegions + i));
}
}
}
}
void transform_tohost_VkPhysicalDeviceGroupProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceGroupProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceGroupProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceGroupProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceGroupProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceGroupProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkDeviceGroupDeviceCreateInfo(
- ResourceTracker* resourceTracker,
- VkDeviceGroupDeviceCreateInfo* toTransform)
-{
+void transform_tohost_VkDeviceGroupDeviceCreateInfo(ResourceTracker* resourceTracker,
+ VkDeviceGroupDeviceCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkDeviceGroupDeviceCreateInfo(
- ResourceTracker* resourceTracker,
- VkDeviceGroupDeviceCreateInfo* toTransform)
-{
+void transform_fromhost_VkDeviceGroupDeviceCreateInfo(ResourceTracker* resourceTracker,
+ VkDeviceGroupDeviceCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkBufferMemoryRequirementsInfo2(
- ResourceTracker* resourceTracker,
- VkBufferMemoryRequirementsInfo2* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBufferMemoryRequirementsInfo2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkBufferMemoryRequirementsInfo2(
- ResourceTracker* resourceTracker,
- VkBufferMemoryRequirementsInfo2* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBufferMemoryRequirementsInfo2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkImageMemoryRequirementsInfo2(
- ResourceTracker* resourceTracker,
- VkImageMemoryRequirementsInfo2* toTransform)
-{
+void transform_tohost_VkImageMemoryRequirementsInfo2(ResourceTracker* resourceTracker,
+ VkImageMemoryRequirementsInfo2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkImageMemoryRequirementsInfo2(
- ResourceTracker* resourceTracker,
- VkImageMemoryRequirementsInfo2* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImageMemoryRequirementsInfo2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkImageSparseMemoryRequirementsInfo2(
- ResourceTracker* resourceTracker,
- VkImageSparseMemoryRequirementsInfo2* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImageSparseMemoryRequirementsInfo2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkImageSparseMemoryRequirementsInfo2(
- ResourceTracker* resourceTracker,
- VkImageSparseMemoryRequirementsInfo2* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImageSparseMemoryRequirementsInfo2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkMemoryRequirements2(
- ResourceTracker* resourceTracker,
- VkMemoryRequirements2* toTransform)
-{
+void transform_tohost_VkMemoryRequirements2(ResourceTracker* resourceTracker,
+ VkMemoryRequirements2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkMemoryRequirements(resourceTracker, (VkMemoryRequirements*)(&toTransform->memoryRequirements));
+ transform_tohost_VkMemoryRequirements(
+ resourceTracker, (VkMemoryRequirements*)(&toTransform->memoryRequirements));
}
-void transform_fromhost_VkMemoryRequirements2(
- ResourceTracker* resourceTracker,
- VkMemoryRequirements2* toTransform)
-{
+void transform_fromhost_VkMemoryRequirements2(ResourceTracker* resourceTracker,
+ VkMemoryRequirements2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkMemoryRequirements(resourceTracker, (VkMemoryRequirements*)(&toTransform->memoryRequirements));
+ transform_fromhost_VkMemoryRequirements(
+ resourceTracker, (VkMemoryRequirements*)(&toTransform->memoryRequirements));
}
void transform_tohost_VkSparseImageMemoryRequirements2(
- ResourceTracker* resourceTracker,
- VkSparseImageMemoryRequirements2* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSparseImageMemoryRequirements2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkSparseImageMemoryRequirements(resourceTracker, (VkSparseImageMemoryRequirements*)(&toTransform->memoryRequirements));
+ transform_tohost_VkSparseImageMemoryRequirements(
+ resourceTracker, (VkSparseImageMemoryRequirements*)(&toTransform->memoryRequirements));
}
void transform_fromhost_VkSparseImageMemoryRequirements2(
- ResourceTracker* resourceTracker,
- VkSparseImageMemoryRequirements2* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSparseImageMemoryRequirements2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkSparseImageMemoryRequirements(resourceTracker, (VkSparseImageMemoryRequirements*)(&toTransform->memoryRequirements));
+ transform_fromhost_VkSparseImageMemoryRequirements(
+ resourceTracker, (VkSparseImageMemoryRequirements*)(&toTransform->memoryRequirements));
}
-void transform_tohost_VkPhysicalDeviceFeatures2(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFeatures2* toTransform)
-{
+void transform_tohost_VkPhysicalDeviceFeatures2(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceFeatures2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkPhysicalDeviceFeatures(resourceTracker, (VkPhysicalDeviceFeatures*)(&toTransform->features));
+ transform_tohost_VkPhysicalDeviceFeatures(resourceTracker,
+ (VkPhysicalDeviceFeatures*)(&toTransform->features));
}
-void transform_fromhost_VkPhysicalDeviceFeatures2(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFeatures2* toTransform)
-{
+void transform_fromhost_VkPhysicalDeviceFeatures2(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceFeatures2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkPhysicalDeviceFeatures(resourceTracker, (VkPhysicalDeviceFeatures*)(&toTransform->features));
+ transform_fromhost_VkPhysicalDeviceFeatures(
+ resourceTracker, (VkPhysicalDeviceFeatures*)(&toTransform->features));
}
-void transform_tohost_VkPhysicalDeviceProperties2(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProperties2* toTransform)
-{
+void transform_tohost_VkPhysicalDeviceProperties2(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceProperties2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkPhysicalDeviceProperties(resourceTracker, (VkPhysicalDeviceProperties*)(&toTransform->properties));
+ transform_tohost_VkPhysicalDeviceProperties(
+ resourceTracker, (VkPhysicalDeviceProperties*)(&toTransform->properties));
}
-void transform_fromhost_VkPhysicalDeviceProperties2(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProperties2* toTransform)
-{
+void transform_fromhost_VkPhysicalDeviceProperties2(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceProperties2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkPhysicalDeviceProperties(resourceTracker, (VkPhysicalDeviceProperties*)(&toTransform->properties));
+ transform_fromhost_VkPhysicalDeviceProperties(
+ resourceTracker, (VkPhysicalDeviceProperties*)(&toTransform->properties));
}
-void transform_tohost_VkFormatProperties2(
- ResourceTracker* resourceTracker,
- VkFormatProperties2* toTransform)
-{
+void transform_tohost_VkFormatProperties2(ResourceTracker* resourceTracker,
+ VkFormatProperties2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkFormatProperties(resourceTracker, (VkFormatProperties*)(&toTransform->formatProperties));
+ transform_tohost_VkFormatProperties(resourceTracker,
+ (VkFormatProperties*)(&toTransform->formatProperties));
}
-void transform_fromhost_VkFormatProperties2(
- ResourceTracker* resourceTracker,
- VkFormatProperties2* toTransform)
-{
+void transform_fromhost_VkFormatProperties2(ResourceTracker* resourceTracker,
+ VkFormatProperties2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkFormatProperties(resourceTracker, (VkFormatProperties*)(&toTransform->formatProperties));
+ transform_fromhost_VkFormatProperties(resourceTracker,
+ (VkFormatProperties*)(&toTransform->formatProperties));
}
-void transform_tohost_VkImageFormatProperties2(
- ResourceTracker* resourceTracker,
- VkImageFormatProperties2* toTransform)
-{
+void transform_tohost_VkImageFormatProperties2(ResourceTracker* resourceTracker,
+ VkImageFormatProperties2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkImageFormatProperties(resourceTracker, (VkImageFormatProperties*)(&toTransform->imageFormatProperties));
+ transform_tohost_VkImageFormatProperties(
+ resourceTracker, (VkImageFormatProperties*)(&toTransform->imageFormatProperties));
}
-void transform_fromhost_VkImageFormatProperties2(
- ResourceTracker* resourceTracker,
- VkImageFormatProperties2* toTransform)
-{
+void transform_fromhost_VkImageFormatProperties2(ResourceTracker* resourceTracker,
+ VkImageFormatProperties2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkImageFormatProperties(resourceTracker, (VkImageFormatProperties*)(&toTransform->imageFormatProperties));
+ transform_fromhost_VkImageFormatProperties(
+ resourceTracker, (VkImageFormatProperties*)(&toTransform->imageFormatProperties));
}
void transform_tohost_VkPhysicalDeviceImageFormatInfo2(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceImageFormatInfo2* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceImageFormatInfo2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceImageFormatInfo2(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceImageFormatInfo2* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceImageFormatInfo2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkQueueFamilyProperties2(
- ResourceTracker* resourceTracker,
- VkQueueFamilyProperties2* toTransform)
-{
+void transform_tohost_VkQueueFamilyProperties2(ResourceTracker* resourceTracker,
+ VkQueueFamilyProperties2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkQueueFamilyProperties(resourceTracker, (VkQueueFamilyProperties*)(&toTransform->queueFamilyProperties));
+ transform_tohost_VkQueueFamilyProperties(
+ resourceTracker, (VkQueueFamilyProperties*)(&toTransform->queueFamilyProperties));
}
-void transform_fromhost_VkQueueFamilyProperties2(
- ResourceTracker* resourceTracker,
- VkQueueFamilyProperties2* toTransform)
-{
+void transform_fromhost_VkQueueFamilyProperties2(ResourceTracker* resourceTracker,
+ VkQueueFamilyProperties2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkQueueFamilyProperties(resourceTracker, (VkQueueFamilyProperties*)(&toTransform->queueFamilyProperties));
+ transform_fromhost_VkQueueFamilyProperties(
+ resourceTracker, (VkQueueFamilyProperties*)(&toTransform->queueFamilyProperties));
}
void transform_tohost_VkPhysicalDeviceMemoryProperties2(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMemoryProperties2* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMemoryProperties2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkPhysicalDeviceMemoryProperties(resourceTracker, (VkPhysicalDeviceMemoryProperties*)(&toTransform->memoryProperties));
+ transform_tohost_VkPhysicalDeviceMemoryProperties(
+ resourceTracker, (VkPhysicalDeviceMemoryProperties*)(&toTransform->memoryProperties));
}
void transform_fromhost_VkPhysicalDeviceMemoryProperties2(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMemoryProperties2* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMemoryProperties2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkPhysicalDeviceMemoryProperties(resourceTracker, (VkPhysicalDeviceMemoryProperties*)(&toTransform->memoryProperties));
+ transform_fromhost_VkPhysicalDeviceMemoryProperties(
+ resourceTracker, (VkPhysicalDeviceMemoryProperties*)(&toTransform->memoryProperties));
}
-void transform_tohost_VkSparseImageFormatProperties2(
- ResourceTracker* resourceTracker,
- VkSparseImageFormatProperties2* toTransform)
-{
+void transform_tohost_VkSparseImageFormatProperties2(ResourceTracker* resourceTracker,
+ VkSparseImageFormatProperties2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkSparseImageFormatProperties(resourceTracker, (VkSparseImageFormatProperties*)(&toTransform->properties));
+ transform_tohost_VkSparseImageFormatProperties(
+ resourceTracker, (VkSparseImageFormatProperties*)(&toTransform->properties));
}
void transform_fromhost_VkSparseImageFormatProperties2(
- ResourceTracker* resourceTracker,
- VkSparseImageFormatProperties2* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSparseImageFormatProperties2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkSparseImageFormatProperties(resourceTracker, (VkSparseImageFormatProperties*)(&toTransform->properties));
+ transform_fromhost_VkSparseImageFormatProperties(
+ resourceTracker, (VkSparseImageFormatProperties*)(&toTransform->properties));
}
void transform_tohost_VkPhysicalDeviceSparseImageFormatInfo2(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSparseImageFormatInfo2* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSparseImageFormatInfo2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceSparseImageFormatInfo2(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSparseImageFormatInfo2* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSparseImageFormatInfo2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDevicePointClippingProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePointClippingProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevicePointClippingProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDevicePointClippingProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePointClippingProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevicePointClippingProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkInputAttachmentAspectReference(
- ResourceTracker* resourceTracker,
- VkInputAttachmentAspectReference* toTransform)
-{
+ ResourceTracker* resourceTracker, VkInputAttachmentAspectReference* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_fromhost_VkInputAttachmentAspectReference(
- ResourceTracker* resourceTracker,
- VkInputAttachmentAspectReference* toTransform)
-{
+ ResourceTracker* resourceTracker, VkInputAttachmentAspectReference* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkRenderPassInputAttachmentAspectCreateInfo(
- ResourceTracker* resourceTracker,
- VkRenderPassInputAttachmentAspectCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRenderPassInputAttachmentAspectCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pAspectReferences)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->aspectReferenceCount; ++i)
- {
- transform_tohost_VkInputAttachmentAspectReference(resourceTracker, (VkInputAttachmentAspectReference*)(toTransform->pAspectReferences + i));
+ if (toTransform) {
+ if (toTransform->pAspectReferences) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->aspectReferenceCount; ++i) {
+ transform_tohost_VkInputAttachmentAspectReference(
+ resourceTracker,
+ (VkInputAttachmentAspectReference*)(toTransform->pAspectReferences + i));
}
}
}
}
void transform_fromhost_VkRenderPassInputAttachmentAspectCreateInfo(
- ResourceTracker* resourceTracker,
- VkRenderPassInputAttachmentAspectCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRenderPassInputAttachmentAspectCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pAspectReferences)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->aspectReferenceCount; ++i)
- {
- transform_fromhost_VkInputAttachmentAspectReference(resourceTracker, (VkInputAttachmentAspectReference*)(toTransform->pAspectReferences + i));
+ if (toTransform) {
+ if (toTransform->pAspectReferences) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->aspectReferenceCount; ++i) {
+ transform_fromhost_VkInputAttachmentAspectReference(
+ resourceTracker,
+ (VkInputAttachmentAspectReference*)(toTransform->pAspectReferences + i));
}
}
}
}
-void transform_tohost_VkImageViewUsageCreateInfo(
- ResourceTracker* resourceTracker,
- VkImageViewUsageCreateInfo* toTransform)
-{
+void transform_tohost_VkImageViewUsageCreateInfo(ResourceTracker* resourceTracker,
+ VkImageViewUsageCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkImageViewUsageCreateInfo(
- ResourceTracker* resourceTracker,
- VkImageViewUsageCreateInfo* toTransform)
-{
+void transform_fromhost_VkImageViewUsageCreateInfo(ResourceTracker* resourceTracker,
+ VkImageViewUsageCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPipelineTessellationDomainOriginStateCreateInfo(
ResourceTracker* resourceTracker,
- VkPipelineTessellationDomainOriginStateCreateInfo* toTransform)
-{
+ VkPipelineTessellationDomainOriginStateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineTessellationDomainOriginStateCreateInfo(
ResourceTracker* resourceTracker,
- VkPipelineTessellationDomainOriginStateCreateInfo* toTransform)
-{
+ VkPipelineTessellationDomainOriginStateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkRenderPassMultiviewCreateInfo(
- ResourceTracker* resourceTracker,
- VkRenderPassMultiviewCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRenderPassMultiviewCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkRenderPassMultiviewCreateInfo(
- ResourceTracker* resourceTracker,
- VkRenderPassMultiviewCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRenderPassMultiviewCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceMultiviewFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMultiviewFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMultiviewFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceMultiviewFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMultiviewFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMultiviewFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceMultiviewProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMultiviewProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMultiviewProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceMultiviewProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMultiviewProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMultiviewProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceVariablePointersFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVariablePointersFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVariablePointersFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceVariablePointersFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVariablePointersFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVariablePointersFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceProtectedMemoryFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProtectedMemoryFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceProtectedMemoryFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceProtectedMemoryFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProtectedMemoryFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceProtectedMemoryFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceProtectedMemoryProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProtectedMemoryProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceProtectedMemoryProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceProtectedMemoryProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProtectedMemoryProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceProtectedMemoryProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkDeviceQueueInfo2(
- ResourceTracker* resourceTracker,
- VkDeviceQueueInfo2* toTransform)
-{
+void transform_tohost_VkDeviceQueueInfo2(ResourceTracker* resourceTracker,
+ VkDeviceQueueInfo2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkDeviceQueueInfo2(
- ResourceTracker* resourceTracker,
- VkDeviceQueueInfo2* toTransform)
-{
+void transform_fromhost_VkDeviceQueueInfo2(ResourceTracker* resourceTracker,
+ VkDeviceQueueInfo2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkProtectedSubmitInfo(
- ResourceTracker* resourceTracker,
- VkProtectedSubmitInfo* toTransform)
-{
+void transform_tohost_VkProtectedSubmitInfo(ResourceTracker* resourceTracker,
+ VkProtectedSubmitInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkProtectedSubmitInfo(
- ResourceTracker* resourceTracker,
- VkProtectedSubmitInfo* toTransform)
-{
+void transform_fromhost_VkProtectedSubmitInfo(ResourceTracker* resourceTracker,
+ VkProtectedSubmitInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkSamplerYcbcrConversionCreateInfo(
- ResourceTracker* resourceTracker,
- VkSamplerYcbcrConversionCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSamplerYcbcrConversionCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkComponentMapping(resourceTracker, (VkComponentMapping*)(&toTransform->components));
+ transform_tohost_VkComponentMapping(resourceTracker,
+ (VkComponentMapping*)(&toTransform->components));
}
void transform_fromhost_VkSamplerYcbcrConversionCreateInfo(
- ResourceTracker* resourceTracker,
- VkSamplerYcbcrConversionCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSamplerYcbcrConversionCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkComponentMapping(resourceTracker, (VkComponentMapping*)(&toTransform->components));
+ transform_fromhost_VkComponentMapping(resourceTracker,
+ (VkComponentMapping*)(&toTransform->components));
}
-void transform_tohost_VkSamplerYcbcrConversionInfo(
- ResourceTracker* resourceTracker,
- VkSamplerYcbcrConversionInfo* toTransform)
-{
+void transform_tohost_VkSamplerYcbcrConversionInfo(ResourceTracker* resourceTracker,
+ VkSamplerYcbcrConversionInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkSamplerYcbcrConversionInfo(
- ResourceTracker* resourceTracker,
- VkSamplerYcbcrConversionInfo* toTransform)
-{
+void transform_fromhost_VkSamplerYcbcrConversionInfo(ResourceTracker* resourceTracker,
+ VkSamplerYcbcrConversionInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkBindImagePlaneMemoryInfo(
- ResourceTracker* resourceTracker,
- VkBindImagePlaneMemoryInfo* toTransform)
-{
+void transform_tohost_VkBindImagePlaneMemoryInfo(ResourceTracker* resourceTracker,
+ VkBindImagePlaneMemoryInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkBindImagePlaneMemoryInfo(
- ResourceTracker* resourceTracker,
- VkBindImagePlaneMemoryInfo* toTransform)
-{
+void transform_fromhost_VkBindImagePlaneMemoryInfo(ResourceTracker* resourceTracker,
+ VkBindImagePlaneMemoryInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkImagePlaneMemoryRequirementsInfo(
- ResourceTracker* resourceTracker,
- VkImagePlaneMemoryRequirementsInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImagePlaneMemoryRequirementsInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkImagePlaneMemoryRequirementsInfo(
- ResourceTracker* resourceTracker,
- VkImagePlaneMemoryRequirementsInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImagePlaneMemoryRequirementsInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSamplerYcbcrConversionFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSamplerYcbcrConversionFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSamplerYcbcrConversionFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSamplerYcbcrConversionFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkSamplerYcbcrConversionImageFormatProperties(
- ResourceTracker* resourceTracker,
- VkSamplerYcbcrConversionImageFormatProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSamplerYcbcrConversionImageFormatProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkSamplerYcbcrConversionImageFormatProperties(
- ResourceTracker* resourceTracker,
- VkSamplerYcbcrConversionImageFormatProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSamplerYcbcrConversionImageFormatProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkDescriptorUpdateTemplateEntry(
- ResourceTracker* resourceTracker,
- VkDescriptorUpdateTemplateEntry* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDescriptorUpdateTemplateEntry* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_fromhost_VkDescriptorUpdateTemplateEntry(
- ResourceTracker* resourceTracker,
- VkDescriptorUpdateTemplateEntry* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDescriptorUpdateTemplateEntry* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkDescriptorUpdateTemplateCreateInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorUpdateTemplateCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDescriptorUpdateTemplateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pDescriptorUpdateEntries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->descriptorUpdateEntryCount; ++i)
- {
- transform_tohost_VkDescriptorUpdateTemplateEntry(resourceTracker, (VkDescriptorUpdateTemplateEntry*)(toTransform->pDescriptorUpdateEntries + i));
+ if (toTransform) {
+ if (toTransform->pDescriptorUpdateEntries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->descriptorUpdateEntryCount; ++i) {
+ transform_tohost_VkDescriptorUpdateTemplateEntry(
+ resourceTracker,
+ (VkDescriptorUpdateTemplateEntry*)(toTransform->pDescriptorUpdateEntries + i));
}
}
}
}
void transform_fromhost_VkDescriptorUpdateTemplateCreateInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorUpdateTemplateCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDescriptorUpdateTemplateCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pDescriptorUpdateEntries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->descriptorUpdateEntryCount; ++i)
- {
- transform_fromhost_VkDescriptorUpdateTemplateEntry(resourceTracker, (VkDescriptorUpdateTemplateEntry*)(toTransform->pDescriptorUpdateEntries + i));
+ if (toTransform) {
+ if (toTransform->pDescriptorUpdateEntries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->descriptorUpdateEntryCount; ++i) {
+ transform_fromhost_VkDescriptorUpdateTemplateEntry(
+ resourceTracker,
+ (VkDescriptorUpdateTemplateEntry*)(toTransform->pDescriptorUpdateEntries + i));
}
}
}
}
-void transform_tohost_VkExternalMemoryProperties(
- ResourceTracker* resourceTracker,
- VkExternalMemoryProperties* toTransform)
-{
+void transform_tohost_VkExternalMemoryProperties(ResourceTracker* resourceTracker,
+ VkExternalMemoryProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkExternalMemoryProperties(
- ResourceTracker* resourceTracker,
- VkExternalMemoryProperties* toTransform)
-{
+void transform_fromhost_VkExternalMemoryProperties(ResourceTracker* resourceTracker,
+ VkExternalMemoryProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkPhysicalDeviceExternalImageFormatInfo(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalImageFormatInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalImageFormatInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceExternalImageFormatInfo(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalImageFormatInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalImageFormatInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkExternalImageFormatProperties(
- ResourceTracker* resourceTracker,
- VkExternalImageFormatProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkExternalImageFormatProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- resourceTracker->transformImpl_VkExternalMemoryProperties_tohost(&toTransform->externalMemoryProperties, 1);
- transform_tohost_VkExternalMemoryProperties(resourceTracker, (VkExternalMemoryProperties*)(&toTransform->externalMemoryProperties));
+ resourceTracker->transformImpl_VkExternalMemoryProperties_tohost(
+ &toTransform->externalMemoryProperties, 1);
+ transform_tohost_VkExternalMemoryProperties(
+ resourceTracker, (VkExternalMemoryProperties*)(&toTransform->externalMemoryProperties));
}
void transform_fromhost_VkExternalImageFormatProperties(
- ResourceTracker* resourceTracker,
- VkExternalImageFormatProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkExternalImageFormatProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- resourceTracker->transformImpl_VkExternalMemoryProperties_fromhost(&toTransform->externalMemoryProperties, 1);
- transform_fromhost_VkExternalMemoryProperties(resourceTracker, (VkExternalMemoryProperties*)(&toTransform->externalMemoryProperties));
+ resourceTracker->transformImpl_VkExternalMemoryProperties_fromhost(
+ &toTransform->externalMemoryProperties, 1);
+ transform_fromhost_VkExternalMemoryProperties(
+ resourceTracker, (VkExternalMemoryProperties*)(&toTransform->externalMemoryProperties));
}
void transform_tohost_VkPhysicalDeviceExternalBufferInfo(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalBufferInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalBufferInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceExternalBufferInfo(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalBufferInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalBufferInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkExternalBufferProperties(
- ResourceTracker* resourceTracker,
- VkExternalBufferProperties* toTransform)
-{
+void transform_tohost_VkExternalBufferProperties(ResourceTracker* resourceTracker,
+ VkExternalBufferProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- resourceTracker->transformImpl_VkExternalMemoryProperties_tohost(&toTransform->externalMemoryProperties, 1);
- transform_tohost_VkExternalMemoryProperties(resourceTracker, (VkExternalMemoryProperties*)(&toTransform->externalMemoryProperties));
+ resourceTracker->transformImpl_VkExternalMemoryProperties_tohost(
+ &toTransform->externalMemoryProperties, 1);
+ transform_tohost_VkExternalMemoryProperties(
+ resourceTracker, (VkExternalMemoryProperties*)(&toTransform->externalMemoryProperties));
}
-void transform_fromhost_VkExternalBufferProperties(
- ResourceTracker* resourceTracker,
- VkExternalBufferProperties* toTransform)
-{
+void transform_fromhost_VkExternalBufferProperties(ResourceTracker* resourceTracker,
+ VkExternalBufferProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- resourceTracker->transformImpl_VkExternalMemoryProperties_fromhost(&toTransform->externalMemoryProperties, 1);
- transform_fromhost_VkExternalMemoryProperties(resourceTracker, (VkExternalMemoryProperties*)(&toTransform->externalMemoryProperties));
+ resourceTracker->transformImpl_VkExternalMemoryProperties_fromhost(
+ &toTransform->externalMemoryProperties, 1);
+ transform_fromhost_VkExternalMemoryProperties(
+ resourceTracker, (VkExternalMemoryProperties*)(&toTransform->externalMemoryProperties));
}
-void transform_tohost_VkPhysicalDeviceIDProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceIDProperties* toTransform)
-{
+void transform_tohost_VkPhysicalDeviceIDProperties(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceIDProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkPhysicalDeviceIDProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceIDProperties* toTransform)
-{
+void transform_fromhost_VkPhysicalDeviceIDProperties(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceIDProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkExternalMemoryImageCreateInfo(
- ResourceTracker* resourceTracker,
- VkExternalMemoryImageCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkExternalMemoryImageCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkExternalMemoryImageCreateInfo(
- ResourceTracker* resourceTracker,
- VkExternalMemoryImageCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkExternalMemoryImageCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkExternalMemoryBufferCreateInfo(
- ResourceTracker* resourceTracker,
- VkExternalMemoryBufferCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkExternalMemoryBufferCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkExternalMemoryBufferCreateInfo(
- ResourceTracker* resourceTracker,
- VkExternalMemoryBufferCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkExternalMemoryBufferCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkExportMemoryAllocateInfo(
- ResourceTracker* resourceTracker,
- VkExportMemoryAllocateInfo* toTransform)
-{
+void transform_tohost_VkExportMemoryAllocateInfo(ResourceTracker* resourceTracker,
+ VkExportMemoryAllocateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkExportMemoryAllocateInfo(
- ResourceTracker* resourceTracker,
- VkExportMemoryAllocateInfo* toTransform)
-{
+void transform_fromhost_VkExportMemoryAllocateInfo(ResourceTracker* resourceTracker,
+ VkExportMemoryAllocateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceExternalFenceInfo(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalFenceInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalFenceInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceExternalFenceInfo(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalFenceInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalFenceInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkExternalFenceProperties(
- ResourceTracker* resourceTracker,
- VkExternalFenceProperties* toTransform)
-{
+void transform_tohost_VkExternalFenceProperties(ResourceTracker* resourceTracker,
+ VkExternalFenceProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkExternalFenceProperties(
- ResourceTracker* resourceTracker,
- VkExternalFenceProperties* toTransform)
-{
+void transform_fromhost_VkExternalFenceProperties(ResourceTracker* resourceTracker,
+ VkExternalFenceProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkExportFenceCreateInfo(
- ResourceTracker* resourceTracker,
- VkExportFenceCreateInfo* toTransform)
-{
+void transform_tohost_VkExportFenceCreateInfo(ResourceTracker* resourceTracker,
+ VkExportFenceCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkExportFenceCreateInfo(
- ResourceTracker* resourceTracker,
- VkExportFenceCreateInfo* toTransform)
-{
+void transform_fromhost_VkExportFenceCreateInfo(ResourceTracker* resourceTracker,
+ VkExportFenceCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkExportSemaphoreCreateInfo(
- ResourceTracker* resourceTracker,
- VkExportSemaphoreCreateInfo* toTransform)
-{
+void transform_tohost_VkExportSemaphoreCreateInfo(ResourceTracker* resourceTracker,
+ VkExportSemaphoreCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkExportSemaphoreCreateInfo(
- ResourceTracker* resourceTracker,
- VkExportSemaphoreCreateInfo* toTransform)
-{
+void transform_fromhost_VkExportSemaphoreCreateInfo(ResourceTracker* resourceTracker,
+ VkExportSemaphoreCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceExternalSemaphoreInfo(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalSemaphoreInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalSemaphoreInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceExternalSemaphoreInfo(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalSemaphoreInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalSemaphoreInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkExternalSemaphoreProperties(
- ResourceTracker* resourceTracker,
- VkExternalSemaphoreProperties* toTransform)
-{
+void transform_tohost_VkExternalSemaphoreProperties(ResourceTracker* resourceTracker,
+ VkExternalSemaphoreProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkExternalSemaphoreProperties(
- ResourceTracker* resourceTracker,
- VkExternalSemaphoreProperties* toTransform)
-{
+void transform_fromhost_VkExternalSemaphoreProperties(ResourceTracker* resourceTracker,
+ VkExternalSemaphoreProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceMaintenance3Properties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMaintenance3Properties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance3Properties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceMaintenance3Properties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMaintenance3Properties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance3Properties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkDescriptorSetLayoutSupport(
- ResourceTracker* resourceTracker,
- VkDescriptorSetLayoutSupport* toTransform)
-{
+void transform_tohost_VkDescriptorSetLayoutSupport(ResourceTracker* resourceTracker,
+ VkDescriptorSetLayoutSupport* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkDescriptorSetLayoutSupport(
- ResourceTracker* resourceTracker,
- VkDescriptorSetLayoutSupport* toTransform)
-{
+void transform_fromhost_VkDescriptorSetLayoutSupport(ResourceTracker* resourceTracker,
+ VkDescriptorSetLayoutSupport* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceShaderDrawParametersFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderDrawParametersFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderDrawParametersFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceShaderDrawParametersFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderDrawParametersFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderDrawParametersFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -4672,1389 +3706,1079 @@
#endif
#ifdef VK_VERSION_1_2
void transform_tohost_VkPhysicalDeviceVulkan11Features(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVulkan11Features* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan11Features* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceVulkan11Features(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVulkan11Features* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan11Features* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceVulkan11Properties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVulkan11Properties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan11Properties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceVulkan11Properties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVulkan11Properties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan11Properties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceVulkan12Features(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVulkan12Features* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan12Features* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceVulkan12Features(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVulkan12Features* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan12Features* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkConformanceVersion(
- ResourceTracker* resourceTracker,
- VkConformanceVersion* toTransform)
-{
+void transform_tohost_VkConformanceVersion(ResourceTracker* resourceTracker,
+ VkConformanceVersion* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkConformanceVersion(
- ResourceTracker* resourceTracker,
- VkConformanceVersion* toTransform)
-{
+void transform_fromhost_VkConformanceVersion(ResourceTracker* resourceTracker,
+ VkConformanceVersion* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkPhysicalDeviceVulkan12Properties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVulkan12Properties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan12Properties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkConformanceVersion(resourceTracker, (VkConformanceVersion*)(&toTransform->conformanceVersion));
+ transform_tohost_VkConformanceVersion(
+ resourceTracker, (VkConformanceVersion*)(&toTransform->conformanceVersion));
}
void transform_fromhost_VkPhysicalDeviceVulkan12Properties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVulkan12Properties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan12Properties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkConformanceVersion(resourceTracker, (VkConformanceVersion*)(&toTransform->conformanceVersion));
+ transform_fromhost_VkConformanceVersion(
+ resourceTracker, (VkConformanceVersion*)(&toTransform->conformanceVersion));
}
-void transform_tohost_VkImageFormatListCreateInfo(
- ResourceTracker* resourceTracker,
- VkImageFormatListCreateInfo* toTransform)
-{
+void transform_tohost_VkImageFormatListCreateInfo(ResourceTracker* resourceTracker,
+ VkImageFormatListCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkImageFormatListCreateInfo(
- ResourceTracker* resourceTracker,
- VkImageFormatListCreateInfo* toTransform)
-{
+void transform_fromhost_VkImageFormatListCreateInfo(ResourceTracker* resourceTracker,
+ VkImageFormatListCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkAttachmentDescription2(
- ResourceTracker* resourceTracker,
- VkAttachmentDescription2* toTransform)
-{
+void transform_tohost_VkAttachmentDescription2(ResourceTracker* resourceTracker,
+ VkAttachmentDescription2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkAttachmentDescription2(
- ResourceTracker* resourceTracker,
- VkAttachmentDescription2* toTransform)
-{
+void transform_fromhost_VkAttachmentDescription2(ResourceTracker* resourceTracker,
+ VkAttachmentDescription2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkAttachmentReference2(
- ResourceTracker* resourceTracker,
- VkAttachmentReference2* toTransform)
-{
+void transform_tohost_VkAttachmentReference2(ResourceTracker* resourceTracker,
+ VkAttachmentReference2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkAttachmentReference2(
- ResourceTracker* resourceTracker,
- VkAttachmentReference2* toTransform)
-{
+void transform_fromhost_VkAttachmentReference2(ResourceTracker* resourceTracker,
+ VkAttachmentReference2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkSubpassDescription2(
- ResourceTracker* resourceTracker,
- VkSubpassDescription2* toTransform)
-{
+void transform_tohost_VkSubpassDescription2(ResourceTracker* resourceTracker,
+ VkSubpassDescription2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pInputAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->inputAttachmentCount; ++i)
- {
- transform_tohost_VkAttachmentReference2(resourceTracker, (VkAttachmentReference2*)(toTransform->pInputAttachments + i));
+ if (toTransform) {
+ if (toTransform->pInputAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->inputAttachmentCount; ++i) {
+ transform_tohost_VkAttachmentReference2(
+ resourceTracker, (VkAttachmentReference2*)(toTransform->pInputAttachments + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pColorAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i)
- {
- transform_tohost_VkAttachmentReference2(resourceTracker, (VkAttachmentReference2*)(toTransform->pColorAttachments + i));
+ if (toTransform) {
+ if (toTransform->pColorAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i) {
+ transform_tohost_VkAttachmentReference2(
+ resourceTracker, (VkAttachmentReference2*)(toTransform->pColorAttachments + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pResolveAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i)
- {
- transform_tohost_VkAttachmentReference2(resourceTracker, (VkAttachmentReference2*)(toTransform->pResolveAttachments + i));
+ if (toTransform) {
+ if (toTransform->pResolveAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i) {
+ transform_tohost_VkAttachmentReference2(
+ resourceTracker,
+ (VkAttachmentReference2*)(toTransform->pResolveAttachments + i));
}
}
}
- if (toTransform->pDepthStencilAttachment)
- {
- transform_tohost_VkAttachmentReference2(resourceTracker, (VkAttachmentReference2*)(toTransform->pDepthStencilAttachment));
+ if (toTransform->pDepthStencilAttachment) {
+ transform_tohost_VkAttachmentReference2(
+ resourceTracker, (VkAttachmentReference2*)(toTransform->pDepthStencilAttachment));
}
}
-void transform_fromhost_VkSubpassDescription2(
- ResourceTracker* resourceTracker,
- VkSubpassDescription2* toTransform)
-{
+void transform_fromhost_VkSubpassDescription2(ResourceTracker* resourceTracker,
+ VkSubpassDescription2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pInputAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->inputAttachmentCount; ++i)
- {
- transform_fromhost_VkAttachmentReference2(resourceTracker, (VkAttachmentReference2*)(toTransform->pInputAttachments + i));
+ if (toTransform) {
+ if (toTransform->pInputAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->inputAttachmentCount; ++i) {
+ transform_fromhost_VkAttachmentReference2(
+ resourceTracker, (VkAttachmentReference2*)(toTransform->pInputAttachments + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pColorAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i)
- {
- transform_fromhost_VkAttachmentReference2(resourceTracker, (VkAttachmentReference2*)(toTransform->pColorAttachments + i));
+ if (toTransform) {
+ if (toTransform->pColorAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i) {
+ transform_fromhost_VkAttachmentReference2(
+ resourceTracker, (VkAttachmentReference2*)(toTransform->pColorAttachments + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pResolveAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i)
- {
- transform_fromhost_VkAttachmentReference2(resourceTracker, (VkAttachmentReference2*)(toTransform->pResolveAttachments + i));
+ if (toTransform) {
+ if (toTransform->pResolveAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i) {
+ transform_fromhost_VkAttachmentReference2(
+ resourceTracker,
+ (VkAttachmentReference2*)(toTransform->pResolveAttachments + i));
}
}
}
- if (toTransform->pDepthStencilAttachment)
- {
- transform_fromhost_VkAttachmentReference2(resourceTracker, (VkAttachmentReference2*)(toTransform->pDepthStencilAttachment));
+ if (toTransform->pDepthStencilAttachment) {
+ transform_fromhost_VkAttachmentReference2(
+ resourceTracker, (VkAttachmentReference2*)(toTransform->pDepthStencilAttachment));
}
}
-void transform_tohost_VkSubpassDependency2(
- ResourceTracker* resourceTracker,
- VkSubpassDependency2* toTransform)
-{
+void transform_tohost_VkSubpassDependency2(ResourceTracker* resourceTracker,
+ VkSubpassDependency2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkSubpassDependency2(
- ResourceTracker* resourceTracker,
- VkSubpassDependency2* toTransform)
-{
+void transform_fromhost_VkSubpassDependency2(ResourceTracker* resourceTracker,
+ VkSubpassDependency2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkRenderPassCreateInfo2(
- ResourceTracker* resourceTracker,
- VkRenderPassCreateInfo2* toTransform)
-{
+void transform_tohost_VkRenderPassCreateInfo2(ResourceTracker* resourceTracker,
+ VkRenderPassCreateInfo2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->attachmentCount; ++i)
- {
- transform_tohost_VkAttachmentDescription2(resourceTracker, (VkAttachmentDescription2*)(toTransform->pAttachments + i));
+ if (toTransform) {
+ if (toTransform->pAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->attachmentCount; ++i) {
+ transform_tohost_VkAttachmentDescription2(
+ resourceTracker, (VkAttachmentDescription2*)(toTransform->pAttachments + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pSubpasses)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->subpassCount; ++i)
- {
- transform_tohost_VkSubpassDescription2(resourceTracker, (VkSubpassDescription2*)(toTransform->pSubpasses + i));
+ if (toTransform) {
+ if (toTransform->pSubpasses) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->subpassCount; ++i) {
+ transform_tohost_VkSubpassDescription2(
+ resourceTracker, (VkSubpassDescription2*)(toTransform->pSubpasses + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pDependencies)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->dependencyCount; ++i)
- {
- transform_tohost_VkSubpassDependency2(resourceTracker, (VkSubpassDependency2*)(toTransform->pDependencies + i));
+ if (toTransform) {
+ if (toTransform->pDependencies) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->dependencyCount; ++i) {
+ transform_tohost_VkSubpassDependency2(
+ resourceTracker, (VkSubpassDependency2*)(toTransform->pDependencies + i));
}
}
}
}
-void transform_fromhost_VkRenderPassCreateInfo2(
- ResourceTracker* resourceTracker,
- VkRenderPassCreateInfo2* toTransform)
-{
+void transform_fromhost_VkRenderPassCreateInfo2(ResourceTracker* resourceTracker,
+ VkRenderPassCreateInfo2* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->attachmentCount; ++i)
- {
- transform_fromhost_VkAttachmentDescription2(resourceTracker, (VkAttachmentDescription2*)(toTransform->pAttachments + i));
+ if (toTransform) {
+ if (toTransform->pAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->attachmentCount; ++i) {
+ transform_fromhost_VkAttachmentDescription2(
+ resourceTracker, (VkAttachmentDescription2*)(toTransform->pAttachments + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pSubpasses)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->subpassCount; ++i)
- {
- transform_fromhost_VkSubpassDescription2(resourceTracker, (VkSubpassDescription2*)(toTransform->pSubpasses + i));
+ if (toTransform) {
+ if (toTransform->pSubpasses) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->subpassCount; ++i) {
+ transform_fromhost_VkSubpassDescription2(
+ resourceTracker, (VkSubpassDescription2*)(toTransform->pSubpasses + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pDependencies)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->dependencyCount; ++i)
- {
- transform_fromhost_VkSubpassDependency2(resourceTracker, (VkSubpassDependency2*)(toTransform->pDependencies + i));
+ if (toTransform) {
+ if (toTransform->pDependencies) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->dependencyCount; ++i) {
+ transform_fromhost_VkSubpassDependency2(
+ resourceTracker, (VkSubpassDependency2*)(toTransform->pDependencies + i));
}
}
}
}
-void transform_tohost_VkSubpassBeginInfo(
- ResourceTracker* resourceTracker,
- VkSubpassBeginInfo* toTransform)
-{
+void transform_tohost_VkSubpassBeginInfo(ResourceTracker* resourceTracker,
+ VkSubpassBeginInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkSubpassBeginInfo(
- ResourceTracker* resourceTracker,
- VkSubpassBeginInfo* toTransform)
-{
+void transform_fromhost_VkSubpassBeginInfo(ResourceTracker* resourceTracker,
+ VkSubpassBeginInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkSubpassEndInfo(
- ResourceTracker* resourceTracker,
- VkSubpassEndInfo* toTransform)
-{
+void transform_tohost_VkSubpassEndInfo(ResourceTracker* resourceTracker,
+ VkSubpassEndInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkSubpassEndInfo(
- ResourceTracker* resourceTracker,
- VkSubpassEndInfo* toTransform)
-{
+void transform_fromhost_VkSubpassEndInfo(ResourceTracker* resourceTracker,
+ VkSubpassEndInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDevice8BitStorageFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDevice8BitStorageFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevice8BitStorageFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDevice8BitStorageFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDevice8BitStorageFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevice8BitStorageFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceDriverProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDriverProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDriverProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkConformanceVersion(resourceTracker, (VkConformanceVersion*)(&toTransform->conformanceVersion));
+ transform_tohost_VkConformanceVersion(
+ resourceTracker, (VkConformanceVersion*)(&toTransform->conformanceVersion));
}
void transform_fromhost_VkPhysicalDeviceDriverProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDriverProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDriverProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkConformanceVersion(resourceTracker, (VkConformanceVersion*)(&toTransform->conformanceVersion));
+ transform_fromhost_VkConformanceVersion(
+ resourceTracker, (VkConformanceVersion*)(&toTransform->conformanceVersion));
}
void transform_tohost_VkPhysicalDeviceShaderAtomicInt64Features(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderAtomicInt64Features* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderAtomicInt64Features* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceShaderAtomicInt64Features(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderAtomicInt64Features* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderAtomicInt64Features* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceShaderFloat16Int8Features(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderFloat16Int8Features* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderFloat16Int8Features* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceShaderFloat16Int8Features(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderFloat16Int8Features* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderFloat16Int8Features* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceFloatControlsProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFloatControlsProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFloatControlsProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceFloatControlsProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFloatControlsProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFloatControlsProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkDescriptorSetLayoutBindingFlagsCreateInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorSetLayoutBindingFlagsCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDescriptorSetLayoutBindingFlagsCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDescriptorSetLayoutBindingFlagsCreateInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorSetLayoutBindingFlagsCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDescriptorSetLayoutBindingFlagsCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceDescriptorIndexingFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDescriptorIndexingFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDescriptorIndexingFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceDescriptorIndexingFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDescriptorIndexingFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDescriptorIndexingFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceDescriptorIndexingProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDescriptorIndexingProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDescriptorIndexingProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceDescriptorIndexingProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDescriptorIndexingProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDescriptorIndexingProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkDescriptorSetVariableDescriptorCountAllocateInfo(
ResourceTracker* resourceTracker,
- VkDescriptorSetVariableDescriptorCountAllocateInfo* toTransform)
-{
+ VkDescriptorSetVariableDescriptorCountAllocateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDescriptorSetVariableDescriptorCountAllocateInfo(
ResourceTracker* resourceTracker,
- VkDescriptorSetVariableDescriptorCountAllocateInfo* toTransform)
-{
+ VkDescriptorSetVariableDescriptorCountAllocateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkDescriptorSetVariableDescriptorCountLayoutSupport(
ResourceTracker* resourceTracker,
- VkDescriptorSetVariableDescriptorCountLayoutSupport* toTransform)
-{
+ VkDescriptorSetVariableDescriptorCountLayoutSupport* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDescriptorSetVariableDescriptorCountLayoutSupport(
ResourceTracker* resourceTracker,
- VkDescriptorSetVariableDescriptorCountLayoutSupport* toTransform)
-{
+ VkDescriptorSetVariableDescriptorCountLayoutSupport* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkSubpassDescriptionDepthStencilResolve(
- ResourceTracker* resourceTracker,
- VkSubpassDescriptionDepthStencilResolve* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSubpassDescriptionDepthStencilResolve* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pDepthStencilResolveAttachment)
- {
- transform_tohost_VkAttachmentReference2(resourceTracker, (VkAttachmentReference2*)(toTransform->pDepthStencilResolveAttachment));
+ if (toTransform->pDepthStencilResolveAttachment) {
+ transform_tohost_VkAttachmentReference2(
+ resourceTracker,
+ (VkAttachmentReference2*)(toTransform->pDepthStencilResolveAttachment));
}
}
void transform_fromhost_VkSubpassDescriptionDepthStencilResolve(
- ResourceTracker* resourceTracker,
- VkSubpassDescriptionDepthStencilResolve* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSubpassDescriptionDepthStencilResolve* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pDepthStencilResolveAttachment)
- {
- transform_fromhost_VkAttachmentReference2(resourceTracker, (VkAttachmentReference2*)(toTransform->pDepthStencilResolveAttachment));
+ if (toTransform->pDepthStencilResolveAttachment) {
+ transform_fromhost_VkAttachmentReference2(
+ resourceTracker,
+ (VkAttachmentReference2*)(toTransform->pDepthStencilResolveAttachment));
}
}
void transform_tohost_VkPhysicalDeviceDepthStencilResolveProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDepthStencilResolveProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDepthStencilResolveProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceDepthStencilResolveProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDepthStencilResolveProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDepthStencilResolveProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceScalarBlockLayoutFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceScalarBlockLayoutFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceScalarBlockLayoutFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceScalarBlockLayoutFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceScalarBlockLayoutFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceScalarBlockLayoutFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkImageStencilUsageCreateInfo(
- ResourceTracker* resourceTracker,
- VkImageStencilUsageCreateInfo* toTransform)
-{
+void transform_tohost_VkImageStencilUsageCreateInfo(ResourceTracker* resourceTracker,
+ VkImageStencilUsageCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkImageStencilUsageCreateInfo(
- ResourceTracker* resourceTracker,
- VkImageStencilUsageCreateInfo* toTransform)
-{
+void transform_fromhost_VkImageStencilUsageCreateInfo(ResourceTracker* resourceTracker,
+ VkImageStencilUsageCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkSamplerReductionModeCreateInfo(
- ResourceTracker* resourceTracker,
- VkSamplerReductionModeCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSamplerReductionModeCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkSamplerReductionModeCreateInfo(
- ResourceTracker* resourceTracker,
- VkSamplerReductionModeCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSamplerReductionModeCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceSamplerFilterMinmaxProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSamplerFilterMinmaxProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSamplerFilterMinmaxProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceSamplerFilterMinmaxProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSamplerFilterMinmaxProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSamplerFilterMinmaxProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceVulkanMemoryModelFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVulkanMemoryModelFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkanMemoryModelFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceVulkanMemoryModelFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVulkanMemoryModelFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkanMemoryModelFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceImagelessFramebufferFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceImagelessFramebufferFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceImagelessFramebufferFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceImagelessFramebufferFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceImagelessFramebufferFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceImagelessFramebufferFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkFramebufferAttachmentImageInfo(
- ResourceTracker* resourceTracker,
- VkFramebufferAttachmentImageInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkFramebufferAttachmentImageInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkFramebufferAttachmentImageInfo(
- ResourceTracker* resourceTracker,
- VkFramebufferAttachmentImageInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkFramebufferAttachmentImageInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkFramebufferAttachmentsCreateInfo(
- ResourceTracker* resourceTracker,
- VkFramebufferAttachmentsCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkFramebufferAttachmentsCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pAttachmentImageInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->attachmentImageInfoCount; ++i)
- {
- transform_tohost_VkFramebufferAttachmentImageInfo(resourceTracker, (VkFramebufferAttachmentImageInfo*)(toTransform->pAttachmentImageInfos + i));
+ if (toTransform) {
+ if (toTransform->pAttachmentImageInfos) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->attachmentImageInfoCount; ++i) {
+ transform_tohost_VkFramebufferAttachmentImageInfo(
+ resourceTracker,
+ (VkFramebufferAttachmentImageInfo*)(toTransform->pAttachmentImageInfos + i));
}
}
}
}
void transform_fromhost_VkFramebufferAttachmentsCreateInfo(
- ResourceTracker* resourceTracker,
- VkFramebufferAttachmentsCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkFramebufferAttachmentsCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pAttachmentImageInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->attachmentImageInfoCount; ++i)
- {
- transform_fromhost_VkFramebufferAttachmentImageInfo(resourceTracker, (VkFramebufferAttachmentImageInfo*)(toTransform->pAttachmentImageInfos + i));
+ if (toTransform) {
+ if (toTransform->pAttachmentImageInfos) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->attachmentImageInfoCount; ++i) {
+ transform_fromhost_VkFramebufferAttachmentImageInfo(
+ resourceTracker,
+ (VkFramebufferAttachmentImageInfo*)(toTransform->pAttachmentImageInfos + i));
}
}
}
}
void transform_tohost_VkRenderPassAttachmentBeginInfo(
- ResourceTracker* resourceTracker,
- VkRenderPassAttachmentBeginInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRenderPassAttachmentBeginInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkRenderPassAttachmentBeginInfo(
- ResourceTracker* resourceTracker,
- VkRenderPassAttachmentBeginInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRenderPassAttachmentBeginInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceUniformBufferStandardLayoutFeatures* toTransform)
-{
+ VkPhysicalDeviceUniformBufferStandardLayoutFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceUniformBufferStandardLayoutFeatures* toTransform)
-{
+ VkPhysicalDeviceUniformBufferStandardLayoutFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* toTransform)
-{
+ VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* toTransform)
-{
+ VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* toTransform)
-{
+ VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* toTransform)
-{
+ VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkAttachmentReferenceStencilLayout(
- ResourceTracker* resourceTracker,
- VkAttachmentReferenceStencilLayout* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAttachmentReferenceStencilLayout* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkAttachmentReferenceStencilLayout(
- ResourceTracker* resourceTracker,
- VkAttachmentReferenceStencilLayout* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAttachmentReferenceStencilLayout* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkAttachmentDescriptionStencilLayout(
- ResourceTracker* resourceTracker,
- VkAttachmentDescriptionStencilLayout* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAttachmentDescriptionStencilLayout* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkAttachmentDescriptionStencilLayout(
- ResourceTracker* resourceTracker,
- VkAttachmentDescriptionStencilLayout* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAttachmentDescriptionStencilLayout* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceHostQueryResetFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceHostQueryResetFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceHostQueryResetFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceHostQueryResetFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceHostQueryResetFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceHostQueryResetFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceTimelineSemaphoreFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceTimelineSemaphoreFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceTimelineSemaphoreFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceTimelineSemaphoreFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceTimelineSemaphoreFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceTimelineSemaphoreFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceTimelineSemaphoreProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceTimelineSemaphoreProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceTimelineSemaphoreProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceTimelineSemaphoreProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceTimelineSemaphoreProperties* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceTimelineSemaphoreProperties* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkSemaphoreTypeCreateInfo(
- ResourceTracker* resourceTracker,
- VkSemaphoreTypeCreateInfo* toTransform)
-{
+void transform_tohost_VkSemaphoreTypeCreateInfo(ResourceTracker* resourceTracker,
+ VkSemaphoreTypeCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkSemaphoreTypeCreateInfo(
- ResourceTracker* resourceTracker,
- VkSemaphoreTypeCreateInfo* toTransform)
-{
+void transform_fromhost_VkSemaphoreTypeCreateInfo(ResourceTracker* resourceTracker,
+ VkSemaphoreTypeCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkTimelineSemaphoreSubmitInfo(
- ResourceTracker* resourceTracker,
- VkTimelineSemaphoreSubmitInfo* toTransform)
-{
+void transform_tohost_VkTimelineSemaphoreSubmitInfo(ResourceTracker* resourceTracker,
+ VkTimelineSemaphoreSubmitInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkTimelineSemaphoreSubmitInfo(
- ResourceTracker* resourceTracker,
- VkTimelineSemaphoreSubmitInfo* toTransform)
-{
+void transform_fromhost_VkTimelineSemaphoreSubmitInfo(ResourceTracker* resourceTracker,
+ VkTimelineSemaphoreSubmitInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkSemaphoreWaitInfo(
- ResourceTracker* resourceTracker,
- VkSemaphoreWaitInfo* toTransform)
-{
+void transform_tohost_VkSemaphoreWaitInfo(ResourceTracker* resourceTracker,
+ VkSemaphoreWaitInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkSemaphoreWaitInfo(
- ResourceTracker* resourceTracker,
- VkSemaphoreWaitInfo* toTransform)
-{
+void transform_fromhost_VkSemaphoreWaitInfo(ResourceTracker* resourceTracker,
+ VkSemaphoreWaitInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkSemaphoreSignalInfo(
- ResourceTracker* resourceTracker,
- VkSemaphoreSignalInfo* toTransform)
-{
+void transform_tohost_VkSemaphoreSignalInfo(ResourceTracker* resourceTracker,
+ VkSemaphoreSignalInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkSemaphoreSignalInfo(
- ResourceTracker* resourceTracker,
- VkSemaphoreSignalInfo* toTransform)
-{
+void transform_fromhost_VkSemaphoreSignalInfo(ResourceTracker* resourceTracker,
+ VkSemaphoreSignalInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceBufferDeviceAddressFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceBufferDeviceAddressFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceBufferDeviceAddressFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceBufferDeviceAddressFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceBufferDeviceAddressFeatures* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceBufferDeviceAddressFeatures* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkBufferDeviceAddressInfo(
- ResourceTracker* resourceTracker,
- VkBufferDeviceAddressInfo* toTransform)
-{
+void transform_tohost_VkBufferDeviceAddressInfo(ResourceTracker* resourceTracker,
+ VkBufferDeviceAddressInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkBufferDeviceAddressInfo(
- ResourceTracker* resourceTracker,
- VkBufferDeviceAddressInfo* toTransform)
-{
+void transform_fromhost_VkBufferDeviceAddressInfo(ResourceTracker* resourceTracker,
+ VkBufferDeviceAddressInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkBufferOpaqueCaptureAddressCreateInfo(
- ResourceTracker* resourceTracker,
- VkBufferOpaqueCaptureAddressCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBufferOpaqueCaptureAddressCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkBufferOpaqueCaptureAddressCreateInfo(
- ResourceTracker* resourceTracker,
- VkBufferOpaqueCaptureAddressCreateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBufferOpaqueCaptureAddressCreateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkMemoryOpaqueCaptureAddressAllocateInfo(
- ResourceTracker* resourceTracker,
- VkMemoryOpaqueCaptureAddressAllocateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMemoryOpaqueCaptureAddressAllocateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkMemoryOpaqueCaptureAddressAllocateInfo(
- ResourceTracker* resourceTracker,
- VkMemoryOpaqueCaptureAddressAllocateInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMemoryOpaqueCaptureAddressAllocateInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkDeviceMemoryOpaqueCaptureAddressInfo(
- ResourceTracker* resourceTracker,
- VkDeviceMemoryOpaqueCaptureAddressInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceMemoryOpaqueCaptureAddressInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&toTransform->memory, 1,
+ (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr,
+ 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDeviceMemoryOpaqueCaptureAddressInfo(
- ResourceTracker* resourceTracker,
- VkDeviceMemoryOpaqueCaptureAddressInfo* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceMemoryOpaqueCaptureAddressInfo* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_fromhost((VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_fromhost(
+ (VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr,
+ 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_KHR_surface
-void transform_tohost_VkSurfaceCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkSurfaceCapabilitiesKHR* toTransform)
-{
+void transform_tohost_VkSurfaceCapabilitiesKHR(ResourceTracker* resourceTracker,
+ VkSurfaceCapabilitiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->currentExtent));
@@ -6062,10 +4786,8 @@
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxImageExtent));
}
-void transform_fromhost_VkSurfaceCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkSurfaceCapabilitiesKHR* toTransform)
-{
+void transform_fromhost_VkSurfaceCapabilitiesKHR(ResourceTracker* resourceTracker,
+ VkSurfaceCapabilitiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->currentExtent));
@@ -6073,286 +4795,222 @@
transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxImageExtent));
}
-void transform_tohost_VkSurfaceFormatKHR(
- ResourceTracker* resourceTracker,
- VkSurfaceFormatKHR* toTransform)
-{
+void transform_tohost_VkSurfaceFormatKHR(ResourceTracker* resourceTracker,
+ VkSurfaceFormatKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkSurfaceFormatKHR(
- ResourceTracker* resourceTracker,
- VkSurfaceFormatKHR* toTransform)
-{
+void transform_fromhost_VkSurfaceFormatKHR(ResourceTracker* resourceTracker,
+ VkSurfaceFormatKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
#endif
#ifdef VK_KHR_swapchain
-void transform_tohost_VkSwapchainCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkSwapchainCreateInfoKHR* toTransform)
-{
+void transform_tohost_VkSwapchainCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkSwapchainCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->imageExtent));
}
-void transform_fromhost_VkSwapchainCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkSwapchainCreateInfoKHR* toTransform)
-{
+void transform_fromhost_VkSwapchainCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkSwapchainCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->imageExtent));
}
-void transform_tohost_VkPresentInfoKHR(
- ResourceTracker* resourceTracker,
- VkPresentInfoKHR* toTransform)
-{
+void transform_tohost_VkPresentInfoKHR(ResourceTracker* resourceTracker,
+ VkPresentInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkPresentInfoKHR(
- ResourceTracker* resourceTracker,
- VkPresentInfoKHR* toTransform)
-{
+void transform_fromhost_VkPresentInfoKHR(ResourceTracker* resourceTracker,
+ VkPresentInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkImageSwapchainCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkImageSwapchainCreateInfoKHR* toTransform)
-{
+void transform_tohost_VkImageSwapchainCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkImageSwapchainCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkImageSwapchainCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkImageSwapchainCreateInfoKHR* toTransform)
-{
+void transform_fromhost_VkImageSwapchainCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkImageSwapchainCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkBindImageMemorySwapchainInfoKHR(
- ResourceTracker* resourceTracker,
- VkBindImageMemorySwapchainInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBindImageMemorySwapchainInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkBindImageMemorySwapchainInfoKHR(
- ResourceTracker* resourceTracker,
- VkBindImageMemorySwapchainInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBindImageMemorySwapchainInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkAcquireNextImageInfoKHR(
- ResourceTracker* resourceTracker,
- VkAcquireNextImageInfoKHR* toTransform)
-{
+void transform_tohost_VkAcquireNextImageInfoKHR(ResourceTracker* resourceTracker,
+ VkAcquireNextImageInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkAcquireNextImageInfoKHR(
- ResourceTracker* resourceTracker,
- VkAcquireNextImageInfoKHR* toTransform)
-{
+void transform_fromhost_VkAcquireNextImageInfoKHR(ResourceTracker* resourceTracker,
+ VkAcquireNextImageInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkDeviceGroupPresentCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkDeviceGroupPresentCapabilitiesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceGroupPresentCapabilitiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDeviceGroupPresentCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkDeviceGroupPresentCapabilitiesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceGroupPresentCapabilitiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkDeviceGroupPresentInfoKHR(
- ResourceTracker* resourceTracker,
- VkDeviceGroupPresentInfoKHR* toTransform)
-{
+void transform_tohost_VkDeviceGroupPresentInfoKHR(ResourceTracker* resourceTracker,
+ VkDeviceGroupPresentInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkDeviceGroupPresentInfoKHR(
- ResourceTracker* resourceTracker,
- VkDeviceGroupPresentInfoKHR* toTransform)
-{
+void transform_fromhost_VkDeviceGroupPresentInfoKHR(ResourceTracker* resourceTracker,
+ VkDeviceGroupPresentInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkDeviceGroupSwapchainCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkDeviceGroupSwapchainCreateInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceGroupSwapchainCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDeviceGroupSwapchainCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkDeviceGroupSwapchainCreateInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceGroupSwapchainCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_KHR_display
-void transform_tohost_VkDisplayModeParametersKHR(
- ResourceTracker* resourceTracker,
- VkDisplayModeParametersKHR* toTransform)
-{
+void transform_tohost_VkDisplayModeParametersKHR(ResourceTracker* resourceTracker,
+ VkDisplayModeParametersKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->visibleRegion));
}
-void transform_fromhost_VkDisplayModeParametersKHR(
- ResourceTracker* resourceTracker,
- VkDisplayModeParametersKHR* toTransform)
-{
+void transform_fromhost_VkDisplayModeParametersKHR(ResourceTracker* resourceTracker,
+ VkDisplayModeParametersKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->visibleRegion));
}
-void transform_tohost_VkDisplayModeCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkDisplayModeCreateInfoKHR* toTransform)
-{
+void transform_tohost_VkDisplayModeCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkDisplayModeCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkDisplayModeParametersKHR(resourceTracker, (VkDisplayModeParametersKHR*)(&toTransform->parameters));
+ transform_tohost_VkDisplayModeParametersKHR(
+ resourceTracker, (VkDisplayModeParametersKHR*)(&toTransform->parameters));
}
-void transform_fromhost_VkDisplayModeCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkDisplayModeCreateInfoKHR* toTransform)
-{
+void transform_fromhost_VkDisplayModeCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkDisplayModeCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkDisplayModeParametersKHR(resourceTracker, (VkDisplayModeParametersKHR*)(&toTransform->parameters));
+ transform_fromhost_VkDisplayModeParametersKHR(
+ resourceTracker, (VkDisplayModeParametersKHR*)(&toTransform->parameters));
}
-void transform_tohost_VkDisplayModePropertiesKHR(
- ResourceTracker* resourceTracker,
- VkDisplayModePropertiesKHR* toTransform)
-{
+void transform_tohost_VkDisplayModePropertiesKHR(ResourceTracker* resourceTracker,
+ VkDisplayModePropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_tohost_VkDisplayModeParametersKHR(resourceTracker, (VkDisplayModeParametersKHR*)(&toTransform->parameters));
+ transform_tohost_VkDisplayModeParametersKHR(
+ resourceTracker, (VkDisplayModeParametersKHR*)(&toTransform->parameters));
}
-void transform_fromhost_VkDisplayModePropertiesKHR(
- ResourceTracker* resourceTracker,
- VkDisplayModePropertiesKHR* toTransform)
-{
+void transform_fromhost_VkDisplayModePropertiesKHR(ResourceTracker* resourceTracker,
+ VkDisplayModePropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_fromhost_VkDisplayModeParametersKHR(resourceTracker, (VkDisplayModeParametersKHR*)(&toTransform->parameters));
+ transform_fromhost_VkDisplayModeParametersKHR(
+ resourceTracker, (VkDisplayModeParametersKHR*)(&toTransform->parameters));
}
-void transform_tohost_VkDisplayPlaneCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkDisplayPlaneCapabilitiesKHR* toTransform)
-{
+void transform_tohost_VkDisplayPlaneCapabilitiesKHR(ResourceTracker* resourceTracker,
+ VkDisplayPlaneCapabilitiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_tohost_VkOffset2D(resourceTracker, (VkOffset2D*)(&toTransform->minSrcPosition));
@@ -6365,10 +5023,8 @@
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxDstExtent));
}
-void transform_fromhost_VkDisplayPlaneCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkDisplayPlaneCapabilitiesKHR* toTransform)
-{
+void transform_fromhost_VkDisplayPlaneCapabilitiesKHR(ResourceTracker* resourceTracker,
+ VkDisplayPlaneCapabilitiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_fromhost_VkOffset2D(resourceTracker, (VkOffset2D*)(&toTransform->minSrcPosition));
@@ -6381,63 +5037,49 @@
transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxDstExtent));
}
-void transform_tohost_VkDisplayPlanePropertiesKHR(
- ResourceTracker* resourceTracker,
- VkDisplayPlanePropertiesKHR* toTransform)
-{
+void transform_tohost_VkDisplayPlanePropertiesKHR(ResourceTracker* resourceTracker,
+ VkDisplayPlanePropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkDisplayPlanePropertiesKHR(
- ResourceTracker* resourceTracker,
- VkDisplayPlanePropertiesKHR* toTransform)
-{
+void transform_fromhost_VkDisplayPlanePropertiesKHR(ResourceTracker* resourceTracker,
+ VkDisplayPlanePropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkDisplayPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkDisplayPropertiesKHR* toTransform)
-{
+void transform_tohost_VkDisplayPropertiesKHR(ResourceTracker* resourceTracker,
+ VkDisplayPropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->physicalDimensions));
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->physicalResolution));
}
-void transform_fromhost_VkDisplayPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkDisplayPropertiesKHR* toTransform)
-{
+void transform_fromhost_VkDisplayPropertiesKHR(ResourceTracker* resourceTracker,
+ VkDisplayPropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->physicalDimensions));
transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->physicalResolution));
}
-void transform_tohost_VkDisplaySurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkDisplaySurfaceCreateInfoKHR* toTransform)
-{
+void transform_tohost_VkDisplaySurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkDisplaySurfaceCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->imageExtent));
}
-void transform_fromhost_VkDisplaySurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkDisplaySurfaceCreateInfoKHR* toTransform)
-{
+void transform_fromhost_VkDisplaySurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkDisplaySurfaceCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->imageExtent));
@@ -6445,28 +5087,22 @@
#endif
#ifdef VK_KHR_display_swapchain
-void transform_tohost_VkDisplayPresentInfoKHR(
- ResourceTracker* resourceTracker,
- VkDisplayPresentInfoKHR* toTransform)
-{
+void transform_tohost_VkDisplayPresentInfoKHR(ResourceTracker* resourceTracker,
+ VkDisplayPresentInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_tohost_VkRect2D(resourceTracker, (VkRect2D*)(&toTransform->srcRect));
transform_tohost_VkRect2D(resourceTracker, (VkRect2D*)(&toTransform->dstRect));
}
-void transform_fromhost_VkDisplayPresentInfoKHR(
- ResourceTracker* resourceTracker,
- VkDisplayPresentInfoKHR* toTransform)
-{
+void transform_fromhost_VkDisplayPresentInfoKHR(ResourceTracker* resourceTracker,
+ VkDisplayPresentInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_fromhost_VkRect2D(resourceTracker, (VkRect2D*)(&toTransform->srcRect));
@@ -6475,130 +5111,100 @@
#endif
#ifdef VK_KHR_xlib_surface
-void transform_tohost_VkXlibSurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkXlibSurfaceCreateInfoKHR* toTransform)
-{
+void transform_tohost_VkXlibSurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkXlibSurfaceCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkXlibSurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkXlibSurfaceCreateInfoKHR* toTransform)
-{
+void transform_fromhost_VkXlibSurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkXlibSurfaceCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_KHR_xcb_surface
-void transform_tohost_VkXcbSurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkXcbSurfaceCreateInfoKHR* toTransform)
-{
+void transform_tohost_VkXcbSurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkXcbSurfaceCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkXcbSurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkXcbSurfaceCreateInfoKHR* toTransform)
-{
+void transform_fromhost_VkXcbSurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkXcbSurfaceCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_KHR_wayland_surface
-void transform_tohost_VkWaylandSurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkWaylandSurfaceCreateInfoKHR* toTransform)
-{
+void transform_tohost_VkWaylandSurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkWaylandSurfaceCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkWaylandSurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkWaylandSurfaceCreateInfoKHR* toTransform)
-{
+void transform_fromhost_VkWaylandSurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkWaylandSurfaceCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_KHR_android_surface
-void transform_tohost_VkAndroidSurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkAndroidSurfaceCreateInfoKHR* toTransform)
-{
+void transform_tohost_VkAndroidSurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkAndroidSurfaceCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkAndroidSurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkAndroidSurfaceCreateInfoKHR* toTransform)
-{
+void transform_fromhost_VkAndroidSurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkAndroidSurfaceCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_KHR_win32_surface
-void transform_tohost_VkWin32SurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkWin32SurfaceCreateInfoKHR* toTransform)
-{
+void transform_tohost_VkWin32SurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkWin32SurfaceCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkWin32SurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkWin32SurfaceCreateInfoKHR* toTransform)
-{
+void transform_fromhost_VkWin32SurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkWin32SurfaceCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -6608,516 +5214,410 @@
#endif
#ifdef VK_KHR_video_queue
void transform_tohost_VkVideoQueueFamilyProperties2KHR(
- ResourceTracker* resourceTracker,
- VkVideoQueueFamilyProperties2KHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoQueueFamilyProperties2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkVideoQueueFamilyProperties2KHR(
- ResourceTracker* resourceTracker,
- VkVideoQueueFamilyProperties2KHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoQueueFamilyProperties2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkVideoProfileKHR(
- ResourceTracker* resourceTracker,
- VkVideoProfileKHR* toTransform)
-{
+void transform_tohost_VkVideoProfileKHR(ResourceTracker* resourceTracker,
+ VkVideoProfileKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkVideoProfileKHR(
- ResourceTracker* resourceTracker,
- VkVideoProfileKHR* toTransform)
-{
+void transform_fromhost_VkVideoProfileKHR(ResourceTracker* resourceTracker,
+ VkVideoProfileKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkVideoProfilesKHR(
- ResourceTracker* resourceTracker,
- VkVideoProfilesKHR* toTransform)
-{
+void transform_tohost_VkVideoProfilesKHR(ResourceTracker* resourceTracker,
+ VkVideoProfilesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pProfiles)
- {
- transform_tohost_VkVideoProfileKHR(resourceTracker, (VkVideoProfileKHR*)(toTransform->pProfiles));
+ if (toTransform->pProfiles) {
+ transform_tohost_VkVideoProfileKHR(resourceTracker,
+ (VkVideoProfileKHR*)(toTransform->pProfiles));
}
}
-void transform_fromhost_VkVideoProfilesKHR(
- ResourceTracker* resourceTracker,
- VkVideoProfilesKHR* toTransform)
-{
+void transform_fromhost_VkVideoProfilesKHR(ResourceTracker* resourceTracker,
+ VkVideoProfilesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pProfiles)
- {
- transform_fromhost_VkVideoProfileKHR(resourceTracker, (VkVideoProfileKHR*)(toTransform->pProfiles));
+ if (toTransform->pProfiles) {
+ transform_fromhost_VkVideoProfileKHR(resourceTracker,
+ (VkVideoProfileKHR*)(toTransform->pProfiles));
}
}
-void transform_tohost_VkVideoCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkVideoCapabilitiesKHR* toTransform)
-{
+void transform_tohost_VkVideoCapabilitiesKHR(ResourceTracker* resourceTracker,
+ VkVideoCapabilitiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->videoPictureExtentGranularity));
+ transform_tohost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->videoPictureExtentGranularity));
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->minExtent));
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxExtent));
}
-void transform_fromhost_VkVideoCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkVideoCapabilitiesKHR* toTransform)
-{
+void transform_fromhost_VkVideoCapabilitiesKHR(ResourceTracker* resourceTracker,
+ VkVideoCapabilitiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->videoPictureExtentGranularity));
+ transform_fromhost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->videoPictureExtentGranularity));
transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->minExtent));
transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxExtent));
}
void transform_tohost_VkPhysicalDeviceVideoFormatInfoKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVideoFormatInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVideoFormatInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pVideoProfiles)
- {
- transform_tohost_VkVideoProfilesKHR(resourceTracker, (VkVideoProfilesKHR*)(toTransform->pVideoProfiles));
+ if (toTransform->pVideoProfiles) {
+ transform_tohost_VkVideoProfilesKHR(resourceTracker,
+ (VkVideoProfilesKHR*)(toTransform->pVideoProfiles));
}
}
void transform_fromhost_VkPhysicalDeviceVideoFormatInfoKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVideoFormatInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVideoFormatInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pVideoProfiles)
- {
- transform_fromhost_VkVideoProfilesKHR(resourceTracker, (VkVideoProfilesKHR*)(toTransform->pVideoProfiles));
+ if (toTransform->pVideoProfiles) {
+ transform_fromhost_VkVideoProfilesKHR(resourceTracker,
+ (VkVideoProfilesKHR*)(toTransform->pVideoProfiles));
}
}
-void transform_tohost_VkVideoFormatPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkVideoFormatPropertiesKHR* toTransform)
-{
+void transform_tohost_VkVideoFormatPropertiesKHR(ResourceTracker* resourceTracker,
+ VkVideoFormatPropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkVideoFormatPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkVideoFormatPropertiesKHR* toTransform)
-{
+void transform_fromhost_VkVideoFormatPropertiesKHR(ResourceTracker* resourceTracker,
+ VkVideoFormatPropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkVideoPictureResourceKHR(
- ResourceTracker* resourceTracker,
- VkVideoPictureResourceKHR* toTransform)
-{
+void transform_tohost_VkVideoPictureResourceKHR(ResourceTracker* resourceTracker,
+ VkVideoPictureResourceKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_tohost_VkOffset2D(resourceTracker, (VkOffset2D*)(&toTransform->codedOffset));
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->codedExtent));
}
-void transform_fromhost_VkVideoPictureResourceKHR(
- ResourceTracker* resourceTracker,
- VkVideoPictureResourceKHR* toTransform)
-{
+void transform_fromhost_VkVideoPictureResourceKHR(ResourceTracker* resourceTracker,
+ VkVideoPictureResourceKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_fromhost_VkOffset2D(resourceTracker, (VkOffset2D*)(&toTransform->codedOffset));
transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->codedExtent));
}
-void transform_tohost_VkVideoReferenceSlotKHR(
- ResourceTracker* resourceTracker,
- VkVideoReferenceSlotKHR* toTransform)
-{
+void transform_tohost_VkVideoReferenceSlotKHR(ResourceTracker* resourceTracker,
+ VkVideoReferenceSlotKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pPictureResource)
- {
- transform_tohost_VkVideoPictureResourceKHR(resourceTracker, (VkVideoPictureResourceKHR*)(toTransform->pPictureResource));
+ if (toTransform->pPictureResource) {
+ transform_tohost_VkVideoPictureResourceKHR(
+ resourceTracker, (VkVideoPictureResourceKHR*)(toTransform->pPictureResource));
}
}
-void transform_fromhost_VkVideoReferenceSlotKHR(
- ResourceTracker* resourceTracker,
- VkVideoReferenceSlotKHR* toTransform)
-{
+void transform_fromhost_VkVideoReferenceSlotKHR(ResourceTracker* resourceTracker,
+ VkVideoReferenceSlotKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pPictureResource)
- {
- transform_fromhost_VkVideoPictureResourceKHR(resourceTracker, (VkVideoPictureResourceKHR*)(toTransform->pPictureResource));
+ if (toTransform->pPictureResource) {
+ transform_fromhost_VkVideoPictureResourceKHR(
+ resourceTracker, (VkVideoPictureResourceKHR*)(toTransform->pPictureResource));
}
}
-void transform_tohost_VkVideoGetMemoryPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkVideoGetMemoryPropertiesKHR* toTransform)
-{
+void transform_tohost_VkVideoGetMemoryPropertiesKHR(ResourceTracker* resourceTracker,
+ VkVideoGetMemoryPropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pMemoryRequirements)
- {
- transform_tohost_VkMemoryRequirements2(resourceTracker, (VkMemoryRequirements2*)(toTransform->pMemoryRequirements));
+ if (toTransform->pMemoryRequirements) {
+ transform_tohost_VkMemoryRequirements2(
+ resourceTracker, (VkMemoryRequirements2*)(toTransform->pMemoryRequirements));
}
}
-void transform_fromhost_VkVideoGetMemoryPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkVideoGetMemoryPropertiesKHR* toTransform)
-{
+void transform_fromhost_VkVideoGetMemoryPropertiesKHR(ResourceTracker* resourceTracker,
+ VkVideoGetMemoryPropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pMemoryRequirements)
- {
- transform_fromhost_VkMemoryRequirements2(resourceTracker, (VkMemoryRequirements2*)(toTransform->pMemoryRequirements));
+ if (toTransform->pMemoryRequirements) {
+ transform_fromhost_VkMemoryRequirements2(
+ resourceTracker, (VkMemoryRequirements2*)(toTransform->pMemoryRequirements));
}
}
-void transform_tohost_VkVideoBindMemoryKHR(
- ResourceTracker* resourceTracker,
- VkVideoBindMemoryKHR* toTransform)
-{
+void transform_tohost_VkVideoBindMemoryKHR(ResourceTracker* resourceTracker,
+ VkVideoBindMemoryKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkVideoBindMemoryKHR(
- ResourceTracker* resourceTracker,
- VkVideoBindMemoryKHR* toTransform)
-{
+void transform_fromhost_VkVideoBindMemoryKHR(ResourceTracker* resourceTracker,
+ VkVideoBindMemoryKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkVideoSessionCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoSessionCreateInfoKHR* toTransform)
-{
+void transform_tohost_VkVideoSessionCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoSessionCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pVideoProfile)
- {
- transform_tohost_VkVideoProfileKHR(resourceTracker, (VkVideoProfileKHR*)(toTransform->pVideoProfile));
+ if (toTransform->pVideoProfile) {
+ transform_tohost_VkVideoProfileKHR(resourceTracker,
+ (VkVideoProfileKHR*)(toTransform->pVideoProfile));
}
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxCodedExtent));
}
-void transform_fromhost_VkVideoSessionCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoSessionCreateInfoKHR* toTransform)
-{
+void transform_fromhost_VkVideoSessionCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoSessionCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pVideoProfile)
- {
- transform_fromhost_VkVideoProfileKHR(resourceTracker, (VkVideoProfileKHR*)(toTransform->pVideoProfile));
+ if (toTransform->pVideoProfile) {
+ transform_fromhost_VkVideoProfileKHR(resourceTracker,
+ (VkVideoProfileKHR*)(toTransform->pVideoProfile));
}
transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxCodedExtent));
}
void transform_tohost_VkVideoSessionParametersCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoSessionParametersCreateInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoSessionParametersCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkVideoSessionParametersCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoSessionParametersCreateInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoSessionParametersCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkVideoSessionParametersUpdateInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoSessionParametersUpdateInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoSessionParametersUpdateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkVideoSessionParametersUpdateInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoSessionParametersUpdateInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoSessionParametersUpdateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkVideoBeginCodingInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoBeginCodingInfoKHR* toTransform)
-{
+void transform_tohost_VkVideoBeginCodingInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoBeginCodingInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pReferenceSlots)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->referenceSlotCount; ++i)
- {
- transform_tohost_VkVideoReferenceSlotKHR(resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pReferenceSlots + i));
+ if (toTransform) {
+ if (toTransform->pReferenceSlots) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->referenceSlotCount; ++i) {
+ transform_tohost_VkVideoReferenceSlotKHR(
+ resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pReferenceSlots + i));
}
}
}
}
-void transform_fromhost_VkVideoBeginCodingInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoBeginCodingInfoKHR* toTransform)
-{
+void transform_fromhost_VkVideoBeginCodingInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoBeginCodingInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pReferenceSlots)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->referenceSlotCount; ++i)
- {
- transform_fromhost_VkVideoReferenceSlotKHR(resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pReferenceSlots + i));
+ if (toTransform) {
+ if (toTransform->pReferenceSlots) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->referenceSlotCount; ++i) {
+ transform_fromhost_VkVideoReferenceSlotKHR(
+ resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pReferenceSlots + i));
}
}
}
}
-void transform_tohost_VkVideoEndCodingInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoEndCodingInfoKHR* toTransform)
-{
+void transform_tohost_VkVideoEndCodingInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoEndCodingInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkVideoEndCodingInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoEndCodingInfoKHR* toTransform)
-{
+void transform_fromhost_VkVideoEndCodingInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoEndCodingInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkVideoCodingControlInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoCodingControlInfoKHR* toTransform)
-{
+void transform_tohost_VkVideoCodingControlInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoCodingControlInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkVideoCodingControlInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoCodingControlInfoKHR* toTransform)
-{
+void transform_fromhost_VkVideoCodingControlInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoCodingControlInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_KHR_video_decode_queue
-void transform_tohost_VkVideoDecodeInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoDecodeInfoKHR* toTransform)
-{
+void transform_tohost_VkVideoDecodeInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoDecodeInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_tohost_VkOffset2D(resourceTracker, (VkOffset2D*)(&toTransform->codedOffset));
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->codedExtent));
- transform_tohost_VkVideoPictureResourceKHR(resourceTracker, (VkVideoPictureResourceKHR*)(&toTransform->dstPictureResource));
- if (toTransform->pSetupReferenceSlot)
- {
- transform_tohost_VkVideoReferenceSlotKHR(resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pSetupReferenceSlot));
+ transform_tohost_VkVideoPictureResourceKHR(
+ resourceTracker, (VkVideoPictureResourceKHR*)(&toTransform->dstPictureResource));
+ if (toTransform->pSetupReferenceSlot) {
+ transform_tohost_VkVideoReferenceSlotKHR(
+ resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pSetupReferenceSlot));
}
- if (toTransform)
- {
- if (toTransform->pReferenceSlots)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->referenceSlotCount; ++i)
- {
- transform_tohost_VkVideoReferenceSlotKHR(resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pReferenceSlots + i));
+ if (toTransform) {
+ if (toTransform->pReferenceSlots) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->referenceSlotCount; ++i) {
+ transform_tohost_VkVideoReferenceSlotKHR(
+ resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pReferenceSlots + i));
}
}
}
}
-void transform_fromhost_VkVideoDecodeInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoDecodeInfoKHR* toTransform)
-{
+void transform_fromhost_VkVideoDecodeInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoDecodeInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_fromhost_VkOffset2D(resourceTracker, (VkOffset2D*)(&toTransform->codedOffset));
transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->codedExtent));
- transform_fromhost_VkVideoPictureResourceKHR(resourceTracker, (VkVideoPictureResourceKHR*)(&toTransform->dstPictureResource));
- if (toTransform->pSetupReferenceSlot)
- {
- transform_fromhost_VkVideoReferenceSlotKHR(resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pSetupReferenceSlot));
+ transform_fromhost_VkVideoPictureResourceKHR(
+ resourceTracker, (VkVideoPictureResourceKHR*)(&toTransform->dstPictureResource));
+ if (toTransform->pSetupReferenceSlot) {
+ transform_fromhost_VkVideoReferenceSlotKHR(
+ resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pSetupReferenceSlot));
}
- if (toTransform)
- {
- if (toTransform->pReferenceSlots)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->referenceSlotCount; ++i)
- {
- transform_fromhost_VkVideoReferenceSlotKHR(resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pReferenceSlots + i));
+ if (toTransform) {
+ if (toTransform->pReferenceSlots) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->referenceSlotCount; ++i) {
+ transform_fromhost_VkVideoReferenceSlotKHR(
+ resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pReferenceSlots + i));
}
}
}
@@ -7125,260 +5625,208 @@
#endif
#ifdef VK_KHR_dynamic_rendering
-void transform_tohost_VkRenderingAttachmentInfoKHR(
- ResourceTracker* resourceTracker,
- VkRenderingAttachmentInfoKHR* toTransform)
-{
+void transform_tohost_VkRenderingAttachmentInfoKHR(ResourceTracker* resourceTracker,
+ VkRenderingAttachmentInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_tohost_VkClearValue(resourceTracker, (VkClearValue*)(&toTransform->clearValue));
}
-void transform_fromhost_VkRenderingAttachmentInfoKHR(
- ResourceTracker* resourceTracker,
- VkRenderingAttachmentInfoKHR* toTransform)
-{
+void transform_fromhost_VkRenderingAttachmentInfoKHR(ResourceTracker* resourceTracker,
+ VkRenderingAttachmentInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_fromhost_VkClearValue(resourceTracker, (VkClearValue*)(&toTransform->clearValue));
}
-void transform_tohost_VkRenderingInfoKHR(
- ResourceTracker* resourceTracker,
- VkRenderingInfoKHR* toTransform)
-{
+void transform_tohost_VkRenderingInfoKHR(ResourceTracker* resourceTracker,
+ VkRenderingInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_tohost_VkRect2D(resourceTracker, (VkRect2D*)(&toTransform->renderArea));
- if (toTransform)
- {
- if (toTransform->pColorAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i)
- {
- transform_tohost_VkRenderingAttachmentInfoKHR(resourceTracker, (VkRenderingAttachmentInfoKHR*)(toTransform->pColorAttachments + i));
+ if (toTransform) {
+ if (toTransform->pColorAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i) {
+ transform_tohost_VkRenderingAttachmentInfoKHR(
+ resourceTracker,
+ (VkRenderingAttachmentInfoKHR*)(toTransform->pColorAttachments + i));
}
}
}
- if (toTransform->pDepthAttachment)
- {
- transform_tohost_VkRenderingAttachmentInfoKHR(resourceTracker, (VkRenderingAttachmentInfoKHR*)(toTransform->pDepthAttachment));
+ if (toTransform->pDepthAttachment) {
+ transform_tohost_VkRenderingAttachmentInfoKHR(
+ resourceTracker, (VkRenderingAttachmentInfoKHR*)(toTransform->pDepthAttachment));
}
- if (toTransform->pStencilAttachment)
- {
- transform_tohost_VkRenderingAttachmentInfoKHR(resourceTracker, (VkRenderingAttachmentInfoKHR*)(toTransform->pStencilAttachment));
+ if (toTransform->pStencilAttachment) {
+ transform_tohost_VkRenderingAttachmentInfoKHR(
+ resourceTracker, (VkRenderingAttachmentInfoKHR*)(toTransform->pStencilAttachment));
}
}
-void transform_fromhost_VkRenderingInfoKHR(
- ResourceTracker* resourceTracker,
- VkRenderingInfoKHR* toTransform)
-{
+void transform_fromhost_VkRenderingInfoKHR(ResourceTracker* resourceTracker,
+ VkRenderingInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_fromhost_VkRect2D(resourceTracker, (VkRect2D*)(&toTransform->renderArea));
- if (toTransform)
- {
- if (toTransform->pColorAttachments)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i)
- {
- transform_fromhost_VkRenderingAttachmentInfoKHR(resourceTracker, (VkRenderingAttachmentInfoKHR*)(toTransform->pColorAttachments + i));
+ if (toTransform) {
+ if (toTransform->pColorAttachments) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i) {
+ transform_fromhost_VkRenderingAttachmentInfoKHR(
+ resourceTracker,
+ (VkRenderingAttachmentInfoKHR*)(toTransform->pColorAttachments + i));
}
}
}
- if (toTransform->pDepthAttachment)
- {
- transform_fromhost_VkRenderingAttachmentInfoKHR(resourceTracker, (VkRenderingAttachmentInfoKHR*)(toTransform->pDepthAttachment));
+ if (toTransform->pDepthAttachment) {
+ transform_fromhost_VkRenderingAttachmentInfoKHR(
+ resourceTracker, (VkRenderingAttachmentInfoKHR*)(toTransform->pDepthAttachment));
}
- if (toTransform->pStencilAttachment)
- {
- transform_fromhost_VkRenderingAttachmentInfoKHR(resourceTracker, (VkRenderingAttachmentInfoKHR*)(toTransform->pStencilAttachment));
+ if (toTransform->pStencilAttachment) {
+ transform_fromhost_VkRenderingAttachmentInfoKHR(
+ resourceTracker, (VkRenderingAttachmentInfoKHR*)(toTransform->pStencilAttachment));
}
}
void transform_tohost_VkPipelineRenderingCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkPipelineRenderingCreateInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineRenderingCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineRenderingCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkPipelineRenderingCreateInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineRenderingCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDynamicRenderingFeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDynamicRenderingFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDynamicRenderingFeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDynamicRenderingFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkCommandBufferInheritanceRenderingInfoKHR(
- ResourceTracker* resourceTracker,
- VkCommandBufferInheritanceRenderingInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkCommandBufferInheritanceRenderingInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkCommandBufferInheritanceRenderingInfoKHR(
- ResourceTracker* resourceTracker,
- VkCommandBufferInheritanceRenderingInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkCommandBufferInheritanceRenderingInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkRenderingFragmentShadingRateAttachmentInfoKHR(
ResourceTracker* resourceTracker,
- VkRenderingFragmentShadingRateAttachmentInfoKHR* toTransform)
-{
+ VkRenderingFragmentShadingRateAttachmentInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->shadingRateAttachmentTexelSize));
+ transform_tohost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->shadingRateAttachmentTexelSize));
}
void transform_fromhost_VkRenderingFragmentShadingRateAttachmentInfoKHR(
ResourceTracker* resourceTracker,
- VkRenderingFragmentShadingRateAttachmentInfoKHR* toTransform)
-{
+ VkRenderingFragmentShadingRateAttachmentInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->shadingRateAttachmentTexelSize));
+ transform_fromhost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->shadingRateAttachmentTexelSize));
}
void transform_tohost_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- ResourceTracker* resourceTracker,
- VkRenderingFragmentDensityMapAttachmentInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRenderingFragmentDensityMapAttachmentInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- ResourceTracker* resourceTracker,
- VkRenderingFragmentDensityMapAttachmentInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRenderingFragmentDensityMapAttachmentInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkAttachmentSampleCountInfoAMD(
- ResourceTracker* resourceTracker,
- VkAttachmentSampleCountInfoAMD* toTransform)
-{
+void transform_tohost_VkAttachmentSampleCountInfoAMD(ResourceTracker* resourceTracker,
+ VkAttachmentSampleCountInfoAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkAttachmentSampleCountInfoAMD(
- ResourceTracker* resourceTracker,
- VkAttachmentSampleCountInfoAMD* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAttachmentSampleCountInfoAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkMultiviewPerViewAttributesInfoNVX(
- ResourceTracker* resourceTracker,
- VkMultiviewPerViewAttributesInfoNVX* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMultiviewPerViewAttributesInfoNVX* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkMultiviewPerViewAttributesInfoNVX(
- ResourceTracker* resourceTracker,
- VkMultiviewPerViewAttributesInfoNVX* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMultiviewPerViewAttributesInfoNVX* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -7402,179 +5850,153 @@
#endif
#ifdef VK_KHR_external_memory_win32
void transform_tohost_VkImportMemoryWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportMemoryWin32HandleInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImportMemoryWin32HandleInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkImportMemoryWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportMemoryWin32HandleInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImportMemoryWin32HandleInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkExportMemoryWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkExportMemoryWin32HandleInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkExportMemoryWin32HandleInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkExportMemoryWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkExportMemoryWin32HandleInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkExportMemoryWin32HandleInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkMemoryWin32HandlePropertiesKHR(
- ResourceTracker* resourceTracker,
- VkMemoryWin32HandlePropertiesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMemoryWin32HandlePropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0,
+ (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkMemoryWin32HandlePropertiesKHR(
- ResourceTracker* resourceTracker,
- VkMemoryWin32HandlePropertiesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMemoryWin32HandlePropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_fromhost((VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_fromhost(
+ (VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0,
+ (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkMemoryGetWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkMemoryGetWin32HandleInfoKHR* toTransform)
-{
+void transform_tohost_VkMemoryGetWin32HandleInfoKHR(ResourceTracker* resourceTracker,
+ VkMemoryGetWin32HandleInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&toTransform->memory, 1,
+ (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr,
+ 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkMemoryGetWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkMemoryGetWin32HandleInfoKHR* toTransform)
-{
+void transform_fromhost_VkMemoryGetWin32HandleInfoKHR(ResourceTracker* resourceTracker,
+ VkMemoryGetWin32HandleInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_fromhost((VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_fromhost(
+ (VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr,
+ 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_KHR_external_memory_fd
-void transform_tohost_VkImportMemoryFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportMemoryFdInfoKHR* toTransform)
-{
+void transform_tohost_VkImportMemoryFdInfoKHR(ResourceTracker* resourceTracker,
+ VkImportMemoryFdInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkImportMemoryFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportMemoryFdInfoKHR* toTransform)
-{
+void transform_fromhost_VkImportMemoryFdInfoKHR(ResourceTracker* resourceTracker,
+ VkImportMemoryFdInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkMemoryFdPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkMemoryFdPropertiesKHR* toTransform)
-{
+void transform_tohost_VkMemoryFdPropertiesKHR(ResourceTracker* resourceTracker,
+ VkMemoryFdPropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0,
+ (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkMemoryFdPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkMemoryFdPropertiesKHR* toTransform)
-{
+void transform_fromhost_VkMemoryFdPropertiesKHR(ResourceTracker* resourceTracker,
+ VkMemoryFdPropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_fromhost((VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_fromhost(
+ (VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0,
+ (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkMemoryGetFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkMemoryGetFdInfoKHR* toTransform)
-{
+void transform_tohost_VkMemoryGetFdInfoKHR(ResourceTracker* resourceTracker,
+ VkMemoryGetFdInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&toTransform->memory, 1,
+ (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr,
+ 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkMemoryGetFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkMemoryGetFdInfoKHR* toTransform)
-{
+void transform_fromhost_VkMemoryGetFdInfoKHR(ResourceTracker* resourceTracker,
+ VkMemoryGetFdInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_fromhost((VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_fromhost(
+ (VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr,
+ 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -7582,27 +6004,27 @@
#endif
#ifdef VK_KHR_win32_keyed_mutex
void transform_tohost_VkWin32KeyedMutexAcquireReleaseInfoKHR(
- ResourceTracker* resourceTracker,
- VkWin32KeyedMutexAcquireReleaseInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkWin32KeyedMutexAcquireReleaseInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)toTransform->pReleaseSyncs, toTransform->releaseCount, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)toTransform->pReleaseSyncs,
+ toTransform->releaseCount, (VkDeviceSize*)nullptr,
+ 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr,
+ 0, (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkWin32KeyedMutexAcquireReleaseInfoKHR(
- ResourceTracker* resourceTracker,
- VkWin32KeyedMutexAcquireReleaseInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkWin32KeyedMutexAcquireReleaseInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_fromhost((VkDeviceMemory*)toTransform->pReleaseSyncs, toTransform->releaseCount, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_fromhost(
+ (VkDeviceMemory*)toTransform->pReleaseSyncs, toTransform->releaseCount,
+ (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0,
+ (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -7614,147 +6036,111 @@
#endif
#ifdef VK_KHR_external_semaphore_win32
void transform_tohost_VkImportSemaphoreWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportSemaphoreWin32HandleInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImportSemaphoreWin32HandleInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkImportSemaphoreWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportSemaphoreWin32HandleInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImportSemaphoreWin32HandleInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkExportSemaphoreWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkExportSemaphoreWin32HandleInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkExportSemaphoreWin32HandleInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkExportSemaphoreWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkExportSemaphoreWin32HandleInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkExportSemaphoreWin32HandleInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkD3D12FenceSubmitInfoKHR(
- ResourceTracker* resourceTracker,
- VkD3D12FenceSubmitInfoKHR* toTransform)
-{
+void transform_tohost_VkD3D12FenceSubmitInfoKHR(ResourceTracker* resourceTracker,
+ VkD3D12FenceSubmitInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkD3D12FenceSubmitInfoKHR(
- ResourceTracker* resourceTracker,
- VkD3D12FenceSubmitInfoKHR* toTransform)
-{
+void transform_fromhost_VkD3D12FenceSubmitInfoKHR(ResourceTracker* resourceTracker,
+ VkD3D12FenceSubmitInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkSemaphoreGetWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkSemaphoreGetWin32HandleInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSemaphoreGetWin32HandleInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkSemaphoreGetWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkSemaphoreGetWin32HandleInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSemaphoreGetWin32HandleInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_KHR_external_semaphore_fd
-void transform_tohost_VkImportSemaphoreFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportSemaphoreFdInfoKHR* toTransform)
-{
+void transform_tohost_VkImportSemaphoreFdInfoKHR(ResourceTracker* resourceTracker,
+ VkImportSemaphoreFdInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkImportSemaphoreFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportSemaphoreFdInfoKHR* toTransform)
-{
+void transform_fromhost_VkImportSemaphoreFdInfoKHR(ResourceTracker* resourceTracker,
+ VkImportSemaphoreFdInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkSemaphoreGetFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkSemaphoreGetFdInfoKHR* toTransform)
-{
+void transform_tohost_VkSemaphoreGetFdInfoKHR(ResourceTracker* resourceTracker,
+ VkSemaphoreGetFdInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkSemaphoreGetFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkSemaphoreGetFdInfoKHR* toTransform)
-{
+void transform_fromhost_VkSemaphoreGetFdInfoKHR(ResourceTracker* resourceTracker,
+ VkSemaphoreGetFdInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -7762,25 +6148,19 @@
#endif
#ifdef VK_KHR_push_descriptor
void transform_tohost_VkPhysicalDevicePushDescriptorPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePushDescriptorPropertiesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevicePushDescriptorPropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDevicePushDescriptorPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePushDescriptorPropertiesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevicePushDescriptorPropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -7791,101 +6171,79 @@
#ifdef VK_KHR_16bit_storage
#endif
#ifdef VK_KHR_incremental_present
-void transform_tohost_VkRectLayerKHR(
- ResourceTracker* resourceTracker,
- VkRectLayerKHR* toTransform)
-{
+void transform_tohost_VkRectLayerKHR(ResourceTracker* resourceTracker,
+ VkRectLayerKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_tohost_VkOffset2D(resourceTracker, (VkOffset2D*)(&toTransform->offset));
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->extent));
}
-void transform_fromhost_VkRectLayerKHR(
- ResourceTracker* resourceTracker,
- VkRectLayerKHR* toTransform)
-{
+void transform_fromhost_VkRectLayerKHR(ResourceTracker* resourceTracker,
+ VkRectLayerKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_fromhost_VkOffset2D(resourceTracker, (VkOffset2D*)(&toTransform->offset));
transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->extent));
}
-void transform_tohost_VkPresentRegionKHR(
- ResourceTracker* resourceTracker,
- VkPresentRegionKHR* toTransform)
-{
+void transform_tohost_VkPresentRegionKHR(ResourceTracker* resourceTracker,
+ VkPresentRegionKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform)
- {
- if (toTransform->pRectangles)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->rectangleCount; ++i)
- {
- transform_tohost_VkRectLayerKHR(resourceTracker, (VkRectLayerKHR*)(toTransform->pRectangles + i));
+ if (toTransform) {
+ if (toTransform->pRectangles) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->rectangleCount; ++i) {
+ transform_tohost_VkRectLayerKHR(resourceTracker,
+ (VkRectLayerKHR*)(toTransform->pRectangles + i));
}
}
}
}
-void transform_fromhost_VkPresentRegionKHR(
- ResourceTracker* resourceTracker,
- VkPresentRegionKHR* toTransform)
-{
+void transform_fromhost_VkPresentRegionKHR(ResourceTracker* resourceTracker,
+ VkPresentRegionKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform)
- {
- if (toTransform->pRectangles)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->rectangleCount; ++i)
- {
- transform_fromhost_VkRectLayerKHR(resourceTracker, (VkRectLayerKHR*)(toTransform->pRectangles + i));
+ if (toTransform) {
+ if (toTransform->pRectangles) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->rectangleCount; ++i) {
+ transform_fromhost_VkRectLayerKHR(resourceTracker,
+ (VkRectLayerKHR*)(toTransform->pRectangles + i));
}
}
}
}
-void transform_tohost_VkPresentRegionsKHR(
- ResourceTracker* resourceTracker,
- VkPresentRegionsKHR* toTransform)
-{
+void transform_tohost_VkPresentRegionsKHR(ResourceTracker* resourceTracker,
+ VkPresentRegionsKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->swapchainCount; ++i)
- {
- transform_tohost_VkPresentRegionKHR(resourceTracker, (VkPresentRegionKHR*)(toTransform->pRegions + i));
+ if (toTransform) {
+ if (toTransform->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->swapchainCount; ++i) {
+ transform_tohost_VkPresentRegionKHR(
+ resourceTracker, (VkPresentRegionKHR*)(toTransform->pRegions + i));
}
}
}
}
-void transform_fromhost_VkPresentRegionsKHR(
- ResourceTracker* resourceTracker,
- VkPresentRegionsKHR* toTransform)
-{
+void transform_fromhost_VkPresentRegionsKHR(ResourceTracker* resourceTracker,
+ VkPresentRegionsKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->swapchainCount; ++i)
- {
- transform_fromhost_VkPresentRegionKHR(resourceTracker, (VkPresentRegionKHR*)(toTransform->pRegions + i));
+ if (toTransform) {
+ if (toTransform->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->swapchainCount; ++i) {
+ transform_fromhost_VkPresentRegionKHR(
+ resourceTracker, (VkPresentRegionKHR*)(toTransform->pRegions + i));
}
}
}
@@ -7900,25 +6258,19 @@
#endif
#ifdef VK_KHR_shared_presentable_image
void transform_tohost_VkSharedPresentSurfaceCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkSharedPresentSurfaceCapabilitiesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSharedPresentSurfaceCapabilitiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkSharedPresentSurfaceCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkSharedPresentSurfaceCapabilitiesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSharedPresentSurfaceCapabilitiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -7930,123 +6282,93 @@
#endif
#ifdef VK_KHR_external_fence_win32
void transform_tohost_VkImportFenceWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportFenceWin32HandleInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImportFenceWin32HandleInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkImportFenceWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportFenceWin32HandleInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImportFenceWin32HandleInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkExportFenceWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkExportFenceWin32HandleInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkExportFenceWin32HandleInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkExportFenceWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkExportFenceWin32HandleInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkExportFenceWin32HandleInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkFenceGetWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkFenceGetWin32HandleInfoKHR* toTransform)
-{
+void transform_tohost_VkFenceGetWin32HandleInfoKHR(ResourceTracker* resourceTracker,
+ VkFenceGetWin32HandleInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkFenceGetWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkFenceGetWin32HandleInfoKHR* toTransform)
-{
+void transform_fromhost_VkFenceGetWin32HandleInfoKHR(ResourceTracker* resourceTracker,
+ VkFenceGetWin32HandleInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_KHR_external_fence_fd
-void transform_tohost_VkImportFenceFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportFenceFdInfoKHR* toTransform)
-{
+void transform_tohost_VkImportFenceFdInfoKHR(ResourceTracker* resourceTracker,
+ VkImportFenceFdInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkImportFenceFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportFenceFdInfoKHR* toTransform)
-{
+void transform_fromhost_VkImportFenceFdInfoKHR(ResourceTracker* resourceTracker,
+ VkImportFenceFdInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkFenceGetFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkFenceGetFdInfoKHR* toTransform)
-{
+void transform_tohost_VkFenceGetFdInfoKHR(ResourceTracker* resourceTracker,
+ VkFenceGetFdInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkFenceGetFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkFenceGetFdInfoKHR* toTransform)
-{
+void transform_fromhost_VkFenceGetFdInfoKHR(ResourceTracker* resourceTracker,
+ VkFenceGetFdInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -8054,185 +6376,139 @@
#endif
#ifdef VK_KHR_performance_query
void transform_tohost_VkPhysicalDevicePerformanceQueryFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePerformanceQueryFeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevicePerformanceQueryFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDevicePerformanceQueryFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePerformanceQueryFeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevicePerformanceQueryFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDevicePerformanceQueryPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePerformanceQueryPropertiesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevicePerformanceQueryPropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDevicePerformanceQueryPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePerformanceQueryPropertiesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevicePerformanceQueryPropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkPerformanceCounterKHR(
- ResourceTracker* resourceTracker,
- VkPerformanceCounterKHR* toTransform)
-{
+void transform_tohost_VkPerformanceCounterKHR(ResourceTracker* resourceTracker,
+ VkPerformanceCounterKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkPerformanceCounterKHR(
- ResourceTracker* resourceTracker,
- VkPerformanceCounterKHR* toTransform)
-{
+void transform_fromhost_VkPerformanceCounterKHR(ResourceTracker* resourceTracker,
+ VkPerformanceCounterKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPerformanceCounterDescriptionKHR(
- ResourceTracker* resourceTracker,
- VkPerformanceCounterDescriptionKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPerformanceCounterDescriptionKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPerformanceCounterDescriptionKHR(
- ResourceTracker* resourceTracker,
- VkPerformanceCounterDescriptionKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPerformanceCounterDescriptionKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkQueryPoolPerformanceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkQueryPoolPerformanceCreateInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkQueryPoolPerformanceCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkQueryPoolPerformanceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkQueryPoolPerformanceCreateInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkQueryPoolPerformanceCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkPerformanceCounterResultKHR(
- ResourceTracker* resourceTracker,
- VkPerformanceCounterResultKHR* toTransform)
-{
+void transform_tohost_VkPerformanceCounterResultKHR(ResourceTracker* resourceTracker,
+ VkPerformanceCounterResultKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkPerformanceCounterResultKHR(
- ResourceTracker* resourceTracker,
- VkPerformanceCounterResultKHR* toTransform)
-{
+void transform_fromhost_VkPerformanceCounterResultKHR(ResourceTracker* resourceTracker,
+ VkPerformanceCounterResultKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkAcquireProfilingLockInfoKHR(
- ResourceTracker* resourceTracker,
- VkAcquireProfilingLockInfoKHR* toTransform)
-{
+void transform_tohost_VkAcquireProfilingLockInfoKHR(ResourceTracker* resourceTracker,
+ VkAcquireProfilingLockInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkAcquireProfilingLockInfoKHR(
- ResourceTracker* resourceTracker,
- VkAcquireProfilingLockInfoKHR* toTransform)
-{
+void transform_fromhost_VkAcquireProfilingLockInfoKHR(ResourceTracker* resourceTracker,
+ VkAcquireProfilingLockInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPerformanceQuerySubmitInfoKHR(
- ResourceTracker* resourceTracker,
- VkPerformanceQuerySubmitInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPerformanceQuerySubmitInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPerformanceQuerySubmitInfoKHR(
- ResourceTracker* resourceTracker,
- VkPerformanceQuerySubmitInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPerformanceQuerySubmitInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -8242,211 +6518,175 @@
#endif
#ifdef VK_KHR_get_surface_capabilities2
void transform_tohost_VkPhysicalDeviceSurfaceInfo2KHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSurfaceInfo2KHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSurfaceInfo2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceSurfaceInfo2KHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSurfaceInfo2KHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSurfaceInfo2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkSurfaceCapabilities2KHR(
- ResourceTracker* resourceTracker,
- VkSurfaceCapabilities2KHR* toTransform)
-{
+void transform_tohost_VkSurfaceCapabilities2KHR(ResourceTracker* resourceTracker,
+ VkSurfaceCapabilities2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkSurfaceCapabilitiesKHR(resourceTracker, (VkSurfaceCapabilitiesKHR*)(&toTransform->surfaceCapabilities));
+ transform_tohost_VkSurfaceCapabilitiesKHR(
+ resourceTracker, (VkSurfaceCapabilitiesKHR*)(&toTransform->surfaceCapabilities));
}
-void transform_fromhost_VkSurfaceCapabilities2KHR(
- ResourceTracker* resourceTracker,
- VkSurfaceCapabilities2KHR* toTransform)
-{
+void transform_fromhost_VkSurfaceCapabilities2KHR(ResourceTracker* resourceTracker,
+ VkSurfaceCapabilities2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkSurfaceCapabilitiesKHR(resourceTracker, (VkSurfaceCapabilitiesKHR*)(&toTransform->surfaceCapabilities));
+ transform_fromhost_VkSurfaceCapabilitiesKHR(
+ resourceTracker, (VkSurfaceCapabilitiesKHR*)(&toTransform->surfaceCapabilities));
}
-void transform_tohost_VkSurfaceFormat2KHR(
- ResourceTracker* resourceTracker,
- VkSurfaceFormat2KHR* toTransform)
-{
+void transform_tohost_VkSurfaceFormat2KHR(ResourceTracker* resourceTracker,
+ VkSurfaceFormat2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkSurfaceFormatKHR(resourceTracker, (VkSurfaceFormatKHR*)(&toTransform->surfaceFormat));
+ transform_tohost_VkSurfaceFormatKHR(resourceTracker,
+ (VkSurfaceFormatKHR*)(&toTransform->surfaceFormat));
}
-void transform_fromhost_VkSurfaceFormat2KHR(
- ResourceTracker* resourceTracker,
- VkSurfaceFormat2KHR* toTransform)
-{
+void transform_fromhost_VkSurfaceFormat2KHR(ResourceTracker* resourceTracker,
+ VkSurfaceFormat2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkSurfaceFormatKHR(resourceTracker, (VkSurfaceFormatKHR*)(&toTransform->surfaceFormat));
+ transform_fromhost_VkSurfaceFormatKHR(resourceTracker,
+ (VkSurfaceFormatKHR*)(&toTransform->surfaceFormat));
}
#endif
#ifdef VK_KHR_variable_pointers
#endif
#ifdef VK_KHR_get_display_properties2
-void transform_tohost_VkDisplayProperties2KHR(
- ResourceTracker* resourceTracker,
- VkDisplayProperties2KHR* toTransform)
-{
+void transform_tohost_VkDisplayProperties2KHR(ResourceTracker* resourceTracker,
+ VkDisplayProperties2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkDisplayPropertiesKHR(resourceTracker, (VkDisplayPropertiesKHR*)(&toTransform->displayProperties));
+ transform_tohost_VkDisplayPropertiesKHR(
+ resourceTracker, (VkDisplayPropertiesKHR*)(&toTransform->displayProperties));
}
-void transform_fromhost_VkDisplayProperties2KHR(
- ResourceTracker* resourceTracker,
- VkDisplayProperties2KHR* toTransform)
-{
+void transform_fromhost_VkDisplayProperties2KHR(ResourceTracker* resourceTracker,
+ VkDisplayProperties2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkDisplayPropertiesKHR(resourceTracker, (VkDisplayPropertiesKHR*)(&toTransform->displayProperties));
+ transform_fromhost_VkDisplayPropertiesKHR(
+ resourceTracker, (VkDisplayPropertiesKHR*)(&toTransform->displayProperties));
}
-void transform_tohost_VkDisplayPlaneProperties2KHR(
- ResourceTracker* resourceTracker,
- VkDisplayPlaneProperties2KHR* toTransform)
-{
+void transform_tohost_VkDisplayPlaneProperties2KHR(ResourceTracker* resourceTracker,
+ VkDisplayPlaneProperties2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkDisplayPlanePropertiesKHR(resourceTracker, (VkDisplayPlanePropertiesKHR*)(&toTransform->displayPlaneProperties));
+ transform_tohost_VkDisplayPlanePropertiesKHR(
+ resourceTracker, (VkDisplayPlanePropertiesKHR*)(&toTransform->displayPlaneProperties));
}
-void transform_fromhost_VkDisplayPlaneProperties2KHR(
- ResourceTracker* resourceTracker,
- VkDisplayPlaneProperties2KHR* toTransform)
-{
+void transform_fromhost_VkDisplayPlaneProperties2KHR(ResourceTracker* resourceTracker,
+ VkDisplayPlaneProperties2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkDisplayPlanePropertiesKHR(resourceTracker, (VkDisplayPlanePropertiesKHR*)(&toTransform->displayPlaneProperties));
+ transform_fromhost_VkDisplayPlanePropertiesKHR(
+ resourceTracker, (VkDisplayPlanePropertiesKHR*)(&toTransform->displayPlaneProperties));
}
-void transform_tohost_VkDisplayModeProperties2KHR(
- ResourceTracker* resourceTracker,
- VkDisplayModeProperties2KHR* toTransform)
-{
+void transform_tohost_VkDisplayModeProperties2KHR(ResourceTracker* resourceTracker,
+ VkDisplayModeProperties2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkDisplayModePropertiesKHR(resourceTracker, (VkDisplayModePropertiesKHR*)(&toTransform->displayModeProperties));
+ transform_tohost_VkDisplayModePropertiesKHR(
+ resourceTracker, (VkDisplayModePropertiesKHR*)(&toTransform->displayModeProperties));
}
-void transform_fromhost_VkDisplayModeProperties2KHR(
- ResourceTracker* resourceTracker,
- VkDisplayModeProperties2KHR* toTransform)
-{
+void transform_fromhost_VkDisplayModeProperties2KHR(ResourceTracker* resourceTracker,
+ VkDisplayModeProperties2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkDisplayModePropertiesKHR(resourceTracker, (VkDisplayModePropertiesKHR*)(&toTransform->displayModeProperties));
+ transform_fromhost_VkDisplayModePropertiesKHR(
+ resourceTracker, (VkDisplayModePropertiesKHR*)(&toTransform->displayModeProperties));
}
-void transform_tohost_VkDisplayPlaneInfo2KHR(
- ResourceTracker* resourceTracker,
- VkDisplayPlaneInfo2KHR* toTransform)
-{
+void transform_tohost_VkDisplayPlaneInfo2KHR(ResourceTracker* resourceTracker,
+ VkDisplayPlaneInfo2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkDisplayPlaneInfo2KHR(
- ResourceTracker* resourceTracker,
- VkDisplayPlaneInfo2KHR* toTransform)
-{
+void transform_fromhost_VkDisplayPlaneInfo2KHR(ResourceTracker* resourceTracker,
+ VkDisplayPlaneInfo2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkDisplayPlaneCapabilities2KHR(
- ResourceTracker* resourceTracker,
- VkDisplayPlaneCapabilities2KHR* toTransform)
-{
+void transform_tohost_VkDisplayPlaneCapabilities2KHR(ResourceTracker* resourceTracker,
+ VkDisplayPlaneCapabilities2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkDisplayPlaneCapabilitiesKHR(resourceTracker, (VkDisplayPlaneCapabilitiesKHR*)(&toTransform->capabilities));
+ transform_tohost_VkDisplayPlaneCapabilitiesKHR(
+ resourceTracker, (VkDisplayPlaneCapabilitiesKHR*)(&toTransform->capabilities));
}
void transform_fromhost_VkDisplayPlaneCapabilities2KHR(
- ResourceTracker* resourceTracker,
- VkDisplayPlaneCapabilities2KHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDisplayPlaneCapabilities2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkDisplayPlaneCapabilitiesKHR(resourceTracker, (VkDisplayPlaneCapabilitiesKHR*)(&toTransform->capabilities));
+ transform_fromhost_VkDisplayPlaneCapabilitiesKHR(
+ resourceTracker, (VkDisplayPlaneCapabilitiesKHR*)(&toTransform->capabilities));
}
#endif
@@ -8466,49 +6706,37 @@
#endif
#ifdef VK_KHR_portability_subset
void transform_tohost_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePortabilitySubsetFeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevicePortabilitySubsetFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePortabilitySubsetFeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevicePortabilitySubsetFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePortabilitySubsetPropertiesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevicePortabilitySubsetPropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePortabilitySubsetPropertiesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevicePortabilitySubsetPropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -8526,25 +6754,19 @@
#endif
#ifdef VK_KHR_shader_clock
void transform_tohost_VkPhysicalDeviceShaderClockFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderClockFeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderClockFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceShaderClockFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderClockFeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderClockFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -8565,24 +6787,20 @@
#ifdef VK_KHR_shader_terminate_invocation
void transform_tohost_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toTransform)
-{
+ VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toTransform)
-{
+ VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -8590,47 +6808,43 @@
#endif
#ifdef VK_KHR_fragment_shading_rate
void transform_tohost_VkFragmentShadingRateAttachmentInfoKHR(
- ResourceTracker* resourceTracker,
- VkFragmentShadingRateAttachmentInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkFragmentShadingRateAttachmentInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pFragmentShadingRateAttachment)
- {
- transform_tohost_VkAttachmentReference2(resourceTracker, (VkAttachmentReference2*)(toTransform->pFragmentShadingRateAttachment));
+ if (toTransform->pFragmentShadingRateAttachment) {
+ transform_tohost_VkAttachmentReference2(
+ resourceTracker,
+ (VkAttachmentReference2*)(toTransform->pFragmentShadingRateAttachment));
}
- transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->shadingRateAttachmentTexelSize));
+ transform_tohost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->shadingRateAttachmentTexelSize));
}
void transform_fromhost_VkFragmentShadingRateAttachmentInfoKHR(
- ResourceTracker* resourceTracker,
- VkFragmentShadingRateAttachmentInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkFragmentShadingRateAttachmentInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pFragmentShadingRateAttachment)
- {
- transform_fromhost_VkAttachmentReference2(resourceTracker, (VkAttachmentReference2*)(toTransform->pFragmentShadingRateAttachment));
+ if (toTransform->pFragmentShadingRateAttachment) {
+ transform_fromhost_VkAttachmentReference2(
+ resourceTracker,
+ (VkAttachmentReference2*)(toTransform->pFragmentShadingRateAttachment));
}
- transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->shadingRateAttachmentTexelSize));
+ transform_fromhost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->shadingRateAttachmentTexelSize));
}
void transform_tohost_VkPipelineFragmentShadingRateStateCreateInfoKHR(
ResourceTracker* resourceTracker,
- VkPipelineFragmentShadingRateStateCreateInfoKHR* toTransform)
-{
+ VkPipelineFragmentShadingRateStateCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->fragmentSize));
@@ -8638,92 +6852,78 @@
void transform_fromhost_VkPipelineFragmentShadingRateStateCreateInfoKHR(
ResourceTracker* resourceTracker,
- VkPipelineFragmentShadingRateStateCreateInfoKHR* toTransform)
-{
+ VkPipelineFragmentShadingRateStateCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->fragmentSize));
}
void transform_tohost_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentShadingRateFeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFragmentShadingRateFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentShadingRateFeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFragmentShadingRateFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentShadingRatePropertiesKHR* toTransform)
-{
+ VkPhysicalDeviceFragmentShadingRatePropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->minFragmentShadingRateAttachmentTexelSize));
- transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxFragmentShadingRateAttachmentTexelSize));
+ transform_tohost_VkExtent2D(
+ resourceTracker, (VkExtent2D*)(&toTransform->minFragmentShadingRateAttachmentTexelSize));
+ transform_tohost_VkExtent2D(
+ resourceTracker, (VkExtent2D*)(&toTransform->maxFragmentShadingRateAttachmentTexelSize));
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxFragmentSize));
}
void transform_fromhost_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentShadingRatePropertiesKHR* toTransform)
-{
+ VkPhysicalDeviceFragmentShadingRatePropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->minFragmentShadingRateAttachmentTexelSize));
- transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxFragmentShadingRateAttachmentTexelSize));
+ transform_fromhost_VkExtent2D(
+ resourceTracker, (VkExtent2D*)(&toTransform->minFragmentShadingRateAttachmentTexelSize));
+ transform_fromhost_VkExtent2D(
+ resourceTracker, (VkExtent2D*)(&toTransform->maxFragmentShadingRateAttachmentTexelSize));
transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxFragmentSize));
}
void transform_tohost_VkPhysicalDeviceFragmentShadingRateKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentShadingRateKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFragmentShadingRateKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->fragmentSize));
}
void transform_fromhost_VkPhysicalDeviceFragmentShadingRateKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentShadingRateKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFragmentShadingRateKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->fragmentSize));
@@ -8734,25 +6934,19 @@
#endif
#ifdef VK_KHR_surface_protected_capabilities
void transform_tohost_VkSurfaceProtectedCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkSurfaceProtectedCapabilitiesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSurfaceProtectedCapabilitiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkSurfaceProtectedCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkSurfaceProtectedCapabilitiesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSurfaceProtectedCapabilitiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -8762,25 +6956,19 @@
#endif
#ifdef VK_KHR_present_wait
void transform_tohost_VkPhysicalDevicePresentWaitFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePresentWaitFeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevicePresentWaitFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDevicePresentWaitFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePresentWaitFeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevicePresentWaitFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -8795,162 +6983,126 @@
#ifdef VK_KHR_pipeline_executable_properties
void transform_tohost_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* toTransform)
-{
+ VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* toTransform)
-{
+ VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkPipelineInfoKHR(
- ResourceTracker* resourceTracker,
- VkPipelineInfoKHR* toTransform)
-{
+void transform_tohost_VkPipelineInfoKHR(ResourceTracker* resourceTracker,
+ VkPipelineInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkPipelineInfoKHR(
- ResourceTracker* resourceTracker,
- VkPipelineInfoKHR* toTransform)
-{
+void transform_fromhost_VkPipelineInfoKHR(ResourceTracker* resourceTracker,
+ VkPipelineInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPipelineExecutablePropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPipelineExecutablePropertiesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineExecutablePropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineExecutablePropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPipelineExecutablePropertiesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineExecutablePropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkPipelineExecutableInfoKHR(
- ResourceTracker* resourceTracker,
- VkPipelineExecutableInfoKHR* toTransform)
-{
+void transform_tohost_VkPipelineExecutableInfoKHR(ResourceTracker* resourceTracker,
+ VkPipelineExecutableInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkPipelineExecutableInfoKHR(
- ResourceTracker* resourceTracker,
- VkPipelineExecutableInfoKHR* toTransform)
-{
+void transform_fromhost_VkPipelineExecutableInfoKHR(ResourceTracker* resourceTracker,
+ VkPipelineExecutableInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPipelineExecutableStatisticValueKHR(
- ResourceTracker* resourceTracker,
- VkPipelineExecutableStatisticValueKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineExecutableStatisticValueKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_fromhost_VkPipelineExecutableStatisticValueKHR(
- ResourceTracker* resourceTracker,
- VkPipelineExecutableStatisticValueKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineExecutableStatisticValueKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkPipelineExecutableStatisticKHR(
- ResourceTracker* resourceTracker,
- VkPipelineExecutableStatisticKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineExecutableStatisticKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkPipelineExecutableStatisticValueKHR(resourceTracker, (VkPipelineExecutableStatisticValueKHR*)(&toTransform->value));
+ transform_tohost_VkPipelineExecutableStatisticValueKHR(
+ resourceTracker, (VkPipelineExecutableStatisticValueKHR*)(&toTransform->value));
}
void transform_fromhost_VkPipelineExecutableStatisticKHR(
- ResourceTracker* resourceTracker,
- VkPipelineExecutableStatisticKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineExecutableStatisticKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkPipelineExecutableStatisticValueKHR(resourceTracker, (VkPipelineExecutableStatisticValueKHR*)(&toTransform->value));
+ transform_fromhost_VkPipelineExecutableStatisticValueKHR(
+ resourceTracker, (VkPipelineExecutableStatisticValueKHR*)(&toTransform->value));
}
void transform_tohost_VkPipelineExecutableInternalRepresentationKHR(
- ResourceTracker* resourceTracker,
- VkPipelineExecutableInternalRepresentationKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineExecutableInternalRepresentationKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineExecutableInternalRepresentationKHR(
- ResourceTracker* resourceTracker,
- VkPipelineExecutableInternalRepresentationKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineExecutableInternalRepresentationKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -8959,74 +7111,60 @@
#ifdef VK_KHR_shader_integer_dot_product
void transform_tohost_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* toTransform)
-{
+ VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* toTransform)
-{
+ VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* toTransform)
-{
+ VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* toTransform)
-{
+ VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_KHR_pipeline_library
-void transform_tohost_VkPipelineLibraryCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkPipelineLibraryCreateInfoKHR* toTransform)
-{
+void transform_tohost_VkPipelineLibraryCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkPipelineLibraryCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineLibraryCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkPipelineLibraryCreateInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineLibraryCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -9035,496 +7173,398 @@
#ifdef VK_KHR_shader_non_semantic_info
#endif
#ifdef VK_KHR_present_id
-void transform_tohost_VkPresentIdKHR(
- ResourceTracker* resourceTracker,
- VkPresentIdKHR* toTransform)
-{
+void transform_tohost_VkPresentIdKHR(ResourceTracker* resourceTracker,
+ VkPresentIdKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkPresentIdKHR(
- ResourceTracker* resourceTracker,
- VkPresentIdKHR* toTransform)
-{
+void transform_fromhost_VkPresentIdKHR(ResourceTracker* resourceTracker,
+ VkPresentIdKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDevicePresentIdFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePresentIdFeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevicePresentIdFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDevicePresentIdFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePresentIdFeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevicePresentIdFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_KHR_video_encode_queue
-void transform_tohost_VkVideoEncodeInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoEncodeInfoKHR* toTransform)
-{
+void transform_tohost_VkVideoEncodeInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoEncodeInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->codedExtent));
- transform_tohost_VkVideoPictureResourceKHR(resourceTracker, (VkVideoPictureResourceKHR*)(&toTransform->srcPictureResource));
- if (toTransform->pSetupReferenceSlot)
- {
- transform_tohost_VkVideoReferenceSlotKHR(resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pSetupReferenceSlot));
+ transform_tohost_VkVideoPictureResourceKHR(
+ resourceTracker, (VkVideoPictureResourceKHR*)(&toTransform->srcPictureResource));
+ if (toTransform->pSetupReferenceSlot) {
+ transform_tohost_VkVideoReferenceSlotKHR(
+ resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pSetupReferenceSlot));
}
- if (toTransform)
- {
- if (toTransform->pReferenceSlots)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->referenceSlotCount; ++i)
- {
- transform_tohost_VkVideoReferenceSlotKHR(resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pReferenceSlots + i));
+ if (toTransform) {
+ if (toTransform->pReferenceSlots) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->referenceSlotCount; ++i) {
+ transform_tohost_VkVideoReferenceSlotKHR(
+ resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pReferenceSlots + i));
}
}
}
}
-void transform_fromhost_VkVideoEncodeInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoEncodeInfoKHR* toTransform)
-{
+void transform_fromhost_VkVideoEncodeInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoEncodeInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->codedExtent));
- transform_fromhost_VkVideoPictureResourceKHR(resourceTracker, (VkVideoPictureResourceKHR*)(&toTransform->srcPictureResource));
- if (toTransform->pSetupReferenceSlot)
- {
- transform_fromhost_VkVideoReferenceSlotKHR(resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pSetupReferenceSlot));
+ transform_fromhost_VkVideoPictureResourceKHR(
+ resourceTracker, (VkVideoPictureResourceKHR*)(&toTransform->srcPictureResource));
+ if (toTransform->pSetupReferenceSlot) {
+ transform_fromhost_VkVideoReferenceSlotKHR(
+ resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pSetupReferenceSlot));
}
- if (toTransform)
- {
- if (toTransform->pReferenceSlots)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->referenceSlotCount; ++i)
- {
- transform_fromhost_VkVideoReferenceSlotKHR(resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pReferenceSlots + i));
+ if (toTransform) {
+ if (toTransform->pReferenceSlots) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->referenceSlotCount; ++i) {
+ transform_fromhost_VkVideoReferenceSlotKHR(
+ resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pReferenceSlots + i));
}
}
}
}
void transform_tohost_VkVideoEncodeRateControlInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoEncodeRateControlInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeRateControlInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkVideoEncodeRateControlInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoEncodeRateControlInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeRateControlInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_KHR_synchronization2
-void transform_tohost_VkMemoryBarrier2KHR(
- ResourceTracker* resourceTracker,
- VkMemoryBarrier2KHR* toTransform)
-{
+void transform_tohost_VkMemoryBarrier2KHR(ResourceTracker* resourceTracker,
+ VkMemoryBarrier2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkMemoryBarrier2KHR(
- ResourceTracker* resourceTracker,
- VkMemoryBarrier2KHR* toTransform)
-{
+void transform_fromhost_VkMemoryBarrier2KHR(ResourceTracker* resourceTracker,
+ VkMemoryBarrier2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkBufferMemoryBarrier2KHR(
- ResourceTracker* resourceTracker,
- VkBufferMemoryBarrier2KHR* toTransform)
-{
+void transform_tohost_VkBufferMemoryBarrier2KHR(ResourceTracker* resourceTracker,
+ VkBufferMemoryBarrier2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkBufferMemoryBarrier2KHR(
- ResourceTracker* resourceTracker,
- VkBufferMemoryBarrier2KHR* toTransform)
-{
+void transform_fromhost_VkBufferMemoryBarrier2KHR(ResourceTracker* resourceTracker,
+ VkBufferMemoryBarrier2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkImageMemoryBarrier2KHR(
- ResourceTracker* resourceTracker,
- VkImageMemoryBarrier2KHR* toTransform)
-{
+void transform_tohost_VkImageMemoryBarrier2KHR(ResourceTracker* resourceTracker,
+ VkImageMemoryBarrier2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkImageSubresourceRange(resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
+ transform_tohost_VkImageSubresourceRange(
+ resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
}
-void transform_fromhost_VkImageMemoryBarrier2KHR(
- ResourceTracker* resourceTracker,
- VkImageMemoryBarrier2KHR* toTransform)
-{
+void transform_fromhost_VkImageMemoryBarrier2KHR(ResourceTracker* resourceTracker,
+ VkImageMemoryBarrier2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkImageSubresourceRange(resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
+ transform_fromhost_VkImageSubresourceRange(
+ resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
}
-void transform_tohost_VkDependencyInfoKHR(
- ResourceTracker* resourceTracker,
- VkDependencyInfoKHR* toTransform)
-{
+void transform_tohost_VkDependencyInfoKHR(ResourceTracker* resourceTracker,
+ VkDependencyInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pMemoryBarriers)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->memoryBarrierCount; ++i)
- {
- transform_tohost_VkMemoryBarrier2KHR(resourceTracker, (VkMemoryBarrier2KHR*)(toTransform->pMemoryBarriers + i));
+ if (toTransform) {
+ if (toTransform->pMemoryBarriers) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->memoryBarrierCount; ++i) {
+ transform_tohost_VkMemoryBarrier2KHR(
+ resourceTracker, (VkMemoryBarrier2KHR*)(toTransform->pMemoryBarriers + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pBufferMemoryBarriers)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->bufferMemoryBarrierCount; ++i)
- {
- transform_tohost_VkBufferMemoryBarrier2KHR(resourceTracker, (VkBufferMemoryBarrier2KHR*)(toTransform->pBufferMemoryBarriers + i));
+ if (toTransform) {
+ if (toTransform->pBufferMemoryBarriers) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->bufferMemoryBarrierCount; ++i) {
+ transform_tohost_VkBufferMemoryBarrier2KHR(
+ resourceTracker,
+ (VkBufferMemoryBarrier2KHR*)(toTransform->pBufferMemoryBarriers + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pImageMemoryBarriers)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->imageMemoryBarrierCount; ++i)
- {
- transform_tohost_VkImageMemoryBarrier2KHR(resourceTracker, (VkImageMemoryBarrier2KHR*)(toTransform->pImageMemoryBarriers + i));
+ if (toTransform) {
+ if (toTransform->pImageMemoryBarriers) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->imageMemoryBarrierCount; ++i) {
+ transform_tohost_VkImageMemoryBarrier2KHR(
+ resourceTracker,
+ (VkImageMemoryBarrier2KHR*)(toTransform->pImageMemoryBarriers + i));
}
}
}
}
-void transform_fromhost_VkDependencyInfoKHR(
- ResourceTracker* resourceTracker,
- VkDependencyInfoKHR* toTransform)
-{
+void transform_fromhost_VkDependencyInfoKHR(ResourceTracker* resourceTracker,
+ VkDependencyInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pMemoryBarriers)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->memoryBarrierCount; ++i)
- {
- transform_fromhost_VkMemoryBarrier2KHR(resourceTracker, (VkMemoryBarrier2KHR*)(toTransform->pMemoryBarriers + i));
+ if (toTransform) {
+ if (toTransform->pMemoryBarriers) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->memoryBarrierCount; ++i) {
+ transform_fromhost_VkMemoryBarrier2KHR(
+ resourceTracker, (VkMemoryBarrier2KHR*)(toTransform->pMemoryBarriers + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pBufferMemoryBarriers)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->bufferMemoryBarrierCount; ++i)
- {
- transform_fromhost_VkBufferMemoryBarrier2KHR(resourceTracker, (VkBufferMemoryBarrier2KHR*)(toTransform->pBufferMemoryBarriers + i));
+ if (toTransform) {
+ if (toTransform->pBufferMemoryBarriers) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->bufferMemoryBarrierCount; ++i) {
+ transform_fromhost_VkBufferMemoryBarrier2KHR(
+ resourceTracker,
+ (VkBufferMemoryBarrier2KHR*)(toTransform->pBufferMemoryBarriers + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pImageMemoryBarriers)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->imageMemoryBarrierCount; ++i)
- {
- transform_fromhost_VkImageMemoryBarrier2KHR(resourceTracker, (VkImageMemoryBarrier2KHR*)(toTransform->pImageMemoryBarriers + i));
+ if (toTransform) {
+ if (toTransform->pImageMemoryBarriers) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->imageMemoryBarrierCount; ++i) {
+ transform_fromhost_VkImageMemoryBarrier2KHR(
+ resourceTracker,
+ (VkImageMemoryBarrier2KHR*)(toTransform->pImageMemoryBarriers + i));
}
}
}
}
-void transform_tohost_VkSemaphoreSubmitInfoKHR(
- ResourceTracker* resourceTracker,
- VkSemaphoreSubmitInfoKHR* toTransform)
-{
+void transform_tohost_VkSemaphoreSubmitInfoKHR(ResourceTracker* resourceTracker,
+ VkSemaphoreSubmitInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkSemaphoreSubmitInfoKHR(
- ResourceTracker* resourceTracker,
- VkSemaphoreSubmitInfoKHR* toTransform)
-{
+void transform_fromhost_VkSemaphoreSubmitInfoKHR(ResourceTracker* resourceTracker,
+ VkSemaphoreSubmitInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkCommandBufferSubmitInfoKHR(
- ResourceTracker* resourceTracker,
- VkCommandBufferSubmitInfoKHR* toTransform)
-{
+void transform_tohost_VkCommandBufferSubmitInfoKHR(ResourceTracker* resourceTracker,
+ VkCommandBufferSubmitInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkCommandBufferSubmitInfoKHR(
- ResourceTracker* resourceTracker,
- VkCommandBufferSubmitInfoKHR* toTransform)
-{
+void transform_fromhost_VkCommandBufferSubmitInfoKHR(ResourceTracker* resourceTracker,
+ VkCommandBufferSubmitInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkSubmitInfo2KHR(
- ResourceTracker* resourceTracker,
- VkSubmitInfo2KHR* toTransform)
-{
+void transform_tohost_VkSubmitInfo2KHR(ResourceTracker* resourceTracker,
+ VkSubmitInfo2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pWaitSemaphoreInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->waitSemaphoreInfoCount; ++i)
- {
- transform_tohost_VkSemaphoreSubmitInfoKHR(resourceTracker, (VkSemaphoreSubmitInfoKHR*)(toTransform->pWaitSemaphoreInfos + i));
+ if (toTransform) {
+ if (toTransform->pWaitSemaphoreInfos) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->waitSemaphoreInfoCount; ++i) {
+ transform_tohost_VkSemaphoreSubmitInfoKHR(
+ resourceTracker,
+ (VkSemaphoreSubmitInfoKHR*)(toTransform->pWaitSemaphoreInfos + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pCommandBufferInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->commandBufferInfoCount; ++i)
- {
- transform_tohost_VkCommandBufferSubmitInfoKHR(resourceTracker, (VkCommandBufferSubmitInfoKHR*)(toTransform->pCommandBufferInfos + i));
+ if (toTransform) {
+ if (toTransform->pCommandBufferInfos) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->commandBufferInfoCount; ++i) {
+ transform_tohost_VkCommandBufferSubmitInfoKHR(
+ resourceTracker,
+ (VkCommandBufferSubmitInfoKHR*)(toTransform->pCommandBufferInfos + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pSignalSemaphoreInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->signalSemaphoreInfoCount; ++i)
- {
- transform_tohost_VkSemaphoreSubmitInfoKHR(resourceTracker, (VkSemaphoreSubmitInfoKHR*)(toTransform->pSignalSemaphoreInfos + i));
+ if (toTransform) {
+ if (toTransform->pSignalSemaphoreInfos) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->signalSemaphoreInfoCount; ++i) {
+ transform_tohost_VkSemaphoreSubmitInfoKHR(
+ resourceTracker,
+ (VkSemaphoreSubmitInfoKHR*)(toTransform->pSignalSemaphoreInfos + i));
}
}
}
}
-void transform_fromhost_VkSubmitInfo2KHR(
- ResourceTracker* resourceTracker,
- VkSubmitInfo2KHR* toTransform)
-{
+void transform_fromhost_VkSubmitInfo2KHR(ResourceTracker* resourceTracker,
+ VkSubmitInfo2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pWaitSemaphoreInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->waitSemaphoreInfoCount; ++i)
- {
- transform_fromhost_VkSemaphoreSubmitInfoKHR(resourceTracker, (VkSemaphoreSubmitInfoKHR*)(toTransform->pWaitSemaphoreInfos + i));
+ if (toTransform) {
+ if (toTransform->pWaitSemaphoreInfos) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->waitSemaphoreInfoCount; ++i) {
+ transform_fromhost_VkSemaphoreSubmitInfoKHR(
+ resourceTracker,
+ (VkSemaphoreSubmitInfoKHR*)(toTransform->pWaitSemaphoreInfos + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pCommandBufferInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->commandBufferInfoCount; ++i)
- {
- transform_fromhost_VkCommandBufferSubmitInfoKHR(resourceTracker, (VkCommandBufferSubmitInfoKHR*)(toTransform->pCommandBufferInfos + i));
+ if (toTransform) {
+ if (toTransform->pCommandBufferInfos) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->commandBufferInfoCount; ++i) {
+ transform_fromhost_VkCommandBufferSubmitInfoKHR(
+ resourceTracker,
+ (VkCommandBufferSubmitInfoKHR*)(toTransform->pCommandBufferInfos + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pSignalSemaphoreInfos)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->signalSemaphoreInfoCount; ++i)
- {
- transform_fromhost_VkSemaphoreSubmitInfoKHR(resourceTracker, (VkSemaphoreSubmitInfoKHR*)(toTransform->pSignalSemaphoreInfos + i));
+ if (toTransform) {
+ if (toTransform->pSignalSemaphoreInfos) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->signalSemaphoreInfoCount; ++i) {
+ transform_fromhost_VkSemaphoreSubmitInfoKHR(
+ resourceTracker,
+ (VkSemaphoreSubmitInfoKHR*)(toTransform->pSignalSemaphoreInfos + i));
}
}
}
}
void transform_tohost_VkPhysicalDeviceSynchronization2FeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSynchronization2FeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSynchronization2FeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceSynchronization2FeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSynchronization2FeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSynchronization2FeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkQueueFamilyCheckpointProperties2NV(
- ResourceTracker* resourceTracker,
- VkQueueFamilyCheckpointProperties2NV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkQueueFamilyCheckpointProperties2NV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkQueueFamilyCheckpointProperties2NV(
- ResourceTracker* resourceTracker,
- VkQueueFamilyCheckpointProperties2NV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkQueueFamilyCheckpointProperties2NV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkCheckpointData2NV(
- ResourceTracker* resourceTracker,
- VkCheckpointData2NV* toTransform)
-{
+void transform_tohost_VkCheckpointData2NV(ResourceTracker* resourceTracker,
+ VkCheckpointData2NV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkCheckpointData2NV(
- ResourceTracker* resourceTracker,
- VkCheckpointData2NV* toTransform)
-{
+void transform_fromhost_VkCheckpointData2NV(ResourceTracker* resourceTracker,
+ VkCheckpointData2NV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -9533,24 +7573,20 @@
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
void transform_tohost_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* toTransform)
-{
+ VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* toTransform)
-{
+ VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -9559,24 +7595,20 @@
#ifdef VK_KHR_zero_initialize_workgroup_memory
void transform_tohost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* toTransform)
-{
+ VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* toTransform)
-{
+ VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -9585,455 +7617,371 @@
#ifdef VK_KHR_workgroup_memory_explicit_layout
void transform_tohost_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* toTransform)
-{
+ VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* toTransform)
-{
+ VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_KHR_copy_commands2
-void transform_tohost_VkBufferCopy2KHR(
- ResourceTracker* resourceTracker,
- VkBufferCopy2KHR* toTransform)
-{
+void transform_tohost_VkBufferCopy2KHR(ResourceTracker* resourceTracker,
+ VkBufferCopy2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkBufferCopy2KHR(
- ResourceTracker* resourceTracker,
- VkBufferCopy2KHR* toTransform)
-{
+void transform_fromhost_VkBufferCopy2KHR(ResourceTracker* resourceTracker,
+ VkBufferCopy2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkCopyBufferInfo2KHR(
- ResourceTracker* resourceTracker,
- VkCopyBufferInfo2KHR* toTransform)
-{
+void transform_tohost_VkCopyBufferInfo2KHR(ResourceTracker* resourceTracker,
+ VkCopyBufferInfo2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i)
- {
- transform_tohost_VkBufferCopy2KHR(resourceTracker, (VkBufferCopy2KHR*)(toTransform->pRegions + i));
+ if (toTransform) {
+ if (toTransform->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+ transform_tohost_VkBufferCopy2KHR(resourceTracker,
+ (VkBufferCopy2KHR*)(toTransform->pRegions + i));
}
}
}
}
-void transform_fromhost_VkCopyBufferInfo2KHR(
- ResourceTracker* resourceTracker,
- VkCopyBufferInfo2KHR* toTransform)
-{
+void transform_fromhost_VkCopyBufferInfo2KHR(ResourceTracker* resourceTracker,
+ VkCopyBufferInfo2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i)
- {
- transform_fromhost_VkBufferCopy2KHR(resourceTracker, (VkBufferCopy2KHR*)(toTransform->pRegions + i));
+ if (toTransform) {
+ if (toTransform->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+ transform_fromhost_VkBufferCopy2KHR(resourceTracker,
+ (VkBufferCopy2KHR*)(toTransform->pRegions + i));
}
}
}
}
-void transform_tohost_VkImageCopy2KHR(
- ResourceTracker* resourceTracker,
- VkImageCopy2KHR* toTransform)
-{
+void transform_tohost_VkImageCopy2KHR(ResourceTracker* resourceTracker,
+ VkImageCopy2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
+ transform_tohost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->srcOffset));
- transform_tohost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
+ transform_tohost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->dstOffset));
transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->extent));
}
-void transform_fromhost_VkImageCopy2KHR(
- ResourceTracker* resourceTracker,
- VkImageCopy2KHR* toTransform)
-{
+void transform_fromhost_VkImageCopy2KHR(ResourceTracker* resourceTracker,
+ VkImageCopy2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
+ transform_fromhost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->srcOffset));
- transform_fromhost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
+ transform_fromhost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->dstOffset));
transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->extent));
}
-void transform_tohost_VkCopyImageInfo2KHR(
- ResourceTracker* resourceTracker,
- VkCopyImageInfo2KHR* toTransform)
-{
+void transform_tohost_VkCopyImageInfo2KHR(ResourceTracker* resourceTracker,
+ VkCopyImageInfo2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i)
- {
- transform_tohost_VkImageCopy2KHR(resourceTracker, (VkImageCopy2KHR*)(toTransform->pRegions + i));
+ if (toTransform) {
+ if (toTransform->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+ transform_tohost_VkImageCopy2KHR(resourceTracker,
+ (VkImageCopy2KHR*)(toTransform->pRegions + i));
}
}
}
}
-void transform_fromhost_VkCopyImageInfo2KHR(
- ResourceTracker* resourceTracker,
- VkCopyImageInfo2KHR* toTransform)
-{
+void transform_fromhost_VkCopyImageInfo2KHR(ResourceTracker* resourceTracker,
+ VkCopyImageInfo2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i)
- {
- transform_fromhost_VkImageCopy2KHR(resourceTracker, (VkImageCopy2KHR*)(toTransform->pRegions + i));
+ if (toTransform) {
+ if (toTransform->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+ transform_fromhost_VkImageCopy2KHR(resourceTracker,
+ (VkImageCopy2KHR*)(toTransform->pRegions + i));
}
}
}
}
-void transform_tohost_VkBufferImageCopy2KHR(
- ResourceTracker* resourceTracker,
- VkBufferImageCopy2KHR* toTransform)
-{
+void transform_tohost_VkBufferImageCopy2KHR(ResourceTracker* resourceTracker,
+ VkBufferImageCopy2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
+ transform_tohost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
}
-void transform_fromhost_VkBufferImageCopy2KHR(
- ResourceTracker* resourceTracker,
- VkBufferImageCopy2KHR* toTransform)
-{
+void transform_fromhost_VkBufferImageCopy2KHR(ResourceTracker* resourceTracker,
+ VkBufferImageCopy2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
+ transform_fromhost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
}
-void transform_tohost_VkCopyBufferToImageInfo2KHR(
- ResourceTracker* resourceTracker,
- VkCopyBufferToImageInfo2KHR* toTransform)
-{
+void transform_tohost_VkCopyBufferToImageInfo2KHR(ResourceTracker* resourceTracker,
+ VkCopyBufferToImageInfo2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i)
- {
- transform_tohost_VkBufferImageCopy2KHR(resourceTracker, (VkBufferImageCopy2KHR*)(toTransform->pRegions + i));
+ if (toTransform) {
+ if (toTransform->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+ transform_tohost_VkBufferImageCopy2KHR(
+ resourceTracker, (VkBufferImageCopy2KHR*)(toTransform->pRegions + i));
}
}
}
}
-void transform_fromhost_VkCopyBufferToImageInfo2KHR(
- ResourceTracker* resourceTracker,
- VkCopyBufferToImageInfo2KHR* toTransform)
-{
+void transform_fromhost_VkCopyBufferToImageInfo2KHR(ResourceTracker* resourceTracker,
+ VkCopyBufferToImageInfo2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i)
- {
- transform_fromhost_VkBufferImageCopy2KHR(resourceTracker, (VkBufferImageCopy2KHR*)(toTransform->pRegions + i));
+ if (toTransform) {
+ if (toTransform->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+ transform_fromhost_VkBufferImageCopy2KHR(
+ resourceTracker, (VkBufferImageCopy2KHR*)(toTransform->pRegions + i));
}
}
}
}
-void transform_tohost_VkCopyImageToBufferInfo2KHR(
- ResourceTracker* resourceTracker,
- VkCopyImageToBufferInfo2KHR* toTransform)
-{
+void transform_tohost_VkCopyImageToBufferInfo2KHR(ResourceTracker* resourceTracker,
+ VkCopyImageToBufferInfo2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i)
- {
- transform_tohost_VkBufferImageCopy2KHR(resourceTracker, (VkBufferImageCopy2KHR*)(toTransform->pRegions + i));
+ if (toTransform) {
+ if (toTransform->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+ transform_tohost_VkBufferImageCopy2KHR(
+ resourceTracker, (VkBufferImageCopy2KHR*)(toTransform->pRegions + i));
}
}
}
}
-void transform_fromhost_VkCopyImageToBufferInfo2KHR(
- ResourceTracker* resourceTracker,
- VkCopyImageToBufferInfo2KHR* toTransform)
-{
+void transform_fromhost_VkCopyImageToBufferInfo2KHR(ResourceTracker* resourceTracker,
+ VkCopyImageToBufferInfo2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i)
- {
- transform_fromhost_VkBufferImageCopy2KHR(resourceTracker, (VkBufferImageCopy2KHR*)(toTransform->pRegions + i));
+ if (toTransform) {
+ if (toTransform->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+ transform_fromhost_VkBufferImageCopy2KHR(
+ resourceTracker, (VkBufferImageCopy2KHR*)(toTransform->pRegions + i));
}
}
}
}
-void transform_tohost_VkImageBlit2KHR(
- ResourceTracker* resourceTracker,
- VkImageBlit2KHR* toTransform)
-{
+void transform_tohost_VkImageBlit2KHR(ResourceTracker* resourceTracker,
+ VkImageBlit2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ transform_tohost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(toTransform->srcOffsets + i));
}
- transform_tohost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ transform_tohost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(toTransform->dstOffsets + i));
}
}
-void transform_fromhost_VkImageBlit2KHR(
- ResourceTracker* resourceTracker,
- VkImageBlit2KHR* toTransform)
-{
+void transform_fromhost_VkImageBlit2KHR(ResourceTracker* resourceTracker,
+ VkImageBlit2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ transform_fromhost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(toTransform->srcOffsets + i));
}
- transform_fromhost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
- for (uint32_t i = 0; i < (uint32_t)2; ++i)
- {
+ transform_fromhost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
+ for (uint32_t i = 0; i < (uint32_t)2; ++i) {
transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(toTransform->dstOffsets + i));
}
}
-void transform_tohost_VkBlitImageInfo2KHR(
- ResourceTracker* resourceTracker,
- VkBlitImageInfo2KHR* toTransform)
-{
+void transform_tohost_VkBlitImageInfo2KHR(ResourceTracker* resourceTracker,
+ VkBlitImageInfo2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i)
- {
- transform_tohost_VkImageBlit2KHR(resourceTracker, (VkImageBlit2KHR*)(toTransform->pRegions + i));
+ if (toTransform) {
+ if (toTransform->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+ transform_tohost_VkImageBlit2KHR(resourceTracker,
+ (VkImageBlit2KHR*)(toTransform->pRegions + i));
}
}
}
}
-void transform_fromhost_VkBlitImageInfo2KHR(
- ResourceTracker* resourceTracker,
- VkBlitImageInfo2KHR* toTransform)
-{
+void transform_fromhost_VkBlitImageInfo2KHR(ResourceTracker* resourceTracker,
+ VkBlitImageInfo2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i)
- {
- transform_fromhost_VkImageBlit2KHR(resourceTracker, (VkImageBlit2KHR*)(toTransform->pRegions + i));
+ if (toTransform) {
+ if (toTransform->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+ transform_fromhost_VkImageBlit2KHR(resourceTracker,
+ (VkImageBlit2KHR*)(toTransform->pRegions + i));
}
}
}
}
-void transform_tohost_VkImageResolve2KHR(
- ResourceTracker* resourceTracker,
- VkImageResolve2KHR* toTransform)
-{
+void transform_tohost_VkImageResolve2KHR(ResourceTracker* resourceTracker,
+ VkImageResolve2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
+ transform_tohost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->srcOffset));
- transform_tohost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
+ transform_tohost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->dstOffset));
transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->extent));
}
-void transform_fromhost_VkImageResolve2KHR(
- ResourceTracker* resourceTracker,
- VkImageResolve2KHR* toTransform)
-{
+void transform_fromhost_VkImageResolve2KHR(ResourceTracker* resourceTracker,
+ VkImageResolve2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
+ transform_fromhost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->srcOffset));
- transform_fromhost_VkImageSubresourceLayers(resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
+ transform_fromhost_VkImageSubresourceLayers(
+ resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->dstOffset));
transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->extent));
}
-void transform_tohost_VkResolveImageInfo2KHR(
- ResourceTracker* resourceTracker,
- VkResolveImageInfo2KHR* toTransform)
-{
+void transform_tohost_VkResolveImageInfo2KHR(ResourceTracker* resourceTracker,
+ VkResolveImageInfo2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i)
- {
- transform_tohost_VkImageResolve2KHR(resourceTracker, (VkImageResolve2KHR*)(toTransform->pRegions + i));
+ if (toTransform) {
+ if (toTransform->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+ transform_tohost_VkImageResolve2KHR(
+ resourceTracker, (VkImageResolve2KHR*)(toTransform->pRegions + i));
}
}
}
}
-void transform_fromhost_VkResolveImageInfo2KHR(
- ResourceTracker* resourceTracker,
- VkResolveImageInfo2KHR* toTransform)
-{
+void transform_fromhost_VkResolveImageInfo2KHR(ResourceTracker* resourceTracker,
+ VkResolveImageInfo2KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pRegions)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i)
- {
- transform_fromhost_VkImageResolve2KHR(resourceTracker, (VkImageResolve2KHR*)(toTransform->pRegions + i));
+ if (toTransform) {
+ if (toTransform->pRegions) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+ transform_fromhost_VkImageResolve2KHR(
+ resourceTracker, (VkImageResolve2KHR*)(toTransform->pRegions + i));
}
}
}
@@ -10041,26 +7989,20 @@
#endif
#ifdef VK_KHR_format_feature_flags2
-void transform_tohost_VkFormatProperties3KHR(
- ResourceTracker* resourceTracker,
- VkFormatProperties3KHR* toTransform)
-{
+void transform_tohost_VkFormatProperties3KHR(ResourceTracker* resourceTracker,
+ VkFormatProperties3KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkFormatProperties3KHR(
- ResourceTracker* resourceTracker,
- VkFormatProperties3KHR* toTransform)
-{
+void transform_fromhost_VkFormatProperties3KHR(ResourceTracker* resourceTracker,
+ VkFormatProperties3KHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -10068,139 +8010,111 @@
#endif
#ifdef VK_KHR_maintenance4
void transform_tohost_VkPhysicalDeviceMaintenance4FeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMaintenance4FeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance4FeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceMaintenance4FeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMaintenance4FeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance4FeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceMaintenance4PropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMaintenance4PropertiesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance4PropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceMaintenance4PropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMaintenance4PropertiesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance4PropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkDeviceBufferMemoryRequirementsKHR(
- ResourceTracker* resourceTracker,
- VkDeviceBufferMemoryRequirementsKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceBufferMemoryRequirementsKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pCreateInfo)
- {
- transform_tohost_VkBufferCreateInfo(resourceTracker, (VkBufferCreateInfo*)(toTransform->pCreateInfo));
+ if (toTransform->pCreateInfo) {
+ transform_tohost_VkBufferCreateInfo(resourceTracker,
+ (VkBufferCreateInfo*)(toTransform->pCreateInfo));
}
}
void transform_fromhost_VkDeviceBufferMemoryRequirementsKHR(
- ResourceTracker* resourceTracker,
- VkDeviceBufferMemoryRequirementsKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceBufferMemoryRequirementsKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pCreateInfo)
- {
- transform_fromhost_VkBufferCreateInfo(resourceTracker, (VkBufferCreateInfo*)(toTransform->pCreateInfo));
+ if (toTransform->pCreateInfo) {
+ transform_fromhost_VkBufferCreateInfo(resourceTracker,
+ (VkBufferCreateInfo*)(toTransform->pCreateInfo));
}
}
void transform_tohost_VkDeviceImageMemoryRequirementsKHR(
- ResourceTracker* resourceTracker,
- VkDeviceImageMemoryRequirementsKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceImageMemoryRequirementsKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pCreateInfo)
- {
- transform_tohost_VkImageCreateInfo(resourceTracker, (VkImageCreateInfo*)(toTransform->pCreateInfo));
+ if (toTransform->pCreateInfo) {
+ resourceTracker->transformImpl_VkImageCreateInfo_tohost(toTransform->pCreateInfo, 1);
+ transform_tohost_VkImageCreateInfo(resourceTracker,
+ (VkImageCreateInfo*)(toTransform->pCreateInfo));
}
}
void transform_fromhost_VkDeviceImageMemoryRequirementsKHR(
- ResourceTracker* resourceTracker,
- VkDeviceImageMemoryRequirementsKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceImageMemoryRequirementsKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pCreateInfo)
- {
- transform_fromhost_VkImageCreateInfo(resourceTracker, (VkImageCreateInfo*)(toTransform->pCreateInfo));
+ if (toTransform->pCreateInfo) {
+ resourceTracker->transformImpl_VkImageCreateInfo_fromhost(toTransform->pCreateInfo, 1);
+ transform_fromhost_VkImageCreateInfo(resourceTracker,
+ (VkImageCreateInfo*)(toTransform->pCreateInfo));
}
}
#endif
#ifdef VK_ANDROID_native_buffer
-void transform_tohost_VkNativeBufferANDROID(
- ResourceTracker* resourceTracker,
- VkNativeBufferANDROID* toTransform)
-{
+void transform_tohost_VkNativeBufferANDROID(ResourceTracker* resourceTracker,
+ VkNativeBufferANDROID* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkNativeBufferANDROID(
- ResourceTracker* resourceTracker,
- VkNativeBufferANDROID* toTransform)
-{
+void transform_fromhost_VkNativeBufferANDROID(ResourceTracker* resourceTracker,
+ VkNativeBufferANDROID* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -10208,25 +8122,19 @@
#endif
#ifdef VK_EXT_debug_report
void transform_tohost_VkDebugReportCallbackCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugReportCallbackCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDebugReportCallbackCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDebugReportCallbackCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugReportCallbackCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDebugReportCallbackCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -10241,24 +8149,20 @@
#ifdef VK_AMD_rasterization_order
void transform_tohost_VkPipelineRasterizationStateRasterizationOrderAMD(
ResourceTracker* resourceTracker,
- VkPipelineRasterizationStateRasterizationOrderAMD* toTransform)
-{
+ VkPipelineRasterizationStateRasterizationOrderAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineRasterizationStateRasterizationOrderAMD(
ResourceTracker* resourceTracker,
- VkPipelineRasterizationStateRasterizationOrderAMD* toTransform)
-{
+ VkPipelineRasterizationStateRasterizationOrderAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -10269,74 +8173,56 @@
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
-void transform_tohost_VkDebugMarkerObjectNameInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugMarkerObjectNameInfoEXT* toTransform)
-{
+void transform_tohost_VkDebugMarkerObjectNameInfoEXT(ResourceTracker* resourceTracker,
+ VkDebugMarkerObjectNameInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDebugMarkerObjectNameInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugMarkerObjectNameInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDebugMarkerObjectNameInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkDebugMarkerObjectTagInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugMarkerObjectTagInfoEXT* toTransform)
-{
+void transform_tohost_VkDebugMarkerObjectTagInfoEXT(ResourceTracker* resourceTracker,
+ VkDebugMarkerObjectTagInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkDebugMarkerObjectTagInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugMarkerObjectTagInfoEXT* toTransform)
-{
+void transform_fromhost_VkDebugMarkerObjectTagInfoEXT(ResourceTracker* resourceTracker,
+ VkDebugMarkerObjectTagInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkDebugMarkerMarkerInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugMarkerMarkerInfoEXT* toTransform)
-{
+void transform_tohost_VkDebugMarkerMarkerInfoEXT(ResourceTracker* resourceTracker,
+ VkDebugMarkerMarkerInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkDebugMarkerMarkerInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugMarkerMarkerInfoEXT* toTransform)
-{
+void transform_fromhost_VkDebugMarkerMarkerInfoEXT(ResourceTracker* resourceTracker,
+ VkDebugMarkerMarkerInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -10346,73 +8232,55 @@
#endif
#ifdef VK_NV_dedicated_allocation
void transform_tohost_VkDedicatedAllocationImageCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkDedicatedAllocationImageCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDedicatedAllocationImageCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDedicatedAllocationImageCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkDedicatedAllocationImageCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDedicatedAllocationImageCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkDedicatedAllocationBufferCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkDedicatedAllocationBufferCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDedicatedAllocationBufferCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDedicatedAllocationBufferCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkDedicatedAllocationBufferCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDedicatedAllocationBufferCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkDedicatedAllocationMemoryAllocateInfoNV(
- ResourceTracker* resourceTracker,
- VkDedicatedAllocationMemoryAllocateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDedicatedAllocationMemoryAllocateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDedicatedAllocationMemoryAllocateInfoNV(
- ResourceTracker* resourceTracker,
- VkDedicatedAllocationMemoryAllocateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDedicatedAllocationMemoryAllocateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -10420,197 +8288,151 @@
#endif
#ifdef VK_EXT_transform_feedback
void transform_tohost_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceTransformFeedbackFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceTransformFeedbackFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceTransformFeedbackFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceTransformFeedbackFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceTransformFeedbackPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceTransformFeedbackPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceTransformFeedbackPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceTransformFeedbackPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPipelineRasterizationStateStreamCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkPipelineRasterizationStateStreamCreateInfoEXT* toTransform)
-{
+ VkPipelineRasterizationStateStreamCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineRasterizationStateStreamCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkPipelineRasterizationStateStreamCreateInfoEXT* toTransform)
-{
+ VkPipelineRasterizationStateStreamCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_NVX_binary_import
-void transform_tohost_VkCuModuleCreateInfoNVX(
- ResourceTracker* resourceTracker,
- VkCuModuleCreateInfoNVX* toTransform)
-{
+void transform_tohost_VkCuModuleCreateInfoNVX(ResourceTracker* resourceTracker,
+ VkCuModuleCreateInfoNVX* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkCuModuleCreateInfoNVX(
- ResourceTracker* resourceTracker,
- VkCuModuleCreateInfoNVX* toTransform)
-{
+void transform_fromhost_VkCuModuleCreateInfoNVX(ResourceTracker* resourceTracker,
+ VkCuModuleCreateInfoNVX* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkCuFunctionCreateInfoNVX(
- ResourceTracker* resourceTracker,
- VkCuFunctionCreateInfoNVX* toTransform)
-{
+void transform_tohost_VkCuFunctionCreateInfoNVX(ResourceTracker* resourceTracker,
+ VkCuFunctionCreateInfoNVX* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkCuFunctionCreateInfoNVX(
- ResourceTracker* resourceTracker,
- VkCuFunctionCreateInfoNVX* toTransform)
-{
+void transform_fromhost_VkCuFunctionCreateInfoNVX(ResourceTracker* resourceTracker,
+ VkCuFunctionCreateInfoNVX* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkCuLaunchInfoNVX(
- ResourceTracker* resourceTracker,
- VkCuLaunchInfoNVX* toTransform)
-{
+void transform_tohost_VkCuLaunchInfoNVX(ResourceTracker* resourceTracker,
+ VkCuLaunchInfoNVX* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkCuLaunchInfoNVX(
- ResourceTracker* resourceTracker,
- VkCuLaunchInfoNVX* toTransform)
-{
+void transform_fromhost_VkCuLaunchInfoNVX(ResourceTracker* resourceTracker,
+ VkCuLaunchInfoNVX* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_NVX_image_view_handle
-void transform_tohost_VkImageViewHandleInfoNVX(
- ResourceTracker* resourceTracker,
- VkImageViewHandleInfoNVX* toTransform)
-{
+void transform_tohost_VkImageViewHandleInfoNVX(ResourceTracker* resourceTracker,
+ VkImageViewHandleInfoNVX* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkImageViewHandleInfoNVX(
- ResourceTracker* resourceTracker,
- VkImageViewHandleInfoNVX* toTransform)
-{
+void transform_fromhost_VkImageViewHandleInfoNVX(ResourceTracker* resourceTracker,
+ VkImageViewHandleInfoNVX* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkImageViewAddressPropertiesNVX(
- ResourceTracker* resourceTracker,
- VkImageViewAddressPropertiesNVX* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImageViewAddressPropertiesNVX* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkImageViewAddressPropertiesNVX(
- ResourceTracker* resourceTracker,
- VkImageViewAddressPropertiesNVX* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImageViewAddressPropertiesNVX* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -10626,351 +8448,302 @@
#endif
#ifdef VK_EXT_video_encode_h264
void transform_tohost_VkVideoEncodeH264CapabilitiesEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264CapabilitiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH264CapabilitiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->minPictureSizeInMbs));
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxPictureSizeInMbs));
- transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->inputImageDataAlignment));
- transform_tohost_VkExtensionProperties(resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
+ transform_tohost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->inputImageDataAlignment));
+ transform_tohost_VkExtensionProperties(
+ resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
}
void transform_fromhost_VkVideoEncodeH264CapabilitiesEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264CapabilitiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH264CapabilitiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->minPictureSizeInMbs));
- transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxPictureSizeInMbs));
- transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->inputImageDataAlignment));
- transform_fromhost_VkExtensionProperties(resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
+ transform_fromhost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->minPictureSizeInMbs));
+ transform_fromhost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->maxPictureSizeInMbs));
+ transform_fromhost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->inputImageDataAlignment));
+ transform_fromhost_VkExtensionProperties(
+ resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
}
void transform_tohost_VkVideoEncodeH264SessionCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264SessionCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH264SessionCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxPictureSizeInMbs));
- if (toTransform->pStdExtensionVersion)
- {
- transform_tohost_VkExtensionProperties(resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
+ if (toTransform->pStdExtensionVersion) {
+ transform_tohost_VkExtensionProperties(
+ resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
}
}
void transform_fromhost_VkVideoEncodeH264SessionCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264SessionCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH264SessionCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxPictureSizeInMbs));
- if (toTransform->pStdExtensionVersion)
- {
- transform_fromhost_VkExtensionProperties(resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
+ transform_fromhost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->maxPictureSizeInMbs));
+ if (toTransform->pStdExtensionVersion) {
+ transform_fromhost_VkExtensionProperties(
+ resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
}
}
void transform_tohost_VkVideoEncodeH264SessionParametersAddInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264SessionParametersAddInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH264SessionParametersAddInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkVideoEncodeH264SessionParametersAddInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264SessionParametersAddInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH264SessionParametersAddInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkVideoEncodeH264SessionParametersCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkVideoEncodeH264SessionParametersCreateInfoEXT* toTransform)
-{
+ VkVideoEncodeH264SessionParametersCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pParametersAddInfo)
- {
- transform_tohost_VkVideoEncodeH264SessionParametersAddInfoEXT(resourceTracker, (VkVideoEncodeH264SessionParametersAddInfoEXT*)(toTransform->pParametersAddInfo));
+ if (toTransform->pParametersAddInfo) {
+ transform_tohost_VkVideoEncodeH264SessionParametersAddInfoEXT(
+ resourceTracker,
+ (VkVideoEncodeH264SessionParametersAddInfoEXT*)(toTransform->pParametersAddInfo));
}
}
void transform_fromhost_VkVideoEncodeH264SessionParametersCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkVideoEncodeH264SessionParametersCreateInfoEXT* toTransform)
-{
+ VkVideoEncodeH264SessionParametersCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pParametersAddInfo)
- {
- transform_fromhost_VkVideoEncodeH264SessionParametersAddInfoEXT(resourceTracker, (VkVideoEncodeH264SessionParametersAddInfoEXT*)(toTransform->pParametersAddInfo));
+ if (toTransform->pParametersAddInfo) {
+ transform_fromhost_VkVideoEncodeH264SessionParametersAddInfoEXT(
+ resourceTracker,
+ (VkVideoEncodeH264SessionParametersAddInfoEXT*)(toTransform->pParametersAddInfo));
}
}
void transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264DpbSlotInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH264DpbSlotInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264DpbSlotInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH264DpbSlotInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkVideoEncodeH264NaluSliceEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264NaluSliceEXT* toTransform)
-{
+void transform_tohost_VkVideoEncodeH264NaluSliceEXT(ResourceTracker* resourceTracker,
+ VkVideoEncodeH264NaluSliceEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pRefFinalList0Entries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->refFinalList0EntryCount; ++i)
- {
- transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(resourceTracker, (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefFinalList0Entries + i));
+ if (toTransform) {
+ if (toTransform->pRefFinalList0Entries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->refFinalList0EntryCount; ++i) {
+ transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(
+ resourceTracker,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefFinalList0Entries + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pRefFinalList1Entries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->refFinalList1EntryCount; ++i)
- {
- transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(resourceTracker, (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefFinalList1Entries + i));
+ if (toTransform) {
+ if (toTransform->pRefFinalList1Entries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->refFinalList1EntryCount; ++i) {
+ transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(
+ resourceTracker,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefFinalList1Entries + i));
}
}
}
}
-void transform_fromhost_VkVideoEncodeH264NaluSliceEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264NaluSliceEXT* toTransform)
-{
+void transform_fromhost_VkVideoEncodeH264NaluSliceEXT(ResourceTracker* resourceTracker,
+ VkVideoEncodeH264NaluSliceEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pRefFinalList0Entries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->refFinalList0EntryCount; ++i)
- {
- transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(resourceTracker, (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefFinalList0Entries + i));
+ if (toTransform) {
+ if (toTransform->pRefFinalList0Entries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->refFinalList0EntryCount; ++i) {
+ transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(
+ resourceTracker,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefFinalList0Entries + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pRefFinalList1Entries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->refFinalList1EntryCount; ++i)
- {
- transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(resourceTracker, (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefFinalList1Entries + i));
+ if (toTransform) {
+ if (toTransform->pRefFinalList1Entries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->refFinalList1EntryCount; ++i) {
+ transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(
+ resourceTracker,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefFinalList1Entries + i));
}
}
}
}
void transform_tohost_VkVideoEncodeH264VclFrameInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264VclFrameInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH264VclFrameInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pRefDefaultFinalList0Entries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->refDefaultFinalList0EntryCount; ++i)
- {
- transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(resourceTracker, (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefDefaultFinalList0Entries + i));
+ if (toTransform) {
+ if (toTransform->pRefDefaultFinalList0Entries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->refDefaultFinalList0EntryCount; ++i) {
+ transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(
+ resourceTracker,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefDefaultFinalList0Entries +
+ i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pRefDefaultFinalList1Entries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->refDefaultFinalList1EntryCount; ++i)
- {
- transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(resourceTracker, (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefDefaultFinalList1Entries + i));
+ if (toTransform) {
+ if (toTransform->pRefDefaultFinalList1Entries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->refDefaultFinalList1EntryCount; ++i) {
+ transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(
+ resourceTracker,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefDefaultFinalList1Entries +
+ i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pNaluSliceEntries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->naluSliceEntryCount; ++i)
- {
- transform_tohost_VkVideoEncodeH264NaluSliceEXT(resourceTracker, (VkVideoEncodeH264NaluSliceEXT*)(toTransform->pNaluSliceEntries + i));
+ if (toTransform) {
+ if (toTransform->pNaluSliceEntries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->naluSliceEntryCount; ++i) {
+ transform_tohost_VkVideoEncodeH264NaluSliceEXT(
+ resourceTracker,
+ (VkVideoEncodeH264NaluSliceEXT*)(toTransform->pNaluSliceEntries + i));
}
}
}
- if (toTransform->pCurrentPictureInfo)
- {
- transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(resourceTracker, (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pCurrentPictureInfo));
+ if (toTransform->pCurrentPictureInfo) {
+ transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(
+ resourceTracker, (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pCurrentPictureInfo));
}
}
void transform_fromhost_VkVideoEncodeH264VclFrameInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264VclFrameInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH264VclFrameInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pRefDefaultFinalList0Entries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->refDefaultFinalList0EntryCount; ++i)
- {
- transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(resourceTracker, (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefDefaultFinalList0Entries + i));
+ if (toTransform) {
+ if (toTransform->pRefDefaultFinalList0Entries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->refDefaultFinalList0EntryCount; ++i) {
+ transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(
+ resourceTracker,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefDefaultFinalList0Entries +
+ i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pRefDefaultFinalList1Entries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->refDefaultFinalList1EntryCount; ++i)
- {
- transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(resourceTracker, (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefDefaultFinalList1Entries + i));
+ if (toTransform) {
+ if (toTransform->pRefDefaultFinalList1Entries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->refDefaultFinalList1EntryCount; ++i) {
+ transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(
+ resourceTracker,
+ (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefDefaultFinalList1Entries +
+ i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pNaluSliceEntries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->naluSliceEntryCount; ++i)
- {
- transform_fromhost_VkVideoEncodeH264NaluSliceEXT(resourceTracker, (VkVideoEncodeH264NaluSliceEXT*)(toTransform->pNaluSliceEntries + i));
+ if (toTransform) {
+ if (toTransform->pNaluSliceEntries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->naluSliceEntryCount; ++i) {
+ transform_fromhost_VkVideoEncodeH264NaluSliceEXT(
+ resourceTracker,
+ (VkVideoEncodeH264NaluSliceEXT*)(toTransform->pNaluSliceEntries + i));
}
}
}
- if (toTransform->pCurrentPictureInfo)
- {
- transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(resourceTracker, (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pCurrentPictureInfo));
+ if (toTransform->pCurrentPictureInfo) {
+ transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(
+ resourceTracker, (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pCurrentPictureInfo));
}
}
void transform_tohost_VkVideoEncodeH264EmitPictureParametersEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264EmitPictureParametersEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH264EmitPictureParametersEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkVideoEncodeH264EmitPictureParametersEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264EmitPictureParametersEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH264EmitPictureParametersEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkVideoEncodeH264ProfileEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264ProfileEXT* toTransform)
-{
+void transform_tohost_VkVideoEncodeH264ProfileEXT(ResourceTracker* resourceTracker,
+ VkVideoEncodeH264ProfileEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkVideoEncodeH264ProfileEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264ProfileEXT* toTransform)
-{
+void transform_fromhost_VkVideoEncodeH264ProfileEXT(ResourceTracker* resourceTracker,
+ VkVideoEncodeH264ProfileEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -10978,551 +8751,457 @@
#endif
#ifdef VK_EXT_video_encode_h265
void transform_tohost_VkVideoEncodeH265CapabilitiesEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265CapabilitiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH265CapabilitiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->inputImageDataAlignment));
- transform_tohost_VkExtensionProperties(resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
+ transform_tohost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->inputImageDataAlignment));
+ transform_tohost_VkExtensionProperties(
+ resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
}
void transform_fromhost_VkVideoEncodeH265CapabilitiesEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265CapabilitiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH265CapabilitiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->inputImageDataAlignment));
- transform_fromhost_VkExtensionProperties(resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
+ transform_fromhost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->inputImageDataAlignment));
+ transform_fromhost_VkExtensionProperties(
+ resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
}
void transform_tohost_VkVideoEncodeH265SessionCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265SessionCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH265SessionCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pStdExtensionVersion)
- {
- transform_tohost_VkExtensionProperties(resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
+ if (toTransform->pStdExtensionVersion) {
+ transform_tohost_VkExtensionProperties(
+ resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
}
}
void transform_fromhost_VkVideoEncodeH265SessionCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265SessionCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH265SessionCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pStdExtensionVersion)
- {
- transform_fromhost_VkExtensionProperties(resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
+ if (toTransform->pStdExtensionVersion) {
+ transform_fromhost_VkExtensionProperties(
+ resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
}
}
void transform_tohost_VkVideoEncodeH265SessionParametersAddInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265SessionParametersAddInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH265SessionParametersAddInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkVideoEncodeH265SessionParametersAddInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265SessionParametersAddInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH265SessionParametersAddInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkVideoEncodeH265SessionParametersCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkVideoEncodeH265SessionParametersCreateInfoEXT* toTransform)
-{
+ VkVideoEncodeH265SessionParametersCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pParametersAddInfo)
- {
- transform_tohost_VkVideoEncodeH265SessionParametersAddInfoEXT(resourceTracker, (VkVideoEncodeH265SessionParametersAddInfoEXT*)(toTransform->pParametersAddInfo));
+ if (toTransform->pParametersAddInfo) {
+ transform_tohost_VkVideoEncodeH265SessionParametersAddInfoEXT(
+ resourceTracker,
+ (VkVideoEncodeH265SessionParametersAddInfoEXT*)(toTransform->pParametersAddInfo));
}
}
void transform_fromhost_VkVideoEncodeH265SessionParametersCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkVideoEncodeH265SessionParametersCreateInfoEXT* toTransform)
-{
+ VkVideoEncodeH265SessionParametersCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pParametersAddInfo)
- {
- transform_fromhost_VkVideoEncodeH265SessionParametersAddInfoEXT(resourceTracker, (VkVideoEncodeH265SessionParametersAddInfoEXT*)(toTransform->pParametersAddInfo));
+ if (toTransform->pParametersAddInfo) {
+ transform_fromhost_VkVideoEncodeH265SessionParametersAddInfoEXT(
+ resourceTracker,
+ (VkVideoEncodeH265SessionParametersAddInfoEXT*)(toTransform->pParametersAddInfo));
}
}
void transform_tohost_VkVideoEncodeH265DpbSlotInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265DpbSlotInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH265DpbSlotInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkVideoEncodeH265DpbSlotInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265DpbSlotInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH265DpbSlotInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkVideoEncodeH265ReferenceListsEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265ReferenceListsEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH265ReferenceListsEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pReferenceList0Entries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->referenceList0EntryCount; ++i)
- {
- transform_tohost_VkVideoEncodeH265DpbSlotInfoEXT(resourceTracker, (VkVideoEncodeH265DpbSlotInfoEXT*)(toTransform->pReferenceList0Entries + i));
+ if (toTransform) {
+ if (toTransform->pReferenceList0Entries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->referenceList0EntryCount; ++i) {
+ transform_tohost_VkVideoEncodeH265DpbSlotInfoEXT(
+ resourceTracker,
+ (VkVideoEncodeH265DpbSlotInfoEXT*)(toTransform->pReferenceList0Entries + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pReferenceList1Entries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->referenceList1EntryCount; ++i)
- {
- transform_tohost_VkVideoEncodeH265DpbSlotInfoEXT(resourceTracker, (VkVideoEncodeH265DpbSlotInfoEXT*)(toTransform->pReferenceList1Entries + i));
+ if (toTransform) {
+ if (toTransform->pReferenceList1Entries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->referenceList1EntryCount; ++i) {
+ transform_tohost_VkVideoEncodeH265DpbSlotInfoEXT(
+ resourceTracker,
+ (VkVideoEncodeH265DpbSlotInfoEXT*)(toTransform->pReferenceList1Entries + i));
}
}
}
}
void transform_fromhost_VkVideoEncodeH265ReferenceListsEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265ReferenceListsEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH265ReferenceListsEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pReferenceList0Entries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->referenceList0EntryCount; ++i)
- {
- transform_fromhost_VkVideoEncodeH265DpbSlotInfoEXT(resourceTracker, (VkVideoEncodeH265DpbSlotInfoEXT*)(toTransform->pReferenceList0Entries + i));
+ if (toTransform) {
+ if (toTransform->pReferenceList0Entries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->referenceList0EntryCount; ++i) {
+ transform_fromhost_VkVideoEncodeH265DpbSlotInfoEXT(
+ resourceTracker,
+ (VkVideoEncodeH265DpbSlotInfoEXT*)(toTransform->pReferenceList0Entries + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pReferenceList1Entries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->referenceList1EntryCount; ++i)
- {
- transform_fromhost_VkVideoEncodeH265DpbSlotInfoEXT(resourceTracker, (VkVideoEncodeH265DpbSlotInfoEXT*)(toTransform->pReferenceList1Entries + i));
+ if (toTransform) {
+ if (toTransform->pReferenceList1Entries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->referenceList1EntryCount; ++i) {
+ transform_fromhost_VkVideoEncodeH265DpbSlotInfoEXT(
+ resourceTracker,
+ (VkVideoEncodeH265DpbSlotInfoEXT*)(toTransform->pReferenceList1Entries + i));
}
}
}
}
-void transform_tohost_VkVideoEncodeH265NaluSliceEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265NaluSliceEXT* toTransform)
-{
+void transform_tohost_VkVideoEncodeH265NaluSliceEXT(ResourceTracker* resourceTracker,
+ VkVideoEncodeH265NaluSliceEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pReferenceFinalLists)
- {
- transform_tohost_VkVideoEncodeH265ReferenceListsEXT(resourceTracker, (VkVideoEncodeH265ReferenceListsEXT*)(toTransform->pReferenceFinalLists));
+ if (toTransform->pReferenceFinalLists) {
+ transform_tohost_VkVideoEncodeH265ReferenceListsEXT(
+ resourceTracker,
+ (VkVideoEncodeH265ReferenceListsEXT*)(toTransform->pReferenceFinalLists));
}
}
-void transform_fromhost_VkVideoEncodeH265NaluSliceEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265NaluSliceEXT* toTransform)
-{
+void transform_fromhost_VkVideoEncodeH265NaluSliceEXT(ResourceTracker* resourceTracker,
+ VkVideoEncodeH265NaluSliceEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pReferenceFinalLists)
- {
- transform_fromhost_VkVideoEncodeH265ReferenceListsEXT(resourceTracker, (VkVideoEncodeH265ReferenceListsEXT*)(toTransform->pReferenceFinalLists));
+ if (toTransform->pReferenceFinalLists) {
+ transform_fromhost_VkVideoEncodeH265ReferenceListsEXT(
+ resourceTracker,
+ (VkVideoEncodeH265ReferenceListsEXT*)(toTransform->pReferenceFinalLists));
}
}
void transform_tohost_VkVideoEncodeH265VclFrameInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265VclFrameInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH265VclFrameInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pReferenceFinalLists)
- {
- transform_tohost_VkVideoEncodeH265ReferenceListsEXT(resourceTracker, (VkVideoEncodeH265ReferenceListsEXT*)(toTransform->pReferenceFinalLists));
+ if (toTransform->pReferenceFinalLists) {
+ transform_tohost_VkVideoEncodeH265ReferenceListsEXT(
+ resourceTracker,
+ (VkVideoEncodeH265ReferenceListsEXT*)(toTransform->pReferenceFinalLists));
}
- if (toTransform)
- {
- if (toTransform->pNaluSliceEntries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->naluSliceEntryCount; ++i)
- {
- transform_tohost_VkVideoEncodeH265NaluSliceEXT(resourceTracker, (VkVideoEncodeH265NaluSliceEXT*)(toTransform->pNaluSliceEntries + i));
+ if (toTransform) {
+ if (toTransform->pNaluSliceEntries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->naluSliceEntryCount; ++i) {
+ transform_tohost_VkVideoEncodeH265NaluSliceEXT(
+ resourceTracker,
+ (VkVideoEncodeH265NaluSliceEXT*)(toTransform->pNaluSliceEntries + i));
}
}
}
}
void transform_fromhost_VkVideoEncodeH265VclFrameInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265VclFrameInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH265VclFrameInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pReferenceFinalLists)
- {
- transform_fromhost_VkVideoEncodeH265ReferenceListsEXT(resourceTracker, (VkVideoEncodeH265ReferenceListsEXT*)(toTransform->pReferenceFinalLists));
+ if (toTransform->pReferenceFinalLists) {
+ transform_fromhost_VkVideoEncodeH265ReferenceListsEXT(
+ resourceTracker,
+ (VkVideoEncodeH265ReferenceListsEXT*)(toTransform->pReferenceFinalLists));
}
- if (toTransform)
- {
- if (toTransform->pNaluSliceEntries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->naluSliceEntryCount; ++i)
- {
- transform_fromhost_VkVideoEncodeH265NaluSliceEXT(resourceTracker, (VkVideoEncodeH265NaluSliceEXT*)(toTransform->pNaluSliceEntries + i));
+ if (toTransform) {
+ if (toTransform->pNaluSliceEntries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->naluSliceEntryCount; ++i) {
+ transform_fromhost_VkVideoEncodeH265NaluSliceEXT(
+ resourceTracker,
+ (VkVideoEncodeH265NaluSliceEXT*)(toTransform->pNaluSliceEntries + i));
}
}
}
}
void transform_tohost_VkVideoEncodeH265EmitPictureParametersEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265EmitPictureParametersEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH265EmitPictureParametersEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkVideoEncodeH265EmitPictureParametersEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265EmitPictureParametersEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoEncodeH265EmitPictureParametersEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkVideoEncodeH265ProfileEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265ProfileEXT* toTransform)
-{
+void transform_tohost_VkVideoEncodeH265ProfileEXT(ResourceTracker* resourceTracker,
+ VkVideoEncodeH265ProfileEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkVideoEncodeH265ProfileEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265ProfileEXT* toTransform)
-{
+void transform_fromhost_VkVideoEncodeH265ProfileEXT(ResourceTracker* resourceTracker,
+ VkVideoEncodeH265ProfileEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_EXT_video_decode_h264
-void transform_tohost_VkVideoDecodeH264ProfileEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264ProfileEXT* toTransform)
-{
+void transform_tohost_VkVideoDecodeH264ProfileEXT(ResourceTracker* resourceTracker,
+ VkVideoDecodeH264ProfileEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkVideoDecodeH264ProfileEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264ProfileEXT* toTransform)
-{
+void transform_fromhost_VkVideoDecodeH264ProfileEXT(ResourceTracker* resourceTracker,
+ VkVideoDecodeH264ProfileEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkVideoDecodeH264CapabilitiesEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264CapabilitiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoDecodeH264CapabilitiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkOffset2D(resourceTracker, (VkOffset2D*)(&toTransform->fieldOffsetGranularity));
- transform_tohost_VkExtensionProperties(resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
+ transform_tohost_VkOffset2D(resourceTracker,
+ (VkOffset2D*)(&toTransform->fieldOffsetGranularity));
+ transform_tohost_VkExtensionProperties(
+ resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
}
void transform_fromhost_VkVideoDecodeH264CapabilitiesEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264CapabilitiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoDecodeH264CapabilitiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkOffset2D(resourceTracker, (VkOffset2D*)(&toTransform->fieldOffsetGranularity));
- transform_fromhost_VkExtensionProperties(resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
+ transform_fromhost_VkOffset2D(resourceTracker,
+ (VkOffset2D*)(&toTransform->fieldOffsetGranularity));
+ transform_fromhost_VkExtensionProperties(
+ resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
}
void transform_tohost_VkVideoDecodeH264SessionCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264SessionCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoDecodeH264SessionCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pStdExtensionVersion)
- {
- transform_tohost_VkExtensionProperties(resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
+ if (toTransform->pStdExtensionVersion) {
+ transform_tohost_VkExtensionProperties(
+ resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
}
}
void transform_fromhost_VkVideoDecodeH264SessionCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264SessionCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoDecodeH264SessionCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pStdExtensionVersion)
- {
- transform_fromhost_VkExtensionProperties(resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
+ if (toTransform->pStdExtensionVersion) {
+ transform_fromhost_VkExtensionProperties(
+ resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
}
}
void transform_tohost_VkVideoDecodeH264SessionParametersAddInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264SessionParametersAddInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoDecodeH264SessionParametersAddInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkVideoDecodeH264SessionParametersAddInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264SessionParametersAddInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoDecodeH264SessionParametersAddInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkVideoDecodeH264SessionParametersCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkVideoDecodeH264SessionParametersCreateInfoEXT* toTransform)
-{
+ VkVideoDecodeH264SessionParametersCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pParametersAddInfo)
- {
- transform_tohost_VkVideoDecodeH264SessionParametersAddInfoEXT(resourceTracker, (VkVideoDecodeH264SessionParametersAddInfoEXT*)(toTransform->pParametersAddInfo));
+ if (toTransform->pParametersAddInfo) {
+ transform_tohost_VkVideoDecodeH264SessionParametersAddInfoEXT(
+ resourceTracker,
+ (VkVideoDecodeH264SessionParametersAddInfoEXT*)(toTransform->pParametersAddInfo));
}
}
void transform_fromhost_VkVideoDecodeH264SessionParametersCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkVideoDecodeH264SessionParametersCreateInfoEXT* toTransform)
-{
+ VkVideoDecodeH264SessionParametersCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pParametersAddInfo)
- {
- transform_fromhost_VkVideoDecodeH264SessionParametersAddInfoEXT(resourceTracker, (VkVideoDecodeH264SessionParametersAddInfoEXT*)(toTransform->pParametersAddInfo));
+ if (toTransform->pParametersAddInfo) {
+ transform_fromhost_VkVideoDecodeH264SessionParametersAddInfoEXT(
+ resourceTracker,
+ (VkVideoDecodeH264SessionParametersAddInfoEXT*)(toTransform->pParametersAddInfo));
}
}
void transform_tohost_VkVideoDecodeH264PictureInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264PictureInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoDecodeH264PictureInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkVideoDecodeH264PictureInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264PictureInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoDecodeH264PictureInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkVideoDecodeH264MvcEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264MvcEXT* toTransform)
-{
+void transform_tohost_VkVideoDecodeH264MvcEXT(ResourceTracker* resourceTracker,
+ VkVideoDecodeH264MvcEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkVideoDecodeH264MvcEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264MvcEXT* toTransform)
-{
+void transform_fromhost_VkVideoDecodeH264MvcEXT(ResourceTracker* resourceTracker,
+ VkVideoDecodeH264MvcEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkVideoDecodeH264DpbSlotInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264DpbSlotInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoDecodeH264DpbSlotInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkVideoDecodeH264DpbSlotInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264DpbSlotInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoDecodeH264DpbSlotInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -11530,63 +9209,51 @@
#endif
#ifdef VK_AMD_texture_gather_bias_lod
void transform_tohost_VkTextureLODGatherFormatPropertiesAMD(
- ResourceTracker* resourceTracker,
- VkTextureLODGatherFormatPropertiesAMD* toTransform)
-{
+ ResourceTracker* resourceTracker, VkTextureLODGatherFormatPropertiesAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkTextureLODGatherFormatPropertiesAMD(
- ResourceTracker* resourceTracker,
- VkTextureLODGatherFormatPropertiesAMD* toTransform)
-{
+ ResourceTracker* resourceTracker, VkTextureLODGatherFormatPropertiesAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_AMD_shader_info
-void transform_tohost_VkShaderResourceUsageAMD(
- ResourceTracker* resourceTracker,
- VkShaderResourceUsageAMD* toTransform)
-{
+void transform_tohost_VkShaderResourceUsageAMD(ResourceTracker* resourceTracker,
+ VkShaderResourceUsageAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkShaderResourceUsageAMD(
- ResourceTracker* resourceTracker,
- VkShaderResourceUsageAMD* toTransform)
-{
+void transform_fromhost_VkShaderResourceUsageAMD(ResourceTracker* resourceTracker,
+ VkShaderResourceUsageAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkShaderStatisticsInfoAMD(
- ResourceTracker* resourceTracker,
- VkShaderStatisticsInfoAMD* toTransform)
-{
+void transform_tohost_VkShaderStatisticsInfoAMD(ResourceTracker* resourceTracker,
+ VkShaderStatisticsInfoAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_tohost_VkShaderResourceUsageAMD(resourceTracker, (VkShaderResourceUsageAMD*)(&toTransform->resourceUsage));
+ transform_tohost_VkShaderResourceUsageAMD(
+ resourceTracker, (VkShaderResourceUsageAMD*)(&toTransform->resourceUsage));
}
-void transform_fromhost_VkShaderStatisticsInfoAMD(
- ResourceTracker* resourceTracker,
- VkShaderStatisticsInfoAMD* toTransform)
-{
+void transform_fromhost_VkShaderStatisticsInfoAMD(ResourceTracker* resourceTracker,
+ VkShaderStatisticsInfoAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_fromhost_VkShaderResourceUsageAMD(resourceTracker, (VkShaderResourceUsageAMD*)(&toTransform->resourceUsage));
+ transform_fromhost_VkShaderResourceUsageAMD(
+ resourceTracker, (VkShaderResourceUsageAMD*)(&toTransform->resourceUsage));
}
#endif
@@ -11594,25 +9261,19 @@
#endif
#ifdef VK_GGP_stream_descriptor_surface
void transform_tohost_VkStreamDescriptorSurfaceCreateInfoGGP(
- ResourceTracker* resourceTracker,
- VkStreamDescriptorSurfaceCreateInfoGGP* toTransform)
-{
+ ResourceTracker* resourceTracker, VkStreamDescriptorSurfaceCreateInfoGGP* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkStreamDescriptorSurfaceCreateInfoGGP(
- ResourceTracker* resourceTracker,
- VkStreamDescriptorSurfaceCreateInfoGGP* toTransform)
-{
+ ResourceTracker* resourceTracker, VkStreamDescriptorSurfaceCreateInfoGGP* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -11620,25 +9281,19 @@
#endif
#ifdef VK_NV_corner_sampled_image
void transform_tohost_VkPhysicalDeviceCornerSampledImageFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCornerSampledImageFeaturesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCornerSampledImageFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceCornerSampledImageFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCornerSampledImageFeaturesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCornerSampledImageFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -11648,69 +9303,55 @@
#endif
#ifdef VK_NV_external_memory_capabilities
void transform_tohost_VkExternalImageFormatPropertiesNV(
- ResourceTracker* resourceTracker,
- VkExternalImageFormatPropertiesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkExternalImageFormatPropertiesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_tohost_VkImageFormatProperties(resourceTracker, (VkImageFormatProperties*)(&toTransform->imageFormatProperties));
+ transform_tohost_VkImageFormatProperties(
+ resourceTracker, (VkImageFormatProperties*)(&toTransform->imageFormatProperties));
}
void transform_fromhost_VkExternalImageFormatPropertiesNV(
- ResourceTracker* resourceTracker,
- VkExternalImageFormatPropertiesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkExternalImageFormatPropertiesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_fromhost_VkImageFormatProperties(resourceTracker, (VkImageFormatProperties*)(&toTransform->imageFormatProperties));
+ transform_fromhost_VkImageFormatProperties(
+ resourceTracker, (VkImageFormatProperties*)(&toTransform->imageFormatProperties));
}
#endif
#ifdef VK_NV_external_memory
void transform_tohost_VkExternalMemoryImageCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkExternalMemoryImageCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkExternalMemoryImageCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkExternalMemoryImageCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkExternalMemoryImageCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkExternalMemoryImageCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkExportMemoryAllocateInfoNV(
- ResourceTracker* resourceTracker,
- VkExportMemoryAllocateInfoNV* toTransform)
-{
+void transform_tohost_VkExportMemoryAllocateInfoNV(ResourceTracker* resourceTracker,
+ VkExportMemoryAllocateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkExportMemoryAllocateInfoNV(
- ResourceTracker* resourceTracker,
- VkExportMemoryAllocateInfoNV* toTransform)
-{
+void transform_fromhost_VkExportMemoryAllocateInfoNV(ResourceTracker* resourceTracker,
+ VkExportMemoryAllocateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -11718,49 +9359,37 @@
#endif
#ifdef VK_NV_external_memory_win32
void transform_tohost_VkImportMemoryWin32HandleInfoNV(
- ResourceTracker* resourceTracker,
- VkImportMemoryWin32HandleInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImportMemoryWin32HandleInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkImportMemoryWin32HandleInfoNV(
- ResourceTracker* resourceTracker,
- VkImportMemoryWin32HandleInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImportMemoryWin32HandleInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkExportMemoryWin32HandleInfoNV(
- ResourceTracker* resourceTracker,
- VkExportMemoryWin32HandleInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkExportMemoryWin32HandleInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkExportMemoryWin32HandleInfoNV(
- ResourceTracker* resourceTracker,
- VkExportMemoryWin32HandleInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkExportMemoryWin32HandleInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -11768,79 +9397,67 @@
#endif
#ifdef VK_NV_win32_keyed_mutex
void transform_tohost_VkWin32KeyedMutexAcquireReleaseInfoNV(
- ResourceTracker* resourceTracker,
- VkWin32KeyedMutexAcquireReleaseInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkWin32KeyedMutexAcquireReleaseInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)toTransform->pReleaseSyncs, toTransform->releaseCount, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)toTransform->pReleaseSyncs,
+ toTransform->releaseCount, (VkDeviceSize*)nullptr,
+ 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr,
+ 0, (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkWin32KeyedMutexAcquireReleaseInfoNV(
- ResourceTracker* resourceTracker,
- VkWin32KeyedMutexAcquireReleaseInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkWin32KeyedMutexAcquireReleaseInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_fromhost((VkDeviceMemory*)toTransform->pReleaseSyncs, toTransform->releaseCount, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_fromhost(
+ (VkDeviceMemory*)toTransform->pReleaseSyncs, toTransform->releaseCount,
+ (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0,
+ (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_EXT_validation_flags
-void transform_tohost_VkValidationFlagsEXT(
- ResourceTracker* resourceTracker,
- VkValidationFlagsEXT* toTransform)
-{
+void transform_tohost_VkValidationFlagsEXT(ResourceTracker* resourceTracker,
+ VkValidationFlagsEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkValidationFlagsEXT(
- ResourceTracker* resourceTracker,
- VkValidationFlagsEXT* toTransform)
-{
+void transform_fromhost_VkValidationFlagsEXT(ResourceTracker* resourceTracker,
+ VkValidationFlagsEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_NN_vi_surface
-void transform_tohost_VkViSurfaceCreateInfoNN(
- ResourceTracker* resourceTracker,
- VkViSurfaceCreateInfoNN* toTransform)
-{
+void transform_tohost_VkViSurfaceCreateInfoNN(ResourceTracker* resourceTracker,
+ VkViSurfaceCreateInfoNN* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkViSurfaceCreateInfoNN(
- ResourceTracker* resourceTracker,
- VkViSurfaceCreateInfoNN* toTransform)
-{
+void transform_fromhost_VkViSurfaceCreateInfoNN(ResourceTracker* resourceTracker,
+ VkViSurfaceCreateInfoNN* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -11853,74 +9470,58 @@
#ifdef VK_EXT_texture_compression_astc_hdr
void transform_tohost_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_EXT_astc_decode_mode
-void transform_tohost_VkImageViewASTCDecodeModeEXT(
- ResourceTracker* resourceTracker,
- VkImageViewASTCDecodeModeEXT* toTransform)
-{
+void transform_tohost_VkImageViewASTCDecodeModeEXT(ResourceTracker* resourceTracker,
+ VkImageViewASTCDecodeModeEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkImageViewASTCDecodeModeEXT(
- ResourceTracker* resourceTracker,
- VkImageViewASTCDecodeModeEXT* toTransform)
-{
+void transform_fromhost_VkImageViewASTCDecodeModeEXT(ResourceTracker* resourceTracker,
+ VkImageViewASTCDecodeModeEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceASTCDecodeFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceASTCDecodeFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceASTCDecodeFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceASTCDecodeFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceASTCDecodeFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceASTCDecodeFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -11928,134 +9529,106 @@
#endif
#ifdef VK_EXT_conditional_rendering
void transform_tohost_VkConditionalRenderingBeginInfoEXT(
- ResourceTracker* resourceTracker,
- VkConditionalRenderingBeginInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkConditionalRenderingBeginInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkConditionalRenderingBeginInfoEXT(
- ResourceTracker* resourceTracker,
- VkConditionalRenderingBeginInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkConditionalRenderingBeginInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceConditionalRenderingFeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceConditionalRenderingFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceConditionalRenderingFeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceConditionalRenderingFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
ResourceTracker* resourceTracker,
- VkCommandBufferInheritanceConditionalRenderingInfoEXT* toTransform)
-{
+ VkCommandBufferInheritanceConditionalRenderingInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
ResourceTracker* resourceTracker,
- VkCommandBufferInheritanceConditionalRenderingInfoEXT* toTransform)
-{
+ VkCommandBufferInheritanceConditionalRenderingInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_NV_clip_space_w_scaling
-void transform_tohost_VkViewportWScalingNV(
- ResourceTracker* resourceTracker,
- VkViewportWScalingNV* toTransform)
-{
+void transform_tohost_VkViewportWScalingNV(ResourceTracker* resourceTracker,
+ VkViewportWScalingNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkViewportWScalingNV(
- ResourceTracker* resourceTracker,
- VkViewportWScalingNV* toTransform)
-{
+void transform_fromhost_VkViewportWScalingNV(ResourceTracker* resourceTracker,
+ VkViewportWScalingNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkPipelineViewportWScalingStateCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkPipelineViewportWScalingStateCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineViewportWScalingStateCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pViewportWScalings)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->viewportCount; ++i)
- {
- transform_tohost_VkViewportWScalingNV(resourceTracker, (VkViewportWScalingNV*)(toTransform->pViewportWScalings + i));
+ if (toTransform) {
+ if (toTransform->pViewportWScalings) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->viewportCount; ++i) {
+ transform_tohost_VkViewportWScalingNV(
+ resourceTracker, (VkViewportWScalingNV*)(toTransform->pViewportWScalings + i));
}
}
}
}
void transform_fromhost_VkPipelineViewportWScalingStateCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkPipelineViewportWScalingStateCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineViewportWScalingStateCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pViewportWScalings)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->viewportCount; ++i)
- {
- transform_fromhost_VkViewportWScalingNV(resourceTracker, (VkViewportWScalingNV*)(toTransform->pViewportWScalings + i));
+ if (toTransform) {
+ if (toTransform->pViewportWScalings) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->viewportCount; ++i) {
+ transform_fromhost_VkViewportWScalingNV(
+ resourceTracker, (VkViewportWScalingNV*)(toTransform->pViewportWScalings + i));
}
}
}
@@ -12067,14 +9640,11 @@
#ifdef VK_EXT_acquire_xlib_display
#endif
#ifdef VK_EXT_display_surface_counter
-void transform_tohost_VkSurfaceCapabilities2EXT(
- ResourceTracker* resourceTracker,
- VkSurfaceCapabilities2EXT* toTransform)
-{
+void transform_tohost_VkSurfaceCapabilities2EXT(ResourceTracker* resourceTracker,
+ VkSurfaceCapabilities2EXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->currentExtent));
@@ -12082,14 +9652,11 @@
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxImageExtent));
}
-void transform_fromhost_VkSurfaceCapabilities2EXT(
- ResourceTracker* resourceTracker,
- VkSurfaceCapabilities2EXT* toTransform)
-{
+void transform_fromhost_VkSurfaceCapabilities2EXT(ResourceTracker* resourceTracker,
+ VkSurfaceCapabilities2EXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->currentExtent));
@@ -12099,191 +9666,145 @@
#endif
#ifdef VK_EXT_display_control
-void transform_tohost_VkDisplayPowerInfoEXT(
- ResourceTracker* resourceTracker,
- VkDisplayPowerInfoEXT* toTransform)
-{
+void transform_tohost_VkDisplayPowerInfoEXT(ResourceTracker* resourceTracker,
+ VkDisplayPowerInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkDisplayPowerInfoEXT(
- ResourceTracker* resourceTracker,
- VkDisplayPowerInfoEXT* toTransform)
-{
+void transform_fromhost_VkDisplayPowerInfoEXT(ResourceTracker* resourceTracker,
+ VkDisplayPowerInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkDeviceEventInfoEXT(
- ResourceTracker* resourceTracker,
- VkDeviceEventInfoEXT* toTransform)
-{
+void transform_tohost_VkDeviceEventInfoEXT(ResourceTracker* resourceTracker,
+ VkDeviceEventInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkDeviceEventInfoEXT(
- ResourceTracker* resourceTracker,
- VkDeviceEventInfoEXT* toTransform)
-{
+void transform_fromhost_VkDeviceEventInfoEXT(ResourceTracker* resourceTracker,
+ VkDeviceEventInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkDisplayEventInfoEXT(
- ResourceTracker* resourceTracker,
- VkDisplayEventInfoEXT* toTransform)
-{
+void transform_tohost_VkDisplayEventInfoEXT(ResourceTracker* resourceTracker,
+ VkDisplayEventInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkDisplayEventInfoEXT(
- ResourceTracker* resourceTracker,
- VkDisplayEventInfoEXT* toTransform)
-{
+void transform_fromhost_VkDisplayEventInfoEXT(ResourceTracker* resourceTracker,
+ VkDisplayEventInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkSwapchainCounterCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkSwapchainCounterCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSwapchainCounterCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkSwapchainCounterCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkSwapchainCounterCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSwapchainCounterCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_GOOGLE_display_timing
-void transform_tohost_VkRefreshCycleDurationGOOGLE(
- ResourceTracker* resourceTracker,
- VkRefreshCycleDurationGOOGLE* toTransform)
-{
+void transform_tohost_VkRefreshCycleDurationGOOGLE(ResourceTracker* resourceTracker,
+ VkRefreshCycleDurationGOOGLE* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkRefreshCycleDurationGOOGLE(
- ResourceTracker* resourceTracker,
- VkRefreshCycleDurationGOOGLE* toTransform)
-{
+void transform_fromhost_VkRefreshCycleDurationGOOGLE(ResourceTracker* resourceTracker,
+ VkRefreshCycleDurationGOOGLE* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkPastPresentationTimingGOOGLE(
- ResourceTracker* resourceTracker,
- VkPastPresentationTimingGOOGLE* toTransform)
-{
+void transform_tohost_VkPastPresentationTimingGOOGLE(ResourceTracker* resourceTracker,
+ VkPastPresentationTimingGOOGLE* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_fromhost_VkPastPresentationTimingGOOGLE(
- ResourceTracker* resourceTracker,
- VkPastPresentationTimingGOOGLE* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPastPresentationTimingGOOGLE* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkPresentTimeGOOGLE(
- ResourceTracker* resourceTracker,
- VkPresentTimeGOOGLE* toTransform)
-{
+void transform_tohost_VkPresentTimeGOOGLE(ResourceTracker* resourceTracker,
+ VkPresentTimeGOOGLE* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkPresentTimeGOOGLE(
- ResourceTracker* resourceTracker,
- VkPresentTimeGOOGLE* toTransform)
-{
+void transform_fromhost_VkPresentTimeGOOGLE(ResourceTracker* resourceTracker,
+ VkPresentTimeGOOGLE* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkPresentTimesInfoGOOGLE(
- ResourceTracker* resourceTracker,
- VkPresentTimesInfoGOOGLE* toTransform)
-{
+void transform_tohost_VkPresentTimesInfoGOOGLE(ResourceTracker* resourceTracker,
+ VkPresentTimesInfoGOOGLE* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pTimes)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->swapchainCount; ++i)
- {
- transform_tohost_VkPresentTimeGOOGLE(resourceTracker, (VkPresentTimeGOOGLE*)(toTransform->pTimes + i));
+ if (toTransform) {
+ if (toTransform->pTimes) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->swapchainCount; ++i) {
+ transform_tohost_VkPresentTimeGOOGLE(
+ resourceTracker, (VkPresentTimeGOOGLE*)(toTransform->pTimes + i));
}
}
}
}
-void transform_fromhost_VkPresentTimesInfoGOOGLE(
- ResourceTracker* resourceTracker,
- VkPresentTimesInfoGOOGLE* toTransform)
-{
+void transform_fromhost_VkPresentTimesInfoGOOGLE(ResourceTracker* resourceTracker,
+ VkPresentTimesInfoGOOGLE* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pTimes)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->swapchainCount; ++i)
- {
- transform_fromhost_VkPresentTimeGOOGLE(resourceTracker, (VkPresentTimeGOOGLE*)(toTransform->pTimes + i));
+ if (toTransform) {
+ if (toTransform->pTimes) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->swapchainCount; ++i) {
+ transform_fromhost_VkPresentTimeGOOGLE(
+ resourceTracker, (VkPresentTimeGOOGLE*)(toTransform->pTimes + i));
}
}
}
@@ -12299,85 +9820,67 @@
#ifdef VK_NVX_multiview_per_view_attributes
void transform_tohost_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toTransform)
-{
+ VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toTransform)
-{
+ VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_NV_viewport_swizzle
-void transform_tohost_VkViewportSwizzleNV(
- ResourceTracker* resourceTracker,
- VkViewportSwizzleNV* toTransform)
-{
+void transform_tohost_VkViewportSwizzleNV(ResourceTracker* resourceTracker,
+ VkViewportSwizzleNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkViewportSwizzleNV(
- ResourceTracker* resourceTracker,
- VkViewportSwizzleNV* toTransform)
-{
+void transform_fromhost_VkViewportSwizzleNV(ResourceTracker* resourceTracker,
+ VkViewportSwizzleNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkPipelineViewportSwizzleStateCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkPipelineViewportSwizzleStateCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineViewportSwizzleStateCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pViewportSwizzles)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->viewportCount; ++i)
- {
- transform_tohost_VkViewportSwizzleNV(resourceTracker, (VkViewportSwizzleNV*)(toTransform->pViewportSwizzles + i));
+ if (toTransform) {
+ if (toTransform->pViewportSwizzles) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->viewportCount; ++i) {
+ transform_tohost_VkViewportSwizzleNV(
+ resourceTracker, (VkViewportSwizzleNV*)(toTransform->pViewportSwizzles + i));
}
}
}
}
void transform_fromhost_VkPipelineViewportSwizzleStateCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkPipelineViewportSwizzleStateCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineViewportSwizzleStateCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pViewportSwizzles)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->viewportCount; ++i)
- {
- transform_fromhost_VkViewportSwizzleNV(resourceTracker, (VkViewportSwizzleNV*)(toTransform->pViewportSwizzles + i));
+ if (toTransform) {
+ if (toTransform->pViewportSwizzles) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->viewportCount; ++i) {
+ transform_fromhost_VkViewportSwizzleNV(
+ resourceTracker, (VkViewportSwizzleNV*)(toTransform->pViewportSwizzles + i));
}
}
}
@@ -12386,68 +9889,52 @@
#endif
#ifdef VK_EXT_discard_rectangles
void transform_tohost_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDiscardRectanglePropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDiscardRectanglePropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDiscardRectanglePropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDiscardRectanglePropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPipelineDiscardRectangleStateCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineDiscardRectangleStateCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineDiscardRectangleStateCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pDiscardRectangles)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->discardRectangleCount; ++i)
- {
- transform_tohost_VkRect2D(resourceTracker, (VkRect2D*)(toTransform->pDiscardRectangles + i));
+ if (toTransform) {
+ if (toTransform->pDiscardRectangles) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->discardRectangleCount; ++i) {
+ transform_tohost_VkRect2D(resourceTracker,
+ (VkRect2D*)(toTransform->pDiscardRectangles + i));
}
}
}
}
void transform_fromhost_VkPipelineDiscardRectangleStateCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineDiscardRectangleStateCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineDiscardRectangleStateCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pDiscardRectangles)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->discardRectangleCount; ++i)
- {
- transform_fromhost_VkRect2D(resourceTracker, (VkRect2D*)(toTransform->pDiscardRectangles + i));
+ if (toTransform) {
+ if (toTransform->pDiscardRectangles) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->discardRectangleCount; ++i) {
+ transform_fromhost_VkRect2D(resourceTracker,
+ (VkRect2D*)(toTransform->pDiscardRectangles + i));
}
}
}
@@ -12457,48 +9944,40 @@
#ifdef VK_EXT_conservative_rasterization
void transform_tohost_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceConservativeRasterizationPropertiesEXT* toTransform)
-{
+ VkPhysicalDeviceConservativeRasterizationPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceConservativeRasterizationPropertiesEXT* toTransform)
-{
+ VkPhysicalDeviceConservativeRasterizationPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPipelineRasterizationConservativeStateCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkPipelineRasterizationConservativeStateCreateInfoEXT* toTransform)
-{
+ VkPipelineRasterizationConservativeStateCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineRasterizationConservativeStateCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkPipelineRasterizationConservativeStateCreateInfoEXT* toTransform)
-{
+ VkPipelineRasterizationConservativeStateCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -12506,49 +9985,39 @@
#endif
#ifdef VK_EXT_depth_clip_enable
void transform_tohost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDepthClipEnableFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDepthClipEnableFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDepthClipEnableFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDepthClipEnableFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkPipelineRasterizationDepthClipStateCreateInfoEXT* toTransform)
-{
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkPipelineRasterizationDepthClipStateCreateInfoEXT* toTransform)
-{
+ VkPipelineRasterizationDepthClipStateCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -12557,102 +10026,84 @@
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
-void transform_tohost_VkXYColorEXT(
- ResourceTracker* resourceTracker,
- VkXYColorEXT* toTransform)
-{
+void transform_tohost_VkXYColorEXT(ResourceTracker* resourceTracker, VkXYColorEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkXYColorEXT(
- ResourceTracker* resourceTracker,
- VkXYColorEXT* toTransform)
-{
+void transform_fromhost_VkXYColorEXT(ResourceTracker* resourceTracker, VkXYColorEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkHdrMetadataEXT(
- ResourceTracker* resourceTracker,
- VkHdrMetadataEXT* toTransform)
-{
+void transform_tohost_VkHdrMetadataEXT(ResourceTracker* resourceTracker,
+ VkHdrMetadataEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkXYColorEXT(resourceTracker, (VkXYColorEXT*)(&toTransform->displayPrimaryRed));
- transform_tohost_VkXYColorEXT(resourceTracker, (VkXYColorEXT*)(&toTransform->displayPrimaryGreen));
- transform_tohost_VkXYColorEXT(resourceTracker, (VkXYColorEXT*)(&toTransform->displayPrimaryBlue));
+ transform_tohost_VkXYColorEXT(resourceTracker,
+ (VkXYColorEXT*)(&toTransform->displayPrimaryRed));
+ transform_tohost_VkXYColorEXT(resourceTracker,
+ (VkXYColorEXT*)(&toTransform->displayPrimaryGreen));
+ transform_tohost_VkXYColorEXT(resourceTracker,
+ (VkXYColorEXT*)(&toTransform->displayPrimaryBlue));
transform_tohost_VkXYColorEXT(resourceTracker, (VkXYColorEXT*)(&toTransform->whitePoint));
}
-void transform_fromhost_VkHdrMetadataEXT(
- ResourceTracker* resourceTracker,
- VkHdrMetadataEXT* toTransform)
-{
+void transform_fromhost_VkHdrMetadataEXT(ResourceTracker* resourceTracker,
+ VkHdrMetadataEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkXYColorEXT(resourceTracker, (VkXYColorEXT*)(&toTransform->displayPrimaryRed));
- transform_fromhost_VkXYColorEXT(resourceTracker, (VkXYColorEXT*)(&toTransform->displayPrimaryGreen));
- transform_fromhost_VkXYColorEXT(resourceTracker, (VkXYColorEXT*)(&toTransform->displayPrimaryBlue));
+ transform_fromhost_VkXYColorEXT(resourceTracker,
+ (VkXYColorEXT*)(&toTransform->displayPrimaryRed));
+ transform_fromhost_VkXYColorEXT(resourceTracker,
+ (VkXYColorEXT*)(&toTransform->displayPrimaryGreen));
+ transform_fromhost_VkXYColorEXT(resourceTracker,
+ (VkXYColorEXT*)(&toTransform->displayPrimaryBlue));
transform_fromhost_VkXYColorEXT(resourceTracker, (VkXYColorEXT*)(&toTransform->whitePoint));
}
#endif
#ifdef VK_MVK_ios_surface
-void transform_tohost_VkIOSSurfaceCreateInfoMVK(
- ResourceTracker* resourceTracker,
- VkIOSSurfaceCreateInfoMVK* toTransform)
-{
+void transform_tohost_VkIOSSurfaceCreateInfoMVK(ResourceTracker* resourceTracker,
+ VkIOSSurfaceCreateInfoMVK* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkIOSSurfaceCreateInfoMVK(
- ResourceTracker* resourceTracker,
- VkIOSSurfaceCreateInfoMVK* toTransform)
-{
+void transform_fromhost_VkIOSSurfaceCreateInfoMVK(ResourceTracker* resourceTracker,
+ VkIOSSurfaceCreateInfoMVK* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_MVK_macos_surface
-void transform_tohost_VkMacOSSurfaceCreateInfoMVK(
- ResourceTracker* resourceTracker,
- VkMacOSSurfaceCreateInfoMVK* toTransform)
-{
+void transform_tohost_VkMacOSSurfaceCreateInfoMVK(ResourceTracker* resourceTracker,
+ VkMacOSSurfaceCreateInfoMVK* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkMacOSSurfaceCreateInfoMVK(
- ResourceTracker* resourceTracker,
- VkMacOSSurfaceCreateInfoMVK* toTransform)
-{
+void transform_fromhost_VkMacOSSurfaceCreateInfoMVK(ResourceTracker* resourceTracker,
+ VkMacOSSurfaceCreateInfoMVK* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -12665,182 +10116,140 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
-void transform_tohost_VkDebugUtilsLabelEXT(
- ResourceTracker* resourceTracker,
- VkDebugUtilsLabelEXT* toTransform)
-{
+void transform_tohost_VkDebugUtilsLabelEXT(ResourceTracker* resourceTracker,
+ VkDebugUtilsLabelEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkDebugUtilsLabelEXT(
- ResourceTracker* resourceTracker,
- VkDebugUtilsLabelEXT* toTransform)
-{
+void transform_fromhost_VkDebugUtilsLabelEXT(ResourceTracker* resourceTracker,
+ VkDebugUtilsLabelEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkDebugUtilsObjectNameInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugUtilsObjectNameInfoEXT* toTransform)
-{
+void transform_tohost_VkDebugUtilsObjectNameInfoEXT(ResourceTracker* resourceTracker,
+ VkDebugUtilsObjectNameInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkDebugUtilsObjectNameInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugUtilsObjectNameInfoEXT* toTransform)
-{
+void transform_fromhost_VkDebugUtilsObjectNameInfoEXT(ResourceTracker* resourceTracker,
+ VkDebugUtilsObjectNameInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkDebugUtilsMessengerCallbackDataEXT(
- ResourceTracker* resourceTracker,
- VkDebugUtilsMessengerCallbackDataEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDebugUtilsMessengerCallbackDataEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pQueueLabels)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->queueLabelCount; ++i)
- {
- transform_tohost_VkDebugUtilsLabelEXT(resourceTracker, (VkDebugUtilsLabelEXT*)(toTransform->pQueueLabels + i));
+ if (toTransform) {
+ if (toTransform->pQueueLabels) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->queueLabelCount; ++i) {
+ transform_tohost_VkDebugUtilsLabelEXT(
+ resourceTracker, (VkDebugUtilsLabelEXT*)(toTransform->pQueueLabels + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pCmdBufLabels)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->cmdBufLabelCount; ++i)
- {
- transform_tohost_VkDebugUtilsLabelEXT(resourceTracker, (VkDebugUtilsLabelEXT*)(toTransform->pCmdBufLabels + i));
+ if (toTransform) {
+ if (toTransform->pCmdBufLabels) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->cmdBufLabelCount; ++i) {
+ transform_tohost_VkDebugUtilsLabelEXT(
+ resourceTracker, (VkDebugUtilsLabelEXT*)(toTransform->pCmdBufLabels + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pObjects)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->objectCount; ++i)
- {
- transform_tohost_VkDebugUtilsObjectNameInfoEXT(resourceTracker, (VkDebugUtilsObjectNameInfoEXT*)(toTransform->pObjects + i));
+ if (toTransform) {
+ if (toTransform->pObjects) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->objectCount; ++i) {
+ transform_tohost_VkDebugUtilsObjectNameInfoEXT(
+ resourceTracker, (VkDebugUtilsObjectNameInfoEXT*)(toTransform->pObjects + i));
}
}
}
}
void transform_fromhost_VkDebugUtilsMessengerCallbackDataEXT(
- ResourceTracker* resourceTracker,
- VkDebugUtilsMessengerCallbackDataEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDebugUtilsMessengerCallbackDataEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pQueueLabels)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->queueLabelCount; ++i)
- {
- transform_fromhost_VkDebugUtilsLabelEXT(resourceTracker, (VkDebugUtilsLabelEXT*)(toTransform->pQueueLabels + i));
+ if (toTransform) {
+ if (toTransform->pQueueLabels) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->queueLabelCount; ++i) {
+ transform_fromhost_VkDebugUtilsLabelEXT(
+ resourceTracker, (VkDebugUtilsLabelEXT*)(toTransform->pQueueLabels + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pCmdBufLabels)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->cmdBufLabelCount; ++i)
- {
- transform_fromhost_VkDebugUtilsLabelEXT(resourceTracker, (VkDebugUtilsLabelEXT*)(toTransform->pCmdBufLabels + i));
+ if (toTransform) {
+ if (toTransform->pCmdBufLabels) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->cmdBufLabelCount; ++i) {
+ transform_fromhost_VkDebugUtilsLabelEXT(
+ resourceTracker, (VkDebugUtilsLabelEXT*)(toTransform->pCmdBufLabels + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pObjects)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->objectCount; ++i)
- {
- transform_fromhost_VkDebugUtilsObjectNameInfoEXT(resourceTracker, (VkDebugUtilsObjectNameInfoEXT*)(toTransform->pObjects + i));
+ if (toTransform) {
+ if (toTransform->pObjects) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->objectCount; ++i) {
+ transform_fromhost_VkDebugUtilsObjectNameInfoEXT(
+ resourceTracker, (VkDebugUtilsObjectNameInfoEXT*)(toTransform->pObjects + i));
}
}
}
}
void transform_tohost_VkDebugUtilsMessengerCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugUtilsMessengerCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDebugUtilsMessengerCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDebugUtilsMessengerCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugUtilsMessengerCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDebugUtilsMessengerCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkDebugUtilsObjectTagInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugUtilsObjectTagInfoEXT* toTransform)
-{
+void transform_tohost_VkDebugUtilsObjectTagInfoEXT(ResourceTracker* resourceTracker,
+ VkDebugUtilsObjectTagInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkDebugUtilsObjectTagInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugUtilsObjectTagInfoEXT* toTransform)
-{
+void transform_fromhost_VkDebugUtilsObjectTagInfoEXT(ResourceTracker* resourceTracker,
+ VkDebugUtilsObjectTagInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -12848,179 +10257,151 @@
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
void transform_tohost_VkAndroidHardwareBufferUsageANDROID(
- ResourceTracker* resourceTracker,
- VkAndroidHardwareBufferUsageANDROID* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAndroidHardwareBufferUsageANDROID* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkAndroidHardwareBufferUsageANDROID(
- ResourceTracker* resourceTracker,
- VkAndroidHardwareBufferUsageANDROID* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAndroidHardwareBufferUsageANDROID* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkAndroidHardwareBufferPropertiesANDROID(
- ResourceTracker* resourceTracker,
- VkAndroidHardwareBufferPropertiesANDROID* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAndroidHardwareBufferPropertiesANDROID* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0,
+ (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkAndroidHardwareBufferPropertiesANDROID(
- ResourceTracker* resourceTracker,
- VkAndroidHardwareBufferPropertiesANDROID* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAndroidHardwareBufferPropertiesANDROID* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_fromhost((VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_fromhost(
+ (VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0,
+ (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkAndroidHardwareBufferFormatPropertiesANDROID(
- ResourceTracker* resourceTracker,
- VkAndroidHardwareBufferFormatPropertiesANDROID* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAndroidHardwareBufferFormatPropertiesANDROID* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkComponentMapping(resourceTracker, (VkComponentMapping*)(&toTransform->samplerYcbcrConversionComponents));
+ transform_tohost_VkComponentMapping(
+ resourceTracker, (VkComponentMapping*)(&toTransform->samplerYcbcrConversionComponents));
}
void transform_fromhost_VkAndroidHardwareBufferFormatPropertiesANDROID(
- ResourceTracker* resourceTracker,
- VkAndroidHardwareBufferFormatPropertiesANDROID* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAndroidHardwareBufferFormatPropertiesANDROID* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkComponentMapping(resourceTracker, (VkComponentMapping*)(&toTransform->samplerYcbcrConversionComponents));
+ transform_fromhost_VkComponentMapping(
+ resourceTracker, (VkComponentMapping*)(&toTransform->samplerYcbcrConversionComponents));
}
void transform_tohost_VkImportAndroidHardwareBufferInfoANDROID(
- ResourceTracker* resourceTracker,
- VkImportAndroidHardwareBufferInfoANDROID* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImportAndroidHardwareBufferInfoANDROID* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkImportAndroidHardwareBufferInfoANDROID(
- ResourceTracker* resourceTracker,
- VkImportAndroidHardwareBufferInfoANDROID* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImportAndroidHardwareBufferInfoANDROID* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkMemoryGetAndroidHardwareBufferInfoANDROID(
- ResourceTracker* resourceTracker,
- VkMemoryGetAndroidHardwareBufferInfoANDROID* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMemoryGetAndroidHardwareBufferInfoANDROID* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&toTransform->memory, 1,
+ (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr,
+ 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkMemoryGetAndroidHardwareBufferInfoANDROID(
- ResourceTracker* resourceTracker,
- VkMemoryGetAndroidHardwareBufferInfoANDROID* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMemoryGetAndroidHardwareBufferInfoANDROID* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_fromhost((VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_fromhost(
+ (VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr,
+ 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkExternalFormatANDROID(
- ResourceTracker* resourceTracker,
- VkExternalFormatANDROID* toTransform)
-{
+void transform_tohost_VkExternalFormatANDROID(ResourceTracker* resourceTracker,
+ VkExternalFormatANDROID* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkExternalFormatANDROID(
- ResourceTracker* resourceTracker,
- VkExternalFormatANDROID* toTransform)
-{
+void transform_fromhost_VkExternalFormatANDROID(ResourceTracker* resourceTracker,
+ VkExternalFormatANDROID* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkAndroidHardwareBufferFormatProperties2ANDROID(
ResourceTracker* resourceTracker,
- VkAndroidHardwareBufferFormatProperties2ANDROID* toTransform)
-{
+ VkAndroidHardwareBufferFormatProperties2ANDROID* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkComponentMapping(resourceTracker, (VkComponentMapping*)(&toTransform->samplerYcbcrConversionComponents));
+ transform_tohost_VkComponentMapping(
+ resourceTracker, (VkComponentMapping*)(&toTransform->samplerYcbcrConversionComponents));
}
void transform_fromhost_VkAndroidHardwareBufferFormatProperties2ANDROID(
ResourceTracker* resourceTracker,
- VkAndroidHardwareBufferFormatProperties2ANDROID* toTransform)
-{
+ VkAndroidHardwareBufferFormatProperties2ANDROID* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkComponentMapping(resourceTracker, (VkComponentMapping*)(&toTransform->samplerYcbcrConversionComponents));
+ transform_fromhost_VkComponentMapping(
+ resourceTracker, (VkComponentMapping*)(&toTransform->samplerYcbcrConversionComponents));
}
#endif
@@ -13034,97 +10415,77 @@
#endif
#ifdef VK_EXT_inline_uniform_block
void transform_tohost_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toTransform)
-{
+ VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toTransform)
-{
+ VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkWriteDescriptorSetInlineUniformBlockEXT(
- ResourceTracker* resourceTracker,
- VkWriteDescriptorSetInlineUniformBlockEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkWriteDescriptorSetInlineUniformBlockEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkWriteDescriptorSetInlineUniformBlockEXT(
- ResourceTracker* resourceTracker,
- VkWriteDescriptorSetInlineUniformBlockEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkWriteDescriptorSetInlineUniformBlockEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toTransform)
-{
+ VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toTransform)
-{
+ VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -13133,316 +10494,270 @@
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
-void transform_tohost_VkSampleLocationEXT(
- ResourceTracker* resourceTracker,
- VkSampleLocationEXT* toTransform)
-{
+void transform_tohost_VkSampleLocationEXT(ResourceTracker* resourceTracker,
+ VkSampleLocationEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkSampleLocationEXT(
- ResourceTracker* resourceTracker,
- VkSampleLocationEXT* toTransform)
-{
+void transform_fromhost_VkSampleLocationEXT(ResourceTracker* resourceTracker,
+ VkSampleLocationEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkSampleLocationsInfoEXT(
- ResourceTracker* resourceTracker,
- VkSampleLocationsInfoEXT* toTransform)
-{
+void transform_tohost_VkSampleLocationsInfoEXT(ResourceTracker* resourceTracker,
+ VkSampleLocationsInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->sampleLocationGridSize));
- if (toTransform)
- {
- if (toTransform->pSampleLocations)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->sampleLocationsCount; ++i)
- {
- transform_tohost_VkSampleLocationEXT(resourceTracker, (VkSampleLocationEXT*)(toTransform->pSampleLocations + i));
+ transform_tohost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->sampleLocationGridSize));
+ if (toTransform) {
+ if (toTransform->pSampleLocations) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->sampleLocationsCount; ++i) {
+ transform_tohost_VkSampleLocationEXT(
+ resourceTracker, (VkSampleLocationEXT*)(toTransform->pSampleLocations + i));
}
}
}
}
-void transform_fromhost_VkSampleLocationsInfoEXT(
- ResourceTracker* resourceTracker,
- VkSampleLocationsInfoEXT* toTransform)
-{
+void transform_fromhost_VkSampleLocationsInfoEXT(ResourceTracker* resourceTracker,
+ VkSampleLocationsInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->sampleLocationGridSize));
- if (toTransform)
- {
- if (toTransform->pSampleLocations)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->sampleLocationsCount; ++i)
- {
- transform_fromhost_VkSampleLocationEXT(resourceTracker, (VkSampleLocationEXT*)(toTransform->pSampleLocations + i));
+ transform_fromhost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->sampleLocationGridSize));
+ if (toTransform) {
+ if (toTransform->pSampleLocations) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->sampleLocationsCount; ++i) {
+ transform_fromhost_VkSampleLocationEXT(
+ resourceTracker, (VkSampleLocationEXT*)(toTransform->pSampleLocations + i));
}
}
}
}
-void transform_tohost_VkAttachmentSampleLocationsEXT(
- ResourceTracker* resourceTracker,
- VkAttachmentSampleLocationsEXT* toTransform)
-{
+void transform_tohost_VkAttachmentSampleLocationsEXT(ResourceTracker* resourceTracker,
+ VkAttachmentSampleLocationsEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_tohost_VkSampleLocationsInfoEXT(resourceTracker, (VkSampleLocationsInfoEXT*)(&toTransform->sampleLocationsInfo));
+ transform_tohost_VkSampleLocationsInfoEXT(
+ resourceTracker, (VkSampleLocationsInfoEXT*)(&toTransform->sampleLocationsInfo));
}
void transform_fromhost_VkAttachmentSampleLocationsEXT(
- ResourceTracker* resourceTracker,
- VkAttachmentSampleLocationsEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAttachmentSampleLocationsEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_fromhost_VkSampleLocationsInfoEXT(resourceTracker, (VkSampleLocationsInfoEXT*)(&toTransform->sampleLocationsInfo));
+ transform_fromhost_VkSampleLocationsInfoEXT(
+ resourceTracker, (VkSampleLocationsInfoEXT*)(&toTransform->sampleLocationsInfo));
}
-void transform_tohost_VkSubpassSampleLocationsEXT(
- ResourceTracker* resourceTracker,
- VkSubpassSampleLocationsEXT* toTransform)
-{
+void transform_tohost_VkSubpassSampleLocationsEXT(ResourceTracker* resourceTracker,
+ VkSubpassSampleLocationsEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_tohost_VkSampleLocationsInfoEXT(resourceTracker, (VkSampleLocationsInfoEXT*)(&toTransform->sampleLocationsInfo));
+ transform_tohost_VkSampleLocationsInfoEXT(
+ resourceTracker, (VkSampleLocationsInfoEXT*)(&toTransform->sampleLocationsInfo));
}
-void transform_fromhost_VkSubpassSampleLocationsEXT(
- ResourceTracker* resourceTracker,
- VkSubpassSampleLocationsEXT* toTransform)
-{
+void transform_fromhost_VkSubpassSampleLocationsEXT(ResourceTracker* resourceTracker,
+ VkSubpassSampleLocationsEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_fromhost_VkSampleLocationsInfoEXT(resourceTracker, (VkSampleLocationsInfoEXT*)(&toTransform->sampleLocationsInfo));
+ transform_fromhost_VkSampleLocationsInfoEXT(
+ resourceTracker, (VkSampleLocationsInfoEXT*)(&toTransform->sampleLocationsInfo));
}
void transform_tohost_VkRenderPassSampleLocationsBeginInfoEXT(
- ResourceTracker* resourceTracker,
- VkRenderPassSampleLocationsBeginInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRenderPassSampleLocationsBeginInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pAttachmentInitialSampleLocations)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->attachmentInitialSampleLocationsCount; ++i)
- {
- transform_tohost_VkAttachmentSampleLocationsEXT(resourceTracker, (VkAttachmentSampleLocationsEXT*)(toTransform->pAttachmentInitialSampleLocations + i));
+ if (toTransform) {
+ if (toTransform->pAttachmentInitialSampleLocations) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->attachmentInitialSampleLocationsCount;
+ ++i) {
+ transform_tohost_VkAttachmentSampleLocationsEXT(
+ resourceTracker,
+ (VkAttachmentSampleLocationsEXT*)(toTransform
+ ->pAttachmentInitialSampleLocations +
+ i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pPostSubpassSampleLocations)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->postSubpassSampleLocationsCount; ++i)
- {
- transform_tohost_VkSubpassSampleLocationsEXT(resourceTracker, (VkSubpassSampleLocationsEXT*)(toTransform->pPostSubpassSampleLocations + i));
+ if (toTransform) {
+ if (toTransform->pPostSubpassSampleLocations) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->postSubpassSampleLocationsCount; ++i) {
+ transform_tohost_VkSubpassSampleLocationsEXT(
+ resourceTracker,
+ (VkSubpassSampleLocationsEXT*)(toTransform->pPostSubpassSampleLocations + i));
}
}
}
}
void transform_fromhost_VkRenderPassSampleLocationsBeginInfoEXT(
- ResourceTracker* resourceTracker,
- VkRenderPassSampleLocationsBeginInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRenderPassSampleLocationsBeginInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pAttachmentInitialSampleLocations)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->attachmentInitialSampleLocationsCount; ++i)
- {
- transform_fromhost_VkAttachmentSampleLocationsEXT(resourceTracker, (VkAttachmentSampleLocationsEXT*)(toTransform->pAttachmentInitialSampleLocations + i));
+ if (toTransform) {
+ if (toTransform->pAttachmentInitialSampleLocations) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->attachmentInitialSampleLocationsCount;
+ ++i) {
+ transform_fromhost_VkAttachmentSampleLocationsEXT(
+ resourceTracker,
+ (VkAttachmentSampleLocationsEXT*)(toTransform
+ ->pAttachmentInitialSampleLocations +
+ i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pPostSubpassSampleLocations)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->postSubpassSampleLocationsCount; ++i)
- {
- transform_fromhost_VkSubpassSampleLocationsEXT(resourceTracker, (VkSubpassSampleLocationsEXT*)(toTransform->pPostSubpassSampleLocations + i));
+ if (toTransform) {
+ if (toTransform->pPostSubpassSampleLocations) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->postSubpassSampleLocationsCount; ++i) {
+ transform_fromhost_VkSubpassSampleLocationsEXT(
+ resourceTracker,
+ (VkSubpassSampleLocationsEXT*)(toTransform->pPostSubpassSampleLocations + i));
}
}
}
}
void transform_tohost_VkPipelineSampleLocationsStateCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineSampleLocationsStateCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineSampleLocationsStateCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkSampleLocationsInfoEXT(resourceTracker, (VkSampleLocationsInfoEXT*)(&toTransform->sampleLocationsInfo));
+ transform_tohost_VkSampleLocationsInfoEXT(
+ resourceTracker, (VkSampleLocationsInfoEXT*)(&toTransform->sampleLocationsInfo));
}
void transform_fromhost_VkPipelineSampleLocationsStateCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineSampleLocationsStateCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineSampleLocationsStateCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkSampleLocationsInfoEXT(resourceTracker, (VkSampleLocationsInfoEXT*)(&toTransform->sampleLocationsInfo));
+ transform_fromhost_VkSampleLocationsInfoEXT(
+ resourceTracker, (VkSampleLocationsInfoEXT*)(&toTransform->sampleLocationsInfo));
}
void transform_tohost_VkPhysicalDeviceSampleLocationsPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSampleLocationsPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSampleLocationsPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxSampleLocationGridSize));
+ transform_tohost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->maxSampleLocationGridSize));
}
void transform_fromhost_VkPhysicalDeviceSampleLocationsPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSampleLocationsPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSampleLocationsPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxSampleLocationGridSize));
+ transform_fromhost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->maxSampleLocationGridSize));
}
-void transform_tohost_VkMultisamplePropertiesEXT(
- ResourceTracker* resourceTracker,
- VkMultisamplePropertiesEXT* toTransform)
-{
+void transform_tohost_VkMultisamplePropertiesEXT(ResourceTracker* resourceTracker,
+ VkMultisamplePropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxSampleLocationGridSize));
+ transform_tohost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->maxSampleLocationGridSize));
}
-void transform_fromhost_VkMultisamplePropertiesEXT(
- ResourceTracker* resourceTracker,
- VkMultisamplePropertiesEXT* toTransform)
-{
+void transform_fromhost_VkMultisamplePropertiesEXT(ResourceTracker* resourceTracker,
+ VkMultisamplePropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxSampleLocationGridSize));
+ transform_fromhost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->maxSampleLocationGridSize));
}
#endif
#ifdef VK_EXT_blend_operation_advanced
void transform_tohost_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toTransform)
-{
+ VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toTransform)
-{
+ VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineColorBlendAdvancedStateCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineColorBlendAdvancedStateCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineColorBlendAdvancedStateCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineColorBlendAdvancedStateCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -13450,25 +10765,19 @@
#endif
#ifdef VK_NV_fragment_coverage_to_color
void transform_tohost_VkPipelineCoverageToColorStateCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkPipelineCoverageToColorStateCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineCoverageToColorStateCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineCoverageToColorStateCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkPipelineCoverageToColorStateCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineCoverageToColorStateCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -13476,25 +10785,19 @@
#endif
#ifdef VK_NV_framebuffer_mixed_samples
void transform_tohost_VkPipelineCoverageModulationStateCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkPipelineCoverageModulationStateCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineCoverageModulationStateCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineCoverageModulationStateCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkPipelineCoverageModulationStateCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineCoverageModulationStateCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -13504,49 +10807,37 @@
#endif
#ifdef VK_NV_shader_sm_builtins
void transform_tohost_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -13556,236 +10847,188 @@
#endif
#ifdef VK_EXT_image_drm_format_modifier
void transform_tohost_VkDrmFormatModifierPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkDrmFormatModifierPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDrmFormatModifierPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_fromhost_VkDrmFormatModifierPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkDrmFormatModifierPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDrmFormatModifierPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkDrmFormatModifierPropertiesListEXT(
- ResourceTracker* resourceTracker,
- VkDrmFormatModifierPropertiesListEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDrmFormatModifierPropertiesListEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pDrmFormatModifierProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->drmFormatModifierCount; ++i)
- {
- transform_tohost_VkDrmFormatModifierPropertiesEXT(resourceTracker, (VkDrmFormatModifierPropertiesEXT*)(toTransform->pDrmFormatModifierProperties + i));
+ if (toTransform) {
+ if (toTransform->pDrmFormatModifierProperties) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->drmFormatModifierCount; ++i) {
+ transform_tohost_VkDrmFormatModifierPropertiesEXT(
+ resourceTracker,
+ (VkDrmFormatModifierPropertiesEXT*)(toTransform->pDrmFormatModifierProperties +
+ i));
}
}
}
}
void transform_fromhost_VkDrmFormatModifierPropertiesListEXT(
- ResourceTracker* resourceTracker,
- VkDrmFormatModifierPropertiesListEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDrmFormatModifierPropertiesListEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pDrmFormatModifierProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->drmFormatModifierCount; ++i)
- {
- transform_fromhost_VkDrmFormatModifierPropertiesEXT(resourceTracker, (VkDrmFormatModifierPropertiesEXT*)(toTransform->pDrmFormatModifierProperties + i));
+ if (toTransform) {
+ if (toTransform->pDrmFormatModifierProperties) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->drmFormatModifierCount; ++i) {
+ transform_fromhost_VkDrmFormatModifierPropertiesEXT(
+ resourceTracker,
+ (VkDrmFormatModifierPropertiesEXT*)(toTransform->pDrmFormatModifierProperties +
+ i));
}
}
}
}
void transform_tohost_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceImageDrmFormatModifierInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceImageDrmFormatModifierInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceImageDrmFormatModifierInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceImageDrmFormatModifierInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkImageDrmFormatModifierListCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkImageDrmFormatModifierListCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImageDrmFormatModifierListCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkImageDrmFormatModifierListCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkImageDrmFormatModifierListCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImageDrmFormatModifierListCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkImageDrmFormatModifierExplicitCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkImageDrmFormatModifierExplicitCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImageDrmFormatModifierExplicitCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pPlaneLayouts)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->drmFormatModifierPlaneCount; ++i)
- {
- transform_tohost_VkSubresourceLayout(resourceTracker, (VkSubresourceLayout*)(toTransform->pPlaneLayouts + i));
+ if (toTransform) {
+ if (toTransform->pPlaneLayouts) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->drmFormatModifierPlaneCount; ++i) {
+ transform_tohost_VkSubresourceLayout(
+ resourceTracker, (VkSubresourceLayout*)(toTransform->pPlaneLayouts + i));
}
}
}
}
void transform_fromhost_VkImageDrmFormatModifierExplicitCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkImageDrmFormatModifierExplicitCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImageDrmFormatModifierExplicitCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pPlaneLayouts)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->drmFormatModifierPlaneCount; ++i)
- {
- transform_fromhost_VkSubresourceLayout(resourceTracker, (VkSubresourceLayout*)(toTransform->pPlaneLayouts + i));
+ if (toTransform) {
+ if (toTransform->pPlaneLayouts) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->drmFormatModifierPlaneCount; ++i) {
+ transform_fromhost_VkSubresourceLayout(
+ resourceTracker, (VkSubresourceLayout*)(toTransform->pPlaneLayouts + i));
}
}
}
}
void transform_tohost_VkImageDrmFormatModifierPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkImageDrmFormatModifierPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImageDrmFormatModifierPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkImageDrmFormatModifierPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkImageDrmFormatModifierPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImageDrmFormatModifierPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkDrmFormatModifierProperties2EXT(
- ResourceTracker* resourceTracker,
- VkDrmFormatModifierProperties2EXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDrmFormatModifierProperties2EXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_fromhost_VkDrmFormatModifierProperties2EXT(
- ResourceTracker* resourceTracker,
- VkDrmFormatModifierProperties2EXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDrmFormatModifierProperties2EXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkDrmFormatModifierPropertiesList2EXT(
- ResourceTracker* resourceTracker,
- VkDrmFormatModifierPropertiesList2EXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDrmFormatModifierPropertiesList2EXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pDrmFormatModifierProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->drmFormatModifierCount; ++i)
- {
- transform_tohost_VkDrmFormatModifierProperties2EXT(resourceTracker, (VkDrmFormatModifierProperties2EXT*)(toTransform->pDrmFormatModifierProperties + i));
+ if (toTransform) {
+ if (toTransform->pDrmFormatModifierProperties) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->drmFormatModifierCount; ++i) {
+ transform_tohost_VkDrmFormatModifierProperties2EXT(
+ resourceTracker,
+ (VkDrmFormatModifierProperties2EXT*)(toTransform->pDrmFormatModifierProperties +
+ i));
}
}
}
}
void transform_fromhost_VkDrmFormatModifierPropertiesList2EXT(
- ResourceTracker* resourceTracker,
- VkDrmFormatModifierPropertiesList2EXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDrmFormatModifierPropertiesList2EXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pDrmFormatModifierProperties)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->drmFormatModifierCount; ++i)
- {
- transform_fromhost_VkDrmFormatModifierProperties2EXT(resourceTracker, (VkDrmFormatModifierProperties2EXT*)(toTransform->pDrmFormatModifierProperties + i));
+ if (toTransform) {
+ if (toTransform->pDrmFormatModifierProperties) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->drmFormatModifierCount; ++i) {
+ transform_fromhost_VkDrmFormatModifierProperties2EXT(
+ resourceTracker,
+ (VkDrmFormatModifierProperties2EXT*)(toTransform->pDrmFormatModifierProperties +
+ i));
}
}
}
@@ -13793,50 +11036,38 @@
#endif
#ifdef VK_EXT_validation_cache
-void transform_tohost_VkValidationCacheCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkValidationCacheCreateInfoEXT* toTransform)
-{
+void transform_tohost_VkValidationCacheCreateInfoEXT(ResourceTracker* resourceTracker,
+ VkValidationCacheCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkValidationCacheCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkValidationCacheCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkValidationCacheCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkShaderModuleValidationCacheCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkShaderModuleValidationCacheCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkShaderModuleValidationCacheCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkShaderModuleValidationCacheCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkShaderModuleValidationCacheCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkShaderModuleValidationCacheCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -13847,39 +11078,32 @@
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_NV_shading_rate_image
-void transform_tohost_VkShadingRatePaletteNV(
- ResourceTracker* resourceTracker,
- VkShadingRatePaletteNV* toTransform)
-{
+void transform_tohost_VkShadingRatePaletteNV(ResourceTracker* resourceTracker,
+ VkShadingRatePaletteNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkShadingRatePaletteNV(
- ResourceTracker* resourceTracker,
- VkShadingRatePaletteNV* toTransform)
-{
+void transform_fromhost_VkShadingRatePaletteNV(ResourceTracker* resourceTracker,
+ VkShadingRatePaletteNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkPipelineViewportShadingRateImageStateCreateInfoNV(
ResourceTracker* resourceTracker,
- VkPipelineViewportShadingRateImageStateCreateInfoNV* toTransform)
-{
+ VkPipelineViewportShadingRateImageStateCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pShadingRatePalettes)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->viewportCount; ++i)
- {
- transform_tohost_VkShadingRatePaletteNV(resourceTracker, (VkShadingRatePaletteNV*)(toTransform->pShadingRatePalettes + i));
+ if (toTransform) {
+ if (toTransform->pShadingRatePalettes) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->viewportCount; ++i) {
+ transform_tohost_VkShadingRatePaletteNV(
+ resourceTracker,
+ (VkShadingRatePaletteNV*)(toTransform->pShadingRatePalettes + i));
}
}
}
@@ -13887,123 +11111,99 @@
void transform_fromhost_VkPipelineViewportShadingRateImageStateCreateInfoNV(
ResourceTracker* resourceTracker,
- VkPipelineViewportShadingRateImageStateCreateInfoNV* toTransform)
-{
+ VkPipelineViewportShadingRateImageStateCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pShadingRatePalettes)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->viewportCount; ++i)
- {
- transform_fromhost_VkShadingRatePaletteNV(resourceTracker, (VkShadingRatePaletteNV*)(toTransform->pShadingRatePalettes + i));
+ if (toTransform) {
+ if (toTransform->pShadingRatePalettes) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->viewportCount; ++i) {
+ transform_fromhost_VkShadingRatePaletteNV(
+ resourceTracker,
+ (VkShadingRatePaletteNV*)(toTransform->pShadingRatePalettes + i));
}
}
}
}
void transform_tohost_VkPhysicalDeviceShadingRateImageFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShadingRateImageFeaturesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShadingRateImageFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceShadingRateImageFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShadingRateImageFeaturesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShadingRateImageFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceShadingRateImagePropertiesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShadingRateImagePropertiesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShadingRateImagePropertiesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->shadingRateTexelSize));
}
void transform_fromhost_VkPhysicalDeviceShadingRateImagePropertiesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShadingRateImagePropertiesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShadingRateImagePropertiesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->shadingRateTexelSize));
+ transform_fromhost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->shadingRateTexelSize));
}
-void transform_tohost_VkCoarseSampleLocationNV(
- ResourceTracker* resourceTracker,
- VkCoarseSampleLocationNV* toTransform)
-{
+void transform_tohost_VkCoarseSampleLocationNV(ResourceTracker* resourceTracker,
+ VkCoarseSampleLocationNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkCoarseSampleLocationNV(
- ResourceTracker* resourceTracker,
- VkCoarseSampleLocationNV* toTransform)
-{
+void transform_fromhost_VkCoarseSampleLocationNV(ResourceTracker* resourceTracker,
+ VkCoarseSampleLocationNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkCoarseSampleOrderCustomNV(
- ResourceTracker* resourceTracker,
- VkCoarseSampleOrderCustomNV* toTransform)
-{
+void transform_tohost_VkCoarseSampleOrderCustomNV(ResourceTracker* resourceTracker,
+ VkCoarseSampleOrderCustomNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform)
- {
- if (toTransform->pSampleLocations)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->sampleLocationCount; ++i)
- {
- transform_tohost_VkCoarseSampleLocationNV(resourceTracker, (VkCoarseSampleLocationNV*)(toTransform->pSampleLocations + i));
+ if (toTransform) {
+ if (toTransform->pSampleLocations) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->sampleLocationCount; ++i) {
+ transform_tohost_VkCoarseSampleLocationNV(
+ resourceTracker,
+ (VkCoarseSampleLocationNV*)(toTransform->pSampleLocations + i));
}
}
}
}
-void transform_fromhost_VkCoarseSampleOrderCustomNV(
- ResourceTracker* resourceTracker,
- VkCoarseSampleOrderCustomNV* toTransform)
-{
+void transform_fromhost_VkCoarseSampleOrderCustomNV(ResourceTracker* resourceTracker,
+ VkCoarseSampleOrderCustomNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform)
- {
- if (toTransform->pSampleLocations)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->sampleLocationCount; ++i)
- {
- transform_fromhost_VkCoarseSampleLocationNV(resourceTracker, (VkCoarseSampleLocationNV*)(toTransform->pSampleLocations + i));
+ if (toTransform) {
+ if (toTransform->pSampleLocations) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->sampleLocationCount; ++i) {
+ transform_fromhost_VkCoarseSampleLocationNV(
+ resourceTracker,
+ (VkCoarseSampleLocationNV*)(toTransform->pSampleLocations + i));
}
}
}
@@ -14011,21 +11211,18 @@
void transform_tohost_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
ResourceTracker* resourceTracker,
- VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* toTransform)
-{
+ VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pCustomSampleOrders)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->customSampleOrderCount; ++i)
- {
- transform_tohost_VkCoarseSampleOrderCustomNV(resourceTracker, (VkCoarseSampleOrderCustomNV*)(toTransform->pCustomSampleOrders + i));
+ if (toTransform) {
+ if (toTransform->pCustomSampleOrders) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->customSampleOrderCount; ++i) {
+ transform_tohost_VkCoarseSampleOrderCustomNV(
+ resourceTracker,
+ (VkCoarseSampleOrderCustomNV*)(toTransform->pCustomSampleOrders + i));
}
}
}
@@ -14033,21 +11230,18 @@
void transform_fromhost_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
ResourceTracker* resourceTracker,
- VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* toTransform)
-{
+ VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pCustomSampleOrders)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->customSampleOrderCount; ++i)
- {
- transform_fromhost_VkCoarseSampleOrderCustomNV(resourceTracker, (VkCoarseSampleOrderCustomNV*)(toTransform->pCustomSampleOrders + i));
+ if (toTransform) {
+ if (toTransform->pCustomSampleOrders) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->customSampleOrderCount; ++i) {
+ transform_fromhost_VkCoarseSampleOrderCustomNV(
+ resourceTracker,
+ (VkCoarseSampleOrderCustomNV*)(toTransform->pCustomSampleOrders + i));
}
}
}
@@ -14056,451 +11250,362 @@
#endif
#ifdef VK_NV_ray_tracing
void transform_tohost_VkRayTracingShaderGroupCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkRayTracingShaderGroupCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRayTracingShaderGroupCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkRayTracingShaderGroupCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkRayTracingShaderGroupCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRayTracingShaderGroupCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkRayTracingPipelineCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkRayTracingPipelineCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRayTracingPipelineCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pStages)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->stageCount; ++i)
- {
- transform_tohost_VkPipelineShaderStageCreateInfo(resourceTracker, (VkPipelineShaderStageCreateInfo*)(toTransform->pStages + i));
+ if (toTransform) {
+ if (toTransform->pStages) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->stageCount; ++i) {
+ transform_tohost_VkPipelineShaderStageCreateInfo(
+ resourceTracker, (VkPipelineShaderStageCreateInfo*)(toTransform->pStages + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pGroups)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->groupCount; ++i)
- {
- transform_tohost_VkRayTracingShaderGroupCreateInfoNV(resourceTracker, (VkRayTracingShaderGroupCreateInfoNV*)(toTransform->pGroups + i));
+ if (toTransform) {
+ if (toTransform->pGroups) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->groupCount; ++i) {
+ transform_tohost_VkRayTracingShaderGroupCreateInfoNV(
+ resourceTracker,
+ (VkRayTracingShaderGroupCreateInfoNV*)(toTransform->pGroups + i));
}
}
}
}
void transform_fromhost_VkRayTracingPipelineCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkRayTracingPipelineCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRayTracingPipelineCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pStages)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->stageCount; ++i)
- {
- transform_fromhost_VkPipelineShaderStageCreateInfo(resourceTracker, (VkPipelineShaderStageCreateInfo*)(toTransform->pStages + i));
+ if (toTransform) {
+ if (toTransform->pStages) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->stageCount; ++i) {
+ transform_fromhost_VkPipelineShaderStageCreateInfo(
+ resourceTracker, (VkPipelineShaderStageCreateInfo*)(toTransform->pStages + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pGroups)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->groupCount; ++i)
- {
- transform_fromhost_VkRayTracingShaderGroupCreateInfoNV(resourceTracker, (VkRayTracingShaderGroupCreateInfoNV*)(toTransform->pGroups + i));
+ if (toTransform) {
+ if (toTransform->pGroups) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->groupCount; ++i) {
+ transform_fromhost_VkRayTracingShaderGroupCreateInfoNV(
+ resourceTracker,
+ (VkRayTracingShaderGroupCreateInfoNV*)(toTransform->pGroups + i));
}
}
}
}
-void transform_tohost_VkGeometryTrianglesNV(
- ResourceTracker* resourceTracker,
- VkGeometryTrianglesNV* toTransform)
-{
+void transform_tohost_VkGeometryTrianglesNV(ResourceTracker* resourceTracker,
+ VkGeometryTrianglesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkGeometryTrianglesNV(
- ResourceTracker* resourceTracker,
- VkGeometryTrianglesNV* toTransform)
-{
+void transform_fromhost_VkGeometryTrianglesNV(ResourceTracker* resourceTracker,
+ VkGeometryTrianglesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkGeometryAABBNV(
- ResourceTracker* resourceTracker,
- VkGeometryAABBNV* toTransform)
-{
+void transform_tohost_VkGeometryAABBNV(ResourceTracker* resourceTracker,
+ VkGeometryAABBNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkGeometryAABBNV(
- ResourceTracker* resourceTracker,
- VkGeometryAABBNV* toTransform)
-{
+void transform_fromhost_VkGeometryAABBNV(ResourceTracker* resourceTracker,
+ VkGeometryAABBNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkGeometryDataNV(
- ResourceTracker* resourceTracker,
- VkGeometryDataNV* toTransform)
-{
+void transform_tohost_VkGeometryDataNV(ResourceTracker* resourceTracker,
+ VkGeometryDataNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_tohost_VkGeometryTrianglesNV(resourceTracker, (VkGeometryTrianglesNV*)(&toTransform->triangles));
+ transform_tohost_VkGeometryTrianglesNV(resourceTracker,
+ (VkGeometryTrianglesNV*)(&toTransform->triangles));
transform_tohost_VkGeometryAABBNV(resourceTracker, (VkGeometryAABBNV*)(&toTransform->aabbs));
}
-void transform_fromhost_VkGeometryDataNV(
- ResourceTracker* resourceTracker,
- VkGeometryDataNV* toTransform)
-{
+void transform_fromhost_VkGeometryDataNV(ResourceTracker* resourceTracker,
+ VkGeometryDataNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_fromhost_VkGeometryTrianglesNV(resourceTracker, (VkGeometryTrianglesNV*)(&toTransform->triangles));
+ transform_fromhost_VkGeometryTrianglesNV(resourceTracker,
+ (VkGeometryTrianglesNV*)(&toTransform->triangles));
transform_fromhost_VkGeometryAABBNV(resourceTracker, (VkGeometryAABBNV*)(&toTransform->aabbs));
}
-void transform_tohost_VkGeometryNV(
- ResourceTracker* resourceTracker,
- VkGeometryNV* toTransform)
-{
+void transform_tohost_VkGeometryNV(ResourceTracker* resourceTracker, VkGeometryNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_tohost_VkGeometryDataNV(resourceTracker, (VkGeometryDataNV*)(&toTransform->geometry));
}
-void transform_fromhost_VkGeometryNV(
- ResourceTracker* resourceTracker,
- VkGeometryNV* toTransform)
-{
+void transform_fromhost_VkGeometryNV(ResourceTracker* resourceTracker, VkGeometryNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkGeometryDataNV(resourceTracker, (VkGeometryDataNV*)(&toTransform->geometry));
+ transform_fromhost_VkGeometryDataNV(resourceTracker,
+ (VkGeometryDataNV*)(&toTransform->geometry));
}
-void transform_tohost_VkAccelerationStructureInfoNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureInfoNV* toTransform)
-{
+void transform_tohost_VkAccelerationStructureInfoNV(ResourceTracker* resourceTracker,
+ VkAccelerationStructureInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pGeometries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->geometryCount; ++i)
- {
- transform_tohost_VkGeometryNV(resourceTracker, (VkGeometryNV*)(toTransform->pGeometries + i));
+ if (toTransform) {
+ if (toTransform->pGeometries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->geometryCount; ++i) {
+ transform_tohost_VkGeometryNV(resourceTracker,
+ (VkGeometryNV*)(toTransform->pGeometries + i));
}
}
}
}
-void transform_fromhost_VkAccelerationStructureInfoNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureInfoNV* toTransform)
-{
+void transform_fromhost_VkAccelerationStructureInfoNV(ResourceTracker* resourceTracker,
+ VkAccelerationStructureInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pGeometries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->geometryCount; ++i)
- {
- transform_fromhost_VkGeometryNV(resourceTracker, (VkGeometryNV*)(toTransform->pGeometries + i));
+ if (toTransform) {
+ if (toTransform->pGeometries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->geometryCount; ++i) {
+ transform_fromhost_VkGeometryNV(resourceTracker,
+ (VkGeometryNV*)(toTransform->pGeometries + i));
}
}
}
}
void transform_tohost_VkAccelerationStructureCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkAccelerationStructureInfoNV(resourceTracker, (VkAccelerationStructureInfoNV*)(&toTransform->info));
+ transform_tohost_VkAccelerationStructureInfoNV(
+ resourceTracker, (VkAccelerationStructureInfoNV*)(&toTransform->info));
}
void transform_fromhost_VkAccelerationStructureCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkAccelerationStructureInfoNV(resourceTracker, (VkAccelerationStructureInfoNV*)(&toTransform->info));
+ transform_fromhost_VkAccelerationStructureInfoNV(
+ resourceTracker, (VkAccelerationStructureInfoNV*)(&toTransform->info));
}
void transform_tohost_VkBindAccelerationStructureMemoryInfoNV(
- ResourceTracker* resourceTracker,
- VkBindAccelerationStructureMemoryInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBindAccelerationStructureMemoryInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->memoryOffset, 1, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->memoryOffset, 1,
+ (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkBindAccelerationStructureMemoryInfoNV(
- ResourceTracker* resourceTracker,
- VkBindAccelerationStructureMemoryInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBindAccelerationStructureMemoryInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_fromhost((VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->memoryOffset, 1, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_fromhost(
+ (VkDeviceMemory*)&toTransform->memory, 1, (VkDeviceSize*)&toTransform->memoryOffset, 1,
+ (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)nullptr, 0);
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkWriteDescriptorSetAccelerationStructureNV(
- ResourceTracker* resourceTracker,
- VkWriteDescriptorSetAccelerationStructureNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkWriteDescriptorSetAccelerationStructureNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkWriteDescriptorSetAccelerationStructureNV(
- ResourceTracker* resourceTracker,
- VkWriteDescriptorSetAccelerationStructureNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkWriteDescriptorSetAccelerationStructureNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkAccelerationStructureMemoryRequirementsInfoNV(
ResourceTracker* resourceTracker,
- VkAccelerationStructureMemoryRequirementsInfoNV* toTransform)
-{
+ VkAccelerationStructureMemoryRequirementsInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkAccelerationStructureMemoryRequirementsInfoNV(
ResourceTracker* resourceTracker,
- VkAccelerationStructureMemoryRequirementsInfoNV* toTransform)
-{
+ VkAccelerationStructureMemoryRequirementsInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceRayTracingPropertiesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRayTracingPropertiesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRayTracingPropertiesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceRayTracingPropertiesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRayTracingPropertiesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRayTracingPropertiesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkTransformMatrixKHR(
- ResourceTracker* resourceTracker,
- VkTransformMatrixKHR* toTransform)
-{
+void transform_tohost_VkTransformMatrixKHR(ResourceTracker* resourceTracker,
+ VkTransformMatrixKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkTransformMatrixKHR(
- ResourceTracker* resourceTracker,
- VkTransformMatrixKHR* toTransform)
-{
+void transform_fromhost_VkTransformMatrixKHR(ResourceTracker* resourceTracker,
+ VkTransformMatrixKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkAabbPositionsKHR(
- ResourceTracker* resourceTracker,
- VkAabbPositionsKHR* toTransform)
-{
+void transform_tohost_VkAabbPositionsKHR(ResourceTracker* resourceTracker,
+ VkAabbPositionsKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkAabbPositionsKHR(
- ResourceTracker* resourceTracker,
- VkAabbPositionsKHR* toTransform)
-{
+void transform_fromhost_VkAabbPositionsKHR(ResourceTracker* resourceTracker,
+ VkAabbPositionsKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkAccelerationStructureInstanceKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureInstanceKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureInstanceKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_tohost_VkTransformMatrixKHR(resourceTracker, (VkTransformMatrixKHR*)(&toTransform->transform));
+ transform_tohost_VkTransformMatrixKHR(resourceTracker,
+ (VkTransformMatrixKHR*)(&toTransform->transform));
}
void transform_fromhost_VkAccelerationStructureInstanceKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureInstanceKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureInstanceKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_fromhost_VkTransformMatrixKHR(resourceTracker, (VkTransformMatrixKHR*)(&toTransform->transform));
+ transform_fromhost_VkTransformMatrixKHR(resourceTracker,
+ (VkTransformMatrixKHR*)(&toTransform->transform));
}
#endif
#ifdef VK_NV_representative_fragment_test
void transform_tohost_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* toTransform)
-{
+ VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* toTransform)
-{
+ VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
ResourceTracker* resourceTracker,
- VkPipelineRepresentativeFragmentTestStateCreateInfoNV* toTransform)
-{
+ VkPipelineRepresentativeFragmentTestStateCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
ResourceTracker* resourceTracker,
- VkPipelineRepresentativeFragmentTestStateCreateInfoNV* toTransform)
-{
+ VkPipelineRepresentativeFragmentTestStateCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -14508,49 +11613,37 @@
#endif
#ifdef VK_EXT_filter_cubic
void transform_tohost_VkPhysicalDeviceImageViewImageFormatInfoEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceImageViewImageFormatInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceImageViewImageFormatInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceImageViewImageFormatInfoEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceImageViewImageFormatInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceImageViewImageFormatInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkFilterCubicImageViewImageFormatPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkFilterCubicImageViewImageFormatPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkFilterCubicImageViewImageFormatPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkFilterCubicImageViewImageFormatPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkFilterCubicImageViewImageFormatPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkFilterCubicImageViewImageFormatPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -14560,25 +11653,19 @@
#endif
#ifdef VK_EXT_global_priority
void transform_tohost_VkDeviceQueueGlobalPriorityCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDeviceQueueGlobalPriorityCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceQueueGlobalPriorityCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDeviceQueueGlobalPriorityCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDeviceQueueGlobalPriorityCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceQueueGlobalPriorityCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -14586,75 +11673,63 @@
#endif
#ifdef VK_EXT_external_memory_host
void transform_tohost_VkImportMemoryHostPointerInfoEXT(
- ResourceTracker* resourceTracker,
- VkImportMemoryHostPointerInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImportMemoryHostPointerInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkImportMemoryHostPointerInfoEXT(
- ResourceTracker* resourceTracker,
- VkImportMemoryHostPointerInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImportMemoryHostPointerInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkMemoryHostPointerPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkMemoryHostPointerPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMemoryHostPointerPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0,
+ (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkMemoryHostPointerPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkMemoryHostPointerPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMemoryHostPointerPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- resourceTracker->deviceMemoryTransform_fromhost((VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
- if (toTransform->pNext)
- {
+ resourceTracker->deviceMemoryTransform_fromhost(
+ (VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0,
+ (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toTransform)
-{
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toTransform)
-{
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -14664,51 +11739,39 @@
#endif
#ifdef VK_AMD_pipeline_compiler_control
void transform_tohost_VkPipelineCompilerControlCreateInfoAMD(
- ResourceTracker* resourceTracker,
- VkPipelineCompilerControlCreateInfoAMD* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineCompilerControlCreateInfoAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineCompilerControlCreateInfoAMD(
- ResourceTracker* resourceTracker,
- VkPipelineCompilerControlCreateInfoAMD* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineCompilerControlCreateInfoAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_EXT_calibrated_timestamps
-void transform_tohost_VkCalibratedTimestampInfoEXT(
- ResourceTracker* resourceTracker,
- VkCalibratedTimestampInfoEXT* toTransform)
-{
+void transform_tohost_VkCalibratedTimestampInfoEXT(ResourceTracker* resourceTracker,
+ VkCalibratedTimestampInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkCalibratedTimestampInfoEXT(
- ResourceTracker* resourceTracker,
- VkCalibratedTimestampInfoEXT* toTransform)
-{
+void transform_fromhost_VkCalibratedTimestampInfoEXT(ResourceTracker* resourceTracker,
+ VkCalibratedTimestampInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -14716,213 +11779,171 @@
#endif
#ifdef VK_AMD_shader_core_properties
void transform_tohost_VkPhysicalDeviceShaderCorePropertiesAMD(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderCorePropertiesAMD* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderCorePropertiesAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceShaderCorePropertiesAMD(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderCorePropertiesAMD* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderCorePropertiesAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_EXT_video_decode_h265
-void transform_tohost_VkVideoDecodeH265ProfileEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265ProfileEXT* toTransform)
-{
+void transform_tohost_VkVideoDecodeH265ProfileEXT(ResourceTracker* resourceTracker,
+ VkVideoDecodeH265ProfileEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkVideoDecodeH265ProfileEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265ProfileEXT* toTransform)
-{
+void transform_fromhost_VkVideoDecodeH265ProfileEXT(ResourceTracker* resourceTracker,
+ VkVideoDecodeH265ProfileEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkVideoDecodeH265CapabilitiesEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265CapabilitiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoDecodeH265CapabilitiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkExtensionProperties(resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
+ transform_tohost_VkExtensionProperties(
+ resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
}
void transform_fromhost_VkVideoDecodeH265CapabilitiesEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265CapabilitiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoDecodeH265CapabilitiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkExtensionProperties(resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
+ transform_fromhost_VkExtensionProperties(
+ resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
}
void transform_tohost_VkVideoDecodeH265SessionCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265SessionCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoDecodeH265SessionCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pStdExtensionVersion)
- {
- transform_tohost_VkExtensionProperties(resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
+ if (toTransform->pStdExtensionVersion) {
+ transform_tohost_VkExtensionProperties(
+ resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
}
}
void transform_fromhost_VkVideoDecodeH265SessionCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265SessionCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoDecodeH265SessionCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pStdExtensionVersion)
- {
- transform_fromhost_VkExtensionProperties(resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
+ if (toTransform->pStdExtensionVersion) {
+ transform_fromhost_VkExtensionProperties(
+ resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
}
}
void transform_tohost_VkVideoDecodeH265SessionParametersAddInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265SessionParametersAddInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoDecodeH265SessionParametersAddInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkVideoDecodeH265SessionParametersAddInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265SessionParametersAddInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoDecodeH265SessionParametersAddInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkVideoDecodeH265SessionParametersCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkVideoDecodeH265SessionParametersCreateInfoEXT* toTransform)
-{
+ VkVideoDecodeH265SessionParametersCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pParametersAddInfo)
- {
- transform_tohost_VkVideoDecodeH265SessionParametersAddInfoEXT(resourceTracker, (VkVideoDecodeH265SessionParametersAddInfoEXT*)(toTransform->pParametersAddInfo));
+ if (toTransform->pParametersAddInfo) {
+ transform_tohost_VkVideoDecodeH265SessionParametersAddInfoEXT(
+ resourceTracker,
+ (VkVideoDecodeH265SessionParametersAddInfoEXT*)(toTransform->pParametersAddInfo));
}
}
void transform_fromhost_VkVideoDecodeH265SessionParametersCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkVideoDecodeH265SessionParametersCreateInfoEXT* toTransform)
-{
+ VkVideoDecodeH265SessionParametersCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pParametersAddInfo)
- {
- transform_fromhost_VkVideoDecodeH265SessionParametersAddInfoEXT(resourceTracker, (VkVideoDecodeH265SessionParametersAddInfoEXT*)(toTransform->pParametersAddInfo));
+ if (toTransform->pParametersAddInfo) {
+ transform_fromhost_VkVideoDecodeH265SessionParametersAddInfoEXT(
+ resourceTracker,
+ (VkVideoDecodeH265SessionParametersAddInfoEXT*)(toTransform->pParametersAddInfo));
}
}
void transform_tohost_VkVideoDecodeH265PictureInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265PictureInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoDecodeH265PictureInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkVideoDecodeH265PictureInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265PictureInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoDecodeH265PictureInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkVideoDecodeH265DpbSlotInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265DpbSlotInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoDecodeH265DpbSlotInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkVideoDecodeH265DpbSlotInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265DpbSlotInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVideoDecodeH265DpbSlotInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -14930,25 +11951,19 @@
#endif
#ifdef VK_AMD_memory_overallocation_behavior
void transform_tohost_VkDeviceMemoryOverallocationCreateInfoAMD(
- ResourceTracker* resourceTracker,
- VkDeviceMemoryOverallocationCreateInfoAMD* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceMemoryOverallocationCreateInfoAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDeviceMemoryOverallocationCreateInfoAMD(
- ResourceTracker* resourceTracker,
- VkDeviceMemoryOverallocationCreateInfoAMD* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceMemoryOverallocationCreateInfoAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -14957,83 +11972,71 @@
#ifdef VK_EXT_vertex_attribute_divisor
void transform_tohost_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toTransform)
-{
+ VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toTransform)
-{
+ VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkVertexInputBindingDivisorDescriptionEXT(
- ResourceTracker* resourceTracker,
- VkVertexInputBindingDivisorDescriptionEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVertexInputBindingDivisorDescriptionEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_fromhost_VkVertexInputBindingDivisorDescriptionEXT(
- ResourceTracker* resourceTracker,
- VkVertexInputBindingDivisorDescriptionEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVertexInputBindingDivisorDescriptionEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkPipelineVertexInputDivisorStateCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineVertexInputDivisorStateCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineVertexInputDivisorStateCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pVertexBindingDivisors)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->vertexBindingDivisorCount; ++i)
- {
- transform_tohost_VkVertexInputBindingDivisorDescriptionEXT(resourceTracker, (VkVertexInputBindingDivisorDescriptionEXT*)(toTransform->pVertexBindingDivisors + i));
+ if (toTransform) {
+ if (toTransform->pVertexBindingDivisors) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->vertexBindingDivisorCount; ++i) {
+ transform_tohost_VkVertexInputBindingDivisorDescriptionEXT(
+ resourceTracker,
+ (VkVertexInputBindingDivisorDescriptionEXT*)(toTransform
+ ->pVertexBindingDivisors +
+ i));
}
}
}
}
void transform_fromhost_VkPipelineVertexInputDivisorStateCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineVertexInputDivisorStateCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineVertexInputDivisorStateCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pVertexBindingDivisors)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->vertexBindingDivisorCount; ++i)
- {
- transform_fromhost_VkVertexInputBindingDivisorDescriptionEXT(resourceTracker, (VkVertexInputBindingDivisorDescriptionEXT*)(toTransform->pVertexBindingDivisors + i));
+ if (toTransform) {
+ if (toTransform->pVertexBindingDivisors) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->vertexBindingDivisorCount; ++i) {
+ transform_fromhost_VkVertexInputBindingDivisorDescriptionEXT(
+ resourceTracker,
+ (VkVertexInputBindingDivisorDescriptionEXT*)(toTransform
+ ->pVertexBindingDivisors +
+ i));
}
}
}
@@ -15041,119 +12044,103 @@
void transform_tohost_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_GGP_frame_token
-void transform_tohost_VkPresentFrameTokenGGP(
- ResourceTracker* resourceTracker,
- VkPresentFrameTokenGGP* toTransform)
-{
+void transform_tohost_VkPresentFrameTokenGGP(ResourceTracker* resourceTracker,
+ VkPresentFrameTokenGGP* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkPresentFrameTokenGGP(
- ResourceTracker* resourceTracker,
- VkPresentFrameTokenGGP* toTransform)
-{
+void transform_fromhost_VkPresentFrameTokenGGP(ResourceTracker* resourceTracker,
+ VkPresentFrameTokenGGP* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_EXT_pipeline_creation_feedback
-void transform_tohost_VkPipelineCreationFeedbackEXT(
- ResourceTracker* resourceTracker,
- VkPipelineCreationFeedbackEXT* toTransform)
-{
+void transform_tohost_VkPipelineCreationFeedbackEXT(ResourceTracker* resourceTracker,
+ VkPipelineCreationFeedbackEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkPipelineCreationFeedbackEXT(
- ResourceTracker* resourceTracker,
- VkPipelineCreationFeedbackEXT* toTransform)
-{
+void transform_fromhost_VkPipelineCreationFeedbackEXT(ResourceTracker* resourceTracker,
+ VkPipelineCreationFeedbackEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkPipelineCreationFeedbackCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineCreationFeedbackCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineCreationFeedbackCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pPipelineCreationFeedback)
- {
- transform_tohost_VkPipelineCreationFeedbackEXT(resourceTracker, (VkPipelineCreationFeedbackEXT*)(toTransform->pPipelineCreationFeedback));
+ if (toTransform->pPipelineCreationFeedback) {
+ transform_tohost_VkPipelineCreationFeedbackEXT(
+ resourceTracker,
+ (VkPipelineCreationFeedbackEXT*)(toTransform->pPipelineCreationFeedback));
}
- if (toTransform)
- {
- if (toTransform->pPipelineStageCreationFeedbacks)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->pipelineStageCreationFeedbackCount; ++i)
- {
- transform_tohost_VkPipelineCreationFeedbackEXT(resourceTracker, (VkPipelineCreationFeedbackEXT*)(toTransform->pPipelineStageCreationFeedbacks + i));
+ if (toTransform) {
+ if (toTransform->pPipelineStageCreationFeedbacks) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->pipelineStageCreationFeedbackCount;
+ ++i) {
+ transform_tohost_VkPipelineCreationFeedbackEXT(
+ resourceTracker,
+ (VkPipelineCreationFeedbackEXT*)(toTransform->pPipelineStageCreationFeedbacks +
+ i));
}
}
}
}
void transform_fromhost_VkPipelineCreationFeedbackCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineCreationFeedbackCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineCreationFeedbackCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pPipelineCreationFeedback)
- {
- transform_fromhost_VkPipelineCreationFeedbackEXT(resourceTracker, (VkPipelineCreationFeedbackEXT*)(toTransform->pPipelineCreationFeedback));
+ if (toTransform->pPipelineCreationFeedback) {
+ transform_fromhost_VkPipelineCreationFeedbackEXT(
+ resourceTracker,
+ (VkPipelineCreationFeedbackEXT*)(toTransform->pPipelineCreationFeedback));
}
- if (toTransform)
- {
- if (toTransform->pPipelineStageCreationFeedbacks)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->pipelineStageCreationFeedbackCount; ++i)
- {
- transform_fromhost_VkPipelineCreationFeedbackEXT(resourceTracker, (VkPipelineCreationFeedbackEXT*)(toTransform->pPipelineStageCreationFeedbacks + i));
+ if (toTransform) {
+ if (toTransform->pPipelineStageCreationFeedbacks) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->pipelineStageCreationFeedbackCount;
+ ++i) {
+ transform_fromhost_VkPipelineCreationFeedbackEXT(
+ resourceTracker,
+ (VkPipelineCreationFeedbackEXT*)(toTransform->pPipelineStageCreationFeedbacks +
+ i));
}
}
}
@@ -15165,24 +12152,20 @@
#ifdef VK_NV_compute_shader_derivatives
void transform_tohost_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* toTransform)
-{
+ VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* toTransform)
-{
+ VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -15190,65 +12173,49 @@
#endif
#ifdef VK_NV_mesh_shader
void transform_tohost_VkPhysicalDeviceMeshShaderFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMeshShaderFeaturesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMeshShaderFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceMeshShaderFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMeshShaderFeaturesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMeshShaderFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceMeshShaderPropertiesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMeshShaderPropertiesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMeshShaderPropertiesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceMeshShaderPropertiesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMeshShaderPropertiesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMeshShaderPropertiesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkDrawMeshTasksIndirectCommandNV(
- ResourceTracker* resourceTracker,
- VkDrawMeshTasksIndirectCommandNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDrawMeshTasksIndirectCommandNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_fromhost_VkDrawMeshTasksIndirectCommandNV(
- ResourceTracker* resourceTracker,
- VkDrawMeshTasksIndirectCommandNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDrawMeshTasksIndirectCommandNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
@@ -15257,24 +12224,20 @@
#ifdef VK_NV_fragment_shader_barycentric
void transform_tohost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toTransform)
-{
+ VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toTransform)
-{
+ VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -15282,25 +12245,19 @@
#endif
#ifdef VK_NV_shader_image_footprint
void transform_tohost_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderImageFootprintFeaturesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderImageFootprintFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderImageFootprintFeaturesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderImageFootprintFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -15309,21 +12266,17 @@
#ifdef VK_NV_scissor_exclusive
void transform_tohost_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
ResourceTracker* resourceTracker,
- VkPipelineViewportExclusiveScissorStateCreateInfoNV* toTransform)
-{
+ VkPipelineViewportExclusiveScissorStateCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pExclusiveScissors)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->exclusiveScissorCount; ++i)
- {
- transform_tohost_VkRect2D(resourceTracker, (VkRect2D*)(toTransform->pExclusiveScissors + i));
+ if (toTransform) {
+ if (toTransform->pExclusiveScissors) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->exclusiveScissorCount; ++i) {
+ transform_tohost_VkRect2D(resourceTracker,
+ (VkRect2D*)(toTransform->pExclusiveScissors + i));
}
}
}
@@ -15331,46 +12284,36 @@
void transform_fromhost_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
ResourceTracker* resourceTracker,
- VkPipelineViewportExclusiveScissorStateCreateInfoNV* toTransform)
-{
+ VkPipelineViewportExclusiveScissorStateCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pExclusiveScissors)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->exclusiveScissorCount; ++i)
- {
- transform_fromhost_VkRect2D(resourceTracker, (VkRect2D*)(toTransform->pExclusiveScissors + i));
+ if (toTransform) {
+ if (toTransform->pExclusiveScissors) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->exclusiveScissorCount; ++i) {
+ transform_fromhost_VkRect2D(resourceTracker,
+ (VkRect2D*)(toTransform->pExclusiveScissors + i));
}
}
}
}
void transform_tohost_VkPhysicalDeviceExclusiveScissorFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExclusiveScissorFeaturesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExclusiveScissorFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceExclusiveScissorFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExclusiveScissorFeaturesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExclusiveScissorFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -15378,49 +12321,37 @@
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
void transform_tohost_VkQueueFamilyCheckpointPropertiesNV(
- ResourceTracker* resourceTracker,
- VkQueueFamilyCheckpointPropertiesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkQueueFamilyCheckpointPropertiesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkQueueFamilyCheckpointPropertiesNV(
- ResourceTracker* resourceTracker,
- VkQueueFamilyCheckpointPropertiesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkQueueFamilyCheckpointPropertiesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkCheckpointDataNV(
- ResourceTracker* resourceTracker,
- VkCheckpointDataNV* toTransform)
-{
+void transform_tohost_VkCheckpointDataNV(ResourceTracker* resourceTracker,
+ VkCheckpointDataNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkCheckpointDataNV(
- ResourceTracker* resourceTracker,
- VkCheckpointDataNV* toTransform)
-{
+void transform_fromhost_VkCheckpointDataNV(ResourceTracker* resourceTracker,
+ VkCheckpointDataNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -15429,204 +12360,158 @@
#ifdef VK_INTEL_shader_integer_functions2
void transform_tohost_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* toTransform)
-{
+ VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* toTransform)
-{
+ VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_INTEL_performance_query
-void transform_tohost_VkPerformanceValueDataINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceValueDataINTEL* toTransform)
-{
+void transform_tohost_VkPerformanceValueDataINTEL(ResourceTracker* resourceTracker,
+ VkPerformanceValueDataINTEL* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkPerformanceValueDataINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceValueDataINTEL* toTransform)
-{
+void transform_fromhost_VkPerformanceValueDataINTEL(ResourceTracker* resourceTracker,
+ VkPerformanceValueDataINTEL* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkPerformanceValueINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceValueINTEL* toTransform)
-{
+void transform_tohost_VkPerformanceValueINTEL(ResourceTracker* resourceTracker,
+ VkPerformanceValueINTEL* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_tohost_VkPerformanceValueDataINTEL(resourceTracker, (VkPerformanceValueDataINTEL*)(&toTransform->data));
+ transform_tohost_VkPerformanceValueDataINTEL(
+ resourceTracker, (VkPerformanceValueDataINTEL*)(&toTransform->data));
}
-void transform_fromhost_VkPerformanceValueINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceValueINTEL* toTransform)
-{
+void transform_fromhost_VkPerformanceValueINTEL(ResourceTracker* resourceTracker,
+ VkPerformanceValueINTEL* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_fromhost_VkPerformanceValueDataINTEL(resourceTracker, (VkPerformanceValueDataINTEL*)(&toTransform->data));
+ transform_fromhost_VkPerformanceValueDataINTEL(
+ resourceTracker, (VkPerformanceValueDataINTEL*)(&toTransform->data));
}
void transform_tohost_VkInitializePerformanceApiInfoINTEL(
- ResourceTracker* resourceTracker,
- VkInitializePerformanceApiInfoINTEL* toTransform)
-{
+ ResourceTracker* resourceTracker, VkInitializePerformanceApiInfoINTEL* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkInitializePerformanceApiInfoINTEL(
- ResourceTracker* resourceTracker,
- VkInitializePerformanceApiInfoINTEL* toTransform)
-{
+ ResourceTracker* resourceTracker, VkInitializePerformanceApiInfoINTEL* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkQueryPoolPerformanceQueryCreateInfoINTEL(
- ResourceTracker* resourceTracker,
- VkQueryPoolPerformanceQueryCreateInfoINTEL* toTransform)
-{
+ ResourceTracker* resourceTracker, VkQueryPoolPerformanceQueryCreateInfoINTEL* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkQueryPoolPerformanceQueryCreateInfoINTEL(
- ResourceTracker* resourceTracker,
- VkQueryPoolPerformanceQueryCreateInfoINTEL* toTransform)
-{
+ ResourceTracker* resourceTracker, VkQueryPoolPerformanceQueryCreateInfoINTEL* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkPerformanceMarkerInfoINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceMarkerInfoINTEL* toTransform)
-{
+void transform_tohost_VkPerformanceMarkerInfoINTEL(ResourceTracker* resourceTracker,
+ VkPerformanceMarkerInfoINTEL* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkPerformanceMarkerInfoINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceMarkerInfoINTEL* toTransform)
-{
+void transform_fromhost_VkPerformanceMarkerInfoINTEL(ResourceTracker* resourceTracker,
+ VkPerformanceMarkerInfoINTEL* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPerformanceStreamMarkerInfoINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceStreamMarkerInfoINTEL* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPerformanceStreamMarkerInfoINTEL* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPerformanceStreamMarkerInfoINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceStreamMarkerInfoINTEL* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPerformanceStreamMarkerInfoINTEL* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkPerformanceOverrideInfoINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceOverrideInfoINTEL* toTransform)
-{
+void transform_tohost_VkPerformanceOverrideInfoINTEL(ResourceTracker* resourceTracker,
+ VkPerformanceOverrideInfoINTEL* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPerformanceOverrideInfoINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceOverrideInfoINTEL* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPerformanceOverrideInfoINTEL* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPerformanceConfigurationAcquireInfoINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceConfigurationAcquireInfoINTEL* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPerformanceConfigurationAcquireInfoINTEL* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPerformanceConfigurationAcquireInfoINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceConfigurationAcquireInfoINTEL* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPerformanceConfigurationAcquireInfoINTEL* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -15634,25 +12519,19 @@
#endif
#ifdef VK_EXT_pci_bus_info
void transform_tohost_VkPhysicalDevicePCIBusInfoPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePCIBusInfoPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevicePCIBusInfoPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDevicePCIBusInfoPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePCIBusInfoPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevicePCIBusInfoPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -15660,49 +12539,37 @@
#endif
#ifdef VK_AMD_display_native_hdr
void transform_tohost_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
- ResourceTracker* resourceTracker,
- VkDisplayNativeHdrSurfaceCapabilitiesAMD* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDisplayNativeHdrSurfaceCapabilitiesAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
- ResourceTracker* resourceTracker,
- VkDisplayNativeHdrSurfaceCapabilitiesAMD* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDisplayNativeHdrSurfaceCapabilitiesAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkSwapchainDisplayNativeHdrCreateInfoAMD(
- ResourceTracker* resourceTracker,
- VkSwapchainDisplayNativeHdrCreateInfoAMD* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSwapchainDisplayNativeHdrCreateInfoAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkSwapchainDisplayNativeHdrCreateInfoAMD(
- ResourceTracker* resourceTracker,
- VkSwapchainDisplayNativeHdrCreateInfoAMD* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSwapchainDisplayNativeHdrCreateInfoAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -15710,51 +12577,39 @@
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
void transform_tohost_VkImagePipeSurfaceCreateInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImagePipeSurfaceCreateInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImagePipeSurfaceCreateInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkImagePipeSurfaceCreateInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImagePipeSurfaceCreateInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImagePipeSurfaceCreateInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_EXT_metal_surface
-void transform_tohost_VkMetalSurfaceCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkMetalSurfaceCreateInfoEXT* toTransform)
-{
+void transform_tohost_VkMetalSurfaceCreateInfoEXT(ResourceTracker* resourceTracker,
+ VkMetalSurfaceCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkMetalSurfaceCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkMetalSurfaceCreateInfoEXT* toTransform)
-{
+void transform_fromhost_VkMetalSurfaceCreateInfoEXT(ResourceTracker* resourceTracker,
+ VkMetalSurfaceCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -15762,81 +12617,71 @@
#endif
#ifdef VK_EXT_fragment_density_map
void transform_tohost_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toTransform)
-{
+ VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->minFragmentDensityTexelSize));
- transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxFragmentDensityTexelSize));
+ transform_tohost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->minFragmentDensityTexelSize));
+ transform_tohost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->maxFragmentDensityTexelSize));
}
void transform_fromhost_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toTransform)
-{
+ VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->minFragmentDensityTexelSize));
- transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxFragmentDensityTexelSize));
+ transform_fromhost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->minFragmentDensityTexelSize));
+ transform_fromhost_VkExtent2D(resourceTracker,
+ (VkExtent2D*)(&toTransform->maxFragmentDensityTexelSize));
}
void transform_tohost_VkRenderPassFragmentDensityMapCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkRenderPassFragmentDensityMapCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRenderPassFragmentDensityMapCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkAttachmentReference(resourceTracker, (VkAttachmentReference*)(&toTransform->fragmentDensityMapAttachment));
+ transform_tohost_VkAttachmentReference(
+ resourceTracker, (VkAttachmentReference*)(&toTransform->fragmentDensityMapAttachment));
}
void transform_fromhost_VkRenderPassFragmentDensityMapCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkRenderPassFragmentDensityMapCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRenderPassFragmentDensityMapCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkAttachmentReference(resourceTracker, (VkAttachmentReference*)(&toTransform->fragmentDensityMapAttachment));
+ transform_fromhost_VkAttachmentReference(
+ resourceTracker, (VkAttachmentReference*)(&toTransform->fragmentDensityMapAttachment));
}
#endif
@@ -15848,73 +12693,59 @@
#endif
#ifdef VK_EXT_subgroup_size_control
void transform_tohost_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* toTransform)
-{
+ VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* toTransform)
-{
+ VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toTransform)
-{
+ VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toTransform)
-{
+ VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -15922,25 +12753,19 @@
#endif
#ifdef VK_AMD_shader_core_properties2
void transform_tohost_VkPhysicalDeviceShaderCoreProperties2AMD(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderCoreProperties2AMD* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderCoreProperties2AMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceShaderCoreProperties2AMD(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderCoreProperties2AMD* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderCoreProperties2AMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -15948,25 +12773,19 @@
#endif
#ifdef VK_AMD_device_coherent_memory
void transform_tohost_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCoherentMemoryFeaturesAMD* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCoherentMemoryFeaturesAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCoherentMemoryFeaturesAMD* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCoherentMemoryFeaturesAMD* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -15975,24 +12794,20 @@
#ifdef VK_EXT_shader_image_atomic_int64
void transform_tohost_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -16000,25 +12815,19 @@
#endif
#ifdef VK_EXT_memory_budget
void transform_tohost_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMemoryBudgetPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMemoryBudgetPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMemoryBudgetPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMemoryBudgetPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -16026,49 +12835,37 @@
#endif
#ifdef VK_EXT_memory_priority
void transform_tohost_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMemoryPriorityFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMemoryPriorityFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMemoryPriorityFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMemoryPriorityFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkMemoryPriorityAllocateInfoEXT(
- ResourceTracker* resourceTracker,
- VkMemoryPriorityAllocateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMemoryPriorityAllocateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkMemoryPriorityAllocateInfoEXT(
- ResourceTracker* resourceTracker,
- VkMemoryPriorityAllocateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMemoryPriorityAllocateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -16077,24 +12874,20 @@
#ifdef VK_NV_dedicated_allocation_image_aliasing
void transform_tohost_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* toTransform)
-{
+ VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* toTransform)
-{
+ VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -16102,49 +12895,37 @@
#endif
#ifdef VK_EXT_buffer_device_address
void transform_tohost_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkBufferDeviceAddressCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkBufferDeviceAddressCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBufferDeviceAddressCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkBufferDeviceAddressCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkBufferDeviceAddressCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBufferDeviceAddressCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -16152,25 +12933,19 @@
#endif
#ifdef VK_EXT_tooling_info
void transform_tohost_VkPhysicalDeviceToolPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceToolPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceToolPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceToolPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceToolPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceToolPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -16179,26 +12954,20 @@
#ifdef VK_EXT_separate_stencil_usage
#endif
#ifdef VK_EXT_validation_features
-void transform_tohost_VkValidationFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkValidationFeaturesEXT* toTransform)
-{
+void transform_tohost_VkValidationFeaturesEXT(ResourceTracker* resourceTracker,
+ VkValidationFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkValidationFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkValidationFeaturesEXT* toTransform)
-{
+void transform_fromhost_VkValidationFeaturesEXT(ResourceTracker* resourceTracker,
+ VkValidationFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -16206,73 +12975,55 @@
#endif
#ifdef VK_NV_cooperative_matrix
void transform_tohost_VkCooperativeMatrixPropertiesNV(
- ResourceTracker* resourceTracker,
- VkCooperativeMatrixPropertiesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkCooperativeMatrixPropertiesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkCooperativeMatrixPropertiesNV(
- ResourceTracker* resourceTracker,
- VkCooperativeMatrixPropertiesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkCooperativeMatrixPropertiesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCooperativeMatrixFeaturesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCooperativeMatrixFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCooperativeMatrixFeaturesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCooperativeMatrixFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCooperativeMatrixPropertiesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCooperativeMatrixPropertiesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCooperativeMatrixPropertiesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCooperativeMatrixPropertiesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -16281,72 +13032,56 @@
#ifdef VK_NV_coverage_reduction_mode
void transform_tohost_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceCoverageReductionModeFeaturesNV* toTransform)
-{
+ VkPhysicalDeviceCoverageReductionModeFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceCoverageReductionModeFeaturesNV* toTransform)
-{
+ VkPhysicalDeviceCoverageReductionModeFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPipelineCoverageReductionStateCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkPipelineCoverageReductionStateCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineCoverageReductionStateCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineCoverageReductionStateCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkPipelineCoverageReductionStateCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineCoverageReductionStateCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkFramebufferMixedSamplesCombinationNV(
- ResourceTracker* resourceTracker,
- VkFramebufferMixedSamplesCombinationNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkFramebufferMixedSamplesCombinationNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkFramebufferMixedSamplesCombinationNV(
- ResourceTracker* resourceTracker,
- VkFramebufferMixedSamplesCombinationNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkFramebufferMixedSamplesCombinationNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -16355,24 +13090,20 @@
#ifdef VK_EXT_fragment_shader_interlock
void transform_tohost_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -16380,25 +13111,19 @@
#endif
#ifdef VK_EXT_ycbcr_image_arrays
void transform_tohost_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -16406,73 +13131,57 @@
#endif
#ifdef VK_EXT_provoking_vertex
void transform_tohost_VkPhysicalDeviceProvokingVertexFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProvokingVertexFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceProvokingVertexFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceProvokingVertexFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProvokingVertexFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceProvokingVertexFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceProvokingVertexPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProvokingVertexPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceProvokingVertexPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceProvokingVertexPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProvokingVertexPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceProvokingVertexPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* toTransform)
-{
+ VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* toTransform)
-{
+ VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -16480,99 +13189,75 @@
#endif
#ifdef VK_EXT_full_screen_exclusive
void transform_tohost_VkSurfaceFullScreenExclusiveInfoEXT(
- ResourceTracker* resourceTracker,
- VkSurfaceFullScreenExclusiveInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSurfaceFullScreenExclusiveInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkSurfaceFullScreenExclusiveInfoEXT(
- ResourceTracker* resourceTracker,
- VkSurfaceFullScreenExclusiveInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSurfaceFullScreenExclusiveInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
- ResourceTracker* resourceTracker,
- VkSurfaceCapabilitiesFullScreenExclusiveEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSurfaceCapabilitiesFullScreenExclusiveEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
- ResourceTracker* resourceTracker,
- VkSurfaceCapabilitiesFullScreenExclusiveEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSurfaceCapabilitiesFullScreenExclusiveEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkSurfaceFullScreenExclusiveWin32InfoEXT(
- ResourceTracker* resourceTracker,
- VkSurfaceFullScreenExclusiveWin32InfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSurfaceFullScreenExclusiveWin32InfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkSurfaceFullScreenExclusiveWin32InfoEXT(
- ResourceTracker* resourceTracker,
- VkSurfaceFullScreenExclusiveWin32InfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSurfaceFullScreenExclusiveWin32InfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_EXT_headless_surface
-void transform_tohost_VkHeadlessSurfaceCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkHeadlessSurfaceCreateInfoEXT* toTransform)
-{
+void transform_tohost_VkHeadlessSurfaceCreateInfoEXT(ResourceTracker* resourceTracker,
+ VkHeadlessSurfaceCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkHeadlessSurfaceCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkHeadlessSurfaceCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkHeadlessSurfaceCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -16580,73 +13265,55 @@
#endif
#ifdef VK_EXT_line_rasterization
void transform_tohost_VkPhysicalDeviceLineRasterizationFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceLineRasterizationFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceLineRasterizationFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceLineRasterizationFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceLineRasterizationPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceLineRasterizationPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceLineRasterizationPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceLineRasterizationPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPipelineRasterizationLineStateCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineRasterizationLineStateCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineRasterizationLineStateCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineRasterizationLineStateCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineRasterizationLineStateCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineRasterizationLineStateCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -16654,25 +13321,19 @@
#endif
#ifdef VK_EXT_shader_atomic_float
void transform_tohost_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -16682,25 +13343,19 @@
#endif
#ifdef VK_EXT_index_type_uint8
void transform_tohost_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceIndexTypeUint8FeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceIndexTypeUint8FeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceIndexTypeUint8FeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceIndexTypeUint8FeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -16709,24 +13364,20 @@
#ifdef VK_EXT_extended_dynamic_state
void transform_tohost_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -16734,25 +13385,19 @@
#endif
#ifdef VK_EXT_shader_atomic_float2
void transform_tohost_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -16761,24 +13406,20 @@
#ifdef VK_EXT_shader_demote_to_helper_invocation
void transform_tohost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -16787,368 +13428,294 @@
#ifdef VK_NV_device_generated_commands
void transform_tohost_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* toTransform)
-{
+ VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* toTransform)
-{
+ VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* toTransform)
-{
+ VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* toTransform)
-{
+ VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkGraphicsShaderGroupCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkGraphicsShaderGroupCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkGraphicsShaderGroupCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pStages)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->stageCount; ++i)
- {
- transform_tohost_VkPipelineShaderStageCreateInfo(resourceTracker, (VkPipelineShaderStageCreateInfo*)(toTransform->pStages + i));
+ if (toTransform) {
+ if (toTransform->pStages) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->stageCount; ++i) {
+ transform_tohost_VkPipelineShaderStageCreateInfo(
+ resourceTracker, (VkPipelineShaderStageCreateInfo*)(toTransform->pStages + i));
}
}
}
- if (toTransform->pVertexInputState)
- {
- transform_tohost_VkPipelineVertexInputStateCreateInfo(resourceTracker, (VkPipelineVertexInputStateCreateInfo*)(toTransform->pVertexInputState));
+ if (toTransform->pVertexInputState) {
+ transform_tohost_VkPipelineVertexInputStateCreateInfo(
+ resourceTracker,
+ (VkPipelineVertexInputStateCreateInfo*)(toTransform->pVertexInputState));
}
- if (toTransform->pTessellationState)
- {
- transform_tohost_VkPipelineTessellationStateCreateInfo(resourceTracker, (VkPipelineTessellationStateCreateInfo*)(toTransform->pTessellationState));
+ if (toTransform->pTessellationState) {
+ transform_tohost_VkPipelineTessellationStateCreateInfo(
+ resourceTracker,
+ (VkPipelineTessellationStateCreateInfo*)(toTransform->pTessellationState));
}
}
void transform_fromhost_VkGraphicsShaderGroupCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkGraphicsShaderGroupCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkGraphicsShaderGroupCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pStages)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->stageCount; ++i)
- {
- transform_fromhost_VkPipelineShaderStageCreateInfo(resourceTracker, (VkPipelineShaderStageCreateInfo*)(toTransform->pStages + i));
+ if (toTransform) {
+ if (toTransform->pStages) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->stageCount; ++i) {
+ transform_fromhost_VkPipelineShaderStageCreateInfo(
+ resourceTracker, (VkPipelineShaderStageCreateInfo*)(toTransform->pStages + i));
}
}
}
- if (toTransform->pVertexInputState)
- {
- transform_fromhost_VkPipelineVertexInputStateCreateInfo(resourceTracker, (VkPipelineVertexInputStateCreateInfo*)(toTransform->pVertexInputState));
+ if (toTransform->pVertexInputState) {
+ transform_fromhost_VkPipelineVertexInputStateCreateInfo(
+ resourceTracker,
+ (VkPipelineVertexInputStateCreateInfo*)(toTransform->pVertexInputState));
}
- if (toTransform->pTessellationState)
- {
- transform_fromhost_VkPipelineTessellationStateCreateInfo(resourceTracker, (VkPipelineTessellationStateCreateInfo*)(toTransform->pTessellationState));
+ if (toTransform->pTessellationState) {
+ transform_fromhost_VkPipelineTessellationStateCreateInfo(
+ resourceTracker,
+ (VkPipelineTessellationStateCreateInfo*)(toTransform->pTessellationState));
}
}
void transform_tohost_VkGraphicsPipelineShaderGroupsCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkGraphicsPipelineShaderGroupsCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkGraphicsPipelineShaderGroupsCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pGroups)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->groupCount; ++i)
- {
- transform_tohost_VkGraphicsShaderGroupCreateInfoNV(resourceTracker, (VkGraphicsShaderGroupCreateInfoNV*)(toTransform->pGroups + i));
+ if (toTransform) {
+ if (toTransform->pGroups) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->groupCount; ++i) {
+ transform_tohost_VkGraphicsShaderGroupCreateInfoNV(
+ resourceTracker,
+ (VkGraphicsShaderGroupCreateInfoNV*)(toTransform->pGroups + i));
}
}
}
}
void transform_fromhost_VkGraphicsPipelineShaderGroupsCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkGraphicsPipelineShaderGroupsCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkGraphicsPipelineShaderGroupsCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pGroups)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->groupCount; ++i)
- {
- transform_fromhost_VkGraphicsShaderGroupCreateInfoNV(resourceTracker, (VkGraphicsShaderGroupCreateInfoNV*)(toTransform->pGroups + i));
+ if (toTransform) {
+ if (toTransform->pGroups) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->groupCount; ++i) {
+ transform_fromhost_VkGraphicsShaderGroupCreateInfoNV(
+ resourceTracker,
+ (VkGraphicsShaderGroupCreateInfoNV*)(toTransform->pGroups + i));
}
}
}
}
void transform_tohost_VkBindShaderGroupIndirectCommandNV(
- ResourceTracker* resourceTracker,
- VkBindShaderGroupIndirectCommandNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBindShaderGroupIndirectCommandNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_fromhost_VkBindShaderGroupIndirectCommandNV(
- ResourceTracker* resourceTracker,
- VkBindShaderGroupIndirectCommandNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBindShaderGroupIndirectCommandNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkBindIndexBufferIndirectCommandNV(
- ResourceTracker* resourceTracker,
- VkBindIndexBufferIndirectCommandNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBindIndexBufferIndirectCommandNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_fromhost_VkBindIndexBufferIndirectCommandNV(
- ResourceTracker* resourceTracker,
- VkBindIndexBufferIndirectCommandNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBindIndexBufferIndirectCommandNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkBindVertexBufferIndirectCommandNV(
- ResourceTracker* resourceTracker,
- VkBindVertexBufferIndirectCommandNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBindVertexBufferIndirectCommandNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_fromhost_VkBindVertexBufferIndirectCommandNV(
- ResourceTracker* resourceTracker,
- VkBindVertexBufferIndirectCommandNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBindVertexBufferIndirectCommandNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkSetStateFlagsIndirectCommandNV(
- ResourceTracker* resourceTracker,
- VkSetStateFlagsIndirectCommandNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSetStateFlagsIndirectCommandNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_fromhost_VkSetStateFlagsIndirectCommandNV(
- ResourceTracker* resourceTracker,
- VkSetStateFlagsIndirectCommandNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSetStateFlagsIndirectCommandNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkIndirectCommandsStreamNV(
- ResourceTracker* resourceTracker,
- VkIndirectCommandsStreamNV* toTransform)
-{
+void transform_tohost_VkIndirectCommandsStreamNV(ResourceTracker* resourceTracker,
+ VkIndirectCommandsStreamNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkIndirectCommandsStreamNV(
- ResourceTracker* resourceTracker,
- VkIndirectCommandsStreamNV* toTransform)
-{
+void transform_fromhost_VkIndirectCommandsStreamNV(ResourceTracker* resourceTracker,
+ VkIndirectCommandsStreamNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkIndirectCommandsLayoutTokenNV(
- ResourceTracker* resourceTracker,
- VkIndirectCommandsLayoutTokenNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkIndirectCommandsLayoutTokenNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkIndirectCommandsLayoutTokenNV(
- ResourceTracker* resourceTracker,
- VkIndirectCommandsLayoutTokenNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkIndirectCommandsLayoutTokenNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkIndirectCommandsLayoutCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkIndirectCommandsLayoutCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkIndirectCommandsLayoutCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pTokens)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->tokenCount; ++i)
- {
- transform_tohost_VkIndirectCommandsLayoutTokenNV(resourceTracker, (VkIndirectCommandsLayoutTokenNV*)(toTransform->pTokens + i));
+ if (toTransform) {
+ if (toTransform->pTokens) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->tokenCount; ++i) {
+ transform_tohost_VkIndirectCommandsLayoutTokenNV(
+ resourceTracker, (VkIndirectCommandsLayoutTokenNV*)(toTransform->pTokens + i));
}
}
}
}
void transform_fromhost_VkIndirectCommandsLayoutCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkIndirectCommandsLayoutCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkIndirectCommandsLayoutCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pTokens)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->tokenCount; ++i)
- {
- transform_fromhost_VkIndirectCommandsLayoutTokenNV(resourceTracker, (VkIndirectCommandsLayoutTokenNV*)(toTransform->pTokens + i));
+ if (toTransform) {
+ if (toTransform->pTokens) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->tokenCount; ++i) {
+ transform_fromhost_VkIndirectCommandsLayoutTokenNV(
+ resourceTracker, (VkIndirectCommandsLayoutTokenNV*)(toTransform->pTokens + i));
}
}
}
}
-void transform_tohost_VkGeneratedCommandsInfoNV(
- ResourceTracker* resourceTracker,
- VkGeneratedCommandsInfoNV* toTransform)
-{
+void transform_tohost_VkGeneratedCommandsInfoNV(ResourceTracker* resourceTracker,
+ VkGeneratedCommandsInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pStreams)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->streamCount; ++i)
- {
- transform_tohost_VkIndirectCommandsStreamNV(resourceTracker, (VkIndirectCommandsStreamNV*)(toTransform->pStreams + i));
+ if (toTransform) {
+ if (toTransform->pStreams) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->streamCount; ++i) {
+ transform_tohost_VkIndirectCommandsStreamNV(
+ resourceTracker, (VkIndirectCommandsStreamNV*)(toTransform->pStreams + i));
}
}
}
}
-void transform_fromhost_VkGeneratedCommandsInfoNV(
- ResourceTracker* resourceTracker,
- VkGeneratedCommandsInfoNV* toTransform)
-{
+void transform_fromhost_VkGeneratedCommandsInfoNV(ResourceTracker* resourceTracker,
+ VkGeneratedCommandsInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pStreams)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->streamCount; ++i)
- {
- transform_fromhost_VkIndirectCommandsStreamNV(resourceTracker, (VkIndirectCommandsStreamNV*)(toTransform->pStreams + i));
+ if (toTransform) {
+ if (toTransform->pStreams) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->streamCount; ++i) {
+ transform_fromhost_VkIndirectCommandsStreamNV(
+ resourceTracker, (VkIndirectCommandsStreamNV*)(toTransform->pStreams + i));
}
}
}
}
void transform_tohost_VkGeneratedCommandsMemoryRequirementsInfoNV(
- ResourceTracker* resourceTracker,
- VkGeneratedCommandsMemoryRequirementsInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkGeneratedCommandsMemoryRequirementsInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkGeneratedCommandsMemoryRequirementsInfoNV(
- ResourceTracker* resourceTracker,
- VkGeneratedCommandsMemoryRequirementsInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkGeneratedCommandsMemoryRequirementsInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -17157,56 +13724,46 @@
#ifdef VK_NV_inherited_viewport_scissor
void transform_tohost_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceInheritedViewportScissorFeaturesNV* toTransform)
-{
+ VkPhysicalDeviceInheritedViewportScissorFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceInheritedViewportScissorFeaturesNV* toTransform)
-{
+ VkPhysicalDeviceInheritedViewportScissorFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkCommandBufferInheritanceViewportScissorInfoNV(
ResourceTracker* resourceTracker,
- VkCommandBufferInheritanceViewportScissorInfoNV* toTransform)
-{
+ VkCommandBufferInheritanceViewportScissorInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pViewportDepths)
- {
+ if (toTransform->pViewportDepths) {
transform_tohost_VkViewport(resourceTracker, (VkViewport*)(toTransform->pViewportDepths));
}
}
void transform_fromhost_VkCommandBufferInheritanceViewportScissorInfoNV(
ResourceTracker* resourceTracker,
- VkCommandBufferInheritanceViewportScissorInfoNV* toTransform)
-{
+ VkCommandBufferInheritanceViewportScissorInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform->pViewportDepths)
- {
+ if (toTransform->pViewportDepths) {
transform_fromhost_VkViewport(resourceTracker, (VkViewport*)(toTransform->pViewportDepths));
}
}
@@ -17215,48 +13772,40 @@
#ifdef VK_EXT_texel_buffer_alignment
void transform_tohost_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* toTransform)
-{
+ VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* toTransform)
-{
+ VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -17264,37 +13813,29 @@
#endif
#ifdef VK_QCOM_render_pass_transform
void transform_tohost_VkRenderPassTransformBeginInfoQCOM(
- ResourceTracker* resourceTracker,
- VkRenderPassTransformBeginInfoQCOM* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRenderPassTransformBeginInfoQCOM* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkRenderPassTransformBeginInfoQCOM(
- ResourceTracker* resourceTracker,
- VkRenderPassTransformBeginInfoQCOM* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRenderPassTransformBeginInfoQCOM* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
ResourceTracker* resourceTracker,
- VkCommandBufferInheritanceRenderPassTransformInfoQCOM* toTransform)
-{
+ VkCommandBufferInheritanceRenderPassTransformInfoQCOM* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_tohost_VkRect2D(resourceTracker, (VkRect2D*)(&toTransform->renderArea));
@@ -17302,12 +13843,10 @@
void transform_fromhost_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
ResourceTracker* resourceTracker,
- VkCommandBufferInheritanceRenderPassTransformInfoQCOM* toTransform)
-{
+ VkCommandBufferInheritanceRenderPassTransformInfoQCOM* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
transform_fromhost_VkRect2D(resourceTracker, (VkRect2D*)(&toTransform->renderArea));
@@ -17316,73 +13855,55 @@
#endif
#ifdef VK_EXT_device_memory_report
void transform_tohost_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkDeviceMemoryReportCallbackDataEXT(
- ResourceTracker* resourceTracker,
- VkDeviceMemoryReportCallbackDataEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceMemoryReportCallbackDataEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDeviceMemoryReportCallbackDataEXT(
- ResourceTracker* resourceTracker,
- VkDeviceMemoryReportCallbackDataEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceMemoryReportCallbackDataEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkDeviceDeviceMemoryReportCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDeviceDeviceMemoryReportCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceDeviceMemoryReportCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDeviceDeviceMemoryReportCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDeviceDeviceMemoryReportCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceDeviceMemoryReportCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -17392,49 +13913,37 @@
#endif
#ifdef VK_EXT_robustness2
void transform_tohost_VkPhysicalDeviceRobustness2FeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRobustness2FeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRobustness2FeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceRobustness2FeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRobustness2FeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRobustness2FeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceRobustness2PropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRobustness2PropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRobustness2PropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceRobustness2PropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRobustness2PropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRobustness2PropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -17442,75 +13951,59 @@
#endif
#ifdef VK_EXT_custom_border_color
void transform_tohost_VkSamplerCustomBorderColorCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkSamplerCustomBorderColorCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSamplerCustomBorderColorCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkClearColorValue(resourceTracker, (VkClearColorValue*)(&toTransform->customBorderColor));
+ transform_tohost_VkClearColorValue(resourceTracker,
+ (VkClearColorValue*)(&toTransform->customBorderColor));
}
void transform_fromhost_VkSamplerCustomBorderColorCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkSamplerCustomBorderColorCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSamplerCustomBorderColorCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkClearColorValue(resourceTracker, (VkClearColorValue*)(&toTransform->customBorderColor));
+ transform_fromhost_VkClearColorValue(resourceTracker,
+ (VkClearColorValue*)(&toTransform->customBorderColor));
}
void transform_tohost_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCustomBorderColorPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCustomBorderColorPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCustomBorderColorPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCustomBorderColorPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCustomBorderColorFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCustomBorderColorFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCustomBorderColorFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCustomBorderColorFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -17520,73 +14013,55 @@
#endif
#ifdef VK_EXT_private_data
void transform_tohost_VkPhysicalDevicePrivateDataFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePrivateDataFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevicePrivateDataFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDevicePrivateDataFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePrivateDataFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevicePrivateDataFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkDevicePrivateDataCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDevicePrivateDataCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDevicePrivateDataCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDevicePrivateDataCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDevicePrivateDataCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDevicePrivateDataCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkPrivateDataSlotCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPrivateDataSlotCreateInfoEXT* toTransform)
-{
+void transform_tohost_VkPrivateDataSlotCreateInfoEXT(ResourceTracker* resourceTracker,
+ VkPrivateDataSlotCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPrivateDataSlotCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPrivateDataSlotCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPrivateDataSlotCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -17595,24 +14070,20 @@
#ifdef VK_EXT_pipeline_creation_cache_control
void transform_tohost_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toTransform)
-{
+ VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toTransform)
-{
+ VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -17620,49 +14091,37 @@
#endif
#ifdef VK_NV_device_diagnostics_config
void transform_tohost_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkDeviceDiagnosticsConfigCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkDeviceDiagnosticsConfigCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceDiagnosticsConfigCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDeviceDiagnosticsConfigCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkDeviceDiagnosticsConfigCreateInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDeviceDiagnosticsConfigCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -17673,184 +14132,152 @@
#ifdef VK_NV_fragment_shading_rate_enums
void transform_tohost_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* toTransform)
-{
+ VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* toTransform)
-{
+ VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* toTransform)
-{
+ VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* toTransform)
-{
+ VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
ResourceTracker* resourceTracker,
- VkPipelineFragmentShadingRateEnumStateCreateInfoNV* toTransform)
-{
+ VkPipelineFragmentShadingRateEnumStateCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
ResourceTracker* resourceTracker,
- VkPipelineFragmentShadingRateEnumStateCreateInfoNV* toTransform)
-{
+ VkPipelineFragmentShadingRateEnumStateCreateInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_NV_ray_tracing_motion_blur
-void transform_tohost_VkDeviceOrHostAddressConstKHR(
- ResourceTracker* resourceTracker,
- VkDeviceOrHostAddressConstKHR* toTransform)
-{
+void transform_tohost_VkDeviceOrHostAddressConstKHR(ResourceTracker* resourceTracker,
+ VkDeviceOrHostAddressConstKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkDeviceOrHostAddressConstKHR(
- ResourceTracker* resourceTracker,
- VkDeviceOrHostAddressConstKHR* toTransform)
-{
+void transform_fromhost_VkDeviceOrHostAddressConstKHR(ResourceTracker* resourceTracker,
+ VkDeviceOrHostAddressConstKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkAccelerationStructureGeometryMotionTrianglesDataNV(
ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryMotionTrianglesDataNV* toTransform)
-{
+ VkAccelerationStructureGeometryMotionTrianglesDataNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkDeviceOrHostAddressConstKHR(resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->vertexData));
+ transform_tohost_VkDeviceOrHostAddressConstKHR(
+ resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->vertexData));
}
void transform_fromhost_VkAccelerationStructureGeometryMotionTrianglesDataNV(
ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryMotionTrianglesDataNV* toTransform)
-{
+ VkAccelerationStructureGeometryMotionTrianglesDataNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkDeviceOrHostAddressConstKHR(resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->vertexData));
+ transform_fromhost_VkDeviceOrHostAddressConstKHR(
+ resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->vertexData));
}
void transform_tohost_VkAccelerationStructureMotionInfoNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureMotionInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureMotionInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkAccelerationStructureMotionInfoNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureMotionInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureMotionInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkAccelerationStructureMatrixMotionInstanceNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureMatrixMotionInstanceNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureMatrixMotionInstanceNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_tohost_VkTransformMatrixKHR(resourceTracker, (VkTransformMatrixKHR*)(&toTransform->transformT0));
- transform_tohost_VkTransformMatrixKHR(resourceTracker, (VkTransformMatrixKHR*)(&toTransform->transformT1));
+ transform_tohost_VkTransformMatrixKHR(resourceTracker,
+ (VkTransformMatrixKHR*)(&toTransform->transformT0));
+ transform_tohost_VkTransformMatrixKHR(resourceTracker,
+ (VkTransformMatrixKHR*)(&toTransform->transformT1));
}
void transform_fromhost_VkAccelerationStructureMatrixMotionInstanceNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureMatrixMotionInstanceNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureMatrixMotionInstanceNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_fromhost_VkTransformMatrixKHR(resourceTracker, (VkTransformMatrixKHR*)(&toTransform->transformT0));
- transform_fromhost_VkTransformMatrixKHR(resourceTracker, (VkTransformMatrixKHR*)(&toTransform->transformT1));
+ transform_fromhost_VkTransformMatrixKHR(resourceTracker,
+ (VkTransformMatrixKHR*)(&toTransform->transformT0));
+ transform_fromhost_VkTransformMatrixKHR(resourceTracker,
+ (VkTransformMatrixKHR*)(&toTransform->transformT1));
}
-void transform_tohost_VkSRTDataNV(
- ResourceTracker* resourceTracker,
- VkSRTDataNV* toTransform)
-{
+void transform_tohost_VkSRTDataNV(ResourceTracker* resourceTracker, VkSRTDataNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkSRTDataNV(
- ResourceTracker* resourceTracker,
- VkSRTDataNV* toTransform)
-{
+void transform_fromhost_VkSRTDataNV(ResourceTracker* resourceTracker, VkSRTDataNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkAccelerationStructureSRTMotionInstanceNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureSRTMotionInstanceNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureSRTMotionInstanceNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_tohost_VkSRTDataNV(resourceTracker, (VkSRTDataNV*)(&toTransform->transformT0));
@@ -17858,9 +14285,7 @@
}
void transform_fromhost_VkAccelerationStructureSRTMotionInstanceNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureSRTMotionInstanceNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureSRTMotionInstanceNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
transform_fromhost_VkSRTDataNV(resourceTracker, (VkSRTDataNV*)(&toTransform->transformT0));
@@ -17868,65 +14293,63 @@
}
void transform_tohost_VkAccelerationStructureMotionInstanceDataNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureMotionInstanceDataNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureMotionInstanceDataNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_tohost_VkAccelerationStructureInstanceKHR(resourceTracker, (VkAccelerationStructureInstanceKHR*)(&toTransform->staticInstance));
- transform_tohost_VkAccelerationStructureMatrixMotionInstanceNV(resourceTracker, (VkAccelerationStructureMatrixMotionInstanceNV*)(&toTransform->matrixMotionInstance));
- transform_tohost_VkAccelerationStructureSRTMotionInstanceNV(resourceTracker, (VkAccelerationStructureSRTMotionInstanceNV*)(&toTransform->srtMotionInstance));
+ transform_tohost_VkAccelerationStructureInstanceKHR(
+ resourceTracker, (VkAccelerationStructureInstanceKHR*)(&toTransform->staticInstance));
+ transform_tohost_VkAccelerationStructureMatrixMotionInstanceNV(
+ resourceTracker,
+ (VkAccelerationStructureMatrixMotionInstanceNV*)(&toTransform->matrixMotionInstance));
+ transform_tohost_VkAccelerationStructureSRTMotionInstanceNV(
+ resourceTracker,
+ (VkAccelerationStructureSRTMotionInstanceNV*)(&toTransform->srtMotionInstance));
}
void transform_fromhost_VkAccelerationStructureMotionInstanceDataNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureMotionInstanceDataNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureMotionInstanceDataNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_fromhost_VkAccelerationStructureInstanceKHR(resourceTracker, (VkAccelerationStructureInstanceKHR*)(&toTransform->staticInstance));
- transform_fromhost_VkAccelerationStructureMatrixMotionInstanceNV(resourceTracker, (VkAccelerationStructureMatrixMotionInstanceNV*)(&toTransform->matrixMotionInstance));
- transform_fromhost_VkAccelerationStructureSRTMotionInstanceNV(resourceTracker, (VkAccelerationStructureSRTMotionInstanceNV*)(&toTransform->srtMotionInstance));
+ transform_fromhost_VkAccelerationStructureInstanceKHR(
+ resourceTracker, (VkAccelerationStructureInstanceKHR*)(&toTransform->staticInstance));
+ transform_fromhost_VkAccelerationStructureMatrixMotionInstanceNV(
+ resourceTracker,
+ (VkAccelerationStructureMatrixMotionInstanceNV*)(&toTransform->matrixMotionInstance));
+ transform_fromhost_VkAccelerationStructureSRTMotionInstanceNV(
+ resourceTracker,
+ (VkAccelerationStructureSRTMotionInstanceNV*)(&toTransform->srtMotionInstance));
}
void transform_tohost_VkAccelerationStructureMotionInstanceNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureMotionInstanceNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureMotionInstanceNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_tohost_VkAccelerationStructureMotionInstanceDataNV(resourceTracker, (VkAccelerationStructureMotionInstanceDataNV*)(&toTransform->data));
+ transform_tohost_VkAccelerationStructureMotionInstanceDataNV(
+ resourceTracker, (VkAccelerationStructureMotionInstanceDataNV*)(&toTransform->data));
}
void transform_fromhost_VkAccelerationStructureMotionInstanceNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureMotionInstanceNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureMotionInstanceNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_fromhost_VkAccelerationStructureMotionInstanceDataNV(resourceTracker, (VkAccelerationStructureMotionInstanceDataNV*)(&toTransform->data));
+ transform_fromhost_VkAccelerationStructureMotionInstanceDataNV(
+ resourceTracker, (VkAccelerationStructureMotionInstanceDataNV*)(&toTransform->data));
}
void transform_tohost_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -17935,24 +14358,20 @@
#ifdef VK_EXT_ycbcr_2plane_444_formats
void transform_tohost_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -17960,75 +14379,59 @@
#endif
#ifdef VK_EXT_fragment_density_map2
void transform_tohost_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* toTransform)
-{
+ VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* toTransform)
-{
+ VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_QCOM_rotated_copy_commands
-void transform_tohost_VkCopyCommandTransformInfoQCOM(
- ResourceTracker* resourceTracker,
- VkCopyCommandTransformInfoQCOM* toTransform)
-{
+void transform_tohost_VkCopyCommandTransformInfoQCOM(ResourceTracker* resourceTracker,
+ VkCopyCommandTransformInfoQCOM* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkCopyCommandTransformInfoQCOM(
- ResourceTracker* resourceTracker,
- VkCopyCommandTransformInfoQCOM* toTransform)
-{
+ ResourceTracker* resourceTracker, VkCopyCommandTransformInfoQCOM* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -18036,25 +14439,19 @@
#endif
#ifdef VK_EXT_image_robustness
void transform_tohost_VkPhysicalDeviceImageRobustnessFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceImageRobustnessFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceImageRobustnessFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceImageRobustnessFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceImageRobustnessFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceImageRobustnessFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -18062,25 +14459,19 @@
#endif
#ifdef VK_EXT_4444_formats
void transform_tohost_VkPhysicalDevice4444FormatsFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDevice4444FormatsFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevice4444FormatsFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDevice4444FormatsFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDevice4444FormatsFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDevice4444FormatsFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -18088,25 +14479,19 @@
#endif
#ifdef VK_EXT_rgba10x6_formats
void transform_tohost_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -18115,26 +14500,20 @@
#ifdef VK_NV_acquire_winrt_display
#endif
#ifdef VK_EXT_directfb_surface
-void transform_tohost_VkDirectFBSurfaceCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDirectFBSurfaceCreateInfoEXT* toTransform)
-{
+void transform_tohost_VkDirectFBSurfaceCreateInfoEXT(ResourceTracker* resourceTracker,
+ VkDirectFBSurfaceCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkDirectFBSurfaceCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDirectFBSurfaceCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkDirectFBSurfaceCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -18143,83 +14522,69 @@
#ifdef VK_VALVE_mutable_descriptor_type
void transform_tohost_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* toTransform)
-{
+ VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* toTransform)
-{
+ VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkMutableDescriptorTypeListVALVE(
- ResourceTracker* resourceTracker,
- VkMutableDescriptorTypeListVALVE* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMutableDescriptorTypeListVALVE* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_fromhost_VkMutableDescriptorTypeListVALVE(
- ResourceTracker* resourceTracker,
- VkMutableDescriptorTypeListVALVE* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMutableDescriptorTypeListVALVE* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkMutableDescriptorTypeCreateInfoVALVE(
- ResourceTracker* resourceTracker,
- VkMutableDescriptorTypeCreateInfoVALVE* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMutableDescriptorTypeCreateInfoVALVE* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pMutableDescriptorTypeLists)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->mutableDescriptorTypeListCount; ++i)
- {
- transform_tohost_VkMutableDescriptorTypeListVALVE(resourceTracker, (VkMutableDescriptorTypeListVALVE*)(toTransform->pMutableDescriptorTypeLists + i));
+ if (toTransform) {
+ if (toTransform->pMutableDescriptorTypeLists) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->mutableDescriptorTypeListCount; ++i) {
+ transform_tohost_VkMutableDescriptorTypeListVALVE(
+ resourceTracker,
+ (VkMutableDescriptorTypeListVALVE*)(toTransform->pMutableDescriptorTypeLists +
+ i));
}
}
}
}
void transform_fromhost_VkMutableDescriptorTypeCreateInfoVALVE(
- ResourceTracker* resourceTracker,
- VkMutableDescriptorTypeCreateInfoVALVE* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMutableDescriptorTypeCreateInfoVALVE* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pMutableDescriptorTypeLists)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->mutableDescriptorTypeListCount; ++i)
- {
- transform_fromhost_VkMutableDescriptorTypeListVALVE(resourceTracker, (VkMutableDescriptorTypeListVALVE*)(toTransform->pMutableDescriptorTypeLists + i));
+ if (toTransform) {
+ if (toTransform->pMutableDescriptorTypeLists) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->mutableDescriptorTypeListCount; ++i) {
+ transform_fromhost_VkMutableDescriptorTypeListVALVE(
+ resourceTracker,
+ (VkMutableDescriptorTypeListVALVE*)(toTransform->pMutableDescriptorTypeLists +
+ i));
}
}
}
@@ -18229,72 +14594,56 @@
#ifdef VK_EXT_vertex_input_dynamic_state
void transform_tohost_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkVertexInputBindingDescription2EXT(
- ResourceTracker* resourceTracker,
- VkVertexInputBindingDescription2EXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVertexInputBindingDescription2EXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkVertexInputBindingDescription2EXT(
- ResourceTracker* resourceTracker,
- VkVertexInputBindingDescription2EXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVertexInputBindingDescription2EXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkVertexInputAttributeDescription2EXT(
- ResourceTracker* resourceTracker,
- VkVertexInputAttributeDescription2EXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVertexInputAttributeDescription2EXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkVertexInputAttributeDescription2EXT(
- ResourceTracker* resourceTracker,
- VkVertexInputAttributeDescription2EXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkVertexInputAttributeDescription2EXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -18302,25 +14651,19 @@
#endif
#ifdef VK_EXT_physical_device_drm
void transform_tohost_VkPhysicalDeviceDrmPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDrmPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDrmPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceDrmPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDrmPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDrmPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -18329,24 +14672,20 @@
#ifdef VK_EXT_primitive_topology_list_restart
void transform_tohost_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* toTransform)
-{
+ VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* toTransform)
-{
+ VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -18354,73 +14693,55 @@
#endif
#ifdef VK_FUCHSIA_external_memory
void transform_tohost_VkImportMemoryZirconHandleInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImportMemoryZirconHandleInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImportMemoryZirconHandleInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkImportMemoryZirconHandleInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImportMemoryZirconHandleInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImportMemoryZirconHandleInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkMemoryZirconHandlePropertiesFUCHSIA(
- ResourceTracker* resourceTracker,
- VkMemoryZirconHandlePropertiesFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMemoryZirconHandlePropertiesFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkMemoryZirconHandlePropertiesFUCHSIA(
- ResourceTracker* resourceTracker,
- VkMemoryZirconHandlePropertiesFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMemoryZirconHandlePropertiesFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkMemoryGetZirconHandleInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkMemoryGetZirconHandleInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMemoryGetZirconHandleInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkMemoryGetZirconHandleInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkMemoryGetZirconHandleInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMemoryGetZirconHandleInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -18428,49 +14749,37 @@
#endif
#ifdef VK_FUCHSIA_external_semaphore
void transform_tohost_VkImportSemaphoreZirconHandleInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImportSemaphoreZirconHandleInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImportSemaphoreZirconHandleInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkImportSemaphoreZirconHandleInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImportSemaphoreZirconHandleInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImportSemaphoreZirconHandleInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkSemaphoreGetZirconHandleInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkSemaphoreGetZirconHandleInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSemaphoreGetZirconHandleInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkSemaphoreGetZirconHandleInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkSemaphoreGetZirconHandleInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSemaphoreGetZirconHandleInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -18478,355 +14787,293 @@
#endif
#ifdef VK_FUCHSIA_buffer_collection
void transform_tohost_VkBufferCollectionCreateInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferCollectionCreateInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBufferCollectionCreateInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkBufferCollectionCreateInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferCollectionCreateInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBufferCollectionCreateInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkImportMemoryBufferCollectionFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImportMemoryBufferCollectionFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImportMemoryBufferCollectionFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkImportMemoryBufferCollectionFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImportMemoryBufferCollectionFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImportMemoryBufferCollectionFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkBufferCollectionImageCreateInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferCollectionImageCreateInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBufferCollectionImageCreateInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkBufferCollectionImageCreateInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferCollectionImageCreateInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBufferCollectionImageCreateInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkBufferCollectionConstraintsInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferCollectionConstraintsInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBufferCollectionConstraintsInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkBufferCollectionConstraintsInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferCollectionConstraintsInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBufferCollectionConstraintsInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkBufferConstraintsInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferConstraintsInfoFUCHSIA* toTransform)
-{
+void transform_tohost_VkBufferConstraintsInfoFUCHSIA(ResourceTracker* resourceTracker,
+ VkBufferConstraintsInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkBufferCreateInfo(resourceTracker, (VkBufferCreateInfo*)(&toTransform->createInfo));
- transform_tohost_VkBufferCollectionConstraintsInfoFUCHSIA(resourceTracker, (VkBufferCollectionConstraintsInfoFUCHSIA*)(&toTransform->bufferCollectionConstraints));
+ transform_tohost_VkBufferCreateInfo(resourceTracker,
+ (VkBufferCreateInfo*)(&toTransform->createInfo));
+ transform_tohost_VkBufferCollectionConstraintsInfoFUCHSIA(
+ resourceTracker,
+ (VkBufferCollectionConstraintsInfoFUCHSIA*)(&toTransform->bufferCollectionConstraints));
}
void transform_fromhost_VkBufferConstraintsInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferConstraintsInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBufferConstraintsInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkBufferCreateInfo(resourceTracker, (VkBufferCreateInfo*)(&toTransform->createInfo));
- transform_fromhost_VkBufferCollectionConstraintsInfoFUCHSIA(resourceTracker, (VkBufferCollectionConstraintsInfoFUCHSIA*)(&toTransform->bufferCollectionConstraints));
+ transform_fromhost_VkBufferCreateInfo(resourceTracker,
+ (VkBufferCreateInfo*)(&toTransform->createInfo));
+ transform_fromhost_VkBufferCollectionConstraintsInfoFUCHSIA(
+ resourceTracker,
+ (VkBufferCollectionConstraintsInfoFUCHSIA*)(&toTransform->bufferCollectionConstraints));
}
void transform_tohost_VkBufferCollectionBufferCreateInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferCollectionBufferCreateInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBufferCollectionBufferCreateInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkBufferCollectionBufferCreateInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferCollectionBufferCreateInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBufferCollectionBufferCreateInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkSysmemColorSpaceFUCHSIA(
- ResourceTracker* resourceTracker,
- VkSysmemColorSpaceFUCHSIA* toTransform)
-{
+void transform_tohost_VkSysmemColorSpaceFUCHSIA(ResourceTracker* resourceTracker,
+ VkSysmemColorSpaceFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkSysmemColorSpaceFUCHSIA(
- ResourceTracker* resourceTracker,
- VkSysmemColorSpaceFUCHSIA* toTransform)
-{
+void transform_fromhost_VkSysmemColorSpaceFUCHSIA(ResourceTracker* resourceTracker,
+ VkSysmemColorSpaceFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkBufferCollectionPropertiesFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferCollectionPropertiesFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBufferCollectionPropertiesFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkSysmemColorSpaceFUCHSIA(resourceTracker, (VkSysmemColorSpaceFUCHSIA*)(&toTransform->sysmemColorSpaceIndex));
- transform_tohost_VkComponentMapping(resourceTracker, (VkComponentMapping*)(&toTransform->samplerYcbcrConversionComponents));
+ transform_tohost_VkSysmemColorSpaceFUCHSIA(
+ resourceTracker, (VkSysmemColorSpaceFUCHSIA*)(&toTransform->sysmemColorSpaceIndex));
+ transform_tohost_VkComponentMapping(
+ resourceTracker, (VkComponentMapping*)(&toTransform->samplerYcbcrConversionComponents));
}
void transform_fromhost_VkBufferCollectionPropertiesFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferCollectionPropertiesFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkBufferCollectionPropertiesFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkSysmemColorSpaceFUCHSIA(resourceTracker, (VkSysmemColorSpaceFUCHSIA*)(&toTransform->sysmemColorSpaceIndex));
- transform_fromhost_VkComponentMapping(resourceTracker, (VkComponentMapping*)(&toTransform->samplerYcbcrConversionComponents));
+ transform_fromhost_VkSysmemColorSpaceFUCHSIA(
+ resourceTracker, (VkSysmemColorSpaceFUCHSIA*)(&toTransform->sysmemColorSpaceIndex));
+ transform_fromhost_VkComponentMapping(
+ resourceTracker, (VkComponentMapping*)(&toTransform->samplerYcbcrConversionComponents));
}
void transform_tohost_VkImageFormatConstraintsInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImageFormatConstraintsInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImageFormatConstraintsInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkImageCreateInfo(resourceTracker, (VkImageCreateInfo*)(&toTransform->imageCreateInfo));
- if (toTransform->pColorSpaces)
- {
- transform_tohost_VkSysmemColorSpaceFUCHSIA(resourceTracker, (VkSysmemColorSpaceFUCHSIA*)(toTransform->pColorSpaces));
+ resourceTracker->transformImpl_VkImageCreateInfo_tohost(&toTransform->imageCreateInfo, 1);
+ transform_tohost_VkImageCreateInfo(resourceTracker,
+ (VkImageCreateInfo*)(&toTransform->imageCreateInfo));
+ if (toTransform->pColorSpaces) {
+ transform_tohost_VkSysmemColorSpaceFUCHSIA(
+ resourceTracker, (VkSysmemColorSpaceFUCHSIA*)(toTransform->pColorSpaces));
}
}
void transform_fromhost_VkImageFormatConstraintsInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImageFormatConstraintsInfoFUCHSIA* toTransform)
-{
+ ResourceTracker* resourceTracker, VkImageFormatConstraintsInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkImageCreateInfo(resourceTracker, (VkImageCreateInfo*)(&toTransform->imageCreateInfo));
- if (toTransform->pColorSpaces)
- {
- transform_fromhost_VkSysmemColorSpaceFUCHSIA(resourceTracker, (VkSysmemColorSpaceFUCHSIA*)(toTransform->pColorSpaces));
+ resourceTracker->transformImpl_VkImageCreateInfo_fromhost(&toTransform->imageCreateInfo, 1);
+ transform_fromhost_VkImageCreateInfo(resourceTracker,
+ (VkImageCreateInfo*)(&toTransform->imageCreateInfo));
+ if (toTransform->pColorSpaces) {
+ transform_fromhost_VkSysmemColorSpaceFUCHSIA(
+ resourceTracker, (VkSysmemColorSpaceFUCHSIA*)(toTransform->pColorSpaces));
}
}
-void transform_tohost_VkImageConstraintsInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImageConstraintsInfoFUCHSIA* toTransform)
-{
+void transform_tohost_VkImageConstraintsInfoFUCHSIA(ResourceTracker* resourceTracker,
+ VkImageConstraintsInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pFormatConstraints)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->formatConstraintsCount; ++i)
- {
- transform_tohost_VkImageFormatConstraintsInfoFUCHSIA(resourceTracker, (VkImageFormatConstraintsInfoFUCHSIA*)(toTransform->pFormatConstraints + i));
+ if (toTransform) {
+ if (toTransform->pFormatConstraints) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->formatConstraintsCount; ++i) {
+ transform_tohost_VkImageFormatConstraintsInfoFUCHSIA(
+ resourceTracker,
+ (VkImageFormatConstraintsInfoFUCHSIA*)(toTransform->pFormatConstraints + i));
}
}
}
- transform_tohost_VkBufferCollectionConstraintsInfoFUCHSIA(resourceTracker, (VkBufferCollectionConstraintsInfoFUCHSIA*)(&toTransform->bufferCollectionConstraints));
+ transform_tohost_VkBufferCollectionConstraintsInfoFUCHSIA(
+ resourceTracker,
+ (VkBufferCollectionConstraintsInfoFUCHSIA*)(&toTransform->bufferCollectionConstraints));
}
-void transform_fromhost_VkImageConstraintsInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImageConstraintsInfoFUCHSIA* toTransform)
-{
+void transform_fromhost_VkImageConstraintsInfoFUCHSIA(ResourceTracker* resourceTracker,
+ VkImageConstraintsInfoFUCHSIA* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pFormatConstraints)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->formatConstraintsCount; ++i)
- {
- transform_fromhost_VkImageFormatConstraintsInfoFUCHSIA(resourceTracker, (VkImageFormatConstraintsInfoFUCHSIA*)(toTransform->pFormatConstraints + i));
+ if (toTransform) {
+ if (toTransform->pFormatConstraints) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->formatConstraintsCount; ++i) {
+ transform_fromhost_VkImageFormatConstraintsInfoFUCHSIA(
+ resourceTracker,
+ (VkImageFormatConstraintsInfoFUCHSIA*)(toTransform->pFormatConstraints + i));
}
}
}
- transform_fromhost_VkBufferCollectionConstraintsInfoFUCHSIA(resourceTracker, (VkBufferCollectionConstraintsInfoFUCHSIA*)(&toTransform->bufferCollectionConstraints));
+ transform_fromhost_VkBufferCollectionConstraintsInfoFUCHSIA(
+ resourceTracker,
+ (VkBufferCollectionConstraintsInfoFUCHSIA*)(&toTransform->bufferCollectionConstraints));
}
#endif
#ifdef VK_HUAWEI_subpass_shading
void transform_tohost_VkSubpassShadingPipelineCreateInfoHUAWEI(
- ResourceTracker* resourceTracker,
- VkSubpassShadingPipelineCreateInfoHUAWEI* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSubpassShadingPipelineCreateInfoHUAWEI* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkSubpassShadingPipelineCreateInfoHUAWEI(
- ResourceTracker* resourceTracker,
- VkSubpassShadingPipelineCreateInfoHUAWEI* toTransform)
-{
+ ResourceTracker* resourceTracker, VkSubpassShadingPipelineCreateInfoHUAWEI* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -18834,75 +15081,57 @@
#endif
#ifdef VK_HUAWEI_invocation_mask
void transform_tohost_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_NV_external_memory_rdma
-void transform_tohost_VkMemoryGetRemoteAddressInfoNV(
- ResourceTracker* resourceTracker,
- VkMemoryGetRemoteAddressInfoNV* toTransform)
-{
+void transform_tohost_VkMemoryGetRemoteAddressInfoNV(ResourceTracker* resourceTracker,
+ VkMemoryGetRemoteAddressInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkMemoryGetRemoteAddressInfoNV(
- ResourceTracker* resourceTracker,
- VkMemoryGetRemoteAddressInfoNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkMemoryGetRemoteAddressInfoNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -18911,50 +15140,40 @@
#ifdef VK_EXT_extended_dynamic_state2
void transform_tohost_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* toTransform)
-{
+ VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_QNX_screen_surface
-void transform_tohost_VkScreenSurfaceCreateInfoQNX(
- ResourceTracker* resourceTracker,
- VkScreenSurfaceCreateInfoQNX* toTransform)
-{
+void transform_tohost_VkScreenSurfaceCreateInfoQNX(ResourceTracker* resourceTracker,
+ VkScreenSurfaceCreateInfoQNX* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkScreenSurfaceCreateInfoQNX(
- ResourceTracker* resourceTracker,
- VkScreenSurfaceCreateInfoQNX* toTransform)
-{
+void transform_fromhost_VkScreenSurfaceCreateInfoQNX(ResourceTracker* resourceTracker,
+ VkScreenSurfaceCreateInfoQNX* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -18962,123 +15181,93 @@
#endif
#ifdef VK_EXT_color_write_enable
void transform_tohost_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceColorWriteEnableFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceColorWriteEnableFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceColorWriteEnableFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceColorWriteEnableFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPipelineColorWriteCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineColorWriteCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineColorWriteCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPipelineColorWriteCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineColorWriteCreateInfoEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPipelineColorWriteCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_GOOGLE_gfxstream
-void transform_tohost_VkImportColorBufferGOOGLE(
- ResourceTracker* resourceTracker,
- VkImportColorBufferGOOGLE* toTransform)
-{
+void transform_tohost_VkImportColorBufferGOOGLE(ResourceTracker* resourceTracker,
+ VkImportColorBufferGOOGLE* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkImportColorBufferGOOGLE(
- ResourceTracker* resourceTracker,
- VkImportColorBufferGOOGLE* toTransform)
-{
+void transform_fromhost_VkImportColorBufferGOOGLE(ResourceTracker* resourceTracker,
+ VkImportColorBufferGOOGLE* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkImportBufferGOOGLE(
- ResourceTracker* resourceTracker,
- VkImportBufferGOOGLE* toTransform)
-{
+void transform_tohost_VkImportBufferGOOGLE(ResourceTracker* resourceTracker,
+ VkImportBufferGOOGLE* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkImportBufferGOOGLE(
- ResourceTracker* resourceTracker,
- VkImportBufferGOOGLE* toTransform)
-{
+void transform_fromhost_VkImportBufferGOOGLE(ResourceTracker* resourceTracker,
+ VkImportBufferGOOGLE* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkImportPhysicalAddressGOOGLE(
- ResourceTracker* resourceTracker,
- VkImportPhysicalAddressGOOGLE* toTransform)
-{
+void transform_tohost_VkImportPhysicalAddressGOOGLE(ResourceTracker* resourceTracker,
+ VkImportPhysicalAddressGOOGLE* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_fromhost_VkImportPhysicalAddressGOOGLE(
- ResourceTracker* resourceTracker,
- VkImportPhysicalAddressGOOGLE* toTransform)
-{
+void transform_fromhost_VkImportPhysicalAddressGOOGLE(ResourceTracker* resourceTracker,
+ VkImportPhysicalAddressGOOGLE* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -19086,49 +15275,37 @@
#endif
#ifdef VK_EXT_global_priority_query
void transform_tohost_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkQueueFamilyGlobalPriorityPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkQueueFamilyGlobalPriorityPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkQueueFamilyGlobalPriorityPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkQueueFamilyGlobalPriorityPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkQueueFamilyGlobalPriorityPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkQueueFamilyGlobalPriorityPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -19136,81 +15313,61 @@
#endif
#ifdef VK_EXT_multi_draw
void transform_tohost_VkPhysicalDeviceMultiDrawFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMultiDrawFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMultiDrawFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceMultiDrawFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMultiDrawFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMultiDrawFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceMultiDrawPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMultiDrawPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMultiDrawPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceMultiDrawPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMultiDrawPropertiesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMultiDrawPropertiesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
-void transform_tohost_VkMultiDrawInfoEXT(
- ResourceTracker* resourceTracker,
- VkMultiDrawInfoEXT* toTransform)
-{
+void transform_tohost_VkMultiDrawInfoEXT(ResourceTracker* resourceTracker,
+ VkMultiDrawInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkMultiDrawInfoEXT(
- ResourceTracker* resourceTracker,
- VkMultiDrawInfoEXT* toTransform)
-{
+void transform_fromhost_VkMultiDrawInfoEXT(ResourceTracker* resourceTracker,
+ VkMultiDrawInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkMultiDrawIndexedInfoEXT(
- ResourceTracker* resourceTracker,
- VkMultiDrawIndexedInfoEXT* toTransform)
-{
+void transform_tohost_VkMultiDrawIndexedInfoEXT(ResourceTracker* resourceTracker,
+ VkMultiDrawIndexedInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkMultiDrawIndexedInfoEXT(
- ResourceTracker* resourceTracker,
- VkMultiDrawIndexedInfoEXT* toTransform)
-{
+void transform_fromhost_VkMultiDrawIndexedInfoEXT(ResourceTracker* resourceTracker,
+ VkMultiDrawIndexedInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
@@ -19220,531 +15377,451 @@
#endif
#ifdef VK_EXT_border_color_swizzle
void transform_tohost_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkSamplerBorderColorComponentMappingCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkSamplerBorderColorComponentMappingCreateInfoEXT* toTransform)
-{
+ VkSamplerBorderColorComponentMappingCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkComponentMapping(resourceTracker, (VkComponentMapping*)(&toTransform->components));
+ transform_tohost_VkComponentMapping(resourceTracker,
+ (VkComponentMapping*)(&toTransform->components));
}
void transform_fromhost_VkSamplerBorderColorComponentMappingCreateInfoEXT(
ResourceTracker* resourceTracker,
- VkSamplerBorderColorComponentMappingCreateInfoEXT* toTransform)
-{
+ VkSamplerBorderColorComponentMappingCreateInfoEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkComponentMapping(resourceTracker, (VkComponentMapping*)(&toTransform->components));
+ transform_fromhost_VkComponentMapping(resourceTracker,
+ (VkComponentMapping*)(&toTransform->components));
}
#endif
#ifdef VK_EXT_pageable_device_local_memory
void transform_tohost_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* toTransform)
-{
+ VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
ResourceTracker* resourceTracker,
- VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* toTransform)
-{
+ VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
#ifdef VK_KHR_acceleration_structure
-void transform_tohost_VkDeviceOrHostAddressKHR(
- ResourceTracker* resourceTracker,
- VkDeviceOrHostAddressKHR* toTransform)
-{
+void transform_tohost_VkDeviceOrHostAddressKHR(ResourceTracker* resourceTracker,
+ VkDeviceOrHostAddressKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkDeviceOrHostAddressKHR(
- ResourceTracker* resourceTracker,
- VkDeviceOrHostAddressKHR* toTransform)
-{
+void transform_fromhost_VkDeviceOrHostAddressKHR(ResourceTracker* resourceTracker,
+ VkDeviceOrHostAddressKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkAccelerationStructureBuildRangeInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureBuildRangeInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureBuildRangeInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_fromhost_VkAccelerationStructureBuildRangeInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureBuildRangeInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureBuildRangeInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_tohost_VkAccelerationStructureGeometryTrianglesDataKHR(
ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryTrianglesDataKHR* toTransform)
-{
+ VkAccelerationStructureGeometryTrianglesDataKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkDeviceOrHostAddressConstKHR(resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->vertexData));
- transform_tohost_VkDeviceOrHostAddressConstKHR(resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->indexData));
- transform_tohost_VkDeviceOrHostAddressConstKHR(resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->transformData));
+ transform_tohost_VkDeviceOrHostAddressConstKHR(
+ resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->vertexData));
+ transform_tohost_VkDeviceOrHostAddressConstKHR(
+ resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->indexData));
+ transform_tohost_VkDeviceOrHostAddressConstKHR(
+ resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->transformData));
}
void transform_fromhost_VkAccelerationStructureGeometryTrianglesDataKHR(
ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryTrianglesDataKHR* toTransform)
-{
+ VkAccelerationStructureGeometryTrianglesDataKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkDeviceOrHostAddressConstKHR(resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->vertexData));
- transform_fromhost_VkDeviceOrHostAddressConstKHR(resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->indexData));
- transform_fromhost_VkDeviceOrHostAddressConstKHR(resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->transformData));
+ transform_fromhost_VkDeviceOrHostAddressConstKHR(
+ resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->vertexData));
+ transform_fromhost_VkDeviceOrHostAddressConstKHR(
+ resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->indexData));
+ transform_fromhost_VkDeviceOrHostAddressConstKHR(
+ resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->transformData));
}
void transform_tohost_VkAccelerationStructureGeometryAabbsDataKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryAabbsDataKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureGeometryAabbsDataKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkDeviceOrHostAddressConstKHR(resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->data));
+ transform_tohost_VkDeviceOrHostAddressConstKHR(
+ resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->data));
}
void transform_fromhost_VkAccelerationStructureGeometryAabbsDataKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryAabbsDataKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureGeometryAabbsDataKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkDeviceOrHostAddressConstKHR(resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->data));
+ transform_fromhost_VkDeviceOrHostAddressConstKHR(
+ resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->data));
}
void transform_tohost_VkAccelerationStructureGeometryInstancesDataKHR(
ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryInstancesDataKHR* toTransform)
-{
+ VkAccelerationStructureGeometryInstancesDataKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkDeviceOrHostAddressConstKHR(resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->data));
+ transform_tohost_VkDeviceOrHostAddressConstKHR(
+ resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->data));
}
void transform_fromhost_VkAccelerationStructureGeometryInstancesDataKHR(
ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryInstancesDataKHR* toTransform)
-{
+ VkAccelerationStructureGeometryInstancesDataKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkDeviceOrHostAddressConstKHR(resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->data));
+ transform_fromhost_VkDeviceOrHostAddressConstKHR(
+ resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->data));
}
void transform_tohost_VkAccelerationStructureGeometryDataKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryDataKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureGeometryDataKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_tohost_VkAccelerationStructureGeometryTrianglesDataKHR(resourceTracker, (VkAccelerationStructureGeometryTrianglesDataKHR*)(&toTransform->triangles));
- transform_tohost_VkAccelerationStructureGeometryAabbsDataKHR(resourceTracker, (VkAccelerationStructureGeometryAabbsDataKHR*)(&toTransform->aabbs));
- transform_tohost_VkAccelerationStructureGeometryInstancesDataKHR(resourceTracker, (VkAccelerationStructureGeometryInstancesDataKHR*)(&toTransform->instances));
+ transform_tohost_VkAccelerationStructureGeometryTrianglesDataKHR(
+ resourceTracker,
+ (VkAccelerationStructureGeometryTrianglesDataKHR*)(&toTransform->triangles));
+ transform_tohost_VkAccelerationStructureGeometryAabbsDataKHR(
+ resourceTracker, (VkAccelerationStructureGeometryAabbsDataKHR*)(&toTransform->aabbs));
+ transform_tohost_VkAccelerationStructureGeometryInstancesDataKHR(
+ resourceTracker,
+ (VkAccelerationStructureGeometryInstancesDataKHR*)(&toTransform->instances));
}
void transform_fromhost_VkAccelerationStructureGeometryDataKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryDataKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureGeometryDataKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- transform_fromhost_VkAccelerationStructureGeometryTrianglesDataKHR(resourceTracker, (VkAccelerationStructureGeometryTrianglesDataKHR*)(&toTransform->triangles));
- transform_fromhost_VkAccelerationStructureGeometryAabbsDataKHR(resourceTracker, (VkAccelerationStructureGeometryAabbsDataKHR*)(&toTransform->aabbs));
- transform_fromhost_VkAccelerationStructureGeometryInstancesDataKHR(resourceTracker, (VkAccelerationStructureGeometryInstancesDataKHR*)(&toTransform->instances));
+ transform_fromhost_VkAccelerationStructureGeometryTrianglesDataKHR(
+ resourceTracker,
+ (VkAccelerationStructureGeometryTrianglesDataKHR*)(&toTransform->triangles));
+ transform_fromhost_VkAccelerationStructureGeometryAabbsDataKHR(
+ resourceTracker, (VkAccelerationStructureGeometryAabbsDataKHR*)(&toTransform->aabbs));
+ transform_fromhost_VkAccelerationStructureGeometryInstancesDataKHR(
+ resourceTracker,
+ (VkAccelerationStructureGeometryInstancesDataKHR*)(&toTransform->instances));
}
void transform_tohost_VkAccelerationStructureGeometryKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureGeometryKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkAccelerationStructureGeometryDataKHR(resourceTracker, (VkAccelerationStructureGeometryDataKHR*)(&toTransform->geometry));
+ transform_tohost_VkAccelerationStructureGeometryDataKHR(
+ resourceTracker, (VkAccelerationStructureGeometryDataKHR*)(&toTransform->geometry));
}
void transform_fromhost_VkAccelerationStructureGeometryKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureGeometryKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkAccelerationStructureGeometryDataKHR(resourceTracker, (VkAccelerationStructureGeometryDataKHR*)(&toTransform->geometry));
+ transform_fromhost_VkAccelerationStructureGeometryDataKHR(
+ resourceTracker, (VkAccelerationStructureGeometryDataKHR*)(&toTransform->geometry));
}
void transform_tohost_VkAccelerationStructureBuildGeometryInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureBuildGeometryInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureBuildGeometryInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pGeometries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->geometryCount; ++i)
- {
- transform_tohost_VkAccelerationStructureGeometryKHR(resourceTracker, (VkAccelerationStructureGeometryKHR*)(toTransform->pGeometries + i));
+ if (toTransform) {
+ if (toTransform->pGeometries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->geometryCount; ++i) {
+ transform_tohost_VkAccelerationStructureGeometryKHR(
+ resourceTracker,
+ (VkAccelerationStructureGeometryKHR*)(toTransform->pGeometries + i));
}
}
}
- transform_tohost_VkDeviceOrHostAddressKHR(resourceTracker, (VkDeviceOrHostAddressKHR*)(&toTransform->scratchData));
+ transform_tohost_VkDeviceOrHostAddressKHR(
+ resourceTracker, (VkDeviceOrHostAddressKHR*)(&toTransform->scratchData));
}
void transform_fromhost_VkAccelerationStructureBuildGeometryInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureBuildGeometryInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureBuildGeometryInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pGeometries)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->geometryCount; ++i)
- {
- transform_fromhost_VkAccelerationStructureGeometryKHR(resourceTracker, (VkAccelerationStructureGeometryKHR*)(toTransform->pGeometries + i));
+ if (toTransform) {
+ if (toTransform->pGeometries) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->geometryCount; ++i) {
+ transform_fromhost_VkAccelerationStructureGeometryKHR(
+ resourceTracker,
+ (VkAccelerationStructureGeometryKHR*)(toTransform->pGeometries + i));
}
}
}
- transform_fromhost_VkDeviceOrHostAddressKHR(resourceTracker, (VkDeviceOrHostAddressKHR*)(&toTransform->scratchData));
+ transform_fromhost_VkDeviceOrHostAddressKHR(
+ resourceTracker, (VkDeviceOrHostAddressKHR*)(&toTransform->scratchData));
}
void transform_tohost_VkAccelerationStructureCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureCreateInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkAccelerationStructureCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureCreateInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkWriteDescriptorSetAccelerationStructureKHR(
- ResourceTracker* resourceTracker,
- VkWriteDescriptorSetAccelerationStructureKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkWriteDescriptorSetAccelerationStructureKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkWriteDescriptorSetAccelerationStructureKHR(
- ResourceTracker* resourceTracker,
- VkWriteDescriptorSetAccelerationStructureKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkWriteDescriptorSetAccelerationStructureKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceAccelerationStructureFeaturesKHR* toTransform)
-{
+ VkPhysicalDeviceAccelerationStructureFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceAccelerationStructureFeaturesKHR* toTransform)
-{
+ VkPhysicalDeviceAccelerationStructureFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceAccelerationStructurePropertiesKHR* toTransform)
-{
+ VkPhysicalDeviceAccelerationStructurePropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceAccelerationStructurePropertiesKHR* toTransform)
-{
+ VkPhysicalDeviceAccelerationStructurePropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkAccelerationStructureDeviceAddressInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureDeviceAddressInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureDeviceAddressInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkAccelerationStructureDeviceAddressInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureDeviceAddressInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureDeviceAddressInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkAccelerationStructureVersionInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureVersionInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureVersionInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkAccelerationStructureVersionInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureVersionInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureVersionInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkCopyAccelerationStructureToMemoryInfoKHR(
- ResourceTracker* resourceTracker,
- VkCopyAccelerationStructureToMemoryInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkCopyAccelerationStructureToMemoryInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkDeviceOrHostAddressKHR(resourceTracker, (VkDeviceOrHostAddressKHR*)(&toTransform->dst));
+ transform_tohost_VkDeviceOrHostAddressKHR(resourceTracker,
+ (VkDeviceOrHostAddressKHR*)(&toTransform->dst));
}
void transform_fromhost_VkCopyAccelerationStructureToMemoryInfoKHR(
- ResourceTracker* resourceTracker,
- VkCopyAccelerationStructureToMemoryInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkCopyAccelerationStructureToMemoryInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkDeviceOrHostAddressKHR(resourceTracker, (VkDeviceOrHostAddressKHR*)(&toTransform->dst));
+ transform_fromhost_VkDeviceOrHostAddressKHR(resourceTracker,
+ (VkDeviceOrHostAddressKHR*)(&toTransform->dst));
}
void transform_tohost_VkCopyMemoryToAccelerationStructureInfoKHR(
- ResourceTracker* resourceTracker,
- VkCopyMemoryToAccelerationStructureInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkCopyMemoryToAccelerationStructureInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_tohost_VkDeviceOrHostAddressConstKHR(resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->src));
+ transform_tohost_VkDeviceOrHostAddressConstKHR(
+ resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->src));
}
void transform_fromhost_VkCopyMemoryToAccelerationStructureInfoKHR(
- ResourceTracker* resourceTracker,
- VkCopyMemoryToAccelerationStructureInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkCopyMemoryToAccelerationStructureInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- transform_fromhost_VkDeviceOrHostAddressConstKHR(resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->src));
+ transform_fromhost_VkDeviceOrHostAddressConstKHR(
+ resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->src));
}
void transform_tohost_VkCopyAccelerationStructureInfoKHR(
- ResourceTracker* resourceTracker,
- VkCopyAccelerationStructureInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkCopyAccelerationStructureInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkCopyAccelerationStructureInfoKHR(
- ResourceTracker* resourceTracker,
- VkCopyAccelerationStructureInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkCopyAccelerationStructureInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkAccelerationStructureBuildSizesInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureBuildSizesInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureBuildSizesInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkAccelerationStructureBuildSizesInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureBuildSizesInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkAccelerationStructureBuildSizesInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
@@ -19752,217 +15829,177 @@
#endif
#ifdef VK_KHR_ray_tracing_pipeline
void transform_tohost_VkRayTracingShaderGroupCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkRayTracingShaderGroupCreateInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRayTracingShaderGroupCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkRayTracingShaderGroupCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkRayTracingShaderGroupCreateInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRayTracingShaderGroupCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkRayTracingPipelineInterfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkRayTracingPipelineInterfaceCreateInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRayTracingPipelineInterfaceCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkRayTracingPipelineInterfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkRayTracingPipelineInterfaceCreateInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRayTracingPipelineInterfaceCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkRayTracingPipelineCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkRayTracingPipelineCreateInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRayTracingPipelineCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pStages)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->stageCount; ++i)
- {
- transform_tohost_VkPipelineShaderStageCreateInfo(resourceTracker, (VkPipelineShaderStageCreateInfo*)(toTransform->pStages + i));
+ if (toTransform) {
+ if (toTransform->pStages) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->stageCount; ++i) {
+ transform_tohost_VkPipelineShaderStageCreateInfo(
+ resourceTracker, (VkPipelineShaderStageCreateInfo*)(toTransform->pStages + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pGroups)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->groupCount; ++i)
- {
- transform_tohost_VkRayTracingShaderGroupCreateInfoKHR(resourceTracker, (VkRayTracingShaderGroupCreateInfoKHR*)(toTransform->pGroups + i));
+ if (toTransform) {
+ if (toTransform->pGroups) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->groupCount; ++i) {
+ transform_tohost_VkRayTracingShaderGroupCreateInfoKHR(
+ resourceTracker,
+ (VkRayTracingShaderGroupCreateInfoKHR*)(toTransform->pGroups + i));
}
}
}
- if (toTransform->pLibraryInfo)
- {
- transform_tohost_VkPipelineLibraryCreateInfoKHR(resourceTracker, (VkPipelineLibraryCreateInfoKHR*)(toTransform->pLibraryInfo));
+ if (toTransform->pLibraryInfo) {
+ transform_tohost_VkPipelineLibraryCreateInfoKHR(
+ resourceTracker, (VkPipelineLibraryCreateInfoKHR*)(toTransform->pLibraryInfo));
}
- if (toTransform->pLibraryInterface)
- {
- transform_tohost_VkRayTracingPipelineInterfaceCreateInfoKHR(resourceTracker, (VkRayTracingPipelineInterfaceCreateInfoKHR*)(toTransform->pLibraryInterface));
+ if (toTransform->pLibraryInterface) {
+ transform_tohost_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ resourceTracker,
+ (VkRayTracingPipelineInterfaceCreateInfoKHR*)(toTransform->pLibraryInterface));
}
- if (toTransform->pDynamicState)
- {
- transform_tohost_VkPipelineDynamicStateCreateInfo(resourceTracker, (VkPipelineDynamicStateCreateInfo*)(toTransform->pDynamicState));
+ if (toTransform->pDynamicState) {
+ transform_tohost_VkPipelineDynamicStateCreateInfo(
+ resourceTracker, (VkPipelineDynamicStateCreateInfo*)(toTransform->pDynamicState));
}
}
void transform_fromhost_VkRayTracingPipelineCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkRayTracingPipelineCreateInfoKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkRayTracingPipelineCreateInfoKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
- if (toTransform)
- {
- if (toTransform->pStages)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->stageCount; ++i)
- {
- transform_fromhost_VkPipelineShaderStageCreateInfo(resourceTracker, (VkPipelineShaderStageCreateInfo*)(toTransform->pStages + i));
+ if (toTransform) {
+ if (toTransform->pStages) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->stageCount; ++i) {
+ transform_fromhost_VkPipelineShaderStageCreateInfo(
+ resourceTracker, (VkPipelineShaderStageCreateInfo*)(toTransform->pStages + i));
}
}
}
- if (toTransform)
- {
- if (toTransform->pGroups)
- {
- for (uint32_t i = 0; i < (uint32_t)toTransform->groupCount; ++i)
- {
- transform_fromhost_VkRayTracingShaderGroupCreateInfoKHR(resourceTracker, (VkRayTracingShaderGroupCreateInfoKHR*)(toTransform->pGroups + i));
+ if (toTransform) {
+ if (toTransform->pGroups) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->groupCount; ++i) {
+ transform_fromhost_VkRayTracingShaderGroupCreateInfoKHR(
+ resourceTracker,
+ (VkRayTracingShaderGroupCreateInfoKHR*)(toTransform->pGroups + i));
}
}
}
- if (toTransform->pLibraryInfo)
- {
- transform_fromhost_VkPipelineLibraryCreateInfoKHR(resourceTracker, (VkPipelineLibraryCreateInfoKHR*)(toTransform->pLibraryInfo));
+ if (toTransform->pLibraryInfo) {
+ transform_fromhost_VkPipelineLibraryCreateInfoKHR(
+ resourceTracker, (VkPipelineLibraryCreateInfoKHR*)(toTransform->pLibraryInfo));
}
- if (toTransform->pLibraryInterface)
- {
- transform_fromhost_VkRayTracingPipelineInterfaceCreateInfoKHR(resourceTracker, (VkRayTracingPipelineInterfaceCreateInfoKHR*)(toTransform->pLibraryInterface));
+ if (toTransform->pLibraryInterface) {
+ transform_fromhost_VkRayTracingPipelineInterfaceCreateInfoKHR(
+ resourceTracker,
+ (VkRayTracingPipelineInterfaceCreateInfoKHR*)(toTransform->pLibraryInterface));
}
- if (toTransform->pDynamicState)
- {
- transform_fromhost_VkPipelineDynamicStateCreateInfo(resourceTracker, (VkPipelineDynamicStateCreateInfo*)(toTransform->pDynamicState));
+ if (toTransform->pDynamicState) {
+ transform_fromhost_VkPipelineDynamicStateCreateInfo(
+ resourceTracker, (VkPipelineDynamicStateCreateInfo*)(toTransform->pDynamicState));
}
}
void transform_tohost_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toTransform)
-{
+ VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
ResourceTracker* resourceTracker,
- VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toTransform)
-{
+ VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_tohost_VkStridedDeviceAddressRegionKHR(
- ResourceTracker* resourceTracker,
- VkStridedDeviceAddressRegionKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkStridedDeviceAddressRegionKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
void transform_fromhost_VkStridedDeviceAddressRegionKHR(
- ResourceTracker* resourceTracker,
- VkStridedDeviceAddressRegionKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkStridedDeviceAddressRegionKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_tohost_VkTraceRaysIndirectCommandKHR(
- ResourceTracker* resourceTracker,
- VkTraceRaysIndirectCommandKHR* toTransform)
-{
+void transform_tohost_VkTraceRaysIndirectCommandKHR(ResourceTracker* resourceTracker,
+ VkTraceRaysIndirectCommandKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
-void transform_fromhost_VkTraceRaysIndirectCommandKHR(
- ResourceTracker* resourceTracker,
- VkTraceRaysIndirectCommandKHR* toTransform)
-{
+void transform_fromhost_VkTraceRaysIndirectCommandKHR(ResourceTracker* resourceTracker,
+ VkTraceRaysIndirectCommandKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
}
@@ -19970,4237 +16007,5014 @@
#endif
#ifdef VK_KHR_ray_query
void transform_tohost_VkPhysicalDeviceRayQueryFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRayQueryFeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRayQueryFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
void transform_fromhost_VkPhysicalDeviceRayQueryFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRayQueryFeaturesKHR* toTransform)
-{
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRayQueryFeaturesKHR* toTransform) {
(void)resourceTracker;
(void)toTransform;
- if (toTransform->pNext)
- {
+ if (toTransform->pNext) {
transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
}
}
#endif
-void transform_tohost_extension_struct(
- ResourceTracker* resourceTracker,
- void* structExtension_out)
-{
- if (!structExtension_out)
- {
+void transform_tohost_extension_struct(ResourceTracker* resourceTracker,
+ void* structExtension_out) {
+ if (!structExtension_out) {
return;
}
uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension_out);
- switch(structType)
- {
+ switch (structType) {
#ifdef VK_VERSION_1_1
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
- {
- transform_tohost_VkPhysicalDeviceSubgroupProperties(resourceTracker, reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
+ transform_tohost_VkPhysicalDeviceSubgroupProperties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
- {
- transform_tohost_VkPhysicalDevice16BitStorageFeatures(resourceTracker, reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
+ transform_tohost_VkPhysicalDevice16BitStorageFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
- {
- transform_tohost_VkMemoryDedicatedRequirements(resourceTracker, reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
+ transform_tohost_VkMemoryDedicatedRequirements(
+ resourceTracker,
+ reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
- {
- transform_tohost_VkMemoryDedicatedAllocateInfo(resourceTracker, reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: {
+ transform_tohost_VkMemoryDedicatedAllocateInfo(
+ resourceTracker,
+ reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
- {
- transform_tohost_VkMemoryAllocateFlagsInfo(resourceTracker, reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: {
+ transform_tohost_VkMemoryAllocateFlagsInfo(
+ resourceTracker, reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
- {
- transform_tohost_VkDeviceGroupRenderPassBeginInfo(resourceTracker, reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: {
+ transform_tohost_VkDeviceGroupRenderPassBeginInfo(
+ resourceTracker,
+ reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
- {
- transform_tohost_VkDeviceGroupCommandBufferBeginInfo(resourceTracker, reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: {
+ transform_tohost_VkDeviceGroupCommandBufferBeginInfo(
+ resourceTracker,
+ reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
- {
- transform_tohost_VkDeviceGroupSubmitInfo(resourceTracker, reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: {
+ transform_tohost_VkDeviceGroupSubmitInfo(
+ resourceTracker, reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
- {
- transform_tohost_VkDeviceGroupBindSparseInfo(resourceTracker, reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: {
+ transform_tohost_VkDeviceGroupBindSparseInfo(
+ resourceTracker,
+ reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
- {
- transform_tohost_VkBindBufferMemoryDeviceGroupInfo(resourceTracker, reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: {
+ transform_tohost_VkBindBufferMemoryDeviceGroupInfo(
+ resourceTracker,
+ reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
- {
- transform_tohost_VkBindImageMemoryDeviceGroupInfo(resourceTracker, reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: {
+ transform_tohost_VkBindImageMemoryDeviceGroupInfo(
+ resourceTracker,
+ reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
- {
- transform_tohost_VkDeviceGroupDeviceCreateInfo(resourceTracker, reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: {
+ transform_tohost_VkDeviceGroupDeviceCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
- {
- transform_tohost_VkPhysicalDeviceFeatures2(resourceTracker, reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
+ transform_tohost_VkPhysicalDeviceFeatures2(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
- {
- transform_tohost_VkPhysicalDevicePointClippingProperties(resourceTracker, reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: {
+ transform_tohost_VkPhysicalDevicePointClippingProperties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
- {
- transform_tohost_VkRenderPassInputAttachmentAspectCreateInfo(resourceTracker, reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: {
+ transform_tohost_VkRenderPassInputAttachmentAspectCreateInfo(
+ resourceTracker, reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
- {
- transform_tohost_VkImageViewUsageCreateInfo(resourceTracker, reinterpret_cast<VkImageViewUsageCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: {
+ transform_tohost_VkImageViewUsageCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkImageViewUsageCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
- {
- transform_tohost_VkPipelineTessellationDomainOriginStateCreateInfo(resourceTracker, reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: {
+ transform_tohost_VkPipelineTessellationDomainOriginStateCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
- {
- transform_tohost_VkRenderPassMultiviewCreateInfo(resourceTracker, reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: {
+ transform_tohost_VkRenderPassMultiviewCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
- {
- transform_tohost_VkPhysicalDeviceMultiviewFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
+ transform_tohost_VkPhysicalDeviceMultiviewFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
- {
- transform_tohost_VkPhysicalDeviceMultiviewProperties(resourceTracker, reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: {
+ transform_tohost_VkPhysicalDeviceMultiviewProperties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
- {
- transform_tohost_VkPhysicalDeviceVariablePointersFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
+ transform_tohost_VkPhysicalDeviceVariablePointersFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
- {
- transform_tohost_VkPhysicalDeviceProtectedMemoryFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
+ transform_tohost_VkPhysicalDeviceProtectedMemoryFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
- {
- transform_tohost_VkPhysicalDeviceProtectedMemoryProperties(resourceTracker, reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: {
+ transform_tohost_VkPhysicalDeviceProtectedMemoryProperties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
- {
- transform_tohost_VkProtectedSubmitInfo(resourceTracker, reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: {
+ transform_tohost_VkProtectedSubmitInfo(
+ resourceTracker, reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
- {
- transform_tohost_VkSamplerYcbcrConversionInfo(resourceTracker, reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: {
+ transform_tohost_VkSamplerYcbcrConversionInfo(
+ resourceTracker,
+ reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
- {
- transform_tohost_VkBindImagePlaneMemoryInfo(resourceTracker, reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: {
+ transform_tohost_VkBindImagePlaneMemoryInfo(
+ resourceTracker,
+ reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
- {
- transform_tohost_VkImagePlaneMemoryRequirementsInfo(resourceTracker, reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: {
+ transform_tohost_VkImagePlaneMemoryRequirementsInfo(
+ resourceTracker,
+ reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
- {
- transform_tohost_VkPhysicalDeviceSamplerYcbcrConversionFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
+ transform_tohost_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
- {
- transform_tohost_VkSamplerYcbcrConversionImageFormatProperties(resourceTracker, reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: {
+ transform_tohost_VkSamplerYcbcrConversionImageFormatProperties(
+ resourceTracker, reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
- {
- resourceTracker->transformImpl_VkPhysicalDeviceExternalImageFormatInfo_tohost(reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out), 1);
- transform_tohost_VkPhysicalDeviceExternalImageFormatInfo(resourceTracker, reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: {
+ resourceTracker->transformImpl_VkPhysicalDeviceExternalImageFormatInfo_tohost(
+ reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out), 1);
+ transform_tohost_VkPhysicalDeviceExternalImageFormatInfo(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
- {
- resourceTracker->transformImpl_VkExternalImageFormatProperties_tohost(reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out), 1);
- transform_tohost_VkExternalImageFormatProperties(resourceTracker, reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: {
+ resourceTracker->transformImpl_VkExternalImageFormatProperties_tohost(
+ reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out), 1);
+ transform_tohost_VkExternalImageFormatProperties(
+ resourceTracker,
+ reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
- {
- transform_tohost_VkPhysicalDeviceIDProperties(resourceTracker, reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: {
+ transform_tohost_VkPhysicalDeviceIDProperties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
- {
- resourceTracker->transformImpl_VkExternalMemoryImageCreateInfo_tohost(reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out), 1);
- transform_tohost_VkExternalMemoryImageCreateInfo(resourceTracker, reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: {
+ resourceTracker->transformImpl_VkExternalMemoryImageCreateInfo_tohost(
+ reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out), 1);
+ transform_tohost_VkExternalMemoryImageCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
- {
- resourceTracker->transformImpl_VkExternalMemoryBufferCreateInfo_tohost(reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out), 1);
- transform_tohost_VkExternalMemoryBufferCreateInfo(resourceTracker, reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: {
+ resourceTracker->transformImpl_VkExternalMemoryBufferCreateInfo_tohost(
+ reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out), 1);
+ transform_tohost_VkExternalMemoryBufferCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
- {
- resourceTracker->transformImpl_VkExportMemoryAllocateInfo_tohost(reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out), 1);
- transform_tohost_VkExportMemoryAllocateInfo(resourceTracker, reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: {
+ resourceTracker->transformImpl_VkExportMemoryAllocateInfo_tohost(
+ reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out), 1);
+ transform_tohost_VkExportMemoryAllocateInfo(
+ resourceTracker,
+ reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
- {
- transform_tohost_VkExportFenceCreateInfo(resourceTracker, reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: {
+ transform_tohost_VkExportFenceCreateInfo(
+ resourceTracker, reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
- {
- transform_tohost_VkExportSemaphoreCreateInfo(resourceTracker, reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: {
+ transform_tohost_VkExportSemaphoreCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
- {
- transform_tohost_VkPhysicalDeviceMaintenance3Properties(resourceTracker, reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: {
+ transform_tohost_VkPhysicalDeviceMaintenance3Properties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
- {
- transform_tohost_VkPhysicalDeviceShaderDrawParametersFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
+ transform_tohost_VkPhysicalDeviceShaderDrawParametersFeatures(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_VERSION_1_2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
- {
- transform_tohost_VkPhysicalDeviceVulkan11Features(resourceTracker, reinterpret_cast<VkPhysicalDeviceVulkan11Features*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: {
+ transform_tohost_VkPhysicalDeviceVulkan11Features(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVulkan11Features*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
- {
- transform_tohost_VkPhysicalDeviceVulkan11Properties(resourceTracker, reinterpret_cast<VkPhysicalDeviceVulkan11Properties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: {
+ transform_tohost_VkPhysicalDeviceVulkan11Properties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVulkan11Properties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
- {
- transform_tohost_VkPhysicalDeviceVulkan12Features(resourceTracker, reinterpret_cast<VkPhysicalDeviceVulkan12Features*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: {
+ transform_tohost_VkPhysicalDeviceVulkan12Features(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVulkan12Features*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
- {
- transform_tohost_VkPhysicalDeviceVulkan12Properties(resourceTracker, reinterpret_cast<VkPhysicalDeviceVulkan12Properties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: {
+ transform_tohost_VkPhysicalDeviceVulkan12Properties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVulkan12Properties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
- {
- transform_tohost_VkImageFormatListCreateInfo(resourceTracker, reinterpret_cast<VkImageFormatListCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: {
+ transform_tohost_VkImageFormatListCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkImageFormatListCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
- {
- transform_tohost_VkPhysicalDevice8BitStorageFeatures(resourceTracker, reinterpret_cast<VkPhysicalDevice8BitStorageFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: {
+ transform_tohost_VkPhysicalDevice8BitStorageFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevice8BitStorageFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
- {
- transform_tohost_VkPhysicalDeviceDriverProperties(resourceTracker, reinterpret_cast<VkPhysicalDeviceDriverProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: {
+ transform_tohost_VkPhysicalDeviceDriverProperties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceDriverProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
- {
- transform_tohost_VkPhysicalDeviceShaderAtomicInt64Features(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: {
+ transform_tohost_VkPhysicalDeviceShaderAtomicInt64Features(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
- {
- transform_tohost_VkPhysicalDeviceShaderFloat16Int8Features(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: {
+ transform_tohost_VkPhysicalDeviceShaderFloat16Int8Features(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
- {
- transform_tohost_VkPhysicalDeviceFloatControlsProperties(resourceTracker, reinterpret_cast<VkPhysicalDeviceFloatControlsProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: {
+ transform_tohost_VkPhysicalDeviceFloatControlsProperties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceFloatControlsProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
- {
- transform_tohost_VkDescriptorSetLayoutBindingFlagsCreateInfo(resourceTracker, reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: {
+ transform_tohost_VkDescriptorSetLayoutBindingFlagsCreateInfo(
+ resourceTracker, reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
- {
- transform_tohost_VkPhysicalDeviceDescriptorIndexingFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: {
+ transform_tohost_VkPhysicalDeviceDescriptorIndexingFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
- {
- transform_tohost_VkPhysicalDeviceDescriptorIndexingProperties(resourceTracker, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: {
+ transform_tohost_VkPhysicalDeviceDescriptorIndexingProperties(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
- {
- transform_tohost_VkDescriptorSetVariableDescriptorCountAllocateInfo(resourceTracker, reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: {
+ transform_tohost_VkDescriptorSetVariableDescriptorCountAllocateInfo(
+ resourceTracker,
+ reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
- {
- transform_tohost_VkDescriptorSetVariableDescriptorCountLayoutSupport(resourceTracker, reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: {
+ transform_tohost_VkDescriptorSetVariableDescriptorCountLayoutSupport(
+ resourceTracker,
+ reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
- {
- transform_tohost_VkSubpassDescriptionDepthStencilResolve(resourceTracker, reinterpret_cast<VkSubpassDescriptionDepthStencilResolve*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: {
+ transform_tohost_VkSubpassDescriptionDepthStencilResolve(
+ resourceTracker,
+ reinterpret_cast<VkSubpassDescriptionDepthStencilResolve*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
- {
- transform_tohost_VkPhysicalDeviceDepthStencilResolveProperties(resourceTracker, reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: {
+ transform_tohost_VkPhysicalDeviceDepthStencilResolveProperties(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
- {
- transform_tohost_VkPhysicalDeviceScalarBlockLayoutFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: {
+ transform_tohost_VkPhysicalDeviceScalarBlockLayoutFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
- {
- transform_tohost_VkImageStencilUsageCreateInfo(resourceTracker, reinterpret_cast<VkImageStencilUsageCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: {
+ transform_tohost_VkImageStencilUsageCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkImageStencilUsageCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
- {
- transform_tohost_VkSamplerReductionModeCreateInfo(resourceTracker, reinterpret_cast<VkSamplerReductionModeCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: {
+ transform_tohost_VkSamplerReductionModeCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkSamplerReductionModeCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
- {
- transform_tohost_VkPhysicalDeviceSamplerFilterMinmaxProperties(resourceTracker, reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: {
+ transform_tohost_VkPhysicalDeviceSamplerFilterMinmaxProperties(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
- {
- transform_tohost_VkPhysicalDeviceVulkanMemoryModelFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: {
+ transform_tohost_VkPhysicalDeviceVulkanMemoryModelFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
- {
- transform_tohost_VkPhysicalDeviceImagelessFramebufferFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: {
+ transform_tohost_VkPhysicalDeviceImagelessFramebufferFeatures(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
- {
- transform_tohost_VkFramebufferAttachmentsCreateInfo(resourceTracker, reinterpret_cast<VkFramebufferAttachmentsCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: {
+ transform_tohost_VkFramebufferAttachmentsCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkFramebufferAttachmentsCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
- {
- transform_tohost_VkRenderPassAttachmentBeginInfo(resourceTracker, reinterpret_cast<VkRenderPassAttachmentBeginInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: {
+ transform_tohost_VkRenderPassAttachmentBeginInfo(
+ resourceTracker,
+ reinterpret_cast<VkRenderPassAttachmentBeginInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
- {
- transform_tohost_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: {
+ transform_tohost_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
- {
- transform_tohost_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: {
+ transform_tohost_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
- {
- transform_tohost_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: {
+ transform_tohost_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
- {
- transform_tohost_VkAttachmentReferenceStencilLayout(resourceTracker, reinterpret_cast<VkAttachmentReferenceStencilLayout*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: {
+ transform_tohost_VkAttachmentReferenceStencilLayout(
+ resourceTracker,
+ reinterpret_cast<VkAttachmentReferenceStencilLayout*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
- {
- transform_tohost_VkAttachmentDescriptionStencilLayout(resourceTracker, reinterpret_cast<VkAttachmentDescriptionStencilLayout*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: {
+ transform_tohost_VkAttachmentDescriptionStencilLayout(
+ resourceTracker,
+ reinterpret_cast<VkAttachmentDescriptionStencilLayout*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
- {
- transform_tohost_VkPhysicalDeviceHostQueryResetFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: {
+ transform_tohost_VkPhysicalDeviceHostQueryResetFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
- {
- transform_tohost_VkPhysicalDeviceTimelineSemaphoreFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: {
+ transform_tohost_VkPhysicalDeviceTimelineSemaphoreFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
- {
- transform_tohost_VkPhysicalDeviceTimelineSemaphoreProperties(resourceTracker, reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: {
+ transform_tohost_VkPhysicalDeviceTimelineSemaphoreProperties(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
- {
- transform_tohost_VkSemaphoreTypeCreateInfo(resourceTracker, reinterpret_cast<VkSemaphoreTypeCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: {
+ transform_tohost_VkSemaphoreTypeCreateInfo(
+ resourceTracker, reinterpret_cast<VkSemaphoreTypeCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
- {
- transform_tohost_VkTimelineSemaphoreSubmitInfo(resourceTracker, reinterpret_cast<VkTimelineSemaphoreSubmitInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: {
+ transform_tohost_VkTimelineSemaphoreSubmitInfo(
+ resourceTracker,
+ reinterpret_cast<VkTimelineSemaphoreSubmitInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
- {
- transform_tohost_VkPhysicalDeviceBufferDeviceAddressFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: {
+ transform_tohost_VkPhysicalDeviceBufferDeviceAddressFeatures(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
- {
- transform_tohost_VkBufferOpaqueCaptureAddressCreateInfo(resourceTracker, reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: {
+ transform_tohost_VkBufferOpaqueCaptureAddressCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
- {
- transform_tohost_VkMemoryOpaqueCaptureAddressAllocateInfo(resourceTracker, reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: {
+ transform_tohost_VkMemoryOpaqueCaptureAddressAllocateInfo(
+ resourceTracker,
+ reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_swapchain
- case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
- {
- transform_tohost_VkImageSwapchainCreateInfoKHR(resourceTracker, reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
+ transform_tohost_VkImageSwapchainCreateInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
- {
- transform_tohost_VkBindImageMemorySwapchainInfoKHR(resourceTracker, reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: {
+ transform_tohost_VkBindImageMemorySwapchainInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
- {
- transform_tohost_VkDeviceGroupPresentInfoKHR(resourceTracker, reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: {
+ transform_tohost_VkDeviceGroupPresentInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
- {
- transform_tohost_VkDeviceGroupSwapchainCreateInfoKHR(resourceTracker, reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: {
+ transform_tohost_VkDeviceGroupSwapchainCreateInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_display_swapchain
- case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
- {
- transform_tohost_VkDisplayPresentInfoKHR(resourceTracker, reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: {
+ transform_tohost_VkDisplayPresentInfoKHR(
+ resourceTracker, reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_video_queue
- case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR:
- {
- transform_tohost_VkVideoQueueFamilyProperties2KHR(resourceTracker, reinterpret_cast<VkVideoQueueFamilyProperties2KHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: {
+ transform_tohost_VkVideoQueueFamilyProperties2KHR(
+ resourceTracker,
+ reinterpret_cast<VkVideoQueueFamilyProperties2KHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR:
- {
- transform_tohost_VkVideoProfileKHR(resourceTracker, reinterpret_cast<VkVideoProfileKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR: {
+ transform_tohost_VkVideoProfileKHR(
+ resourceTracker, reinterpret_cast<VkVideoProfileKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR:
- {
- transform_tohost_VkVideoProfilesKHR(resourceTracker, reinterpret_cast<VkVideoProfilesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR: {
+ transform_tohost_VkVideoProfilesKHR(
+ resourceTracker, reinterpret_cast<VkVideoProfilesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_dynamic_rendering
- case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR:
- {
- transform_tohost_VkPipelineRenderingCreateInfoKHR(resourceTracker, reinterpret_cast<VkPipelineRenderingCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: {
+ transform_tohost_VkPipelineRenderingCreateInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkPipelineRenderingCreateInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR:
- {
- transform_tohost_VkPhysicalDeviceDynamicRenderingFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: {
+ transform_tohost_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR:
- {
- transform_tohost_VkCommandBufferInheritanceRenderingInfoKHR(resourceTracker, reinterpret_cast<VkCommandBufferInheritanceRenderingInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: {
+ transform_tohost_VkCommandBufferInheritanceRenderingInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkCommandBufferInheritanceRenderingInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
- {
- transform_tohost_VkRenderingFragmentShadingRateAttachmentInfoKHR(resourceTracker, reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
+ transform_tohost_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+ resourceTracker, reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
- {
- transform_tohost_VkRenderingFragmentDensityMapAttachmentInfoEXT(resourceTracker, reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
+ transform_tohost_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ resourceTracker, reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
- {
- transform_tohost_VkAttachmentSampleCountInfoAMD(resourceTracker, reinterpret_cast<VkAttachmentSampleCountInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
+ transform_tohost_VkAttachmentSampleCountInfoAMD(
+ resourceTracker,
+ reinterpret_cast<VkAttachmentSampleCountInfoAMD*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
- {
- transform_tohost_VkMultiviewPerViewAttributesInfoNVX(resourceTracker, reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
+ transform_tohost_VkMultiviewPerViewAttributesInfoNVX(
+ resourceTracker,
+ reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_memory_win32
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
- {
- transform_tohost_VkImportMemoryWin32HandleInfoKHR(resourceTracker, reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
+ transform_tohost_VkImportMemoryWin32HandleInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
- {
- transform_tohost_VkExportMemoryWin32HandleInfoKHR(resourceTracker, reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
+ transform_tohost_VkExportMemoryWin32HandleInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_memory_fd
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
- {
- transform_tohost_VkImportMemoryFdInfoKHR(resourceTracker, reinterpret_cast<VkImportMemoryFdInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: {
+ transform_tohost_VkImportMemoryFdInfoKHR(
+ resourceTracker, reinterpret_cast<VkImportMemoryFdInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_win32_keyed_mutex
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
- {
- transform_tohost_VkWin32KeyedMutexAcquireReleaseInfoKHR(resourceTracker, reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: {
+ transform_tohost_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_semaphore_win32
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
- {
- transform_tohost_VkExportSemaphoreWin32HandleInfoKHR(resourceTracker, reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: {
+ transform_tohost_VkExportSemaphoreWin32HandleInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
- {
- transform_tohost_VkD3D12FenceSubmitInfoKHR(resourceTracker, reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: {
+ transform_tohost_VkD3D12FenceSubmitInfoKHR(
+ resourceTracker, reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_push_descriptor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
- {
- transform_tohost_VkPhysicalDevicePushDescriptorPropertiesKHR(resourceTracker, reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: {
+ transform_tohost_VkPhysicalDevicePushDescriptorPropertiesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_incremental_present
- case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
- {
- transform_tohost_VkPresentRegionsKHR(resourceTracker, reinterpret_cast<VkPresentRegionsKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: {
+ transform_tohost_VkPresentRegionsKHR(
+ resourceTracker, reinterpret_cast<VkPresentRegionsKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shared_presentable_image
- case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
- {
- transform_tohost_VkSharedPresentSurfaceCapabilitiesKHR(resourceTracker, reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
+ transform_tohost_VkSharedPresentSurfaceCapabilitiesKHR(
+ resourceTracker,
+ reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_fence_win32
- case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
- {
- transform_tohost_VkExportFenceWin32HandleInfoKHR(resourceTracker, reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: {
+ transform_tohost_VkExportFenceWin32HandleInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_performance_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
- {
- transform_tohost_VkPhysicalDevicePerformanceQueryFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: {
+ transform_tohost_VkPhysicalDevicePerformanceQueryFeaturesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
- {
- transform_tohost_VkPhysicalDevicePerformanceQueryPropertiesKHR(resourceTracker, reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: {
+ transform_tohost_VkPhysicalDevicePerformanceQueryPropertiesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
- {
- transform_tohost_VkQueryPoolPerformanceCreateInfoKHR(resourceTracker, reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: {
+ transform_tohost_VkQueryPoolPerformanceCreateInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
- {
- transform_tohost_VkPerformanceQuerySubmitInfoKHR(resourceTracker, reinterpret_cast<VkPerformanceQuerySubmitInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: {
+ transform_tohost_VkPerformanceQuerySubmitInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkPerformanceQuerySubmitInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_portability_subset
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
- {
- transform_tohost_VkPhysicalDevicePortabilitySubsetFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
+ transform_tohost_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
- {
- transform_tohost_VkPhysicalDevicePortabilitySubsetPropertiesKHR(resourceTracker, reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
+ transform_tohost_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shader_clock
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
- {
- transform_tohost_VkPhysicalDeviceShaderClockFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
+ transform_tohost_VkPhysicalDeviceShaderClockFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shader_terminate_invocation
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR:
- {
- transform_tohost_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: {
+ transform_tohost_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_fragment_shading_rate
- case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
- {
- transform_tohost_VkFragmentShadingRateAttachmentInfoKHR(resourceTracker, reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
+ transform_tohost_VkFragmentShadingRateAttachmentInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
- {
- transform_tohost_VkPipelineFragmentShadingRateStateCreateInfoKHR(resourceTracker, reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: {
+ transform_tohost_VkPipelineFragmentShadingRateStateCreateInfoKHR(
+ resourceTracker, reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
- {
- transform_tohost_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: {
+ transform_tohost_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
- {
- transform_tohost_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: {
+ transform_tohost_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_surface_protected_capabilities
- case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
- {
- transform_tohost_VkSurfaceProtectedCapabilitiesKHR(resourceTracker, reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: {
+ transform_tohost_VkSurfaceProtectedCapabilitiesKHR(
+ resourceTracker,
+ reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_present_wait
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
- {
- transform_tohost_VkPhysicalDevicePresentWaitFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDevicePresentWaitFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: {
+ transform_tohost_VkPhysicalDevicePresentWaitFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePresentWaitFeaturesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
- {
- transform_tohost_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: {
+ transform_tohost_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shader_integer_dot_product
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR:
- {
- transform_tohost_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: {
+ transform_tohost_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR:
- {
- transform_tohost_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: {
+ transform_tohost_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_present_id
- case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
- {
- transform_tohost_VkPresentIdKHR(resourceTracker, reinterpret_cast<VkPresentIdKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: {
+ transform_tohost_VkPresentIdKHR(resourceTracker,
+ reinterpret_cast<VkPresentIdKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
- {
- transform_tohost_VkPhysicalDevicePresentIdFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDevicePresentIdFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: {
+ transform_tohost_VkPhysicalDevicePresentIdFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePresentIdFeaturesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_video_encode_queue
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
- {
- transform_tohost_VkVideoEncodeRateControlInfoKHR(resourceTracker, reinterpret_cast<VkVideoEncodeRateControlInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
+ transform_tohost_VkVideoEncodeRateControlInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeRateControlInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_synchronization2
- case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR:
- {
- transform_tohost_VkMemoryBarrier2KHR(resourceTracker, reinterpret_cast<VkMemoryBarrier2KHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: {
+ transform_tohost_VkMemoryBarrier2KHR(
+ resourceTracker, reinterpret_cast<VkMemoryBarrier2KHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR:
- {
- transform_tohost_VkPhysicalDeviceSynchronization2FeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceSynchronization2FeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: {
+ transform_tohost_VkPhysicalDeviceSynchronization2FeaturesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceSynchronization2FeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
- {
- transform_tohost_VkQueueFamilyCheckpointProperties2NV(resourceTracker, reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
+ transform_tohost_VkQueueFamilyCheckpointProperties2NV(
+ resourceTracker,
+ reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
- {
- transform_tohost_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
+ transform_tohost_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR:
- {
- transform_tohost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: {
+ transform_tohost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
- {
- transform_tohost_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
+ transform_tohost_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_format_feature_flags2
- case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR:
- {
- transform_tohost_VkFormatProperties3KHR(resourceTracker, reinterpret_cast<VkFormatProperties3KHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: {
+ transform_tohost_VkFormatProperties3KHR(
+ resourceTracker, reinterpret_cast<VkFormatProperties3KHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_maintenance4
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR:
- {
- transform_tohost_VkPhysicalDeviceMaintenance4FeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: {
+ transform_tohost_VkPhysicalDeviceMaintenance4FeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR:
- {
- transform_tohost_VkPhysicalDeviceMaintenance4PropertiesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: {
+ transform_tohost_VkPhysicalDeviceMaintenance4PropertiesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_ANDROID_native_buffer
- case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
- {
- transform_tohost_VkNativeBufferANDROID(resourceTracker, reinterpret_cast<VkNativeBufferANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
+ transform_tohost_VkNativeBufferANDROID(
+ resourceTracker, reinterpret_cast<VkNativeBufferANDROID*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_debug_report
- case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
- {
- transform_tohost_VkDebugReportCallbackCreateInfoEXT(resourceTracker, reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: {
+ transform_tohost_VkDebugReportCallbackCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_rasterization_order
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
- {
- transform_tohost_VkPipelineRasterizationStateRasterizationOrderAMD(resourceTracker, reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: {
+ transform_tohost_VkPipelineRasterizationStateRasterizationOrderAMD(
+ resourceTracker,
+ reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_dedicated_allocation
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
- {
- transform_tohost_VkDedicatedAllocationImageCreateInfoNV(resourceTracker, reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: {
+ transform_tohost_VkDedicatedAllocationImageCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
- {
- transform_tohost_VkDedicatedAllocationBufferCreateInfoNV(resourceTracker, reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: {
+ transform_tohost_VkDedicatedAllocationBufferCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
- {
- transform_tohost_VkDedicatedAllocationMemoryAllocateInfoNV(resourceTracker, reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: {
+ transform_tohost_VkDedicatedAllocationMemoryAllocateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_transform_feedback
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceTransformFeedbackFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
- {
- transform_tohost_VkPhysicalDeviceTransformFeedbackPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
- {
- transform_tohost_VkPipelineRasterizationStateStreamCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: {
+ transform_tohost_VkPipelineRasterizationStateStreamCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_video_encode_h264
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT:
- {
- transform_tohost_VkVideoEncodeH264CapabilitiesEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH264CapabilitiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
+ transform_tohost_VkVideoEncodeH264CapabilitiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeH264CapabilitiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT:
- {
- transform_tohost_VkVideoEncodeH264SessionCreateInfoEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: {
+ transform_tohost_VkVideoEncodeH264SessionCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- transform_tohost_VkVideoEncodeH264SessionParametersAddInfoEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ transform_tohost_VkVideoEncodeH264SessionParametersAddInfoEXT(
+ resourceTracker, reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- transform_tohost_VkVideoEncodeH264SessionParametersCreateInfoEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ transform_tohost_VkVideoEncodeH264SessionParametersCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT:
- {
- transform_tohost_VkVideoEncodeH264VclFrameInfoEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
+ transform_tohost_VkVideoEncodeH264VclFrameInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT:
- {
- transform_tohost_VkVideoEncodeH264EmitPictureParametersEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: {
+ transform_tohost_VkVideoEncodeH264EmitPictureParametersEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT:
- {
- transform_tohost_VkVideoEncodeH264ProfileEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH264ProfileEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT: {
+ transform_tohost_VkVideoEncodeH264ProfileEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeH264ProfileEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_video_encode_h265
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT:
- {
- transform_tohost_VkVideoEncodeH265CapabilitiesEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH265CapabilitiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
+ transform_tohost_VkVideoEncodeH265CapabilitiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeH265CapabilitiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT:
- {
- transform_tohost_VkVideoEncodeH265SessionCreateInfoEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: {
+ transform_tohost_VkVideoEncodeH265SessionCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- transform_tohost_VkVideoEncodeH265SessionParametersAddInfoEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ transform_tohost_VkVideoEncodeH265SessionParametersAddInfoEXT(
+ resourceTracker, reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- transform_tohost_VkVideoEncodeH265SessionParametersCreateInfoEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ transform_tohost_VkVideoEncodeH265SessionParametersCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT:
- {
- transform_tohost_VkVideoEncodeH265VclFrameInfoEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
+ transform_tohost_VkVideoEncodeH265VclFrameInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT:
- {
- transform_tohost_VkVideoEncodeH265EmitPictureParametersEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: {
+ transform_tohost_VkVideoEncodeH265EmitPictureParametersEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT:
- {
- transform_tohost_VkVideoEncodeH265ProfileEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH265ProfileEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT: {
+ transform_tohost_VkVideoEncodeH265ProfileEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeH265ProfileEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_video_decode_h264
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT:
- {
- transform_tohost_VkVideoDecodeH264ProfileEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH264ProfileEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT: {
+ transform_tohost_VkVideoDecodeH264ProfileEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoDecodeH264ProfileEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT:
- {
- transform_tohost_VkVideoDecodeH264CapabilitiesEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH264CapabilitiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: {
+ transform_tohost_VkVideoDecodeH264CapabilitiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoDecodeH264CapabilitiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT:
- {
- transform_tohost_VkVideoDecodeH264SessionCreateInfoEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: {
+ transform_tohost_VkVideoDecodeH264SessionCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- transform_tohost_VkVideoDecodeH264SessionParametersAddInfoEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ transform_tohost_VkVideoDecodeH264SessionParametersAddInfoEXT(
+ resourceTracker, reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- transform_tohost_VkVideoDecodeH264SessionParametersCreateInfoEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ transform_tohost_VkVideoDecodeH264SessionParametersCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT:
- {
- transform_tohost_VkVideoDecodeH264PictureInfoEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH264PictureInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: {
+ transform_tohost_VkVideoDecodeH264PictureInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoDecodeH264PictureInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT:
- {
- transform_tohost_VkVideoDecodeH264MvcEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH264MvcEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT: {
+ transform_tohost_VkVideoDecodeH264MvcEXT(
+ resourceTracker, reinterpret_cast<VkVideoDecodeH264MvcEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT:
- {
- transform_tohost_VkVideoDecodeH264DpbSlotInfoEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: {
+ transform_tohost_VkVideoDecodeH264DpbSlotInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_texture_gather_bias_lod
- case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
- {
- transform_tohost_VkTextureLODGatherFormatPropertiesAMD(resourceTracker, reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
+ transform_tohost_VkTextureLODGatherFormatPropertiesAMD(
+ resourceTracker,
+ reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_corner_sampled_image
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
- {
- transform_tohost_VkPhysicalDeviceCornerSampledImageFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: {
+ transform_tohost_VkPhysicalDeviceCornerSampledImageFeaturesNV(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_external_memory
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
- {
- transform_tohost_VkExternalMemoryImageCreateInfoNV(resourceTracker, reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: {
+ transform_tohost_VkExternalMemoryImageCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
- {
- transform_tohost_VkExportMemoryAllocateInfoNV(resourceTracker, reinterpret_cast<VkExportMemoryAllocateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: {
+ transform_tohost_VkExportMemoryAllocateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkExportMemoryAllocateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_external_memory_win32
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
- {
- transform_tohost_VkImportMemoryWin32HandleInfoNV(resourceTracker, reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
+ transform_tohost_VkImportMemoryWin32HandleInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
- {
- transform_tohost_VkExportMemoryWin32HandleInfoNV(resourceTracker, reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
+ transform_tohost_VkExportMemoryWin32HandleInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_win32_keyed_mutex
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
- {
- transform_tohost_VkWin32KeyedMutexAcquireReleaseInfoNV(resourceTracker, reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: {
+ transform_tohost_VkWin32KeyedMutexAcquireReleaseInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_validation_flags
- case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
- {
- transform_tohost_VkValidationFlagsEXT(resourceTracker, reinterpret_cast<VkValidationFlagsEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: {
+ transform_tohost_VkValidationFlagsEXT(
+ resourceTracker, reinterpret_cast<VkValidationFlagsEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_astc_decode_mode
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
- {
- transform_tohost_VkImageViewASTCDecodeModeEXT(resourceTracker, reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
+ transform_tohost_VkImageViewASTCDecodeModeEXT(
+ resourceTracker,
+ reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceASTCDecodeFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceASTCDecodeFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_conditional_rendering
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceConditionalRenderingFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
- {
- transform_tohost_VkCommandBufferInheritanceConditionalRenderingInfoEXT(resourceTracker, reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: {
+ transform_tohost_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_clip_space_w_scaling
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
- {
- transform_tohost_VkPipelineViewportWScalingStateCreateInfoNV(resourceTracker, reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: {
+ transform_tohost_VkPipelineViewportWScalingStateCreateInfoNV(
+ resourceTracker, reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_display_control
- case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
- {
- transform_tohost_VkSwapchainCounterCreateInfoEXT(resourceTracker, reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: {
+ transform_tohost_VkSwapchainCounterCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_GOOGLE_display_timing
- case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
- {
- transform_tohost_VkPresentTimesInfoGOOGLE(resourceTracker, reinterpret_cast<VkPresentTimesInfoGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: {
+ transform_tohost_VkPresentTimesInfoGOOGLE(
+ resourceTracker, reinterpret_cast<VkPresentTimesInfoGOOGLE*>(structExtension_out));
break;
}
#endif
#ifdef VK_NVX_multiview_per_view_attributes
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
- {
- transform_tohost_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(resourceTracker, reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: {
+ transform_tohost_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_viewport_swizzle
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
- {
- transform_tohost_VkPipelineViewportSwizzleStateCreateInfoNV(resourceTracker, reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: {
+ transform_tohost_VkPipelineViewportSwizzleStateCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_discard_rectangles
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
- {
- transform_tohost_VkPhysicalDeviceDiscardRectanglePropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
- {
- transform_tohost_VkPipelineDiscardRectangleStateCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: {
+ transform_tohost_VkPipelineDiscardRectangleStateCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_conservative_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
- {
- transform_tohost_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
- {
- transform_tohost_VkPipelineRasterizationConservativeStateCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: {
+ transform_tohost_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_depth_clip_enable
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
- {
- transform_tohost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ transform_tohost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_debug_utils
- case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
- {
- transform_tohost_VkDebugUtilsMessengerCreateInfoEXT(resourceTracker, reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
+ transform_tohost_VkDebugUtilsMessengerCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
- {
- transform_tohost_VkAndroidHardwareBufferUsageANDROID(resourceTracker, reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: {
+ transform_tohost_VkAndroidHardwareBufferUsageANDROID(
+ resourceTracker,
+ reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
- {
- transform_tohost_VkAndroidHardwareBufferFormatPropertiesANDROID(resourceTracker, reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: {
+ transform_tohost_VkAndroidHardwareBufferFormatPropertiesANDROID(
+ resourceTracker, reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
- {
- transform_tohost_VkImportAndroidHardwareBufferInfoANDROID(resourceTracker, reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: {
+ transform_tohost_VkImportAndroidHardwareBufferInfoANDROID(
+ resourceTracker,
+ reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
- {
- transform_tohost_VkExternalFormatANDROID(resourceTracker, reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: {
+ transform_tohost_VkExternalFormatANDROID(
+ resourceTracker, reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
- {
- transform_tohost_VkAndroidHardwareBufferFormatProperties2ANDROID(resourceTracker, reinterpret_cast<VkAndroidHardwareBufferFormatProperties2ANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: {
+ transform_tohost_VkAndroidHardwareBufferFormatProperties2ANDROID(
+ resourceTracker, reinterpret_cast<VkAndroidHardwareBufferFormatProperties2ANDROID*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_inline_uniform_block
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
- {
- transform_tohost_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT:
- {
- transform_tohost_VkWriteDescriptorSetInlineUniformBlockEXT(resourceTracker, reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
+ transform_tohost_VkWriteDescriptorSetInlineUniformBlockEXT(
+ resourceTracker,
+ reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT:
- {
- transform_tohost_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(resourceTracker, reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
+ transform_tohost_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_sample_locations
- case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
- {
- transform_tohost_VkSampleLocationsInfoEXT(resourceTracker, reinterpret_cast<VkSampleLocationsInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
+ transform_tohost_VkSampleLocationsInfoEXT(
+ resourceTracker, reinterpret_cast<VkSampleLocationsInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
- {
- transform_tohost_VkRenderPassSampleLocationsBeginInfoEXT(resourceTracker, reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: {
+ transform_tohost_VkRenderPassSampleLocationsBeginInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
- {
- transform_tohost_VkPipelineSampleLocationsStateCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: {
+ transform_tohost_VkPipelineSampleLocationsStateCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
- {
- transform_tohost_VkPhysicalDeviceSampleLocationsPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_blend_operation_advanced
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
- {
- transform_tohost_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
- {
- transform_tohost_VkPipelineColorBlendAdvancedStateCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: {
+ transform_tohost_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_fragment_coverage_to_color
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
- {
- transform_tohost_VkPipelineCoverageToColorStateCreateInfoNV(resourceTracker, reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: {
+ transform_tohost_VkPipelineCoverageToColorStateCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_framebuffer_mixed_samples
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
- {
- transform_tohost_VkPipelineCoverageModulationStateCreateInfoNV(resourceTracker, reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: {
+ transform_tohost_VkPipelineCoverageModulationStateCreateInfoNV(
+ resourceTracker, reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_shader_sm_builtins
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
- {
- transform_tohost_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: {
+ transform_tohost_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
- {
- transform_tohost_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: {
+ transform_tohost_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_image_drm_format_modifier
- case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
- {
- transform_tohost_VkDrmFormatModifierPropertiesListEXT(resourceTracker, reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: {
+ transform_tohost_VkDrmFormatModifierPropertiesListEXT(
+ resourceTracker,
+ reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
- {
- transform_tohost_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: {
+ transform_tohost_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
- {
- transform_tohost_VkImageDrmFormatModifierListCreateInfoEXT(resourceTracker, reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: {
+ transform_tohost_VkImageDrmFormatModifierListCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
- {
- transform_tohost_VkImageDrmFormatModifierExplicitCreateInfoEXT(resourceTracker, reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: {
+ transform_tohost_VkImageDrmFormatModifierExplicitCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
- {
- transform_tohost_VkDrmFormatModifierPropertiesList2EXT(resourceTracker, reinterpret_cast<VkDrmFormatModifierPropertiesList2EXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: {
+ transform_tohost_VkDrmFormatModifierPropertiesList2EXT(
+ resourceTracker,
+ reinterpret_cast<VkDrmFormatModifierPropertiesList2EXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_validation_cache
- case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
- {
- transform_tohost_VkShaderModuleValidationCacheCreateInfoEXT(resourceTracker, reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: {
+ transform_tohost_VkShaderModuleValidationCacheCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_shading_rate_image
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
- {
- transform_tohost_VkPipelineViewportShadingRateImageStateCreateInfoNV(resourceTracker, reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: {
+ transform_tohost_VkPipelineViewportShadingRateImageStateCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
- {
- transform_tohost_VkPhysicalDeviceShadingRateImageFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: {
+ transform_tohost_VkPhysicalDeviceShadingRateImageFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
- {
- transform_tohost_VkPhysicalDeviceShadingRateImagePropertiesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: {
+ transform_tohost_VkPhysicalDeviceShadingRateImagePropertiesNV(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
- {
- transform_tohost_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(resourceTracker, reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: {
+ transform_tohost_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_ray_tracing
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
- {
- transform_tohost_VkWriteDescriptorSetAccelerationStructureNV(resourceTracker, reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: {
+ transform_tohost_VkWriteDescriptorSetAccelerationStructureNV(
+ resourceTracker, reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
- {
- transform_tohost_VkPhysicalDeviceRayTracingPropertiesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: {
+ transform_tohost_VkPhysicalDeviceRayTracingPropertiesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_representative_fragment_test
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
- {
- transform_tohost_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: {
+ transform_tohost_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
- {
- transform_tohost_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(resourceTracker, reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: {
+ transform_tohost_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_filter_cubic
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
- {
- transform_tohost_VkPhysicalDeviceImageViewImageFormatInfoEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: {
+ transform_tohost_VkPhysicalDeviceImageViewImageFormatInfoEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
- {
- transform_tohost_VkFilterCubicImageViewImageFormatPropertiesEXT(resourceTracker, reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: {
+ transform_tohost_VkFilterCubicImageViewImageFormatPropertiesEXT(
+ resourceTracker, reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_global_priority
- case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
- {
- transform_tohost_VkDeviceQueueGlobalPriorityCreateInfoEXT(resourceTracker, reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
+ transform_tohost_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_external_memory_host
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
- {
- transform_tohost_VkImportMemoryHostPointerInfoEXT(resourceTracker, reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
+ transform_tohost_VkImportMemoryHostPointerInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
- {
- transform_tohost_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_AMD_pipeline_compiler_control
- case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
- {
- transform_tohost_VkPipelineCompilerControlCreateInfoAMD(resourceTracker, reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: {
+ transform_tohost_VkPipelineCompilerControlCreateInfoAMD(
+ resourceTracker,
+ reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_shader_core_properties
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
- {
- transform_tohost_VkPhysicalDeviceShaderCorePropertiesAMD(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: {
+ transform_tohost_VkPhysicalDeviceShaderCorePropertiesAMD(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_video_decode_h265
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT:
- {
- transform_tohost_VkVideoDecodeH265ProfileEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH265ProfileEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT: {
+ transform_tohost_VkVideoDecodeH265ProfileEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoDecodeH265ProfileEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT:
- {
- transform_tohost_VkVideoDecodeH265CapabilitiesEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH265CapabilitiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: {
+ transform_tohost_VkVideoDecodeH265CapabilitiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoDecodeH265CapabilitiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT:
- {
- transform_tohost_VkVideoDecodeH265SessionCreateInfoEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: {
+ transform_tohost_VkVideoDecodeH265SessionCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- transform_tohost_VkVideoDecodeH265SessionParametersAddInfoEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ transform_tohost_VkVideoDecodeH265SessionParametersAddInfoEXT(
+ resourceTracker, reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- transform_tohost_VkVideoDecodeH265SessionParametersCreateInfoEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ transform_tohost_VkVideoDecodeH265SessionParametersCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT:
- {
- transform_tohost_VkVideoDecodeH265PictureInfoEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH265PictureInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: {
+ transform_tohost_VkVideoDecodeH265PictureInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoDecodeH265PictureInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT:
- {
- transform_tohost_VkVideoDecodeH265DpbSlotInfoEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: {
+ transform_tohost_VkVideoDecodeH265DpbSlotInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_memory_overallocation_behavior
- case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
- {
- transform_tohost_VkDeviceMemoryOverallocationCreateInfoAMD(resourceTracker, reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
+ transform_tohost_VkDeviceMemoryOverallocationCreateInfoAMD(
+ resourceTracker,
+ reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_vertex_attribute_divisor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
- {
- transform_tohost_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
- {
- transform_tohost_VkPipelineVertexInputDivisorStateCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: {
+ transform_tohost_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_GGP_frame_token
- case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
- {
- transform_tohost_VkPresentFrameTokenGGP(resourceTracker, reinterpret_cast<VkPresentFrameTokenGGP*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: {
+ transform_tohost_VkPresentFrameTokenGGP(
+ resourceTracker, reinterpret_cast<VkPresentFrameTokenGGP*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_pipeline_creation_feedback
- case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT:
- {
- transform_tohost_VkPipelineCreationFeedbackCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
+ transform_tohost_VkPipelineCreationFeedbackCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_compute_shader_derivatives
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
- {
- transform_tohost_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
+ transform_tohost_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_mesh_shader
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
- {
- transform_tohost_VkPhysicalDeviceMeshShaderFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: {
+ transform_tohost_VkPhysicalDeviceMeshShaderFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
- {
- transform_tohost_VkPhysicalDeviceMeshShaderPropertiesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: {
+ transform_tohost_VkPhysicalDeviceMeshShaderPropertiesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_fragment_shader_barycentric
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV:
- {
- transform_tohost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
+ transform_tohost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_shader_image_footprint
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
- {
- transform_tohost_VkPhysicalDeviceShaderImageFootprintFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
+ transform_tohost_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_scissor_exclusive
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
- {
- transform_tohost_VkPipelineViewportExclusiveScissorStateCreateInfoNV(resourceTracker, reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: {
+ transform_tohost_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
- {
- transform_tohost_VkPhysicalDeviceExclusiveScissorFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: {
+ transform_tohost_VkPhysicalDeviceExclusiveScissorFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
- {
- transform_tohost_VkQueueFamilyCheckpointPropertiesNV(resourceTracker, reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: {
+ transform_tohost_VkQueueFamilyCheckpointPropertiesNV(
+ resourceTracker,
+ reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_INTEL_shader_integer_functions2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
- {
- transform_tohost_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: {
+ transform_tohost_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_INTEL_performance_query
- case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
- {
- transform_tohost_VkQueryPoolPerformanceQueryCreateInfoINTEL(resourceTracker, reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: {
+ transform_tohost_VkQueryPoolPerformanceQueryCreateInfoINTEL(
+ resourceTracker,
+ reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_pci_bus_info
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
- {
- transform_tohost_VkPhysicalDevicePCIBusInfoPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDevicePCIBusInfoPropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_display_native_hdr
- case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
- {
- transform_tohost_VkDisplayNativeHdrSurfaceCapabilitiesAMD(resourceTracker, reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: {
+ transform_tohost_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
+ resourceTracker,
+ reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
- {
- transform_tohost_VkSwapchainDisplayNativeHdrCreateInfoAMD(resourceTracker, reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: {
+ transform_tohost_VkSwapchainDisplayNativeHdrCreateInfoAMD(
+ resourceTracker,
+ reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_fragment_density_map
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
- {
- transform_tohost_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
- {
- transform_tohost_VkRenderPassFragmentDensityMapCreateInfoEXT(resourceTracker, reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: {
+ transform_tohost_VkRenderPassFragmentDensityMapCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_subgroup_size_control
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
- {
- transform_tohost_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:
- {
- transform_tohost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: {
+ transform_tohost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_AMD_shader_core_properties2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
- {
- transform_tohost_VkPhysicalDeviceShaderCoreProperties2AMD(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
+ transform_tohost_VkPhysicalDeviceShaderCoreProperties2AMD(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_device_coherent_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
- {
- transform_tohost_VkPhysicalDeviceCoherentMemoryFeaturesAMD(resourceTracker, reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: {
+ transform_tohost_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_shader_image_atomic_int64
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_memory_budget
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
- {
- transform_tohost_VkPhysicalDeviceMemoryBudgetPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_memory_priority
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceMemoryPriorityFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
- {
- transform_tohost_VkMemoryPriorityAllocateInfoEXT(resourceTracker, reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: {
+ transform_tohost_VkMemoryPriorityAllocateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
- {
- transform_tohost_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: {
+ transform_tohost_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_buffer_device_address
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
- {
- transform_tohost_VkBufferDeviceAddressCreateInfoEXT(resourceTracker, reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: {
+ transform_tohost_VkBufferDeviceAddressCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_validation_features
- case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
- {
- transform_tohost_VkValidationFeaturesEXT(resourceTracker, reinterpret_cast<VkValidationFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: {
+ transform_tohost_VkValidationFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkValidationFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_cooperative_matrix
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
- {
- transform_tohost_VkPhysicalDeviceCooperativeMatrixFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: {
+ transform_tohost_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
- {
- transform_tohost_VkPhysicalDeviceCooperativeMatrixPropertiesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: {
+ transform_tohost_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_coverage_reduction_mode
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
- {
- transform_tohost_VkPhysicalDeviceCoverageReductionModeFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: {
+ transform_tohost_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
- {
- transform_tohost_VkPipelineCoverageReductionStateCreateInfoNV(resourceTracker, reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: {
+ transform_tohost_VkPipelineCoverageReductionStateCreateInfoNV(
+ resourceTracker, reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_fragment_shader_interlock
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_ycbcr_image_arrays
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_provoking_vertex
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceProvokingVertexFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceProvokingVertexFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
- {
- transform_tohost_VkPhysicalDeviceProvokingVertexPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceProvokingVertexPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDeviceProvokingVertexPropertiesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceProvokingVertexPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
- {
- transform_tohost_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: {
+ transform_tohost_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_full_screen_exclusive
- case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
- {
- transform_tohost_VkSurfaceFullScreenExclusiveInfoEXT(resourceTracker, reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: {
+ transform_tohost_VkSurfaceFullScreenExclusiveInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
- {
- transform_tohost_VkSurfaceCapabilitiesFullScreenExclusiveEXT(resourceTracker, reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: {
+ transform_tohost_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
+ resourceTracker, reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
- {
- transform_tohost_VkSurfaceFullScreenExclusiveWin32InfoEXT(resourceTracker, reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: {
+ transform_tohost_VkSurfaceFullScreenExclusiveWin32InfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_line_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceLineRasterizationFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceLineRasterizationFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
- {
- transform_tohost_VkPhysicalDeviceLineRasterizationPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDeviceLineRasterizationPropertiesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
- {
- transform_tohost_VkPipelineRasterizationLineStateCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: {
+ transform_tohost_VkPipelineRasterizationLineStateCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_shader_atomic_float
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_index_type_uint8
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_shader_atomic_float2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_device_generated_commands
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
- {
- transform_tohost_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: {
+ transform_tohost_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
- {
- transform_tohost_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: {
+ transform_tohost_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
- {
- transform_tohost_VkGraphicsPipelineShaderGroupsCreateInfoNV(resourceTracker, reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: {
+ transform_tohost_VkGraphicsPipelineShaderGroupsCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_inherited_viewport_scissor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
- {
- transform_tohost_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: {
+ transform_tohost_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
- {
- transform_tohost_VkCommandBufferInheritanceViewportScissorInfoNV(resourceTracker, reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: {
+ transform_tohost_VkCommandBufferInheritanceViewportScissorInfoNV(
+ resourceTracker, reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_texel_buffer_alignment
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
- {
- transform_tohost_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_QCOM_render_pass_transform
- case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
- {
- transform_tohost_VkRenderPassTransformBeginInfoQCOM(resourceTracker, reinterpret_cast<VkRenderPassTransformBeginInfoQCOM*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
+ transform_tohost_VkRenderPassTransformBeginInfoQCOM(
+ resourceTracker,
+ reinterpret_cast<VkRenderPassTransformBeginInfoQCOM*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
- {
- transform_tohost_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(resourceTracker, reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: {
+ transform_tohost_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
+ resourceTracker,
+ reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_device_memory_report
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
- {
- transform_tohost_VkDeviceDeviceMemoryReportCreateInfoEXT(resourceTracker, reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: {
+ transform_tohost_VkDeviceDeviceMemoryReportCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_robustness2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceRobustness2FeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceRobustness2FeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
- {
- transform_tohost_VkPhysicalDeviceRobustness2PropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDeviceRobustness2PropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_custom_border_color
- case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
- {
- transform_tohost_VkSamplerCustomBorderColorCreateInfoEXT(resourceTracker, reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: {
+ transform_tohost_VkSamplerCustomBorderColorCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
- {
- transform_tohost_VkPhysicalDeviceCustomBorderColorPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceCustomBorderColorFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_private_data
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDevicePrivateDataFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDevicePrivateDataFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
- {
- transform_tohost_VkDevicePrivateDataCreateInfoEXT(resourceTracker, reinterpret_cast<VkDevicePrivateDataCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: {
+ transform_tohost_VkDevicePrivateDataCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkDevicePrivateDataCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_device_diagnostics_config
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
- {
- transform_tohost_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: {
+ transform_tohost_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
- {
- transform_tohost_VkDeviceDiagnosticsConfigCreateInfoNV(resourceTracker, reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: {
+ transform_tohost_VkDeviceDiagnosticsConfigCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_fragment_shading_rate_enums
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
- {
- transform_tohost_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
+ transform_tohost_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
- {
- transform_tohost_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: {
+ transform_tohost_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
- {
- transform_tohost_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(resourceTracker, reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: {
+ transform_tohost_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_ray_tracing_motion_blur
- case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
- {
- transform_tohost_VkAccelerationStructureGeometryMotionTrianglesDataNV(resourceTracker, reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: {
+ transform_tohost_VkAccelerationStructureGeometryMotionTrianglesDataNV(
+ resourceTracker,
+ reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
- {
- transform_tohost_VkAccelerationStructureMotionInfoNV(resourceTracker, reinterpret_cast<VkAccelerationStructureMotionInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: {
+ transform_tohost_VkAccelerationStructureMotionInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkAccelerationStructureMotionInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
- {
- transform_tohost_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: {
+ transform_tohost_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_fragment_density_map2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
- {
- transform_tohost_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_QCOM_rotated_copy_commands
- case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
- {
- transform_tohost_VkCopyCommandTransformInfoQCOM(resourceTracker, reinterpret_cast<VkCopyCommandTransformInfoQCOM*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: {
+ transform_tohost_VkCopyCommandTransformInfoQCOM(
+ resourceTracker,
+ reinterpret_cast<VkCopyCommandTransformInfoQCOM*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_image_robustness
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceImageRobustnessFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_4444_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDevice4444FormatsFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDevice4444FormatsFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_rgba10x6_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_VALVE_mutable_descriptor_type
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE:
- {
- transform_tohost_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(resourceTracker, reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: {
+ transform_tohost_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE:
- {
- transform_tohost_VkMutableDescriptorTypeCreateInfoVALVE(resourceTracker, reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: {
+ transform_tohost_VkMutableDescriptorTypeCreateInfoVALVE(
+ resourceTracker,
+ reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_physical_device_drm
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
- {
- transform_tohost_VkPhysicalDeviceDrmPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceDrmPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDeviceDrmPropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceDrmPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_primitive_topology_list_restart
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_FUCHSIA_external_memory
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
- {
- transform_tohost_VkImportMemoryZirconHandleInfoFUCHSIA(resourceTracker, reinterpret_cast<VkImportMemoryZirconHandleInfoFUCHSIA*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: {
+ transform_tohost_VkImportMemoryZirconHandleInfoFUCHSIA(
+ resourceTracker,
+ reinterpret_cast<VkImportMemoryZirconHandleInfoFUCHSIA*>(structExtension_out));
break;
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
- {
- transform_tohost_VkImportMemoryBufferCollectionFUCHSIA(resourceTracker, reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIA*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: {
+ transform_tohost_VkImportMemoryBufferCollectionFUCHSIA(
+ resourceTracker,
+ reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIA*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
- {
- transform_tohost_VkBufferCollectionImageCreateInfoFUCHSIA(resourceTracker, reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: {
+ transform_tohost_VkBufferCollectionImageCreateInfoFUCHSIA(
+ resourceTracker,
+ reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
- {
- transform_tohost_VkBufferCollectionBufferCreateInfoFUCHSIA(resourceTracker, reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: {
+ transform_tohost_VkBufferCollectionBufferCreateInfoFUCHSIA(
+ resourceTracker,
+ reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA*>(structExtension_out));
break;
}
#endif
#ifdef VK_HUAWEI_subpass_shading
- case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
- {
- transform_tohost_VkSubpassShadingPipelineCreateInfoHUAWEI(resourceTracker, reinterpret_cast<VkSubpassShadingPipelineCreateInfoHUAWEI*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: {
+ transform_tohost_VkSubpassShadingPipelineCreateInfoHUAWEI(
+ resourceTracker,
+ reinterpret_cast<VkSubpassShadingPipelineCreateInfoHUAWEI*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
- {
- transform_tohost_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(resourceTracker, reinterpret_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: {
+ transform_tohost_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
- {
- transform_tohost_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(resourceTracker, reinterpret_cast<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: {
+ transform_tohost_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_HUAWEI_invocation_mask
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
- {
- transform_tohost_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(resourceTracker, reinterpret_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: {
+ transform_tohost_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_external_memory_rdma
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
- {
- transform_tohost_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: {
+ transform_tohost_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_extended_dynamic_state2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_color_write_enable
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceColorWriteEnableFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
- {
- transform_tohost_VkPipelineColorWriteCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineColorWriteCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: {
+ transform_tohost_VkPipelineColorWriteCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkPipelineColorWriteCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_GOOGLE_gfxstream
- case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
- {
- transform_tohost_VkImportColorBufferGOOGLE(resourceTracker, reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
+ transform_tohost_VkImportColorBufferGOOGLE(
+ resourceTracker, reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
- {
- transform_tohost_VkImportBufferGOOGLE(resourceTracker, reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE: {
+ transform_tohost_VkImportBufferGOOGLE(
+ resourceTracker, reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
- {
- transform_tohost_VkImportPhysicalAddressGOOGLE(resourceTracker, reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE: {
+ transform_tohost_VkImportPhysicalAddressGOOGLE(
+ resourceTracker,
+ reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_global_priority_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT:
- {
- transform_tohost_VkQueueFamilyGlobalPriorityPropertiesEXT(resourceTracker, reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: {
+ transform_tohost_VkQueueFamilyGlobalPriorityPropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_multi_draw
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceMultiDrawFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceMultiDrawFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceMultiDrawFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMultiDrawFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
- {
- transform_tohost_VkPhysicalDeviceMultiDrawPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceMultiDrawPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDeviceMultiDrawPropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMultiDrawPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_border_color_swizzle
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
- {
- transform_tohost_VkSamplerBorderColorComponentMappingCreateInfoEXT(resourceTracker, reinterpret_cast<VkSamplerBorderColorComponentMappingCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: {
+ transform_tohost_VkSamplerBorderColorComponentMappingCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkSamplerBorderColorComponentMappingCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_pageable_device_local_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
- {
- transform_tohost_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: {
+ transform_tohost_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_acceleration_structure
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
- {
- transform_tohost_VkWriteDescriptorSetAccelerationStructureKHR(resourceTracker, reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
+ transform_tohost_VkWriteDescriptorSetAccelerationStructureKHR(
+ resourceTracker, reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
- {
- transform_tohost_VkPhysicalDeviceAccelerationStructureFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: {
+ transform_tohost_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
- {
- transform_tohost_VkPhysicalDeviceAccelerationStructurePropertiesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: {
+ transform_tohost_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
- {
- transform_tohost_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
+ transform_tohost_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
- {
- transform_tohost_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: {
+ transform_tohost_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_ray_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
- {
- transform_tohost_VkPhysicalDeviceRayQueryFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: {
+ transform_tohost_VkPhysicalDeviceRayQueryFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension_out));
break;
}
#endif
- default:
- {
+ default: {
return;
}
}
}
-void transform_fromhost_extension_struct(
- ResourceTracker* resourceTracker,
- void* structExtension_out)
-{
- if (!structExtension_out)
- {
+void transform_fromhost_extension_struct(ResourceTracker* resourceTracker,
+ void* structExtension_out) {
+ if (!structExtension_out) {
return;
}
uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension_out);
- switch(structType)
- {
+ switch (structType) {
#ifdef VK_VERSION_1_1
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
- {
- transform_fromhost_VkPhysicalDeviceSubgroupProperties(resourceTracker, reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
+ transform_fromhost_VkPhysicalDeviceSubgroupProperties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
- {
- transform_fromhost_VkPhysicalDevice16BitStorageFeatures(resourceTracker, reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
+ transform_fromhost_VkPhysicalDevice16BitStorageFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
- {
- transform_fromhost_VkMemoryDedicatedRequirements(resourceTracker, reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
+ transform_fromhost_VkMemoryDedicatedRequirements(
+ resourceTracker,
+ reinterpret_cast<VkMemoryDedicatedRequirements*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
- {
- transform_fromhost_VkMemoryDedicatedAllocateInfo(resourceTracker, reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: {
+ transform_fromhost_VkMemoryDedicatedAllocateInfo(
+ resourceTracker,
+ reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
- {
- transform_fromhost_VkMemoryAllocateFlagsInfo(resourceTracker, reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: {
+ transform_fromhost_VkMemoryAllocateFlagsInfo(
+ resourceTracker, reinterpret_cast<VkMemoryAllocateFlagsInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
- {
- transform_fromhost_VkDeviceGroupRenderPassBeginInfo(resourceTracker, reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: {
+ transform_fromhost_VkDeviceGroupRenderPassBeginInfo(
+ resourceTracker,
+ reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
- {
- transform_fromhost_VkDeviceGroupCommandBufferBeginInfo(resourceTracker, reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: {
+ transform_fromhost_VkDeviceGroupCommandBufferBeginInfo(
+ resourceTracker,
+ reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
- {
- transform_fromhost_VkDeviceGroupSubmitInfo(resourceTracker, reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: {
+ transform_fromhost_VkDeviceGroupSubmitInfo(
+ resourceTracker, reinterpret_cast<VkDeviceGroupSubmitInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
- {
- transform_fromhost_VkDeviceGroupBindSparseInfo(resourceTracker, reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: {
+ transform_fromhost_VkDeviceGroupBindSparseInfo(
+ resourceTracker,
+ reinterpret_cast<VkDeviceGroupBindSparseInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
- {
- transform_fromhost_VkBindBufferMemoryDeviceGroupInfo(resourceTracker, reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: {
+ transform_fromhost_VkBindBufferMemoryDeviceGroupInfo(
+ resourceTracker,
+ reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
- {
- transform_fromhost_VkBindImageMemoryDeviceGroupInfo(resourceTracker, reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: {
+ transform_fromhost_VkBindImageMemoryDeviceGroupInfo(
+ resourceTracker,
+ reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
- {
- transform_fromhost_VkDeviceGroupDeviceCreateInfo(resourceTracker, reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: {
+ transform_fromhost_VkDeviceGroupDeviceCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
- {
- transform_fromhost_VkPhysicalDeviceFeatures2(resourceTracker, reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
+ transform_fromhost_VkPhysicalDeviceFeatures2(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceFeatures2*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
- {
- transform_fromhost_VkPhysicalDevicePointClippingProperties(resourceTracker, reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: {
+ transform_fromhost_VkPhysicalDevicePointClippingProperties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
- {
- transform_fromhost_VkRenderPassInputAttachmentAspectCreateInfo(resourceTracker, reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: {
+ transform_fromhost_VkRenderPassInputAttachmentAspectCreateInfo(
+ resourceTracker, reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
- {
- transform_fromhost_VkImageViewUsageCreateInfo(resourceTracker, reinterpret_cast<VkImageViewUsageCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: {
+ transform_fromhost_VkImageViewUsageCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkImageViewUsageCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
- {
- transform_fromhost_VkPipelineTessellationDomainOriginStateCreateInfo(resourceTracker, reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: {
+ transform_fromhost_VkPipelineTessellationDomainOriginStateCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
- {
- transform_fromhost_VkRenderPassMultiviewCreateInfo(resourceTracker, reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: {
+ transform_fromhost_VkRenderPassMultiviewCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
- {
- transform_fromhost_VkPhysicalDeviceMultiviewFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceMultiviewFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
- {
- transform_fromhost_VkPhysicalDeviceMultiviewProperties(resourceTracker, reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: {
+ transform_fromhost_VkPhysicalDeviceMultiviewProperties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
- {
- transform_fromhost_VkPhysicalDeviceVariablePointersFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceVariablePointersFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
- {
- transform_fromhost_VkPhysicalDeviceProtectedMemoryFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceProtectedMemoryFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
- {
- transform_fromhost_VkPhysicalDeviceProtectedMemoryProperties(resourceTracker, reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: {
+ transform_fromhost_VkPhysicalDeviceProtectedMemoryProperties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
- {
- transform_fromhost_VkProtectedSubmitInfo(resourceTracker, reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: {
+ transform_fromhost_VkProtectedSubmitInfo(
+ resourceTracker, reinterpret_cast<VkProtectedSubmitInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
- {
- transform_fromhost_VkSamplerYcbcrConversionInfo(resourceTracker, reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: {
+ transform_fromhost_VkSamplerYcbcrConversionInfo(
+ resourceTracker,
+ reinterpret_cast<VkSamplerYcbcrConversionInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
- {
- transform_fromhost_VkBindImagePlaneMemoryInfo(resourceTracker, reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: {
+ transform_fromhost_VkBindImagePlaneMemoryInfo(
+ resourceTracker,
+ reinterpret_cast<VkBindImagePlaneMemoryInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
- {
- transform_fromhost_VkImagePlaneMemoryRequirementsInfo(resourceTracker, reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: {
+ transform_fromhost_VkImagePlaneMemoryRequirementsInfo(
+ resourceTracker,
+ reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
- {
- transform_fromhost_VkPhysicalDeviceSamplerYcbcrConversionFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
- {
- transform_fromhost_VkSamplerYcbcrConversionImageFormatProperties(resourceTracker, reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: {
+ transform_fromhost_VkSamplerYcbcrConversionImageFormatProperties(
+ resourceTracker, reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
- {
- resourceTracker->transformImpl_VkPhysicalDeviceExternalImageFormatInfo_fromhost(reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out), 1);
- transform_fromhost_VkPhysicalDeviceExternalImageFormatInfo(resourceTracker, reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: {
+ resourceTracker->transformImpl_VkPhysicalDeviceExternalImageFormatInfo_fromhost(
+ reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out), 1);
+ transform_fromhost_VkPhysicalDeviceExternalImageFormatInfo(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
- {
- resourceTracker->transformImpl_VkExternalImageFormatProperties_fromhost(reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out), 1);
- transform_fromhost_VkExternalImageFormatProperties(resourceTracker, reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: {
+ resourceTracker->transformImpl_VkExternalImageFormatProperties_fromhost(
+ reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out), 1);
+ transform_fromhost_VkExternalImageFormatProperties(
+ resourceTracker,
+ reinterpret_cast<VkExternalImageFormatProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
- {
- transform_fromhost_VkPhysicalDeviceIDProperties(resourceTracker, reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: {
+ transform_fromhost_VkPhysicalDeviceIDProperties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceIDProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
- {
- resourceTracker->transformImpl_VkExternalMemoryImageCreateInfo_fromhost(reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out), 1);
- transform_fromhost_VkExternalMemoryImageCreateInfo(resourceTracker, reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: {
+ resourceTracker->transformImpl_VkExternalMemoryImageCreateInfo_fromhost(
+ reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out), 1);
+ transform_fromhost_VkExternalMemoryImageCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkExternalMemoryImageCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
- {
- resourceTracker->transformImpl_VkExternalMemoryBufferCreateInfo_fromhost(reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out), 1);
- transform_fromhost_VkExternalMemoryBufferCreateInfo(resourceTracker, reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: {
+ resourceTracker->transformImpl_VkExternalMemoryBufferCreateInfo_fromhost(
+ reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out), 1);
+ transform_fromhost_VkExternalMemoryBufferCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
- {
- resourceTracker->transformImpl_VkExportMemoryAllocateInfo_fromhost(reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out), 1);
- transform_fromhost_VkExportMemoryAllocateInfo(resourceTracker, reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: {
+ resourceTracker->transformImpl_VkExportMemoryAllocateInfo_fromhost(
+ reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out), 1);
+ transform_fromhost_VkExportMemoryAllocateInfo(
+ resourceTracker,
+ reinterpret_cast<VkExportMemoryAllocateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
- {
- transform_fromhost_VkExportFenceCreateInfo(resourceTracker, reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: {
+ transform_fromhost_VkExportFenceCreateInfo(
+ resourceTracker, reinterpret_cast<VkExportFenceCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
- {
- transform_fromhost_VkExportSemaphoreCreateInfo(resourceTracker, reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: {
+ transform_fromhost_VkExportSemaphoreCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkExportSemaphoreCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
- {
- transform_fromhost_VkPhysicalDeviceMaintenance3Properties(resourceTracker, reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: {
+ transform_fromhost_VkPhysicalDeviceMaintenance3Properties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
- {
- transform_fromhost_VkPhysicalDeviceShaderDrawParametersFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceShaderDrawParametersFeatures(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_VERSION_1_2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
- {
- transform_fromhost_VkPhysicalDeviceVulkan11Features(resourceTracker, reinterpret_cast<VkPhysicalDeviceVulkan11Features*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceVulkan11Features(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVulkan11Features*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
- {
- transform_fromhost_VkPhysicalDeviceVulkan11Properties(resourceTracker, reinterpret_cast<VkPhysicalDeviceVulkan11Properties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: {
+ transform_fromhost_VkPhysicalDeviceVulkan11Properties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVulkan11Properties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
- {
- transform_fromhost_VkPhysicalDeviceVulkan12Features(resourceTracker, reinterpret_cast<VkPhysicalDeviceVulkan12Features*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceVulkan12Features(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVulkan12Features*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
- {
- transform_fromhost_VkPhysicalDeviceVulkan12Properties(resourceTracker, reinterpret_cast<VkPhysicalDeviceVulkan12Properties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: {
+ transform_fromhost_VkPhysicalDeviceVulkan12Properties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVulkan12Properties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
- {
- transform_fromhost_VkImageFormatListCreateInfo(resourceTracker, reinterpret_cast<VkImageFormatListCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: {
+ transform_fromhost_VkImageFormatListCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkImageFormatListCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
- {
- transform_fromhost_VkPhysicalDevice8BitStorageFeatures(resourceTracker, reinterpret_cast<VkPhysicalDevice8BitStorageFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: {
+ transform_fromhost_VkPhysicalDevice8BitStorageFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevice8BitStorageFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
- {
- transform_fromhost_VkPhysicalDeviceDriverProperties(resourceTracker, reinterpret_cast<VkPhysicalDeviceDriverProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: {
+ transform_fromhost_VkPhysicalDeviceDriverProperties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceDriverProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
- {
- transform_fromhost_VkPhysicalDeviceShaderAtomicInt64Features(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceShaderAtomicInt64Features(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
- {
- transform_fromhost_VkPhysicalDeviceShaderFloat16Int8Features(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceShaderFloat16Int8Features(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
- {
- transform_fromhost_VkPhysicalDeviceFloatControlsProperties(resourceTracker, reinterpret_cast<VkPhysicalDeviceFloatControlsProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: {
+ transform_fromhost_VkPhysicalDeviceFloatControlsProperties(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceFloatControlsProperties*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
- {
- transform_fromhost_VkDescriptorSetLayoutBindingFlagsCreateInfo(resourceTracker, reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: {
+ transform_fromhost_VkDescriptorSetLayoutBindingFlagsCreateInfo(
+ resourceTracker, reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
- {
- transform_fromhost_VkPhysicalDeviceDescriptorIndexingFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceDescriptorIndexingFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
- {
- transform_fromhost_VkPhysicalDeviceDescriptorIndexingProperties(resourceTracker, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: {
+ transform_fromhost_VkPhysicalDeviceDescriptorIndexingProperties(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
- {
- transform_fromhost_VkDescriptorSetVariableDescriptorCountAllocateInfo(resourceTracker, reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: {
+ transform_fromhost_VkDescriptorSetVariableDescriptorCountAllocateInfo(
+ resourceTracker,
+ reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
- {
- transform_fromhost_VkDescriptorSetVariableDescriptorCountLayoutSupport(resourceTracker, reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: {
+ transform_fromhost_VkDescriptorSetVariableDescriptorCountLayoutSupport(
+ resourceTracker,
+ reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
- {
- transform_fromhost_VkSubpassDescriptionDepthStencilResolve(resourceTracker, reinterpret_cast<VkSubpassDescriptionDepthStencilResolve*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: {
+ transform_fromhost_VkSubpassDescriptionDepthStencilResolve(
+ resourceTracker,
+ reinterpret_cast<VkSubpassDescriptionDepthStencilResolve*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
- {
- transform_fromhost_VkPhysicalDeviceDepthStencilResolveProperties(resourceTracker, reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: {
+ transform_fromhost_VkPhysicalDeviceDepthStencilResolveProperties(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
- {
- transform_fromhost_VkPhysicalDeviceScalarBlockLayoutFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceScalarBlockLayoutFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
- {
- transform_fromhost_VkImageStencilUsageCreateInfo(resourceTracker, reinterpret_cast<VkImageStencilUsageCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: {
+ transform_fromhost_VkImageStencilUsageCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkImageStencilUsageCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
- {
- transform_fromhost_VkSamplerReductionModeCreateInfo(resourceTracker, reinterpret_cast<VkSamplerReductionModeCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: {
+ transform_fromhost_VkSamplerReductionModeCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkSamplerReductionModeCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
- {
- transform_fromhost_VkPhysicalDeviceSamplerFilterMinmaxProperties(resourceTracker, reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: {
+ transform_fromhost_VkPhysicalDeviceSamplerFilterMinmaxProperties(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
- {
- transform_fromhost_VkPhysicalDeviceVulkanMemoryModelFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceVulkanMemoryModelFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
- {
- transform_fromhost_VkPhysicalDeviceImagelessFramebufferFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceImagelessFramebufferFeatures(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
- {
- transform_fromhost_VkFramebufferAttachmentsCreateInfo(resourceTracker, reinterpret_cast<VkFramebufferAttachmentsCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: {
+ transform_fromhost_VkFramebufferAttachmentsCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkFramebufferAttachmentsCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
- {
- transform_fromhost_VkRenderPassAttachmentBeginInfo(resourceTracker, reinterpret_cast<VkRenderPassAttachmentBeginInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: {
+ transform_fromhost_VkRenderPassAttachmentBeginInfo(
+ resourceTracker,
+ reinterpret_cast<VkRenderPassAttachmentBeginInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
- {
- transform_fromhost_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
- {
- transform_fromhost_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
- {
- transform_fromhost_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
- {
- transform_fromhost_VkAttachmentReferenceStencilLayout(resourceTracker, reinterpret_cast<VkAttachmentReferenceStencilLayout*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: {
+ transform_fromhost_VkAttachmentReferenceStencilLayout(
+ resourceTracker,
+ reinterpret_cast<VkAttachmentReferenceStencilLayout*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
- {
- transform_fromhost_VkAttachmentDescriptionStencilLayout(resourceTracker, reinterpret_cast<VkAttachmentDescriptionStencilLayout*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: {
+ transform_fromhost_VkAttachmentDescriptionStencilLayout(
+ resourceTracker,
+ reinterpret_cast<VkAttachmentDescriptionStencilLayout*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
- {
- transform_fromhost_VkPhysicalDeviceHostQueryResetFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceHostQueryResetFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
- {
- transform_fromhost_VkPhysicalDeviceTimelineSemaphoreFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceTimelineSemaphoreFeatures(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
- {
- transform_fromhost_VkPhysicalDeviceTimelineSemaphoreProperties(resourceTracker, reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: {
+ transform_fromhost_VkPhysicalDeviceTimelineSemaphoreProperties(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
- {
- transform_fromhost_VkSemaphoreTypeCreateInfo(resourceTracker, reinterpret_cast<VkSemaphoreTypeCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: {
+ transform_fromhost_VkSemaphoreTypeCreateInfo(
+ resourceTracker, reinterpret_cast<VkSemaphoreTypeCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
- {
- transform_fromhost_VkTimelineSemaphoreSubmitInfo(resourceTracker, reinterpret_cast<VkTimelineSemaphoreSubmitInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: {
+ transform_fromhost_VkTimelineSemaphoreSubmitInfo(
+ resourceTracker,
+ reinterpret_cast<VkTimelineSemaphoreSubmitInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
- {
- transform_fromhost_VkPhysicalDeviceBufferDeviceAddressFeatures(resourceTracker, reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: {
+ transform_fromhost_VkPhysicalDeviceBufferDeviceAddressFeatures(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
- {
- transform_fromhost_VkBufferOpaqueCaptureAddressCreateInfo(resourceTracker, reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: {
+ transform_fromhost_VkBufferOpaqueCaptureAddressCreateInfo(
+ resourceTracker,
+ reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
- {
- transform_fromhost_VkMemoryOpaqueCaptureAddressAllocateInfo(resourceTracker, reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: {
+ transform_fromhost_VkMemoryOpaqueCaptureAddressAllocateInfo(
+ resourceTracker,
+ reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_swapchain
- case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
- {
- transform_fromhost_VkImageSwapchainCreateInfoKHR(resourceTracker, reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
+ transform_fromhost_VkImageSwapchainCreateInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
- {
- transform_fromhost_VkBindImageMemorySwapchainInfoKHR(resourceTracker, reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: {
+ transform_fromhost_VkBindImageMemorySwapchainInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
- {
- transform_fromhost_VkDeviceGroupPresentInfoKHR(resourceTracker, reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: {
+ transform_fromhost_VkDeviceGroupPresentInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
- {
- transform_fromhost_VkDeviceGroupSwapchainCreateInfoKHR(resourceTracker, reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: {
+ transform_fromhost_VkDeviceGroupSwapchainCreateInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_display_swapchain
- case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
- {
- transform_fromhost_VkDisplayPresentInfoKHR(resourceTracker, reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: {
+ transform_fromhost_VkDisplayPresentInfoKHR(
+ resourceTracker, reinterpret_cast<VkDisplayPresentInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_video_queue
- case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR:
- {
- transform_fromhost_VkVideoQueueFamilyProperties2KHR(resourceTracker, reinterpret_cast<VkVideoQueueFamilyProperties2KHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: {
+ transform_fromhost_VkVideoQueueFamilyProperties2KHR(
+ resourceTracker,
+ reinterpret_cast<VkVideoQueueFamilyProperties2KHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR:
- {
- transform_fromhost_VkVideoProfileKHR(resourceTracker, reinterpret_cast<VkVideoProfileKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR: {
+ transform_fromhost_VkVideoProfileKHR(
+ resourceTracker, reinterpret_cast<VkVideoProfileKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR:
- {
- transform_fromhost_VkVideoProfilesKHR(resourceTracker, reinterpret_cast<VkVideoProfilesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR: {
+ transform_fromhost_VkVideoProfilesKHR(
+ resourceTracker, reinterpret_cast<VkVideoProfilesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_dynamic_rendering
- case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR:
- {
- transform_fromhost_VkPipelineRenderingCreateInfoKHR(resourceTracker, reinterpret_cast<VkPipelineRenderingCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: {
+ transform_fromhost_VkPipelineRenderingCreateInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkPipelineRenderingCreateInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR:
- {
- transform_fromhost_VkPhysicalDeviceDynamicRenderingFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: {
+ transform_fromhost_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR:
- {
- transform_fromhost_VkCommandBufferInheritanceRenderingInfoKHR(resourceTracker, reinterpret_cast<VkCommandBufferInheritanceRenderingInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: {
+ transform_fromhost_VkCommandBufferInheritanceRenderingInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkCommandBufferInheritanceRenderingInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
- {
- transform_fromhost_VkRenderingFragmentShadingRateAttachmentInfoKHR(resourceTracker, reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
+ transform_fromhost_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+ resourceTracker, reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
- {
- transform_fromhost_VkRenderingFragmentDensityMapAttachmentInfoEXT(resourceTracker, reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: {
+ transform_fromhost_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+ resourceTracker, reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
- {
- transform_fromhost_VkAttachmentSampleCountInfoAMD(resourceTracker, reinterpret_cast<VkAttachmentSampleCountInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: {
+ transform_fromhost_VkAttachmentSampleCountInfoAMD(
+ resourceTracker,
+ reinterpret_cast<VkAttachmentSampleCountInfoAMD*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
- {
- transform_fromhost_VkMultiviewPerViewAttributesInfoNVX(resourceTracker, reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: {
+ transform_fromhost_VkMultiviewPerViewAttributesInfoNVX(
+ resourceTracker,
+ reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_memory_win32
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
- {
- transform_fromhost_VkImportMemoryWin32HandleInfoKHR(resourceTracker, reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
+ transform_fromhost_VkImportMemoryWin32HandleInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
- {
- transform_fromhost_VkExportMemoryWin32HandleInfoKHR(resourceTracker, reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
+ transform_fromhost_VkExportMemoryWin32HandleInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_memory_fd
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
- {
- transform_fromhost_VkImportMemoryFdInfoKHR(resourceTracker, reinterpret_cast<VkImportMemoryFdInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: {
+ transform_fromhost_VkImportMemoryFdInfoKHR(
+ resourceTracker, reinterpret_cast<VkImportMemoryFdInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_win32_keyed_mutex
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
- {
- transform_fromhost_VkWin32KeyedMutexAcquireReleaseInfoKHR(resourceTracker, reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: {
+ transform_fromhost_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_semaphore_win32
- case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
- {
- transform_fromhost_VkExportSemaphoreWin32HandleInfoKHR(resourceTracker, reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: {
+ transform_fromhost_VkExportSemaphoreWin32HandleInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
- {
- transform_fromhost_VkD3D12FenceSubmitInfoKHR(resourceTracker, reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: {
+ transform_fromhost_VkD3D12FenceSubmitInfoKHR(
+ resourceTracker, reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_push_descriptor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
- {
- transform_fromhost_VkPhysicalDevicePushDescriptorPropertiesKHR(resourceTracker, reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: {
+ transform_fromhost_VkPhysicalDevicePushDescriptorPropertiesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_incremental_present
- case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
- {
- transform_fromhost_VkPresentRegionsKHR(resourceTracker, reinterpret_cast<VkPresentRegionsKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: {
+ transform_fromhost_VkPresentRegionsKHR(
+ resourceTracker, reinterpret_cast<VkPresentRegionsKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shared_presentable_image
- case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
- {
- transform_fromhost_VkSharedPresentSurfaceCapabilitiesKHR(resourceTracker, reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
+ transform_fromhost_VkSharedPresentSurfaceCapabilitiesKHR(
+ resourceTracker,
+ reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_external_fence_win32
- case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
- {
- transform_fromhost_VkExportFenceWin32HandleInfoKHR(resourceTracker, reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: {
+ transform_fromhost_VkExportFenceWin32HandleInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_performance_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
- {
- transform_fromhost_VkPhysicalDevicePerformanceQueryFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: {
+ transform_fromhost_VkPhysicalDevicePerformanceQueryFeaturesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
- {
- transform_fromhost_VkPhysicalDevicePerformanceQueryPropertiesKHR(resourceTracker, reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: {
+ transform_fromhost_VkPhysicalDevicePerformanceQueryPropertiesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
- {
- transform_fromhost_VkQueryPoolPerformanceCreateInfoKHR(resourceTracker, reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: {
+ transform_fromhost_VkQueryPoolPerformanceCreateInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
- {
- transform_fromhost_VkPerformanceQuerySubmitInfoKHR(resourceTracker, reinterpret_cast<VkPerformanceQuerySubmitInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: {
+ transform_fromhost_VkPerformanceQuerySubmitInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkPerformanceQuerySubmitInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_portability_subset
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
- {
- transform_fromhost_VkPhysicalDevicePortabilitySubsetFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
+ transform_fromhost_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
- {
- transform_fromhost_VkPhysicalDevicePortabilitySubsetPropertiesKHR(resourceTracker, reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
+ transform_fromhost_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shader_clock
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
- {
- transform_fromhost_VkPhysicalDeviceShaderClockFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
+ transform_fromhost_VkPhysicalDeviceShaderClockFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shader_terminate_invocation
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR:
- {
- transform_fromhost_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: {
+ transform_fromhost_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_fragment_shading_rate
- case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
- {
- transform_fromhost_VkFragmentShadingRateAttachmentInfoKHR(resourceTracker, reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
+ transform_fromhost_VkFragmentShadingRateAttachmentInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
- {
- transform_fromhost_VkPipelineFragmentShadingRateStateCreateInfoKHR(resourceTracker, reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: {
+ transform_fromhost_VkPipelineFragmentShadingRateStateCreateInfoKHR(
+ resourceTracker, reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
- {
- transform_fromhost_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: {
+ transform_fromhost_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
- {
- transform_fromhost_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: {
+ transform_fromhost_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_surface_protected_capabilities
- case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
- {
- transform_fromhost_VkSurfaceProtectedCapabilitiesKHR(resourceTracker, reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: {
+ transform_fromhost_VkSurfaceProtectedCapabilitiesKHR(
+ resourceTracker,
+ reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_present_wait
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
- {
- transform_fromhost_VkPhysicalDevicePresentWaitFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDevicePresentWaitFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: {
+ transform_fromhost_VkPhysicalDevicePresentWaitFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePresentWaitFeaturesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
- {
- transform_fromhost_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: {
+ transform_fromhost_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shader_integer_dot_product
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR:
- {
- transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: {
+ transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR:
- {
- transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: {
+ transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_present_id
- case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
- {
- transform_fromhost_VkPresentIdKHR(resourceTracker, reinterpret_cast<VkPresentIdKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: {
+ transform_fromhost_VkPresentIdKHR(
+ resourceTracker, reinterpret_cast<VkPresentIdKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
- {
- transform_fromhost_VkPhysicalDevicePresentIdFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDevicePresentIdFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: {
+ transform_fromhost_VkPhysicalDevicePresentIdFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePresentIdFeaturesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_video_encode_queue
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
- {
- transform_fromhost_VkVideoEncodeRateControlInfoKHR(resourceTracker, reinterpret_cast<VkVideoEncodeRateControlInfoKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
+ transform_fromhost_VkVideoEncodeRateControlInfoKHR(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeRateControlInfoKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_synchronization2
- case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR:
- {
- transform_fromhost_VkMemoryBarrier2KHR(resourceTracker, reinterpret_cast<VkMemoryBarrier2KHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: {
+ transform_fromhost_VkMemoryBarrier2KHR(
+ resourceTracker, reinterpret_cast<VkMemoryBarrier2KHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR:
- {
- transform_fromhost_VkPhysicalDeviceSynchronization2FeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceSynchronization2FeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: {
+ transform_fromhost_VkPhysicalDeviceSynchronization2FeaturesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceSynchronization2FeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
- {
- transform_fromhost_VkQueueFamilyCheckpointProperties2NV(resourceTracker, reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
+ transform_fromhost_VkQueueFamilyCheckpointProperties2NV(
+ resourceTracker,
+ reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
- {
- transform_fromhost_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
+ transform_fromhost_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR:
- {
- transform_fromhost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: {
+ transform_fromhost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
- {
- transform_fromhost_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
+ transform_fromhost_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_format_feature_flags2
- case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR:
- {
- transform_fromhost_VkFormatProperties3KHR(resourceTracker, reinterpret_cast<VkFormatProperties3KHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: {
+ transform_fromhost_VkFormatProperties3KHR(
+ resourceTracker, reinterpret_cast<VkFormatProperties3KHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_KHR_maintenance4
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR:
- {
- transform_fromhost_VkPhysicalDeviceMaintenance4FeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: {
+ transform_fromhost_VkPhysicalDeviceMaintenance4FeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR:
- {
- transform_fromhost_VkPhysicalDeviceMaintenance4PropertiesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: {
+ transform_fromhost_VkPhysicalDeviceMaintenance4PropertiesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension_out));
break;
}
#endif
#ifdef VK_ANDROID_native_buffer
- case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID:
- {
- transform_fromhost_VkNativeBufferANDROID(resourceTracker, reinterpret_cast<VkNativeBufferANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
+ transform_fromhost_VkNativeBufferANDROID(
+ resourceTracker, reinterpret_cast<VkNativeBufferANDROID*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_debug_report
- case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
- {
- transform_fromhost_VkDebugReportCallbackCreateInfoEXT(resourceTracker, reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: {
+ transform_fromhost_VkDebugReportCallbackCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_rasterization_order
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
- {
- transform_fromhost_VkPipelineRasterizationStateRasterizationOrderAMD(resourceTracker, reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: {
+ transform_fromhost_VkPipelineRasterizationStateRasterizationOrderAMD(
+ resourceTracker,
+ reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_dedicated_allocation
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
- {
- transform_fromhost_VkDedicatedAllocationImageCreateInfoNV(resourceTracker, reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: {
+ transform_fromhost_VkDedicatedAllocationImageCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
- {
- transform_fromhost_VkDedicatedAllocationBufferCreateInfoNV(resourceTracker, reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: {
+ transform_fromhost_VkDedicatedAllocationBufferCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
- {
- transform_fromhost_VkDedicatedAllocationMemoryAllocateInfoNV(resourceTracker, reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: {
+ transform_fromhost_VkDedicatedAllocationMemoryAllocateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_transform_feedback
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceTransformFeedbackFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceTransformFeedbackPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
- {
- transform_fromhost_VkPipelineRasterizationStateStreamCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: {
+ transform_fromhost_VkPipelineRasterizationStateStreamCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_video_encode_h264
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT:
- {
- transform_fromhost_VkVideoEncodeH264CapabilitiesEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH264CapabilitiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
+ transform_fromhost_VkVideoEncodeH264CapabilitiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeH264CapabilitiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT:
- {
- transform_fromhost_VkVideoEncodeH264SessionCreateInfoEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: {
+ transform_fromhost_VkVideoEncodeH264SessionCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- transform_fromhost_VkVideoEncodeH264SessionParametersAddInfoEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ transform_fromhost_VkVideoEncodeH264SessionParametersAddInfoEXT(
+ resourceTracker, reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- transform_fromhost_VkVideoEncodeH264SessionParametersCreateInfoEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ transform_fromhost_VkVideoEncodeH264SessionParametersCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT:
- {
- transform_fromhost_VkVideoEncodeH264VclFrameInfoEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
+ transform_fromhost_VkVideoEncodeH264VclFrameInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT:
- {
- transform_fromhost_VkVideoEncodeH264EmitPictureParametersEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: {
+ transform_fromhost_VkVideoEncodeH264EmitPictureParametersEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT:
- {
- transform_fromhost_VkVideoEncodeH264ProfileEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH264ProfileEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT: {
+ transform_fromhost_VkVideoEncodeH264ProfileEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeH264ProfileEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_video_encode_h265
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT:
- {
- transform_fromhost_VkVideoEncodeH265CapabilitiesEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH265CapabilitiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
+ transform_fromhost_VkVideoEncodeH265CapabilitiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeH265CapabilitiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT:
- {
- transform_fromhost_VkVideoEncodeH265SessionCreateInfoEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: {
+ transform_fromhost_VkVideoEncodeH265SessionCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- transform_fromhost_VkVideoEncodeH265SessionParametersAddInfoEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ transform_fromhost_VkVideoEncodeH265SessionParametersAddInfoEXT(
+ resourceTracker, reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- transform_fromhost_VkVideoEncodeH265SessionParametersCreateInfoEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ transform_fromhost_VkVideoEncodeH265SessionParametersCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT:
- {
- transform_fromhost_VkVideoEncodeH265VclFrameInfoEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
+ transform_fromhost_VkVideoEncodeH265VclFrameInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT:
- {
- transform_fromhost_VkVideoEncodeH265EmitPictureParametersEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: {
+ transform_fromhost_VkVideoEncodeH265EmitPictureParametersEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT:
- {
- transform_fromhost_VkVideoEncodeH265ProfileEXT(resourceTracker, reinterpret_cast<VkVideoEncodeH265ProfileEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT: {
+ transform_fromhost_VkVideoEncodeH265ProfileEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoEncodeH265ProfileEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_video_decode_h264
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT:
- {
- transform_fromhost_VkVideoDecodeH264ProfileEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH264ProfileEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT: {
+ transform_fromhost_VkVideoDecodeH264ProfileEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoDecodeH264ProfileEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT:
- {
- transform_fromhost_VkVideoDecodeH264CapabilitiesEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH264CapabilitiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: {
+ transform_fromhost_VkVideoDecodeH264CapabilitiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoDecodeH264CapabilitiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT:
- {
- transform_fromhost_VkVideoDecodeH264SessionCreateInfoEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: {
+ transform_fromhost_VkVideoDecodeH264SessionCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- transform_fromhost_VkVideoDecodeH264SessionParametersAddInfoEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ transform_fromhost_VkVideoDecodeH264SessionParametersAddInfoEXT(
+ resourceTracker, reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- transform_fromhost_VkVideoDecodeH264SessionParametersCreateInfoEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ transform_fromhost_VkVideoDecodeH264SessionParametersCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT:
- {
- transform_fromhost_VkVideoDecodeH264PictureInfoEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH264PictureInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: {
+ transform_fromhost_VkVideoDecodeH264PictureInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoDecodeH264PictureInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT:
- {
- transform_fromhost_VkVideoDecodeH264MvcEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH264MvcEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT: {
+ transform_fromhost_VkVideoDecodeH264MvcEXT(
+ resourceTracker, reinterpret_cast<VkVideoDecodeH264MvcEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT:
- {
- transform_fromhost_VkVideoDecodeH264DpbSlotInfoEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: {
+ transform_fromhost_VkVideoDecodeH264DpbSlotInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_texture_gather_bias_lod
- case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
- {
- transform_fromhost_VkTextureLODGatherFormatPropertiesAMD(resourceTracker, reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
+ transform_fromhost_VkTextureLODGatherFormatPropertiesAMD(
+ resourceTracker,
+ reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_corner_sampled_image
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
- {
- transform_fromhost_VkPhysicalDeviceCornerSampledImageFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: {
+ transform_fromhost_VkPhysicalDeviceCornerSampledImageFeaturesNV(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_external_memory
- case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
- {
- transform_fromhost_VkExternalMemoryImageCreateInfoNV(resourceTracker, reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: {
+ transform_fromhost_VkExternalMemoryImageCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
- {
- transform_fromhost_VkExportMemoryAllocateInfoNV(resourceTracker, reinterpret_cast<VkExportMemoryAllocateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: {
+ transform_fromhost_VkExportMemoryAllocateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkExportMemoryAllocateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_external_memory_win32
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
- {
- transform_fromhost_VkImportMemoryWin32HandleInfoNV(resourceTracker, reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
+ transform_fromhost_VkImportMemoryWin32HandleInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
- {
- transform_fromhost_VkExportMemoryWin32HandleInfoNV(resourceTracker, reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
+ transform_fromhost_VkExportMemoryWin32HandleInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_win32_keyed_mutex
- case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
- {
- transform_fromhost_VkWin32KeyedMutexAcquireReleaseInfoNV(resourceTracker, reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: {
+ transform_fromhost_VkWin32KeyedMutexAcquireReleaseInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_validation_flags
- case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
- {
- transform_fromhost_VkValidationFlagsEXT(resourceTracker, reinterpret_cast<VkValidationFlagsEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: {
+ transform_fromhost_VkValidationFlagsEXT(
+ resourceTracker, reinterpret_cast<VkValidationFlagsEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_astc_decode_mode
- case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
- {
- transform_fromhost_VkImageViewASTCDecodeModeEXT(resourceTracker, reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
+ transform_fromhost_VkImageViewASTCDecodeModeEXT(
+ resourceTracker,
+ reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceASTCDecodeFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceASTCDecodeFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_conditional_rendering
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceConditionalRenderingFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
- {
- transform_fromhost_VkCommandBufferInheritanceConditionalRenderingInfoEXT(resourceTracker, reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: {
+ transform_fromhost_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_clip_space_w_scaling
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
- {
- transform_fromhost_VkPipelineViewportWScalingStateCreateInfoNV(resourceTracker, reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: {
+ transform_fromhost_VkPipelineViewportWScalingStateCreateInfoNV(
+ resourceTracker, reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_display_control
- case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
- {
- transform_fromhost_VkSwapchainCounterCreateInfoEXT(resourceTracker, reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: {
+ transform_fromhost_VkSwapchainCounterCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_GOOGLE_display_timing
- case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
- {
- transform_fromhost_VkPresentTimesInfoGOOGLE(resourceTracker, reinterpret_cast<VkPresentTimesInfoGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: {
+ transform_fromhost_VkPresentTimesInfoGOOGLE(
+ resourceTracker, reinterpret_cast<VkPresentTimesInfoGOOGLE*>(structExtension_out));
break;
}
#endif
#ifdef VK_NVX_multiview_per_view_attributes
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
- {
- transform_fromhost_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(resourceTracker, reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: {
+ transform_fromhost_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_viewport_swizzle
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
- {
- transform_fromhost_VkPipelineViewportSwizzleStateCreateInfoNV(resourceTracker, reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: {
+ transform_fromhost_VkPipelineViewportSwizzleStateCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_discard_rectangles
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceDiscardRectanglePropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
- {
- transform_fromhost_VkPipelineDiscardRectangleStateCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: {
+ transform_fromhost_VkPipelineDiscardRectangleStateCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_conservative_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
- {
- transform_fromhost_VkPipelineRasterizationConservativeStateCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: {
+ transform_fromhost_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_depth_clip_enable
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
- {
- transform_fromhost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+ transform_fromhost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_debug_utils
- case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
- {
- transform_fromhost_VkDebugUtilsMessengerCreateInfoEXT(resourceTracker, reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
+ transform_fromhost_VkDebugUtilsMessengerCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
- {
- transform_fromhost_VkAndroidHardwareBufferUsageANDROID(resourceTracker, reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: {
+ transform_fromhost_VkAndroidHardwareBufferUsageANDROID(
+ resourceTracker,
+ reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
- {
- transform_fromhost_VkAndroidHardwareBufferFormatPropertiesANDROID(resourceTracker, reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: {
+ transform_fromhost_VkAndroidHardwareBufferFormatPropertiesANDROID(
+ resourceTracker, reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
- {
- transform_fromhost_VkImportAndroidHardwareBufferInfoANDROID(resourceTracker, reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: {
+ transform_fromhost_VkImportAndroidHardwareBufferInfoANDROID(
+ resourceTracker,
+ reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
- {
- transform_fromhost_VkExternalFormatANDROID(resourceTracker, reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: {
+ transform_fromhost_VkExternalFormatANDROID(
+ resourceTracker, reinterpret_cast<VkExternalFormatANDROID*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
- {
- transform_fromhost_VkAndroidHardwareBufferFormatProperties2ANDROID(resourceTracker, reinterpret_cast<VkAndroidHardwareBufferFormatProperties2ANDROID*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: {
+ transform_fromhost_VkAndroidHardwareBufferFormatProperties2ANDROID(
+ resourceTracker, reinterpret_cast<VkAndroidHardwareBufferFormatProperties2ANDROID*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_inline_uniform_block
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT:
- {
- transform_fromhost_VkWriteDescriptorSetInlineUniformBlockEXT(resourceTracker, reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
+ transform_fromhost_VkWriteDescriptorSetInlineUniformBlockEXT(
+ resourceTracker,
+ reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT:
- {
- transform_fromhost_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(resourceTracker, reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
+ transform_fromhost_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_sample_locations
- case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
- {
- transform_fromhost_VkSampleLocationsInfoEXT(resourceTracker, reinterpret_cast<VkSampleLocationsInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
+ transform_fromhost_VkSampleLocationsInfoEXT(
+ resourceTracker, reinterpret_cast<VkSampleLocationsInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
- {
- transform_fromhost_VkRenderPassSampleLocationsBeginInfoEXT(resourceTracker, reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: {
+ transform_fromhost_VkRenderPassSampleLocationsBeginInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
- {
- transform_fromhost_VkPipelineSampleLocationsStateCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: {
+ transform_fromhost_VkPipelineSampleLocationsStateCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceSampleLocationsPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_blend_operation_advanced
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
- {
- transform_fromhost_VkPipelineColorBlendAdvancedStateCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: {
+ transform_fromhost_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_fragment_coverage_to_color
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
- {
- transform_fromhost_VkPipelineCoverageToColorStateCreateInfoNV(resourceTracker, reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: {
+ transform_fromhost_VkPipelineCoverageToColorStateCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_framebuffer_mixed_samples
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
- {
- transform_fromhost_VkPipelineCoverageModulationStateCreateInfoNV(resourceTracker, reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: {
+ transform_fromhost_VkPipelineCoverageModulationStateCreateInfoNV(
+ resourceTracker, reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_shader_sm_builtins
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
- {
- transform_fromhost_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: {
+ transform_fromhost_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
- {
- transform_fromhost_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: {
+ transform_fromhost_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_image_drm_format_modifier
- case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
- {
- transform_fromhost_VkDrmFormatModifierPropertiesListEXT(resourceTracker, reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: {
+ transform_fromhost_VkDrmFormatModifierPropertiesListEXT(
+ resourceTracker,
+ reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
- {
- transform_fromhost_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: {
+ transform_fromhost_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
- {
- transform_fromhost_VkImageDrmFormatModifierListCreateInfoEXT(resourceTracker, reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: {
+ transform_fromhost_VkImageDrmFormatModifierListCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
- {
- transform_fromhost_VkImageDrmFormatModifierExplicitCreateInfoEXT(resourceTracker, reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: {
+ transform_fromhost_VkImageDrmFormatModifierExplicitCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
- {
- transform_fromhost_VkDrmFormatModifierPropertiesList2EXT(resourceTracker, reinterpret_cast<VkDrmFormatModifierPropertiesList2EXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: {
+ transform_fromhost_VkDrmFormatModifierPropertiesList2EXT(
+ resourceTracker,
+ reinterpret_cast<VkDrmFormatModifierPropertiesList2EXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_validation_cache
- case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
- {
- transform_fromhost_VkShaderModuleValidationCacheCreateInfoEXT(resourceTracker, reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: {
+ transform_fromhost_VkShaderModuleValidationCacheCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_shading_rate_image
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
- {
- transform_fromhost_VkPipelineViewportShadingRateImageStateCreateInfoNV(resourceTracker, reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: {
+ transform_fromhost_VkPipelineViewportShadingRateImageStateCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
- {
- transform_fromhost_VkPhysicalDeviceShadingRateImageFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: {
+ transform_fromhost_VkPhysicalDeviceShadingRateImageFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
- {
- transform_fromhost_VkPhysicalDeviceShadingRateImagePropertiesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: {
+ transform_fromhost_VkPhysicalDeviceShadingRateImagePropertiesNV(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
- {
- transform_fromhost_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(resourceTracker, reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: {
+ transform_fromhost_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_ray_tracing
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
- {
- transform_fromhost_VkWriteDescriptorSetAccelerationStructureNV(resourceTracker, reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: {
+ transform_fromhost_VkWriteDescriptorSetAccelerationStructureNV(
+ resourceTracker, reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
- {
- transform_fromhost_VkPhysicalDeviceRayTracingPropertiesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: {
+ transform_fromhost_VkPhysicalDeviceRayTracingPropertiesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_representative_fragment_test
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
- {
- transform_fromhost_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: {
+ transform_fromhost_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
- {
- transform_fromhost_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(resourceTracker, reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: {
+ transform_fromhost_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_filter_cubic
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
- {
- transform_fromhost_VkPhysicalDeviceImageViewImageFormatInfoEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: {
+ transform_fromhost_VkPhysicalDeviceImageViewImageFormatInfoEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
- {
- transform_fromhost_VkFilterCubicImageViewImageFormatPropertiesEXT(resourceTracker, reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: {
+ transform_fromhost_VkFilterCubicImageViewImageFormatPropertiesEXT(
+ resourceTracker, reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_global_priority
- case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
- {
- transform_fromhost_VkDeviceQueueGlobalPriorityCreateInfoEXT(resourceTracker, reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
+ transform_fromhost_VkDeviceQueueGlobalPriorityCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_external_memory_host
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
- {
- transform_fromhost_VkImportMemoryHostPointerInfoEXT(resourceTracker, reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
+ transform_fromhost_VkImportMemoryHostPointerInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_AMD_pipeline_compiler_control
- case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
- {
- transform_fromhost_VkPipelineCompilerControlCreateInfoAMD(resourceTracker, reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: {
+ transform_fromhost_VkPipelineCompilerControlCreateInfoAMD(
+ resourceTracker,
+ reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_shader_core_properties
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
- {
- transform_fromhost_VkPhysicalDeviceShaderCorePropertiesAMD(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: {
+ transform_fromhost_VkPhysicalDeviceShaderCorePropertiesAMD(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_video_decode_h265
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT:
- {
- transform_fromhost_VkVideoDecodeH265ProfileEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH265ProfileEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT: {
+ transform_fromhost_VkVideoDecodeH265ProfileEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoDecodeH265ProfileEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT:
- {
- transform_fromhost_VkVideoDecodeH265CapabilitiesEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH265CapabilitiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: {
+ transform_fromhost_VkVideoDecodeH265CapabilitiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoDecodeH265CapabilitiesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT:
- {
- transform_fromhost_VkVideoDecodeH265SessionCreateInfoEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: {
+ transform_fromhost_VkVideoDecodeH265SessionCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT:
- {
- transform_fromhost_VkVideoDecodeH265SessionParametersAddInfoEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
+ transform_fromhost_VkVideoDecodeH265SessionParametersAddInfoEXT(
+ resourceTracker, reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT:
- {
- transform_fromhost_VkVideoDecodeH265SessionParametersCreateInfoEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
+ transform_fromhost_VkVideoDecodeH265SessionParametersCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT:
- {
- transform_fromhost_VkVideoDecodeH265PictureInfoEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH265PictureInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: {
+ transform_fromhost_VkVideoDecodeH265PictureInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoDecodeH265PictureInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT:
- {
- transform_fromhost_VkVideoDecodeH265DpbSlotInfoEXT(resourceTracker, reinterpret_cast<VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: {
+ transform_fromhost_VkVideoDecodeH265DpbSlotInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_memory_overallocation_behavior
- case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
- {
- transform_fromhost_VkDeviceMemoryOverallocationCreateInfoAMD(resourceTracker, reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
+ transform_fromhost_VkDeviceMemoryOverallocationCreateInfoAMD(
+ resourceTracker,
+ reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_vertex_attribute_divisor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
- {
- transform_fromhost_VkPipelineVertexInputDivisorStateCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: {
+ transform_fromhost_VkPipelineVertexInputDivisorStateCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_GGP_frame_token
- case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
- {
- transform_fromhost_VkPresentFrameTokenGGP(resourceTracker, reinterpret_cast<VkPresentFrameTokenGGP*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: {
+ transform_fromhost_VkPresentFrameTokenGGP(
+ resourceTracker, reinterpret_cast<VkPresentFrameTokenGGP*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_pipeline_creation_feedback
- case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT:
- {
- transform_fromhost_VkPipelineCreationFeedbackCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
+ transform_fromhost_VkPipelineCreationFeedbackCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_compute_shader_derivatives
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
- {
- transform_fromhost_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
+ transform_fromhost_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_mesh_shader
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
- {
- transform_fromhost_VkPhysicalDeviceMeshShaderFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: {
+ transform_fromhost_VkPhysicalDeviceMeshShaderFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
- {
- transform_fromhost_VkPhysicalDeviceMeshShaderPropertiesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: {
+ transform_fromhost_VkPhysicalDeviceMeshShaderPropertiesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_fragment_shader_barycentric
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV:
- {
- transform_fromhost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
+ transform_fromhost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_shader_image_footprint
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
- {
- transform_fromhost_VkPhysicalDeviceShaderImageFootprintFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
+ transform_fromhost_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_scissor_exclusive
- case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
- {
- transform_fromhost_VkPipelineViewportExclusiveScissorStateCreateInfoNV(resourceTracker, reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: {
+ transform_fromhost_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
- {
- transform_fromhost_VkPhysicalDeviceExclusiveScissorFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: {
+ transform_fromhost_VkPhysicalDeviceExclusiveScissorFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
- {
- transform_fromhost_VkQueueFamilyCheckpointPropertiesNV(resourceTracker, reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: {
+ transform_fromhost_VkQueueFamilyCheckpointPropertiesNV(
+ resourceTracker,
+ reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_INTEL_shader_integer_functions2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
- {
- transform_fromhost_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: {
+ transform_fromhost_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_INTEL_performance_query
- case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
- {
- transform_fromhost_VkQueryPoolPerformanceQueryCreateInfoINTEL(resourceTracker, reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: {
+ transform_fromhost_VkQueryPoolPerformanceQueryCreateInfoINTEL(
+ resourceTracker,
+ reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_pci_bus_info
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
- {
- transform_fromhost_VkPhysicalDevicePCIBusInfoPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDevicePCIBusInfoPropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_display_native_hdr
- case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
- {
- transform_fromhost_VkDisplayNativeHdrSurfaceCapabilitiesAMD(resourceTracker, reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: {
+ transform_fromhost_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
+ resourceTracker,
+ reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
- {
- transform_fromhost_VkSwapchainDisplayNativeHdrCreateInfoAMD(resourceTracker, reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: {
+ transform_fromhost_VkSwapchainDisplayNativeHdrCreateInfoAMD(
+ resourceTracker,
+ reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_fragment_density_map
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
- {
- transform_fromhost_VkRenderPassFragmentDensityMapCreateInfoEXT(resourceTracker, reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: {
+ transform_fromhost_VkRenderPassFragmentDensityMapCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_subgroup_size_control
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:
- {
- transform_fromhost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: {
+ transform_fromhost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_AMD_shader_core_properties2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
- {
- transform_fromhost_VkPhysicalDeviceShaderCoreProperties2AMD(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
+ transform_fromhost_VkPhysicalDeviceShaderCoreProperties2AMD(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_AMD_device_coherent_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
- {
- transform_fromhost_VkPhysicalDeviceCoherentMemoryFeaturesAMD(resourceTracker, reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: {
+ transform_fromhost_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_shader_image_atomic_int64
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_memory_budget
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceMemoryBudgetPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_memory_priority
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceMemoryPriorityFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
- {
- transform_fromhost_VkMemoryPriorityAllocateInfoEXT(resourceTracker, reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: {
+ transform_fromhost_VkMemoryPriorityAllocateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
- {
- transform_fromhost_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: {
+ transform_fromhost_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_buffer_device_address
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
- {
- transform_fromhost_VkBufferDeviceAddressCreateInfoEXT(resourceTracker, reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: {
+ transform_fromhost_VkBufferDeviceAddressCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_validation_features
- case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
- {
- transform_fromhost_VkValidationFeaturesEXT(resourceTracker, reinterpret_cast<VkValidationFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: {
+ transform_fromhost_VkValidationFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkValidationFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_cooperative_matrix
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
- {
- transform_fromhost_VkPhysicalDeviceCooperativeMatrixFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: {
+ transform_fromhost_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
- {
- transform_fromhost_VkPhysicalDeviceCooperativeMatrixPropertiesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: {
+ transform_fromhost_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_coverage_reduction_mode
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
- {
- transform_fromhost_VkPhysicalDeviceCoverageReductionModeFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: {
+ transform_fromhost_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
- {
- transform_fromhost_VkPipelineCoverageReductionStateCreateInfoNV(resourceTracker, reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: {
+ transform_fromhost_VkPipelineCoverageReductionStateCreateInfoNV(
+ resourceTracker, reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_fragment_shader_interlock
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_ycbcr_image_arrays
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_provoking_vertex
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceProvokingVertexFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceProvokingVertexFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceProvokingVertexPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceProvokingVertexPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDeviceProvokingVertexPropertiesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceProvokingVertexPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
- {
- transform_fromhost_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: {
+ transform_fromhost_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_full_screen_exclusive
- case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
- {
- transform_fromhost_VkSurfaceFullScreenExclusiveInfoEXT(resourceTracker, reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: {
+ transform_fromhost_VkSurfaceFullScreenExclusiveInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
- {
- transform_fromhost_VkSurfaceCapabilitiesFullScreenExclusiveEXT(resourceTracker, reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: {
+ transform_fromhost_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
+ resourceTracker, reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
- {
- transform_fromhost_VkSurfaceFullScreenExclusiveWin32InfoEXT(resourceTracker, reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: {
+ transform_fromhost_VkSurfaceFullScreenExclusiveWin32InfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_line_rasterization
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceLineRasterizationFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceLineRasterizationFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceLineRasterizationPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDeviceLineRasterizationPropertiesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
- {
- transform_fromhost_VkPipelineRasterizationLineStateCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: {
+ transform_fromhost_VkPipelineRasterizationLineStateCreateInfoEXT(
+ resourceTracker, reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_shader_atomic_float
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_index_type_uint8
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_extended_dynamic_state
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_shader_atomic_float2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_device_generated_commands
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
- {
- transform_fromhost_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: {
+ transform_fromhost_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
- {
- transform_fromhost_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: {
+ transform_fromhost_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
- {
- transform_fromhost_VkGraphicsPipelineShaderGroupsCreateInfoNV(resourceTracker, reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: {
+ transform_fromhost_VkGraphicsPipelineShaderGroupsCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_inherited_viewport_scissor
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
- {
- transform_fromhost_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: {
+ transform_fromhost_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
- {
- transform_fromhost_VkCommandBufferInheritanceViewportScissorInfoNV(resourceTracker, reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: {
+ transform_fromhost_VkCommandBufferInheritanceViewportScissorInfoNV(
+ resourceTracker, reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_texel_buffer_alignment
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_QCOM_render_pass_transform
- case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
- {
- transform_fromhost_VkRenderPassTransformBeginInfoQCOM(resourceTracker, reinterpret_cast<VkRenderPassTransformBeginInfoQCOM*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
+ transform_fromhost_VkRenderPassTransformBeginInfoQCOM(
+ resourceTracker,
+ reinterpret_cast<VkRenderPassTransformBeginInfoQCOM*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
- {
- transform_fromhost_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(resourceTracker, reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: {
+ transform_fromhost_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
+ resourceTracker,
+ reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_device_memory_report
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
- {
- transform_fromhost_VkDeviceDeviceMemoryReportCreateInfoEXT(resourceTracker, reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: {
+ transform_fromhost_VkDeviceDeviceMemoryReportCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_robustness2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceRobustness2FeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceRobustness2FeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceRobustness2PropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDeviceRobustness2PropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_custom_border_color
- case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
- {
- transform_fromhost_VkSamplerCustomBorderColorCreateInfoEXT(resourceTracker, reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: {
+ transform_fromhost_VkSamplerCustomBorderColorCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceCustomBorderColorPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceCustomBorderColorFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_private_data
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDevicePrivateDataFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDevicePrivateDataFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT:
- {
- transform_fromhost_VkDevicePrivateDataCreateInfoEXT(resourceTracker, reinterpret_cast<VkDevicePrivateDataCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: {
+ transform_fromhost_VkDevicePrivateDataCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkDevicePrivateDataCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_device_diagnostics_config
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
- {
- transform_fromhost_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: {
+ transform_fromhost_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
- {
- transform_fromhost_VkDeviceDiagnosticsConfigCreateInfoNV(resourceTracker, reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: {
+ transform_fromhost_VkDeviceDiagnosticsConfigCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV*>(structExtension_out));
break;
}
#endif
#ifdef VK_NV_fragment_shading_rate_enums
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
- {
- transform_fromhost_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
+ transform_fromhost_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
- {
- transform_fromhost_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: {
+ transform_fromhost_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
- {
- transform_fromhost_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(resourceTracker, reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: {
+ transform_fromhost_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_ray_tracing_motion_blur
- case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
- {
- transform_fromhost_VkAccelerationStructureGeometryMotionTrianglesDataNV(resourceTracker, reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: {
+ transform_fromhost_VkAccelerationStructureGeometryMotionTrianglesDataNV(
+ resourceTracker,
+ reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
- {
- transform_fromhost_VkAccelerationStructureMotionInfoNV(resourceTracker, reinterpret_cast<VkAccelerationStructureMotionInfoNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: {
+ transform_fromhost_VkAccelerationStructureMotionInfoNV(
+ resourceTracker,
+ reinterpret_cast<VkAccelerationStructureMotionInfoNV*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
- {
- transform_fromhost_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: {
+ transform_fromhost_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_fragment_density_map2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_QCOM_rotated_copy_commands
- case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
- {
- transform_fromhost_VkCopyCommandTransformInfoQCOM(resourceTracker, reinterpret_cast<VkCopyCommandTransformInfoQCOM*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: {
+ transform_fromhost_VkCopyCommandTransformInfoQCOM(
+ resourceTracker,
+ reinterpret_cast<VkCopyCommandTransformInfoQCOM*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_image_robustness
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceImageRobustnessFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_4444_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDevice4444FormatsFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDevice4444FormatsFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_rgba10x6_formats
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_VALVE_mutable_descriptor_type
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE:
- {
- transform_fromhost_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(resourceTracker, reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: {
+ transform_fromhost_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE:
- {
- transform_fromhost_VkMutableDescriptorTypeCreateInfoVALVE(resourceTracker, reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: {
+ transform_fromhost_VkMutableDescriptorTypeCreateInfoVALVE(
+ resourceTracker,
+ reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_physical_device_drm
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceDrmPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceDrmPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDeviceDrmPropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceDrmPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_primitive_topology_list_restart
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_FUCHSIA_external_memory
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
- {
- transform_fromhost_VkImportMemoryZirconHandleInfoFUCHSIA(resourceTracker, reinterpret_cast<VkImportMemoryZirconHandleInfoFUCHSIA*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: {
+ transform_fromhost_VkImportMemoryZirconHandleInfoFUCHSIA(
+ resourceTracker,
+ reinterpret_cast<VkImportMemoryZirconHandleInfoFUCHSIA*>(structExtension_out));
break;
}
#endif
#ifdef VK_FUCHSIA_buffer_collection
- case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
- {
- transform_fromhost_VkImportMemoryBufferCollectionFUCHSIA(resourceTracker, reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIA*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: {
+ transform_fromhost_VkImportMemoryBufferCollectionFUCHSIA(
+ resourceTracker,
+ reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIA*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
- {
- transform_fromhost_VkBufferCollectionImageCreateInfoFUCHSIA(resourceTracker, reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: {
+ transform_fromhost_VkBufferCollectionImageCreateInfoFUCHSIA(
+ resourceTracker,
+ reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
- {
- transform_fromhost_VkBufferCollectionBufferCreateInfoFUCHSIA(resourceTracker, reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: {
+ transform_fromhost_VkBufferCollectionBufferCreateInfoFUCHSIA(
+ resourceTracker,
+ reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA*>(structExtension_out));
break;
}
#endif
#ifdef VK_HUAWEI_subpass_shading
- case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
- {
- transform_fromhost_VkSubpassShadingPipelineCreateInfoHUAWEI(resourceTracker, reinterpret_cast<VkSubpassShadingPipelineCreateInfoHUAWEI*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: {
+ transform_fromhost_VkSubpassShadingPipelineCreateInfoHUAWEI(
+ resourceTracker,
+ reinterpret_cast<VkSubpassShadingPipelineCreateInfoHUAWEI*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
- {
- transform_fromhost_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(resourceTracker, reinterpret_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: {
+ transform_fromhost_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
- {
- transform_fromhost_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(resourceTracker, reinterpret_cast<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: {
+ transform_fromhost_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_HUAWEI_invocation_mask
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
- {
- transform_fromhost_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(resourceTracker, reinterpret_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: {
+ transform_fromhost_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_NV_external_memory_rdma
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
- {
- transform_fromhost_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(resourceTracker, reinterpret_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: {
+ transform_fromhost_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_extended_dynamic_state2
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_color_write_enable
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceColorWriteEnableFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
- {
- transform_fromhost_VkPipelineColorWriteCreateInfoEXT(resourceTracker, reinterpret_cast<VkPipelineColorWriteCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: {
+ transform_fromhost_VkPipelineColorWriteCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkPipelineColorWriteCreateInfoEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_GOOGLE_gfxstream
- case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE:
- {
- transform_fromhost_VkImportColorBufferGOOGLE(resourceTracker, reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
+ transform_fromhost_VkImportColorBufferGOOGLE(
+ resourceTracker, reinterpret_cast<VkImportColorBufferGOOGLE*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE:
- {
- transform_fromhost_VkImportBufferGOOGLE(resourceTracker, reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE: {
+ transform_fromhost_VkImportBufferGOOGLE(
+ resourceTracker, reinterpret_cast<VkImportBufferGOOGLE*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE:
- {
- transform_fromhost_VkImportPhysicalAddressGOOGLE(resourceTracker, reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE: {
+ transform_fromhost_VkImportPhysicalAddressGOOGLE(
+ resourceTracker,
+ reinterpret_cast<VkImportPhysicalAddressGOOGLE*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_global_priority_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT:
- {
- transform_fromhost_VkQueueFamilyGlobalPriorityPropertiesEXT(resourceTracker, reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: {
+ transform_fromhost_VkQueueFamilyGlobalPriorityPropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_multi_draw
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceMultiDrawFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceMultiDrawFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceMultiDrawFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMultiDrawFeaturesEXT*>(structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceMultiDrawPropertiesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceMultiDrawPropertiesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDeviceMultiDrawPropertiesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceMultiDrawPropertiesEXT*>(structExtension_out));
break;
}
#endif
#ifdef VK_EXT_border_color_swizzle
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
- {
- transform_fromhost_VkSamplerBorderColorComponentMappingCreateInfoEXT(resourceTracker, reinterpret_cast<VkSamplerBorderColorComponentMappingCreateInfoEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: {
+ transform_fromhost_VkSamplerBorderColorComponentMappingCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkSamplerBorderColorComponentMappingCreateInfoEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_EXT_pageable_device_local_memory
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
- {
- transform_fromhost_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(resourceTracker, reinterpret_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: {
+ transform_fromhost_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_acceleration_structure
- case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
- {
- transform_fromhost_VkWriteDescriptorSetAccelerationStructureKHR(resourceTracker, reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
+ transform_fromhost_VkWriteDescriptorSetAccelerationStructureKHR(
+ resourceTracker, reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
- {
- transform_fromhost_VkPhysicalDeviceAccelerationStructureFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: {
+ transform_fromhost_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
- {
- transform_fromhost_VkPhysicalDeviceAccelerationStructurePropertiesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: {
+ transform_fromhost_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_ray_tracing_pipeline
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
- {
- transform_fromhost_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: {
+ transform_fromhost_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(
+ structExtension_out));
break;
}
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
- {
- transform_fromhost_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: {
+ transform_fromhost_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(
+ structExtension_out));
break;
}
#endif
#ifdef VK_KHR_ray_query
- case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
- {
- transform_fromhost_VkPhysicalDeviceRayQueryFeaturesKHR(resourceTracker, reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension_out));
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: {
+ transform_fromhost_VkPhysicalDeviceRayQueryFeaturesKHR(
+ resourceTracker,
+ reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR*>(structExtension_out));
break;
}
#endif
- default:
- {
+ default: {
return;
}
}
}
-
-} // namespace goldfish_vk
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/goldfish_vk_transform_guest.h b/system/vulkan_enc/goldfish_vk_transform_guest.h
index e88bf65..2b70e3d 100644
--- a/system/vulkan_enc/goldfish_vk_transform_guest.h
+++ b/system/vulkan_enc/goldfish_vk_transform_guest.h
@@ -14,1190 +14,877 @@
// limitations under the License.
// Autogenerated module goldfish_vk_transform_guest
-// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal -o ../qemu/android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
+//
+// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
+// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
-// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR
-
+//
+// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
+// $CEREAL_OUTPUT_DIR
+//
#pragma once
-
#include <vulkan/vulkan.h>
-
-#include "vk_platform_compat.h"
-
#include "goldfish_vk_private_defs.h"
-
+#include "vk_platform_compat.h"
+#include "vulkan_gfxstream.h"
namespace goldfish_vk {
-
class ResourceTracker;
-#define LIST_TRIVIAL_TRANSFORMED_TYPES(f) \
-f(VkPhysicalDeviceExternalImageFormatInfo) \
-f(VkPhysicalDeviceExternalBufferInfo) \
-f(VkExternalMemoryImageCreateInfo) \
-f(VkExternalMemoryBufferCreateInfo) \
-f(VkExportMemoryAllocateInfo) \
-f(VkExternalImageFormatProperties) \
-f(VkExternalBufferProperties) \
+#define LIST_TRIVIAL_TRANSFORMED_TYPES(f) \
+ f(VkPhysicalDeviceExternalImageFormatInfo) \
+ f(VkPhysicalDeviceExternalBufferInfo) \
+ f(VkExternalMemoryImageCreateInfo) \
+ f(VkExternalMemoryBufferCreateInfo) \
+ f(VkExportMemoryAllocateInfo) \
+ f(VkExternalImageFormatProperties) \
+ f(VkExternalBufferProperties)
#define LIST_NON_TRIVIAL_TRANSFORMED_TYPES(f) \
-f(VkExternalMemoryProperties) \
+ f(VkExternalMemoryProperties) \
+ f(VkImageCreateInfo)
-#define LIST_TRANSFORMED_TYPES(f) \
-LIST_TRIVIAL_TRANSFORMED_TYPES(f) \
-LIST_NON_TRIVIAL_TRANSFORMED_TYPES(f) \
+#define LIST_TRANSFORMED_TYPES(f) \
+ LIST_TRIVIAL_TRANSFORMED_TYPES(f) \
+ LIST_NON_TRIVIAL_TRANSFORMED_TYPES(f)
#ifdef VK_VERSION_1_0
-void transform_tohost_VkExtent2D(
- ResourceTracker* resourceTracker,
- VkExtent2D* toTransform);
+void transform_tohost_VkExtent2D(ResourceTracker* resourceTracker, VkExtent2D* toTransform);
-void transform_fromhost_VkExtent2D(
- ResourceTracker* resourceTracker,
- VkExtent2D* toTransform);
+void transform_fromhost_VkExtent2D(ResourceTracker* resourceTracker, VkExtent2D* toTransform);
-void transform_tohost_VkExtent3D(
- ResourceTracker* resourceTracker,
- VkExtent3D* toTransform);
+void transform_tohost_VkExtent3D(ResourceTracker* resourceTracker, VkExtent3D* toTransform);
-void transform_fromhost_VkExtent3D(
- ResourceTracker* resourceTracker,
- VkExtent3D* toTransform);
+void transform_fromhost_VkExtent3D(ResourceTracker* resourceTracker, VkExtent3D* toTransform);
-void transform_tohost_VkOffset2D(
- ResourceTracker* resourceTracker,
- VkOffset2D* toTransform);
+void transform_tohost_VkOffset2D(ResourceTracker* resourceTracker, VkOffset2D* toTransform);
-void transform_fromhost_VkOffset2D(
- ResourceTracker* resourceTracker,
- VkOffset2D* toTransform);
+void transform_fromhost_VkOffset2D(ResourceTracker* resourceTracker, VkOffset2D* toTransform);
-void transform_tohost_VkOffset3D(
- ResourceTracker* resourceTracker,
- VkOffset3D* toTransform);
+void transform_tohost_VkOffset3D(ResourceTracker* resourceTracker, VkOffset3D* toTransform);
-void transform_fromhost_VkOffset3D(
- ResourceTracker* resourceTracker,
- VkOffset3D* toTransform);
+void transform_fromhost_VkOffset3D(ResourceTracker* resourceTracker, VkOffset3D* toTransform);
-void transform_tohost_VkRect2D(
- ResourceTracker* resourceTracker,
- VkRect2D* toTransform);
+void transform_tohost_VkRect2D(ResourceTracker* resourceTracker, VkRect2D* toTransform);
-void transform_fromhost_VkRect2D(
- ResourceTracker* resourceTracker,
- VkRect2D* toTransform);
+void transform_fromhost_VkRect2D(ResourceTracker* resourceTracker, VkRect2D* toTransform);
-void transform_tohost_VkBaseInStructure(
- ResourceTracker* resourceTracker,
- VkBaseInStructure* toTransform);
+void transform_tohost_VkBaseInStructure(ResourceTracker* resourceTracker,
+ VkBaseInStructure* toTransform);
-void transform_fromhost_VkBaseInStructure(
- ResourceTracker* resourceTracker,
- VkBaseInStructure* toTransform);
+void transform_fromhost_VkBaseInStructure(ResourceTracker* resourceTracker,
+ VkBaseInStructure* toTransform);
-void transform_tohost_VkBaseOutStructure(
- ResourceTracker* resourceTracker,
- VkBaseOutStructure* toTransform);
+void transform_tohost_VkBaseOutStructure(ResourceTracker* resourceTracker,
+ VkBaseOutStructure* toTransform);
-void transform_fromhost_VkBaseOutStructure(
- ResourceTracker* resourceTracker,
- VkBaseOutStructure* toTransform);
+void transform_fromhost_VkBaseOutStructure(ResourceTracker* resourceTracker,
+ VkBaseOutStructure* toTransform);
-void transform_tohost_VkBufferMemoryBarrier(
- ResourceTracker* resourceTracker,
- VkBufferMemoryBarrier* toTransform);
+void transform_tohost_VkBufferMemoryBarrier(ResourceTracker* resourceTracker,
+ VkBufferMemoryBarrier* toTransform);
-void transform_fromhost_VkBufferMemoryBarrier(
- ResourceTracker* resourceTracker,
- VkBufferMemoryBarrier* toTransform);
+void transform_fromhost_VkBufferMemoryBarrier(ResourceTracker* resourceTracker,
+ VkBufferMemoryBarrier* toTransform);
-void transform_tohost_VkDispatchIndirectCommand(
- ResourceTracker* resourceTracker,
- VkDispatchIndirectCommand* toTransform);
+void transform_tohost_VkDispatchIndirectCommand(ResourceTracker* resourceTracker,
+ VkDispatchIndirectCommand* toTransform);
-void transform_fromhost_VkDispatchIndirectCommand(
- ResourceTracker* resourceTracker,
- VkDispatchIndirectCommand* toTransform);
+void transform_fromhost_VkDispatchIndirectCommand(ResourceTracker* resourceTracker,
+ VkDispatchIndirectCommand* toTransform);
-void transform_tohost_VkDrawIndexedIndirectCommand(
- ResourceTracker* resourceTracker,
- VkDrawIndexedIndirectCommand* toTransform);
+void transform_tohost_VkDrawIndexedIndirectCommand(ResourceTracker* resourceTracker,
+ VkDrawIndexedIndirectCommand* toTransform);
-void transform_fromhost_VkDrawIndexedIndirectCommand(
- ResourceTracker* resourceTracker,
- VkDrawIndexedIndirectCommand* toTransform);
+void transform_fromhost_VkDrawIndexedIndirectCommand(ResourceTracker* resourceTracker,
+ VkDrawIndexedIndirectCommand* toTransform);
-void transform_tohost_VkDrawIndirectCommand(
- ResourceTracker* resourceTracker,
- VkDrawIndirectCommand* toTransform);
+void transform_tohost_VkDrawIndirectCommand(ResourceTracker* resourceTracker,
+ VkDrawIndirectCommand* toTransform);
-void transform_fromhost_VkDrawIndirectCommand(
- ResourceTracker* resourceTracker,
- VkDrawIndirectCommand* toTransform);
+void transform_fromhost_VkDrawIndirectCommand(ResourceTracker* resourceTracker,
+ VkDrawIndirectCommand* toTransform);
-void transform_tohost_VkImageSubresourceRange(
- ResourceTracker* resourceTracker,
- VkImageSubresourceRange* toTransform);
+void transform_tohost_VkImageSubresourceRange(ResourceTracker* resourceTracker,
+ VkImageSubresourceRange* toTransform);
-void transform_fromhost_VkImageSubresourceRange(
- ResourceTracker* resourceTracker,
- VkImageSubresourceRange* toTransform);
+void transform_fromhost_VkImageSubresourceRange(ResourceTracker* resourceTracker,
+ VkImageSubresourceRange* toTransform);
-void transform_tohost_VkImageMemoryBarrier(
- ResourceTracker* resourceTracker,
- VkImageMemoryBarrier* toTransform);
+void transform_tohost_VkImageMemoryBarrier(ResourceTracker* resourceTracker,
+ VkImageMemoryBarrier* toTransform);
-void transform_fromhost_VkImageMemoryBarrier(
- ResourceTracker* resourceTracker,
- VkImageMemoryBarrier* toTransform);
+void transform_fromhost_VkImageMemoryBarrier(ResourceTracker* resourceTracker,
+ VkImageMemoryBarrier* toTransform);
-void transform_tohost_VkMemoryBarrier(
- ResourceTracker* resourceTracker,
- VkMemoryBarrier* toTransform);
+void transform_tohost_VkMemoryBarrier(ResourceTracker* resourceTracker,
+ VkMemoryBarrier* toTransform);
-void transform_fromhost_VkMemoryBarrier(
- ResourceTracker* resourceTracker,
- VkMemoryBarrier* toTransform);
+void transform_fromhost_VkMemoryBarrier(ResourceTracker* resourceTracker,
+ VkMemoryBarrier* toTransform);
-void transform_tohost_VkPipelineCacheHeaderVersionOne(
- ResourceTracker* resourceTracker,
- VkPipelineCacheHeaderVersionOne* toTransform);
+void transform_tohost_VkPipelineCacheHeaderVersionOne(ResourceTracker* resourceTracker,
+ VkPipelineCacheHeaderVersionOne* toTransform);
void transform_fromhost_VkPipelineCacheHeaderVersionOne(
- ResourceTracker* resourceTracker,
- VkPipelineCacheHeaderVersionOne* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineCacheHeaderVersionOne* toTransform);
-void transform_tohost_VkAllocationCallbacks(
- ResourceTracker* resourceTracker,
- VkAllocationCallbacks* toTransform);
+void transform_tohost_VkAllocationCallbacks(ResourceTracker* resourceTracker,
+ VkAllocationCallbacks* toTransform);
-void transform_fromhost_VkAllocationCallbacks(
- ResourceTracker* resourceTracker,
- VkAllocationCallbacks* toTransform);
+void transform_fromhost_VkAllocationCallbacks(ResourceTracker* resourceTracker,
+ VkAllocationCallbacks* toTransform);
-void transform_tohost_VkApplicationInfo(
- ResourceTracker* resourceTracker,
- VkApplicationInfo* toTransform);
+void transform_tohost_VkApplicationInfo(ResourceTracker* resourceTracker,
+ VkApplicationInfo* toTransform);
-void transform_fromhost_VkApplicationInfo(
- ResourceTracker* resourceTracker,
- VkApplicationInfo* toTransform);
+void transform_fromhost_VkApplicationInfo(ResourceTracker* resourceTracker,
+ VkApplicationInfo* toTransform);
-void transform_tohost_VkFormatProperties(
- ResourceTracker* resourceTracker,
- VkFormatProperties* toTransform);
+void transform_tohost_VkFormatProperties(ResourceTracker* resourceTracker,
+ VkFormatProperties* toTransform);
-void transform_fromhost_VkFormatProperties(
- ResourceTracker* resourceTracker,
- VkFormatProperties* toTransform);
+void transform_fromhost_VkFormatProperties(ResourceTracker* resourceTracker,
+ VkFormatProperties* toTransform);
-void transform_tohost_VkImageFormatProperties(
- ResourceTracker* resourceTracker,
- VkImageFormatProperties* toTransform);
+void transform_tohost_VkImageFormatProperties(ResourceTracker* resourceTracker,
+ VkImageFormatProperties* toTransform);
-void transform_fromhost_VkImageFormatProperties(
- ResourceTracker* resourceTracker,
- VkImageFormatProperties* toTransform);
+void transform_fromhost_VkImageFormatProperties(ResourceTracker* resourceTracker,
+ VkImageFormatProperties* toTransform);
-void transform_tohost_VkInstanceCreateInfo(
- ResourceTracker* resourceTracker,
- VkInstanceCreateInfo* toTransform);
+void transform_tohost_VkInstanceCreateInfo(ResourceTracker* resourceTracker,
+ VkInstanceCreateInfo* toTransform);
-void transform_fromhost_VkInstanceCreateInfo(
- ResourceTracker* resourceTracker,
- VkInstanceCreateInfo* toTransform);
+void transform_fromhost_VkInstanceCreateInfo(ResourceTracker* resourceTracker,
+ VkInstanceCreateInfo* toTransform);
-void transform_tohost_VkMemoryHeap(
- ResourceTracker* resourceTracker,
- VkMemoryHeap* toTransform);
+void transform_tohost_VkMemoryHeap(ResourceTracker* resourceTracker, VkMemoryHeap* toTransform);
-void transform_fromhost_VkMemoryHeap(
- ResourceTracker* resourceTracker,
- VkMemoryHeap* toTransform);
+void transform_fromhost_VkMemoryHeap(ResourceTracker* resourceTracker, VkMemoryHeap* toTransform);
-void transform_tohost_VkMemoryType(
- ResourceTracker* resourceTracker,
- VkMemoryType* toTransform);
+void transform_tohost_VkMemoryType(ResourceTracker* resourceTracker, VkMemoryType* toTransform);
-void transform_fromhost_VkMemoryType(
- ResourceTracker* resourceTracker,
- VkMemoryType* toTransform);
+void transform_fromhost_VkMemoryType(ResourceTracker* resourceTracker, VkMemoryType* toTransform);
-void transform_tohost_VkPhysicalDeviceFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFeatures* toTransform);
+void transform_tohost_VkPhysicalDeviceFeatures(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceFeatures* toTransform);
-void transform_fromhost_VkPhysicalDeviceFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFeatures* toTransform);
+void transform_fromhost_VkPhysicalDeviceFeatures(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceFeatures* toTransform);
-void transform_tohost_VkPhysicalDeviceLimits(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceLimits* toTransform);
+void transform_tohost_VkPhysicalDeviceLimits(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceLimits* toTransform);
-void transform_fromhost_VkPhysicalDeviceLimits(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceLimits* toTransform);
+void transform_fromhost_VkPhysicalDeviceLimits(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceLimits* toTransform);
void transform_tohost_VkPhysicalDeviceMemoryProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMemoryProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMemoryProperties* toTransform);
void transform_fromhost_VkPhysicalDeviceMemoryProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMemoryProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMemoryProperties* toTransform);
void transform_tohost_VkPhysicalDeviceSparseProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSparseProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSparseProperties* toTransform);
void transform_fromhost_VkPhysicalDeviceSparseProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSparseProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSparseProperties* toTransform);
-void transform_tohost_VkPhysicalDeviceProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProperties* toTransform);
+void transform_tohost_VkPhysicalDeviceProperties(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceProperties* toTransform);
-void transform_fromhost_VkPhysicalDeviceProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProperties* toTransform);
+void transform_fromhost_VkPhysicalDeviceProperties(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceProperties* toTransform);
-void transform_tohost_VkQueueFamilyProperties(
- ResourceTracker* resourceTracker,
- VkQueueFamilyProperties* toTransform);
+void transform_tohost_VkQueueFamilyProperties(ResourceTracker* resourceTracker,
+ VkQueueFamilyProperties* toTransform);
-void transform_fromhost_VkQueueFamilyProperties(
- ResourceTracker* resourceTracker,
- VkQueueFamilyProperties* toTransform);
+void transform_fromhost_VkQueueFamilyProperties(ResourceTracker* resourceTracker,
+ VkQueueFamilyProperties* toTransform);
-void transform_tohost_VkDeviceQueueCreateInfo(
- ResourceTracker* resourceTracker,
- VkDeviceQueueCreateInfo* toTransform);
+void transform_tohost_VkDeviceQueueCreateInfo(ResourceTracker* resourceTracker,
+ VkDeviceQueueCreateInfo* toTransform);
-void transform_fromhost_VkDeviceQueueCreateInfo(
- ResourceTracker* resourceTracker,
- VkDeviceQueueCreateInfo* toTransform);
+void transform_fromhost_VkDeviceQueueCreateInfo(ResourceTracker* resourceTracker,
+ VkDeviceQueueCreateInfo* toTransform);
-void transform_tohost_VkDeviceCreateInfo(
- ResourceTracker* resourceTracker,
- VkDeviceCreateInfo* toTransform);
+void transform_tohost_VkDeviceCreateInfo(ResourceTracker* resourceTracker,
+ VkDeviceCreateInfo* toTransform);
-void transform_fromhost_VkDeviceCreateInfo(
- ResourceTracker* resourceTracker,
- VkDeviceCreateInfo* toTransform);
+void transform_fromhost_VkDeviceCreateInfo(ResourceTracker* resourceTracker,
+ VkDeviceCreateInfo* toTransform);
-void transform_tohost_VkExtensionProperties(
- ResourceTracker* resourceTracker,
- VkExtensionProperties* toTransform);
+void transform_tohost_VkExtensionProperties(ResourceTracker* resourceTracker,
+ VkExtensionProperties* toTransform);
-void transform_fromhost_VkExtensionProperties(
- ResourceTracker* resourceTracker,
- VkExtensionProperties* toTransform);
+void transform_fromhost_VkExtensionProperties(ResourceTracker* resourceTracker,
+ VkExtensionProperties* toTransform);
-void transform_tohost_VkLayerProperties(
- ResourceTracker* resourceTracker,
- VkLayerProperties* toTransform);
+void transform_tohost_VkLayerProperties(ResourceTracker* resourceTracker,
+ VkLayerProperties* toTransform);
-void transform_fromhost_VkLayerProperties(
- ResourceTracker* resourceTracker,
- VkLayerProperties* toTransform);
+void transform_fromhost_VkLayerProperties(ResourceTracker* resourceTracker,
+ VkLayerProperties* toTransform);
-void transform_tohost_VkSubmitInfo(
- ResourceTracker* resourceTracker,
- VkSubmitInfo* toTransform);
+void transform_tohost_VkSubmitInfo(ResourceTracker* resourceTracker, VkSubmitInfo* toTransform);
-void transform_fromhost_VkSubmitInfo(
- ResourceTracker* resourceTracker,
- VkSubmitInfo* toTransform);
+void transform_fromhost_VkSubmitInfo(ResourceTracker* resourceTracker, VkSubmitInfo* toTransform);
-void transform_tohost_VkMappedMemoryRange(
- ResourceTracker* resourceTracker,
- VkMappedMemoryRange* toTransform);
+void transform_tohost_VkMappedMemoryRange(ResourceTracker* resourceTracker,
+ VkMappedMemoryRange* toTransform);
-void transform_fromhost_VkMappedMemoryRange(
- ResourceTracker* resourceTracker,
- VkMappedMemoryRange* toTransform);
+void transform_fromhost_VkMappedMemoryRange(ResourceTracker* resourceTracker,
+ VkMappedMemoryRange* toTransform);
-void transform_tohost_VkMemoryAllocateInfo(
- ResourceTracker* resourceTracker,
- VkMemoryAllocateInfo* toTransform);
+void transform_tohost_VkMemoryAllocateInfo(ResourceTracker* resourceTracker,
+ VkMemoryAllocateInfo* toTransform);
-void transform_fromhost_VkMemoryAllocateInfo(
- ResourceTracker* resourceTracker,
- VkMemoryAllocateInfo* toTransform);
+void transform_fromhost_VkMemoryAllocateInfo(ResourceTracker* resourceTracker,
+ VkMemoryAllocateInfo* toTransform);
-void transform_tohost_VkMemoryRequirements(
- ResourceTracker* resourceTracker,
- VkMemoryRequirements* toTransform);
+void transform_tohost_VkMemoryRequirements(ResourceTracker* resourceTracker,
+ VkMemoryRequirements* toTransform);
-void transform_fromhost_VkMemoryRequirements(
- ResourceTracker* resourceTracker,
- VkMemoryRequirements* toTransform);
+void transform_fromhost_VkMemoryRequirements(ResourceTracker* resourceTracker,
+ VkMemoryRequirements* toTransform);
-void transform_tohost_VkSparseMemoryBind(
- ResourceTracker* resourceTracker,
- VkSparseMemoryBind* toTransform);
+void transform_tohost_VkSparseMemoryBind(ResourceTracker* resourceTracker,
+ VkSparseMemoryBind* toTransform);
-void transform_fromhost_VkSparseMemoryBind(
- ResourceTracker* resourceTracker,
- VkSparseMemoryBind* toTransform);
+void transform_fromhost_VkSparseMemoryBind(ResourceTracker* resourceTracker,
+ VkSparseMemoryBind* toTransform);
-void transform_tohost_VkSparseBufferMemoryBindInfo(
- ResourceTracker* resourceTracker,
- VkSparseBufferMemoryBindInfo* toTransform);
+void transform_tohost_VkSparseBufferMemoryBindInfo(ResourceTracker* resourceTracker,
+ VkSparseBufferMemoryBindInfo* toTransform);
-void transform_fromhost_VkSparseBufferMemoryBindInfo(
- ResourceTracker* resourceTracker,
- VkSparseBufferMemoryBindInfo* toTransform);
+void transform_fromhost_VkSparseBufferMemoryBindInfo(ResourceTracker* resourceTracker,
+ VkSparseBufferMemoryBindInfo* toTransform);
void transform_tohost_VkSparseImageOpaqueMemoryBindInfo(
- ResourceTracker* resourceTracker,
- VkSparseImageOpaqueMemoryBindInfo* toTransform);
+ ResourceTracker* resourceTracker, VkSparseImageOpaqueMemoryBindInfo* toTransform);
void transform_fromhost_VkSparseImageOpaqueMemoryBindInfo(
- ResourceTracker* resourceTracker,
- VkSparseImageOpaqueMemoryBindInfo* toTransform);
+ ResourceTracker* resourceTracker, VkSparseImageOpaqueMemoryBindInfo* toTransform);
-void transform_tohost_VkImageSubresource(
- ResourceTracker* resourceTracker,
- VkImageSubresource* toTransform);
+void transform_tohost_VkImageSubresource(ResourceTracker* resourceTracker,
+ VkImageSubresource* toTransform);
-void transform_fromhost_VkImageSubresource(
- ResourceTracker* resourceTracker,
- VkImageSubresource* toTransform);
+void transform_fromhost_VkImageSubresource(ResourceTracker* resourceTracker,
+ VkImageSubresource* toTransform);
-void transform_tohost_VkSparseImageMemoryBind(
- ResourceTracker* resourceTracker,
- VkSparseImageMemoryBind* toTransform);
+void transform_tohost_VkSparseImageMemoryBind(ResourceTracker* resourceTracker,
+ VkSparseImageMemoryBind* toTransform);
-void transform_fromhost_VkSparseImageMemoryBind(
- ResourceTracker* resourceTracker,
- VkSparseImageMemoryBind* toTransform);
+void transform_fromhost_VkSparseImageMemoryBind(ResourceTracker* resourceTracker,
+ VkSparseImageMemoryBind* toTransform);
-void transform_tohost_VkSparseImageMemoryBindInfo(
- ResourceTracker* resourceTracker,
- VkSparseImageMemoryBindInfo* toTransform);
+void transform_tohost_VkSparseImageMemoryBindInfo(ResourceTracker* resourceTracker,
+ VkSparseImageMemoryBindInfo* toTransform);
-void transform_fromhost_VkSparseImageMemoryBindInfo(
- ResourceTracker* resourceTracker,
- VkSparseImageMemoryBindInfo* toTransform);
+void transform_fromhost_VkSparseImageMemoryBindInfo(ResourceTracker* resourceTracker,
+ VkSparseImageMemoryBindInfo* toTransform);
-void transform_tohost_VkBindSparseInfo(
- ResourceTracker* resourceTracker,
- VkBindSparseInfo* toTransform);
+void transform_tohost_VkBindSparseInfo(ResourceTracker* resourceTracker,
+ VkBindSparseInfo* toTransform);
-void transform_fromhost_VkBindSparseInfo(
- ResourceTracker* resourceTracker,
- VkBindSparseInfo* toTransform);
+void transform_fromhost_VkBindSparseInfo(ResourceTracker* resourceTracker,
+ VkBindSparseInfo* toTransform);
-void transform_tohost_VkSparseImageFormatProperties(
- ResourceTracker* resourceTracker,
- VkSparseImageFormatProperties* toTransform);
+void transform_tohost_VkSparseImageFormatProperties(ResourceTracker* resourceTracker,
+ VkSparseImageFormatProperties* toTransform);
-void transform_fromhost_VkSparseImageFormatProperties(
- ResourceTracker* resourceTracker,
- VkSparseImageFormatProperties* toTransform);
+void transform_fromhost_VkSparseImageFormatProperties(ResourceTracker* resourceTracker,
+ VkSparseImageFormatProperties* toTransform);
-void transform_tohost_VkSparseImageMemoryRequirements(
- ResourceTracker* resourceTracker,
- VkSparseImageMemoryRequirements* toTransform);
+void transform_tohost_VkSparseImageMemoryRequirements(ResourceTracker* resourceTracker,
+ VkSparseImageMemoryRequirements* toTransform);
void transform_fromhost_VkSparseImageMemoryRequirements(
- ResourceTracker* resourceTracker,
- VkSparseImageMemoryRequirements* toTransform);
+ ResourceTracker* resourceTracker, VkSparseImageMemoryRequirements* toTransform);
-void transform_tohost_VkFenceCreateInfo(
- ResourceTracker* resourceTracker,
- VkFenceCreateInfo* toTransform);
+void transform_tohost_VkFenceCreateInfo(ResourceTracker* resourceTracker,
+ VkFenceCreateInfo* toTransform);
-void transform_fromhost_VkFenceCreateInfo(
- ResourceTracker* resourceTracker,
- VkFenceCreateInfo* toTransform);
+void transform_fromhost_VkFenceCreateInfo(ResourceTracker* resourceTracker,
+ VkFenceCreateInfo* toTransform);
-void transform_tohost_VkSemaphoreCreateInfo(
- ResourceTracker* resourceTracker,
- VkSemaphoreCreateInfo* toTransform);
+void transform_tohost_VkSemaphoreCreateInfo(ResourceTracker* resourceTracker,
+ VkSemaphoreCreateInfo* toTransform);
-void transform_fromhost_VkSemaphoreCreateInfo(
- ResourceTracker* resourceTracker,
- VkSemaphoreCreateInfo* toTransform);
+void transform_fromhost_VkSemaphoreCreateInfo(ResourceTracker* resourceTracker,
+ VkSemaphoreCreateInfo* toTransform);
-void transform_tohost_VkEventCreateInfo(
- ResourceTracker* resourceTracker,
- VkEventCreateInfo* toTransform);
+void transform_tohost_VkEventCreateInfo(ResourceTracker* resourceTracker,
+ VkEventCreateInfo* toTransform);
-void transform_fromhost_VkEventCreateInfo(
- ResourceTracker* resourceTracker,
- VkEventCreateInfo* toTransform);
+void transform_fromhost_VkEventCreateInfo(ResourceTracker* resourceTracker,
+ VkEventCreateInfo* toTransform);
-void transform_tohost_VkQueryPoolCreateInfo(
- ResourceTracker* resourceTracker,
- VkQueryPoolCreateInfo* toTransform);
+void transform_tohost_VkQueryPoolCreateInfo(ResourceTracker* resourceTracker,
+ VkQueryPoolCreateInfo* toTransform);
-void transform_fromhost_VkQueryPoolCreateInfo(
- ResourceTracker* resourceTracker,
- VkQueryPoolCreateInfo* toTransform);
+void transform_fromhost_VkQueryPoolCreateInfo(ResourceTracker* resourceTracker,
+ VkQueryPoolCreateInfo* toTransform);
-void transform_tohost_VkBufferCreateInfo(
- ResourceTracker* resourceTracker,
- VkBufferCreateInfo* toTransform);
+void transform_tohost_VkBufferCreateInfo(ResourceTracker* resourceTracker,
+ VkBufferCreateInfo* toTransform);
-void transform_fromhost_VkBufferCreateInfo(
- ResourceTracker* resourceTracker,
- VkBufferCreateInfo* toTransform);
+void transform_fromhost_VkBufferCreateInfo(ResourceTracker* resourceTracker,
+ VkBufferCreateInfo* toTransform);
-void transform_tohost_VkBufferViewCreateInfo(
- ResourceTracker* resourceTracker,
- VkBufferViewCreateInfo* toTransform);
+void transform_tohost_VkBufferViewCreateInfo(ResourceTracker* resourceTracker,
+ VkBufferViewCreateInfo* toTransform);
-void transform_fromhost_VkBufferViewCreateInfo(
- ResourceTracker* resourceTracker,
- VkBufferViewCreateInfo* toTransform);
+void transform_fromhost_VkBufferViewCreateInfo(ResourceTracker* resourceTracker,
+ VkBufferViewCreateInfo* toTransform);
-void transform_tohost_VkImageCreateInfo(
- ResourceTracker* resourceTracker,
- VkImageCreateInfo* toTransform);
+void transform_tohost_VkImageCreateInfo(ResourceTracker* resourceTracker,
+ VkImageCreateInfo* toTransform);
-void transform_fromhost_VkImageCreateInfo(
- ResourceTracker* resourceTracker,
- VkImageCreateInfo* toTransform);
+void transform_fromhost_VkImageCreateInfo(ResourceTracker* resourceTracker,
+ VkImageCreateInfo* toTransform);
-void transform_tohost_VkSubresourceLayout(
- ResourceTracker* resourceTracker,
- VkSubresourceLayout* toTransform);
+void transform_tohost_VkSubresourceLayout(ResourceTracker* resourceTracker,
+ VkSubresourceLayout* toTransform);
-void transform_fromhost_VkSubresourceLayout(
- ResourceTracker* resourceTracker,
- VkSubresourceLayout* toTransform);
+void transform_fromhost_VkSubresourceLayout(ResourceTracker* resourceTracker,
+ VkSubresourceLayout* toTransform);
-void transform_tohost_VkComponentMapping(
- ResourceTracker* resourceTracker,
- VkComponentMapping* toTransform);
+void transform_tohost_VkComponentMapping(ResourceTracker* resourceTracker,
+ VkComponentMapping* toTransform);
-void transform_fromhost_VkComponentMapping(
- ResourceTracker* resourceTracker,
- VkComponentMapping* toTransform);
+void transform_fromhost_VkComponentMapping(ResourceTracker* resourceTracker,
+ VkComponentMapping* toTransform);
-void transform_tohost_VkImageViewCreateInfo(
- ResourceTracker* resourceTracker,
- VkImageViewCreateInfo* toTransform);
+void transform_tohost_VkImageViewCreateInfo(ResourceTracker* resourceTracker,
+ VkImageViewCreateInfo* toTransform);
-void transform_fromhost_VkImageViewCreateInfo(
- ResourceTracker* resourceTracker,
- VkImageViewCreateInfo* toTransform);
+void transform_fromhost_VkImageViewCreateInfo(ResourceTracker* resourceTracker,
+ VkImageViewCreateInfo* toTransform);
-void transform_tohost_VkShaderModuleCreateInfo(
- ResourceTracker* resourceTracker,
- VkShaderModuleCreateInfo* toTransform);
+void transform_tohost_VkShaderModuleCreateInfo(ResourceTracker* resourceTracker,
+ VkShaderModuleCreateInfo* toTransform);
-void transform_fromhost_VkShaderModuleCreateInfo(
- ResourceTracker* resourceTracker,
- VkShaderModuleCreateInfo* toTransform);
+void transform_fromhost_VkShaderModuleCreateInfo(ResourceTracker* resourceTracker,
+ VkShaderModuleCreateInfo* toTransform);
-void transform_tohost_VkPipelineCacheCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineCacheCreateInfo* toTransform);
+void transform_tohost_VkPipelineCacheCreateInfo(ResourceTracker* resourceTracker,
+ VkPipelineCacheCreateInfo* toTransform);
-void transform_fromhost_VkPipelineCacheCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineCacheCreateInfo* toTransform);
+void transform_fromhost_VkPipelineCacheCreateInfo(ResourceTracker* resourceTracker,
+ VkPipelineCacheCreateInfo* toTransform);
-void transform_tohost_VkSpecializationMapEntry(
- ResourceTracker* resourceTracker,
- VkSpecializationMapEntry* toTransform);
+void transform_tohost_VkSpecializationMapEntry(ResourceTracker* resourceTracker,
+ VkSpecializationMapEntry* toTransform);
-void transform_fromhost_VkSpecializationMapEntry(
- ResourceTracker* resourceTracker,
- VkSpecializationMapEntry* toTransform);
+void transform_fromhost_VkSpecializationMapEntry(ResourceTracker* resourceTracker,
+ VkSpecializationMapEntry* toTransform);
-void transform_tohost_VkSpecializationInfo(
- ResourceTracker* resourceTracker,
- VkSpecializationInfo* toTransform);
+void transform_tohost_VkSpecializationInfo(ResourceTracker* resourceTracker,
+ VkSpecializationInfo* toTransform);
-void transform_fromhost_VkSpecializationInfo(
- ResourceTracker* resourceTracker,
- VkSpecializationInfo* toTransform);
+void transform_fromhost_VkSpecializationInfo(ResourceTracker* resourceTracker,
+ VkSpecializationInfo* toTransform);
-void transform_tohost_VkPipelineShaderStageCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineShaderStageCreateInfo* toTransform);
+void transform_tohost_VkPipelineShaderStageCreateInfo(ResourceTracker* resourceTracker,
+ VkPipelineShaderStageCreateInfo* toTransform);
void transform_fromhost_VkPipelineShaderStageCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineShaderStageCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineShaderStageCreateInfo* toTransform);
-void transform_tohost_VkComputePipelineCreateInfo(
- ResourceTracker* resourceTracker,
- VkComputePipelineCreateInfo* toTransform);
+void transform_tohost_VkComputePipelineCreateInfo(ResourceTracker* resourceTracker,
+ VkComputePipelineCreateInfo* toTransform);
-void transform_fromhost_VkComputePipelineCreateInfo(
- ResourceTracker* resourceTracker,
- VkComputePipelineCreateInfo* toTransform);
+void transform_fromhost_VkComputePipelineCreateInfo(ResourceTracker* resourceTracker,
+ VkComputePipelineCreateInfo* toTransform);
-void transform_tohost_VkVertexInputBindingDescription(
- ResourceTracker* resourceTracker,
- VkVertexInputBindingDescription* toTransform);
+void transform_tohost_VkVertexInputBindingDescription(ResourceTracker* resourceTracker,
+ VkVertexInputBindingDescription* toTransform);
void transform_fromhost_VkVertexInputBindingDescription(
- ResourceTracker* resourceTracker,
- VkVertexInputBindingDescription* toTransform);
+ ResourceTracker* resourceTracker, VkVertexInputBindingDescription* toTransform);
void transform_tohost_VkVertexInputAttributeDescription(
- ResourceTracker* resourceTracker,
- VkVertexInputAttributeDescription* toTransform);
+ ResourceTracker* resourceTracker, VkVertexInputAttributeDescription* toTransform);
void transform_fromhost_VkVertexInputAttributeDescription(
- ResourceTracker* resourceTracker,
- VkVertexInputAttributeDescription* toTransform);
+ ResourceTracker* resourceTracker, VkVertexInputAttributeDescription* toTransform);
void transform_tohost_VkPipelineVertexInputStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineVertexInputStateCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineVertexInputStateCreateInfo* toTransform);
void transform_fromhost_VkPipelineVertexInputStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineVertexInputStateCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineVertexInputStateCreateInfo* toTransform);
void transform_tohost_VkPipelineInputAssemblyStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineInputAssemblyStateCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineInputAssemblyStateCreateInfo* toTransform);
void transform_fromhost_VkPipelineInputAssemblyStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineInputAssemblyStateCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineInputAssemblyStateCreateInfo* toTransform);
void transform_tohost_VkPipelineTessellationStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineTessellationStateCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineTessellationStateCreateInfo* toTransform);
void transform_fromhost_VkPipelineTessellationStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineTessellationStateCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineTessellationStateCreateInfo* toTransform);
-void transform_tohost_VkViewport(
- ResourceTracker* resourceTracker,
- VkViewport* toTransform);
+void transform_tohost_VkViewport(ResourceTracker* resourceTracker, VkViewport* toTransform);
-void transform_fromhost_VkViewport(
- ResourceTracker* resourceTracker,
- VkViewport* toTransform);
+void transform_fromhost_VkViewport(ResourceTracker* resourceTracker, VkViewport* toTransform);
void transform_tohost_VkPipelineViewportStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineViewportStateCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineViewportStateCreateInfo* toTransform);
void transform_fromhost_VkPipelineViewportStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineViewportStateCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineViewportStateCreateInfo* toTransform);
void transform_tohost_VkPipelineRasterizationStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineRasterizationStateCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineRasterizationStateCreateInfo* toTransform);
void transform_fromhost_VkPipelineRasterizationStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineRasterizationStateCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineRasterizationStateCreateInfo* toTransform);
void transform_tohost_VkPipelineMultisampleStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineMultisampleStateCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineMultisampleStateCreateInfo* toTransform);
void transform_fromhost_VkPipelineMultisampleStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineMultisampleStateCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineMultisampleStateCreateInfo* toTransform);
-void transform_tohost_VkStencilOpState(
- ResourceTracker* resourceTracker,
- VkStencilOpState* toTransform);
+void transform_tohost_VkStencilOpState(ResourceTracker* resourceTracker,
+ VkStencilOpState* toTransform);
-void transform_fromhost_VkStencilOpState(
- ResourceTracker* resourceTracker,
- VkStencilOpState* toTransform);
+void transform_fromhost_VkStencilOpState(ResourceTracker* resourceTracker,
+ VkStencilOpState* toTransform);
void transform_tohost_VkPipelineDepthStencilStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineDepthStencilStateCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineDepthStencilStateCreateInfo* toTransform);
void transform_fromhost_VkPipelineDepthStencilStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineDepthStencilStateCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineDepthStencilStateCreateInfo* toTransform);
void transform_tohost_VkPipelineColorBlendAttachmentState(
- ResourceTracker* resourceTracker,
- VkPipelineColorBlendAttachmentState* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineColorBlendAttachmentState* toTransform);
void transform_fromhost_VkPipelineColorBlendAttachmentState(
- ResourceTracker* resourceTracker,
- VkPipelineColorBlendAttachmentState* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineColorBlendAttachmentState* toTransform);
void transform_tohost_VkPipelineColorBlendStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineColorBlendStateCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineColorBlendStateCreateInfo* toTransform);
void transform_fromhost_VkPipelineColorBlendStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineColorBlendStateCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineColorBlendStateCreateInfo* toTransform);
void transform_tohost_VkPipelineDynamicStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineDynamicStateCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineDynamicStateCreateInfo* toTransform);
void transform_fromhost_VkPipelineDynamicStateCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineDynamicStateCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineDynamicStateCreateInfo* toTransform);
-void transform_tohost_VkGraphicsPipelineCreateInfo(
- ResourceTracker* resourceTracker,
- VkGraphicsPipelineCreateInfo* toTransform);
+void transform_tohost_VkGraphicsPipelineCreateInfo(ResourceTracker* resourceTracker,
+ VkGraphicsPipelineCreateInfo* toTransform);
-void transform_fromhost_VkGraphicsPipelineCreateInfo(
- ResourceTracker* resourceTracker,
- VkGraphicsPipelineCreateInfo* toTransform);
+void transform_fromhost_VkGraphicsPipelineCreateInfo(ResourceTracker* resourceTracker,
+ VkGraphicsPipelineCreateInfo* toTransform);
-void transform_tohost_VkPushConstantRange(
- ResourceTracker* resourceTracker,
- VkPushConstantRange* toTransform);
+void transform_tohost_VkPushConstantRange(ResourceTracker* resourceTracker,
+ VkPushConstantRange* toTransform);
-void transform_fromhost_VkPushConstantRange(
- ResourceTracker* resourceTracker,
- VkPushConstantRange* toTransform);
+void transform_fromhost_VkPushConstantRange(ResourceTracker* resourceTracker,
+ VkPushConstantRange* toTransform);
-void transform_tohost_VkPipelineLayoutCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineLayoutCreateInfo* toTransform);
+void transform_tohost_VkPipelineLayoutCreateInfo(ResourceTracker* resourceTracker,
+ VkPipelineLayoutCreateInfo* toTransform);
-void transform_fromhost_VkPipelineLayoutCreateInfo(
- ResourceTracker* resourceTracker,
- VkPipelineLayoutCreateInfo* toTransform);
+void transform_fromhost_VkPipelineLayoutCreateInfo(ResourceTracker* resourceTracker,
+ VkPipelineLayoutCreateInfo* toTransform);
-void transform_tohost_VkSamplerCreateInfo(
- ResourceTracker* resourceTracker,
- VkSamplerCreateInfo* toTransform);
+void transform_tohost_VkSamplerCreateInfo(ResourceTracker* resourceTracker,
+ VkSamplerCreateInfo* toTransform);
-void transform_fromhost_VkSamplerCreateInfo(
- ResourceTracker* resourceTracker,
- VkSamplerCreateInfo* toTransform);
+void transform_fromhost_VkSamplerCreateInfo(ResourceTracker* resourceTracker,
+ VkSamplerCreateInfo* toTransform);
-void transform_tohost_VkCopyDescriptorSet(
- ResourceTracker* resourceTracker,
- VkCopyDescriptorSet* toTransform);
+void transform_tohost_VkCopyDescriptorSet(ResourceTracker* resourceTracker,
+ VkCopyDescriptorSet* toTransform);
-void transform_fromhost_VkCopyDescriptorSet(
- ResourceTracker* resourceTracker,
- VkCopyDescriptorSet* toTransform);
+void transform_fromhost_VkCopyDescriptorSet(ResourceTracker* resourceTracker,
+ VkCopyDescriptorSet* toTransform);
-void transform_tohost_VkDescriptorBufferInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorBufferInfo* toTransform);
+void transform_tohost_VkDescriptorBufferInfo(ResourceTracker* resourceTracker,
+ VkDescriptorBufferInfo* toTransform);
-void transform_fromhost_VkDescriptorBufferInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorBufferInfo* toTransform);
+void transform_fromhost_VkDescriptorBufferInfo(ResourceTracker* resourceTracker,
+ VkDescriptorBufferInfo* toTransform);
-void transform_tohost_VkDescriptorImageInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorImageInfo* toTransform);
+void transform_tohost_VkDescriptorImageInfo(ResourceTracker* resourceTracker,
+ VkDescriptorImageInfo* toTransform);
-void transform_fromhost_VkDescriptorImageInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorImageInfo* toTransform);
+void transform_fromhost_VkDescriptorImageInfo(ResourceTracker* resourceTracker,
+ VkDescriptorImageInfo* toTransform);
-void transform_tohost_VkDescriptorPoolSize(
- ResourceTracker* resourceTracker,
- VkDescriptorPoolSize* toTransform);
+void transform_tohost_VkDescriptorPoolSize(ResourceTracker* resourceTracker,
+ VkDescriptorPoolSize* toTransform);
-void transform_fromhost_VkDescriptorPoolSize(
- ResourceTracker* resourceTracker,
- VkDescriptorPoolSize* toTransform);
+void transform_fromhost_VkDescriptorPoolSize(ResourceTracker* resourceTracker,
+ VkDescriptorPoolSize* toTransform);
-void transform_tohost_VkDescriptorPoolCreateInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorPoolCreateInfo* toTransform);
+void transform_tohost_VkDescriptorPoolCreateInfo(ResourceTracker* resourceTracker,
+ VkDescriptorPoolCreateInfo* toTransform);
-void transform_fromhost_VkDescriptorPoolCreateInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorPoolCreateInfo* toTransform);
+void transform_fromhost_VkDescriptorPoolCreateInfo(ResourceTracker* resourceTracker,
+ VkDescriptorPoolCreateInfo* toTransform);
-void transform_tohost_VkDescriptorSetAllocateInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorSetAllocateInfo* toTransform);
+void transform_tohost_VkDescriptorSetAllocateInfo(ResourceTracker* resourceTracker,
+ VkDescriptorSetAllocateInfo* toTransform);
-void transform_fromhost_VkDescriptorSetAllocateInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorSetAllocateInfo* toTransform);
+void transform_fromhost_VkDescriptorSetAllocateInfo(ResourceTracker* resourceTracker,
+ VkDescriptorSetAllocateInfo* toTransform);
-void transform_tohost_VkDescriptorSetLayoutBinding(
- ResourceTracker* resourceTracker,
- VkDescriptorSetLayoutBinding* toTransform);
+void transform_tohost_VkDescriptorSetLayoutBinding(ResourceTracker* resourceTracker,
+ VkDescriptorSetLayoutBinding* toTransform);
-void transform_fromhost_VkDescriptorSetLayoutBinding(
- ResourceTracker* resourceTracker,
- VkDescriptorSetLayoutBinding* toTransform);
+void transform_fromhost_VkDescriptorSetLayoutBinding(ResourceTracker* resourceTracker,
+ VkDescriptorSetLayoutBinding* toTransform);
-void transform_tohost_VkDescriptorSetLayoutCreateInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorSetLayoutCreateInfo* toTransform);
+void transform_tohost_VkDescriptorSetLayoutCreateInfo(ResourceTracker* resourceTracker,
+ VkDescriptorSetLayoutCreateInfo* toTransform);
void transform_fromhost_VkDescriptorSetLayoutCreateInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorSetLayoutCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkDescriptorSetLayoutCreateInfo* toTransform);
-void transform_tohost_VkWriteDescriptorSet(
- ResourceTracker* resourceTracker,
- VkWriteDescriptorSet* toTransform);
+void transform_tohost_VkWriteDescriptorSet(ResourceTracker* resourceTracker,
+ VkWriteDescriptorSet* toTransform);
-void transform_fromhost_VkWriteDescriptorSet(
- ResourceTracker* resourceTracker,
- VkWriteDescriptorSet* toTransform);
+void transform_fromhost_VkWriteDescriptorSet(ResourceTracker* resourceTracker,
+ VkWriteDescriptorSet* toTransform);
-void transform_tohost_VkAttachmentDescription(
- ResourceTracker* resourceTracker,
- VkAttachmentDescription* toTransform);
+void transform_tohost_VkAttachmentDescription(ResourceTracker* resourceTracker,
+ VkAttachmentDescription* toTransform);
-void transform_fromhost_VkAttachmentDescription(
- ResourceTracker* resourceTracker,
- VkAttachmentDescription* toTransform);
+void transform_fromhost_VkAttachmentDescription(ResourceTracker* resourceTracker,
+ VkAttachmentDescription* toTransform);
-void transform_tohost_VkAttachmentReference(
- ResourceTracker* resourceTracker,
- VkAttachmentReference* toTransform);
+void transform_tohost_VkAttachmentReference(ResourceTracker* resourceTracker,
+ VkAttachmentReference* toTransform);
-void transform_fromhost_VkAttachmentReference(
- ResourceTracker* resourceTracker,
- VkAttachmentReference* toTransform);
+void transform_fromhost_VkAttachmentReference(ResourceTracker* resourceTracker,
+ VkAttachmentReference* toTransform);
-void transform_tohost_VkFramebufferCreateInfo(
- ResourceTracker* resourceTracker,
- VkFramebufferCreateInfo* toTransform);
+void transform_tohost_VkFramebufferCreateInfo(ResourceTracker* resourceTracker,
+ VkFramebufferCreateInfo* toTransform);
-void transform_fromhost_VkFramebufferCreateInfo(
- ResourceTracker* resourceTracker,
- VkFramebufferCreateInfo* toTransform);
+void transform_fromhost_VkFramebufferCreateInfo(ResourceTracker* resourceTracker,
+ VkFramebufferCreateInfo* toTransform);
-void transform_tohost_VkSubpassDescription(
- ResourceTracker* resourceTracker,
- VkSubpassDescription* toTransform);
+void transform_tohost_VkSubpassDescription(ResourceTracker* resourceTracker,
+ VkSubpassDescription* toTransform);
-void transform_fromhost_VkSubpassDescription(
- ResourceTracker* resourceTracker,
- VkSubpassDescription* toTransform);
+void transform_fromhost_VkSubpassDescription(ResourceTracker* resourceTracker,
+ VkSubpassDescription* toTransform);
-void transform_tohost_VkSubpassDependency(
- ResourceTracker* resourceTracker,
- VkSubpassDependency* toTransform);
+void transform_tohost_VkSubpassDependency(ResourceTracker* resourceTracker,
+ VkSubpassDependency* toTransform);
-void transform_fromhost_VkSubpassDependency(
- ResourceTracker* resourceTracker,
- VkSubpassDependency* toTransform);
+void transform_fromhost_VkSubpassDependency(ResourceTracker* resourceTracker,
+ VkSubpassDependency* toTransform);
-void transform_tohost_VkRenderPassCreateInfo(
- ResourceTracker* resourceTracker,
- VkRenderPassCreateInfo* toTransform);
+void transform_tohost_VkRenderPassCreateInfo(ResourceTracker* resourceTracker,
+ VkRenderPassCreateInfo* toTransform);
-void transform_fromhost_VkRenderPassCreateInfo(
- ResourceTracker* resourceTracker,
- VkRenderPassCreateInfo* toTransform);
+void transform_fromhost_VkRenderPassCreateInfo(ResourceTracker* resourceTracker,
+ VkRenderPassCreateInfo* toTransform);
-void transform_tohost_VkCommandPoolCreateInfo(
- ResourceTracker* resourceTracker,
- VkCommandPoolCreateInfo* toTransform);
+void transform_tohost_VkCommandPoolCreateInfo(ResourceTracker* resourceTracker,
+ VkCommandPoolCreateInfo* toTransform);
-void transform_fromhost_VkCommandPoolCreateInfo(
- ResourceTracker* resourceTracker,
- VkCommandPoolCreateInfo* toTransform);
+void transform_fromhost_VkCommandPoolCreateInfo(ResourceTracker* resourceTracker,
+ VkCommandPoolCreateInfo* toTransform);
-void transform_tohost_VkCommandBufferAllocateInfo(
- ResourceTracker* resourceTracker,
- VkCommandBufferAllocateInfo* toTransform);
+void transform_tohost_VkCommandBufferAllocateInfo(ResourceTracker* resourceTracker,
+ VkCommandBufferAllocateInfo* toTransform);
-void transform_fromhost_VkCommandBufferAllocateInfo(
- ResourceTracker* resourceTracker,
- VkCommandBufferAllocateInfo* toTransform);
+void transform_fromhost_VkCommandBufferAllocateInfo(ResourceTracker* resourceTracker,
+ VkCommandBufferAllocateInfo* toTransform);
-void transform_tohost_VkCommandBufferInheritanceInfo(
- ResourceTracker* resourceTracker,
- VkCommandBufferInheritanceInfo* toTransform);
+void transform_tohost_VkCommandBufferInheritanceInfo(ResourceTracker* resourceTracker,
+ VkCommandBufferInheritanceInfo* toTransform);
-void transform_fromhost_VkCommandBufferInheritanceInfo(
- ResourceTracker* resourceTracker,
- VkCommandBufferInheritanceInfo* toTransform);
+void transform_fromhost_VkCommandBufferInheritanceInfo(ResourceTracker* resourceTracker,
+ VkCommandBufferInheritanceInfo* toTransform);
-void transform_tohost_VkCommandBufferBeginInfo(
- ResourceTracker* resourceTracker,
- VkCommandBufferBeginInfo* toTransform);
+void transform_tohost_VkCommandBufferBeginInfo(ResourceTracker* resourceTracker,
+ VkCommandBufferBeginInfo* toTransform);
-void transform_fromhost_VkCommandBufferBeginInfo(
- ResourceTracker* resourceTracker,
- VkCommandBufferBeginInfo* toTransform);
+void transform_fromhost_VkCommandBufferBeginInfo(ResourceTracker* resourceTracker,
+ VkCommandBufferBeginInfo* toTransform);
-void transform_tohost_VkBufferCopy(
- ResourceTracker* resourceTracker,
- VkBufferCopy* toTransform);
+void transform_tohost_VkBufferCopy(ResourceTracker* resourceTracker, VkBufferCopy* toTransform);
-void transform_fromhost_VkBufferCopy(
- ResourceTracker* resourceTracker,
- VkBufferCopy* toTransform);
+void transform_fromhost_VkBufferCopy(ResourceTracker* resourceTracker, VkBufferCopy* toTransform);
-void transform_tohost_VkImageSubresourceLayers(
- ResourceTracker* resourceTracker,
- VkImageSubresourceLayers* toTransform);
+void transform_tohost_VkImageSubresourceLayers(ResourceTracker* resourceTracker,
+ VkImageSubresourceLayers* toTransform);
-void transform_fromhost_VkImageSubresourceLayers(
- ResourceTracker* resourceTracker,
- VkImageSubresourceLayers* toTransform);
+void transform_fromhost_VkImageSubresourceLayers(ResourceTracker* resourceTracker,
+ VkImageSubresourceLayers* toTransform);
-void transform_tohost_VkBufferImageCopy(
- ResourceTracker* resourceTracker,
- VkBufferImageCopy* toTransform);
+void transform_tohost_VkBufferImageCopy(ResourceTracker* resourceTracker,
+ VkBufferImageCopy* toTransform);
-void transform_fromhost_VkBufferImageCopy(
- ResourceTracker* resourceTracker,
- VkBufferImageCopy* toTransform);
+void transform_fromhost_VkBufferImageCopy(ResourceTracker* resourceTracker,
+ VkBufferImageCopy* toTransform);
-void transform_tohost_VkClearColorValue(
- ResourceTracker* resourceTracker,
- VkClearColorValue* toTransform);
+void transform_tohost_VkClearColorValue(ResourceTracker* resourceTracker,
+ VkClearColorValue* toTransform);
-void transform_fromhost_VkClearColorValue(
- ResourceTracker* resourceTracker,
- VkClearColorValue* toTransform);
+void transform_fromhost_VkClearColorValue(ResourceTracker* resourceTracker,
+ VkClearColorValue* toTransform);
-void transform_tohost_VkClearDepthStencilValue(
- ResourceTracker* resourceTracker,
- VkClearDepthStencilValue* toTransform);
+void transform_tohost_VkClearDepthStencilValue(ResourceTracker* resourceTracker,
+ VkClearDepthStencilValue* toTransform);
-void transform_fromhost_VkClearDepthStencilValue(
- ResourceTracker* resourceTracker,
- VkClearDepthStencilValue* toTransform);
+void transform_fromhost_VkClearDepthStencilValue(ResourceTracker* resourceTracker,
+ VkClearDepthStencilValue* toTransform);
-void transform_tohost_VkClearValue(
- ResourceTracker* resourceTracker,
- VkClearValue* toTransform);
+void transform_tohost_VkClearValue(ResourceTracker* resourceTracker, VkClearValue* toTransform);
-void transform_fromhost_VkClearValue(
- ResourceTracker* resourceTracker,
- VkClearValue* toTransform);
+void transform_fromhost_VkClearValue(ResourceTracker* resourceTracker, VkClearValue* toTransform);
-void transform_tohost_VkClearAttachment(
- ResourceTracker* resourceTracker,
- VkClearAttachment* toTransform);
+void transform_tohost_VkClearAttachment(ResourceTracker* resourceTracker,
+ VkClearAttachment* toTransform);
-void transform_fromhost_VkClearAttachment(
- ResourceTracker* resourceTracker,
- VkClearAttachment* toTransform);
+void transform_fromhost_VkClearAttachment(ResourceTracker* resourceTracker,
+ VkClearAttachment* toTransform);
-void transform_tohost_VkClearRect(
- ResourceTracker* resourceTracker,
- VkClearRect* toTransform);
+void transform_tohost_VkClearRect(ResourceTracker* resourceTracker, VkClearRect* toTransform);
-void transform_fromhost_VkClearRect(
- ResourceTracker* resourceTracker,
- VkClearRect* toTransform);
+void transform_fromhost_VkClearRect(ResourceTracker* resourceTracker, VkClearRect* toTransform);
-void transform_tohost_VkImageBlit(
- ResourceTracker* resourceTracker,
- VkImageBlit* toTransform);
+void transform_tohost_VkImageBlit(ResourceTracker* resourceTracker, VkImageBlit* toTransform);
-void transform_fromhost_VkImageBlit(
- ResourceTracker* resourceTracker,
- VkImageBlit* toTransform);
+void transform_fromhost_VkImageBlit(ResourceTracker* resourceTracker, VkImageBlit* toTransform);
-void transform_tohost_VkImageCopy(
- ResourceTracker* resourceTracker,
- VkImageCopy* toTransform);
+void transform_tohost_VkImageCopy(ResourceTracker* resourceTracker, VkImageCopy* toTransform);
-void transform_fromhost_VkImageCopy(
- ResourceTracker* resourceTracker,
- VkImageCopy* toTransform);
+void transform_fromhost_VkImageCopy(ResourceTracker* resourceTracker, VkImageCopy* toTransform);
-void transform_tohost_VkImageResolve(
- ResourceTracker* resourceTracker,
- VkImageResolve* toTransform);
+void transform_tohost_VkImageResolve(ResourceTracker* resourceTracker, VkImageResolve* toTransform);
-void transform_fromhost_VkImageResolve(
- ResourceTracker* resourceTracker,
- VkImageResolve* toTransform);
+void transform_fromhost_VkImageResolve(ResourceTracker* resourceTracker,
+ VkImageResolve* toTransform);
-void transform_tohost_VkRenderPassBeginInfo(
- ResourceTracker* resourceTracker,
- VkRenderPassBeginInfo* toTransform);
+void transform_tohost_VkRenderPassBeginInfo(ResourceTracker* resourceTracker,
+ VkRenderPassBeginInfo* toTransform);
-void transform_fromhost_VkRenderPassBeginInfo(
- ResourceTracker* resourceTracker,
- VkRenderPassBeginInfo* toTransform);
+void transform_fromhost_VkRenderPassBeginInfo(ResourceTracker* resourceTracker,
+ VkRenderPassBeginInfo* toTransform);
#endif
#ifdef VK_VERSION_1_1
void transform_tohost_VkPhysicalDeviceSubgroupProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSubgroupProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSubgroupProperties* toTransform);
void transform_fromhost_VkPhysicalDeviceSubgroupProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSubgroupProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSubgroupProperties* toTransform);
-void transform_tohost_VkBindBufferMemoryInfo(
- ResourceTracker* resourceTracker,
- VkBindBufferMemoryInfo* toTransform);
+void transform_tohost_VkBindBufferMemoryInfo(ResourceTracker* resourceTracker,
+ VkBindBufferMemoryInfo* toTransform);
-void transform_fromhost_VkBindBufferMemoryInfo(
- ResourceTracker* resourceTracker,
- VkBindBufferMemoryInfo* toTransform);
+void transform_fromhost_VkBindBufferMemoryInfo(ResourceTracker* resourceTracker,
+ VkBindBufferMemoryInfo* toTransform);
-void transform_tohost_VkBindImageMemoryInfo(
- ResourceTracker* resourceTracker,
- VkBindImageMemoryInfo* toTransform);
+void transform_tohost_VkBindImageMemoryInfo(ResourceTracker* resourceTracker,
+ VkBindImageMemoryInfo* toTransform);
-void transform_fromhost_VkBindImageMemoryInfo(
- ResourceTracker* resourceTracker,
- VkBindImageMemoryInfo* toTransform);
+void transform_fromhost_VkBindImageMemoryInfo(ResourceTracker* resourceTracker,
+ VkBindImageMemoryInfo* toTransform);
void transform_tohost_VkPhysicalDevice16BitStorageFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDevice16BitStorageFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevice16BitStorageFeatures* toTransform);
void transform_fromhost_VkPhysicalDevice16BitStorageFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDevice16BitStorageFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevice16BitStorageFeatures* toTransform);
-void transform_tohost_VkMemoryDedicatedRequirements(
- ResourceTracker* resourceTracker,
- VkMemoryDedicatedRequirements* toTransform);
+void transform_tohost_VkMemoryDedicatedRequirements(ResourceTracker* resourceTracker,
+ VkMemoryDedicatedRequirements* toTransform);
-void transform_fromhost_VkMemoryDedicatedRequirements(
- ResourceTracker* resourceTracker,
- VkMemoryDedicatedRequirements* toTransform);
+void transform_fromhost_VkMemoryDedicatedRequirements(ResourceTracker* resourceTracker,
+ VkMemoryDedicatedRequirements* toTransform);
-void transform_tohost_VkMemoryDedicatedAllocateInfo(
- ResourceTracker* resourceTracker,
- VkMemoryDedicatedAllocateInfo* toTransform);
+void transform_tohost_VkMemoryDedicatedAllocateInfo(ResourceTracker* resourceTracker,
+ VkMemoryDedicatedAllocateInfo* toTransform);
-void transform_fromhost_VkMemoryDedicatedAllocateInfo(
- ResourceTracker* resourceTracker,
- VkMemoryDedicatedAllocateInfo* toTransform);
+void transform_fromhost_VkMemoryDedicatedAllocateInfo(ResourceTracker* resourceTracker,
+ VkMemoryDedicatedAllocateInfo* toTransform);
-void transform_tohost_VkMemoryAllocateFlagsInfo(
- ResourceTracker* resourceTracker,
- VkMemoryAllocateFlagsInfo* toTransform);
+void transform_tohost_VkMemoryAllocateFlagsInfo(ResourceTracker* resourceTracker,
+ VkMemoryAllocateFlagsInfo* toTransform);
-void transform_fromhost_VkMemoryAllocateFlagsInfo(
- ResourceTracker* resourceTracker,
- VkMemoryAllocateFlagsInfo* toTransform);
+void transform_fromhost_VkMemoryAllocateFlagsInfo(ResourceTracker* resourceTracker,
+ VkMemoryAllocateFlagsInfo* toTransform);
void transform_tohost_VkDeviceGroupRenderPassBeginInfo(
- ResourceTracker* resourceTracker,
- VkDeviceGroupRenderPassBeginInfo* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceGroupRenderPassBeginInfo* toTransform);
void transform_fromhost_VkDeviceGroupRenderPassBeginInfo(
- ResourceTracker* resourceTracker,
- VkDeviceGroupRenderPassBeginInfo* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceGroupRenderPassBeginInfo* toTransform);
void transform_tohost_VkDeviceGroupCommandBufferBeginInfo(
- ResourceTracker* resourceTracker,
- VkDeviceGroupCommandBufferBeginInfo* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceGroupCommandBufferBeginInfo* toTransform);
void transform_fromhost_VkDeviceGroupCommandBufferBeginInfo(
- ResourceTracker* resourceTracker,
- VkDeviceGroupCommandBufferBeginInfo* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceGroupCommandBufferBeginInfo* toTransform);
-void transform_tohost_VkDeviceGroupSubmitInfo(
- ResourceTracker* resourceTracker,
- VkDeviceGroupSubmitInfo* toTransform);
+void transform_tohost_VkDeviceGroupSubmitInfo(ResourceTracker* resourceTracker,
+ VkDeviceGroupSubmitInfo* toTransform);
-void transform_fromhost_VkDeviceGroupSubmitInfo(
- ResourceTracker* resourceTracker,
- VkDeviceGroupSubmitInfo* toTransform);
+void transform_fromhost_VkDeviceGroupSubmitInfo(ResourceTracker* resourceTracker,
+ VkDeviceGroupSubmitInfo* toTransform);
-void transform_tohost_VkDeviceGroupBindSparseInfo(
- ResourceTracker* resourceTracker,
- VkDeviceGroupBindSparseInfo* toTransform);
+void transform_tohost_VkDeviceGroupBindSparseInfo(ResourceTracker* resourceTracker,
+ VkDeviceGroupBindSparseInfo* toTransform);
-void transform_fromhost_VkDeviceGroupBindSparseInfo(
- ResourceTracker* resourceTracker,
- VkDeviceGroupBindSparseInfo* toTransform);
+void transform_fromhost_VkDeviceGroupBindSparseInfo(ResourceTracker* resourceTracker,
+ VkDeviceGroupBindSparseInfo* toTransform);
void transform_tohost_VkBindBufferMemoryDeviceGroupInfo(
- ResourceTracker* resourceTracker,
- VkBindBufferMemoryDeviceGroupInfo* toTransform);
+ ResourceTracker* resourceTracker, VkBindBufferMemoryDeviceGroupInfo* toTransform);
void transform_fromhost_VkBindBufferMemoryDeviceGroupInfo(
- ResourceTracker* resourceTracker,
- VkBindBufferMemoryDeviceGroupInfo* toTransform);
+ ResourceTracker* resourceTracker, VkBindBufferMemoryDeviceGroupInfo* toTransform);
void transform_tohost_VkBindImageMemoryDeviceGroupInfo(
- ResourceTracker* resourceTracker,
- VkBindImageMemoryDeviceGroupInfo* toTransform);
+ ResourceTracker* resourceTracker, VkBindImageMemoryDeviceGroupInfo* toTransform);
void transform_fromhost_VkBindImageMemoryDeviceGroupInfo(
- ResourceTracker* resourceTracker,
- VkBindImageMemoryDeviceGroupInfo* toTransform);
+ ResourceTracker* resourceTracker, VkBindImageMemoryDeviceGroupInfo* toTransform);
-void transform_tohost_VkPhysicalDeviceGroupProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceGroupProperties* toTransform);
+void transform_tohost_VkPhysicalDeviceGroupProperties(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceGroupProperties* toTransform);
void transform_fromhost_VkPhysicalDeviceGroupProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceGroupProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceGroupProperties* toTransform);
-void transform_tohost_VkDeviceGroupDeviceCreateInfo(
- ResourceTracker* resourceTracker,
- VkDeviceGroupDeviceCreateInfo* toTransform);
+void transform_tohost_VkDeviceGroupDeviceCreateInfo(ResourceTracker* resourceTracker,
+ VkDeviceGroupDeviceCreateInfo* toTransform);
-void transform_fromhost_VkDeviceGroupDeviceCreateInfo(
- ResourceTracker* resourceTracker,
- VkDeviceGroupDeviceCreateInfo* toTransform);
+void transform_fromhost_VkDeviceGroupDeviceCreateInfo(ResourceTracker* resourceTracker,
+ VkDeviceGroupDeviceCreateInfo* toTransform);
-void transform_tohost_VkBufferMemoryRequirementsInfo2(
- ResourceTracker* resourceTracker,
- VkBufferMemoryRequirementsInfo2* toTransform);
+void transform_tohost_VkBufferMemoryRequirementsInfo2(ResourceTracker* resourceTracker,
+ VkBufferMemoryRequirementsInfo2* toTransform);
void transform_fromhost_VkBufferMemoryRequirementsInfo2(
- ResourceTracker* resourceTracker,
- VkBufferMemoryRequirementsInfo2* toTransform);
+ ResourceTracker* resourceTracker, VkBufferMemoryRequirementsInfo2* toTransform);
-void transform_tohost_VkImageMemoryRequirementsInfo2(
- ResourceTracker* resourceTracker,
- VkImageMemoryRequirementsInfo2* toTransform);
+void transform_tohost_VkImageMemoryRequirementsInfo2(ResourceTracker* resourceTracker,
+ VkImageMemoryRequirementsInfo2* toTransform);
-void transform_fromhost_VkImageMemoryRequirementsInfo2(
- ResourceTracker* resourceTracker,
- VkImageMemoryRequirementsInfo2* toTransform);
+void transform_fromhost_VkImageMemoryRequirementsInfo2(ResourceTracker* resourceTracker,
+ VkImageMemoryRequirementsInfo2* toTransform);
void transform_tohost_VkImageSparseMemoryRequirementsInfo2(
- ResourceTracker* resourceTracker,
- VkImageSparseMemoryRequirementsInfo2* toTransform);
+ ResourceTracker* resourceTracker, VkImageSparseMemoryRequirementsInfo2* toTransform);
void transform_fromhost_VkImageSparseMemoryRequirementsInfo2(
- ResourceTracker* resourceTracker,
- VkImageSparseMemoryRequirementsInfo2* toTransform);
+ ResourceTracker* resourceTracker, VkImageSparseMemoryRequirementsInfo2* toTransform);
-void transform_tohost_VkMemoryRequirements2(
- ResourceTracker* resourceTracker,
- VkMemoryRequirements2* toTransform);
+void transform_tohost_VkMemoryRequirements2(ResourceTracker* resourceTracker,
+ VkMemoryRequirements2* toTransform);
-void transform_fromhost_VkMemoryRequirements2(
- ResourceTracker* resourceTracker,
- VkMemoryRequirements2* toTransform);
+void transform_fromhost_VkMemoryRequirements2(ResourceTracker* resourceTracker,
+ VkMemoryRequirements2* toTransform);
void transform_tohost_VkSparseImageMemoryRequirements2(
- ResourceTracker* resourceTracker,
- VkSparseImageMemoryRequirements2* toTransform);
+ ResourceTracker* resourceTracker, VkSparseImageMemoryRequirements2* toTransform);
void transform_fromhost_VkSparseImageMemoryRequirements2(
- ResourceTracker* resourceTracker,
- VkSparseImageMemoryRequirements2* toTransform);
+ ResourceTracker* resourceTracker, VkSparseImageMemoryRequirements2* toTransform);
-void transform_tohost_VkPhysicalDeviceFeatures2(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFeatures2* toTransform);
+void transform_tohost_VkPhysicalDeviceFeatures2(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceFeatures2* toTransform);
-void transform_fromhost_VkPhysicalDeviceFeatures2(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFeatures2* toTransform);
+void transform_fromhost_VkPhysicalDeviceFeatures2(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceFeatures2* toTransform);
-void transform_tohost_VkPhysicalDeviceProperties2(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProperties2* toTransform);
+void transform_tohost_VkPhysicalDeviceProperties2(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceProperties2* toTransform);
-void transform_fromhost_VkPhysicalDeviceProperties2(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProperties2* toTransform);
+void transform_fromhost_VkPhysicalDeviceProperties2(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceProperties2* toTransform);
-void transform_tohost_VkFormatProperties2(
- ResourceTracker* resourceTracker,
- VkFormatProperties2* toTransform);
+void transform_tohost_VkFormatProperties2(ResourceTracker* resourceTracker,
+ VkFormatProperties2* toTransform);
-void transform_fromhost_VkFormatProperties2(
- ResourceTracker* resourceTracker,
- VkFormatProperties2* toTransform);
+void transform_fromhost_VkFormatProperties2(ResourceTracker* resourceTracker,
+ VkFormatProperties2* toTransform);
-void transform_tohost_VkImageFormatProperties2(
- ResourceTracker* resourceTracker,
- VkImageFormatProperties2* toTransform);
+void transform_tohost_VkImageFormatProperties2(ResourceTracker* resourceTracker,
+ VkImageFormatProperties2* toTransform);
-void transform_fromhost_VkImageFormatProperties2(
- ResourceTracker* resourceTracker,
- VkImageFormatProperties2* toTransform);
+void transform_fromhost_VkImageFormatProperties2(ResourceTracker* resourceTracker,
+ VkImageFormatProperties2* toTransform);
void transform_tohost_VkPhysicalDeviceImageFormatInfo2(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceImageFormatInfo2* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceImageFormatInfo2* toTransform);
void transform_fromhost_VkPhysicalDeviceImageFormatInfo2(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceImageFormatInfo2* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceImageFormatInfo2* toTransform);
-void transform_tohost_VkQueueFamilyProperties2(
- ResourceTracker* resourceTracker,
- VkQueueFamilyProperties2* toTransform);
+void transform_tohost_VkQueueFamilyProperties2(ResourceTracker* resourceTracker,
+ VkQueueFamilyProperties2* toTransform);
-void transform_fromhost_VkQueueFamilyProperties2(
- ResourceTracker* resourceTracker,
- VkQueueFamilyProperties2* toTransform);
+void transform_fromhost_VkQueueFamilyProperties2(ResourceTracker* resourceTracker,
+ VkQueueFamilyProperties2* toTransform);
void transform_tohost_VkPhysicalDeviceMemoryProperties2(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMemoryProperties2* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMemoryProperties2* toTransform);
void transform_fromhost_VkPhysicalDeviceMemoryProperties2(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMemoryProperties2* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMemoryProperties2* toTransform);
-void transform_tohost_VkSparseImageFormatProperties2(
- ResourceTracker* resourceTracker,
- VkSparseImageFormatProperties2* toTransform);
+void transform_tohost_VkSparseImageFormatProperties2(ResourceTracker* resourceTracker,
+ VkSparseImageFormatProperties2* toTransform);
-void transform_fromhost_VkSparseImageFormatProperties2(
- ResourceTracker* resourceTracker,
- VkSparseImageFormatProperties2* toTransform);
+void transform_fromhost_VkSparseImageFormatProperties2(ResourceTracker* resourceTracker,
+ VkSparseImageFormatProperties2* toTransform);
void transform_tohost_VkPhysicalDeviceSparseImageFormatInfo2(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSparseImageFormatInfo2* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSparseImageFormatInfo2* toTransform);
void transform_fromhost_VkPhysicalDeviceSparseImageFormatInfo2(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSparseImageFormatInfo2* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSparseImageFormatInfo2* toTransform);
void transform_tohost_VkPhysicalDevicePointClippingProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePointClippingProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevicePointClippingProperties* toTransform);
void transform_fromhost_VkPhysicalDevicePointClippingProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePointClippingProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevicePointClippingProperties* toTransform);
void transform_tohost_VkInputAttachmentAspectReference(
- ResourceTracker* resourceTracker,
- VkInputAttachmentAspectReference* toTransform);
+ ResourceTracker* resourceTracker, VkInputAttachmentAspectReference* toTransform);
void transform_fromhost_VkInputAttachmentAspectReference(
- ResourceTracker* resourceTracker,
- VkInputAttachmentAspectReference* toTransform);
+ ResourceTracker* resourceTracker, VkInputAttachmentAspectReference* toTransform);
void transform_tohost_VkRenderPassInputAttachmentAspectCreateInfo(
- ResourceTracker* resourceTracker,
- VkRenderPassInputAttachmentAspectCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkRenderPassInputAttachmentAspectCreateInfo* toTransform);
void transform_fromhost_VkRenderPassInputAttachmentAspectCreateInfo(
- ResourceTracker* resourceTracker,
- VkRenderPassInputAttachmentAspectCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkRenderPassInputAttachmentAspectCreateInfo* toTransform);
-void transform_tohost_VkImageViewUsageCreateInfo(
- ResourceTracker* resourceTracker,
- VkImageViewUsageCreateInfo* toTransform);
+void transform_tohost_VkImageViewUsageCreateInfo(ResourceTracker* resourceTracker,
+ VkImageViewUsageCreateInfo* toTransform);
-void transform_fromhost_VkImageViewUsageCreateInfo(
- ResourceTracker* resourceTracker,
- VkImageViewUsageCreateInfo* toTransform);
+void transform_fromhost_VkImageViewUsageCreateInfo(ResourceTracker* resourceTracker,
+ VkImageViewUsageCreateInfo* toTransform);
void transform_tohost_VkPipelineTessellationDomainOriginStateCreateInfo(
ResourceTracker* resourceTracker,
@@ -1207,455 +894,349 @@
ResourceTracker* resourceTracker,
VkPipelineTessellationDomainOriginStateCreateInfo* toTransform);
-void transform_tohost_VkRenderPassMultiviewCreateInfo(
- ResourceTracker* resourceTracker,
- VkRenderPassMultiviewCreateInfo* toTransform);
+void transform_tohost_VkRenderPassMultiviewCreateInfo(ResourceTracker* resourceTracker,
+ VkRenderPassMultiviewCreateInfo* toTransform);
void transform_fromhost_VkRenderPassMultiviewCreateInfo(
- ResourceTracker* resourceTracker,
- VkRenderPassMultiviewCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkRenderPassMultiviewCreateInfo* toTransform);
void transform_tohost_VkPhysicalDeviceMultiviewFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMultiviewFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMultiviewFeatures* toTransform);
void transform_fromhost_VkPhysicalDeviceMultiviewFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMultiviewFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMultiviewFeatures* toTransform);
void transform_tohost_VkPhysicalDeviceMultiviewProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMultiviewProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMultiviewProperties* toTransform);
void transform_fromhost_VkPhysicalDeviceMultiviewProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMultiviewProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMultiviewProperties* toTransform);
void transform_tohost_VkPhysicalDeviceVariablePointersFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVariablePointersFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVariablePointersFeatures* toTransform);
void transform_fromhost_VkPhysicalDeviceVariablePointersFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVariablePointersFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVariablePointersFeatures* toTransform);
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceVariablePointersFeatures, transform_tohost_VkPhysicalDeviceVariablePointerFeatures)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceVariablePointersFeatures,
+ transform_tohost_VkPhysicalDeviceVariablePointerFeatures)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceVariablePointersFeatures, transform_fromhost_VkPhysicalDeviceVariablePointerFeatures)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceVariablePointersFeatures,
+ transform_fromhost_VkPhysicalDeviceVariablePointerFeatures)
void transform_tohost_VkPhysicalDeviceProtectedMemoryFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProtectedMemoryFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceProtectedMemoryFeatures* toTransform);
void transform_fromhost_VkPhysicalDeviceProtectedMemoryFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProtectedMemoryFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceProtectedMemoryFeatures* toTransform);
void transform_tohost_VkPhysicalDeviceProtectedMemoryProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProtectedMemoryProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceProtectedMemoryProperties* toTransform);
void transform_fromhost_VkPhysicalDeviceProtectedMemoryProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProtectedMemoryProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceProtectedMemoryProperties* toTransform);
-void transform_tohost_VkDeviceQueueInfo2(
- ResourceTracker* resourceTracker,
- VkDeviceQueueInfo2* toTransform);
+void transform_tohost_VkDeviceQueueInfo2(ResourceTracker* resourceTracker,
+ VkDeviceQueueInfo2* toTransform);
-void transform_fromhost_VkDeviceQueueInfo2(
- ResourceTracker* resourceTracker,
- VkDeviceQueueInfo2* toTransform);
+void transform_fromhost_VkDeviceQueueInfo2(ResourceTracker* resourceTracker,
+ VkDeviceQueueInfo2* toTransform);
-void transform_tohost_VkProtectedSubmitInfo(
- ResourceTracker* resourceTracker,
- VkProtectedSubmitInfo* toTransform);
+void transform_tohost_VkProtectedSubmitInfo(ResourceTracker* resourceTracker,
+ VkProtectedSubmitInfo* toTransform);
-void transform_fromhost_VkProtectedSubmitInfo(
- ResourceTracker* resourceTracker,
- VkProtectedSubmitInfo* toTransform);
+void transform_fromhost_VkProtectedSubmitInfo(ResourceTracker* resourceTracker,
+ VkProtectedSubmitInfo* toTransform);
void transform_tohost_VkSamplerYcbcrConversionCreateInfo(
- ResourceTracker* resourceTracker,
- VkSamplerYcbcrConversionCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkSamplerYcbcrConversionCreateInfo* toTransform);
void transform_fromhost_VkSamplerYcbcrConversionCreateInfo(
- ResourceTracker* resourceTracker,
- VkSamplerYcbcrConversionCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkSamplerYcbcrConversionCreateInfo* toTransform);
-void transform_tohost_VkSamplerYcbcrConversionInfo(
- ResourceTracker* resourceTracker,
- VkSamplerYcbcrConversionInfo* toTransform);
+void transform_tohost_VkSamplerYcbcrConversionInfo(ResourceTracker* resourceTracker,
+ VkSamplerYcbcrConversionInfo* toTransform);
-void transform_fromhost_VkSamplerYcbcrConversionInfo(
- ResourceTracker* resourceTracker,
- VkSamplerYcbcrConversionInfo* toTransform);
+void transform_fromhost_VkSamplerYcbcrConversionInfo(ResourceTracker* resourceTracker,
+ VkSamplerYcbcrConversionInfo* toTransform);
-void transform_tohost_VkBindImagePlaneMemoryInfo(
- ResourceTracker* resourceTracker,
- VkBindImagePlaneMemoryInfo* toTransform);
+void transform_tohost_VkBindImagePlaneMemoryInfo(ResourceTracker* resourceTracker,
+ VkBindImagePlaneMemoryInfo* toTransform);
-void transform_fromhost_VkBindImagePlaneMemoryInfo(
- ResourceTracker* resourceTracker,
- VkBindImagePlaneMemoryInfo* toTransform);
+void transform_fromhost_VkBindImagePlaneMemoryInfo(ResourceTracker* resourceTracker,
+ VkBindImagePlaneMemoryInfo* toTransform);
void transform_tohost_VkImagePlaneMemoryRequirementsInfo(
- ResourceTracker* resourceTracker,
- VkImagePlaneMemoryRequirementsInfo* toTransform);
+ ResourceTracker* resourceTracker, VkImagePlaneMemoryRequirementsInfo* toTransform);
void transform_fromhost_VkImagePlaneMemoryRequirementsInfo(
- ResourceTracker* resourceTracker,
- VkImagePlaneMemoryRequirementsInfo* toTransform);
+ ResourceTracker* resourceTracker, VkImagePlaneMemoryRequirementsInfo* toTransform);
void transform_tohost_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSamplerYcbcrConversionFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSamplerYcbcrConversionFeatures* toTransform);
void transform_fromhost_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSamplerYcbcrConversionFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSamplerYcbcrConversionFeatures* toTransform);
void transform_tohost_VkSamplerYcbcrConversionImageFormatProperties(
- ResourceTracker* resourceTracker,
- VkSamplerYcbcrConversionImageFormatProperties* toTransform);
+ ResourceTracker* resourceTracker, VkSamplerYcbcrConversionImageFormatProperties* toTransform);
void transform_fromhost_VkSamplerYcbcrConversionImageFormatProperties(
- ResourceTracker* resourceTracker,
- VkSamplerYcbcrConversionImageFormatProperties* toTransform);
+ ResourceTracker* resourceTracker, VkSamplerYcbcrConversionImageFormatProperties* toTransform);
-void transform_tohost_VkDescriptorUpdateTemplateEntry(
- ResourceTracker* resourceTracker,
- VkDescriptorUpdateTemplateEntry* toTransform);
+void transform_tohost_VkDescriptorUpdateTemplateEntry(ResourceTracker* resourceTracker,
+ VkDescriptorUpdateTemplateEntry* toTransform);
void transform_fromhost_VkDescriptorUpdateTemplateEntry(
- ResourceTracker* resourceTracker,
- VkDescriptorUpdateTemplateEntry* toTransform);
+ ResourceTracker* resourceTracker, VkDescriptorUpdateTemplateEntry* toTransform);
void transform_tohost_VkDescriptorUpdateTemplateCreateInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorUpdateTemplateCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkDescriptorUpdateTemplateCreateInfo* toTransform);
void transform_fromhost_VkDescriptorUpdateTemplateCreateInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorUpdateTemplateCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkDescriptorUpdateTemplateCreateInfo* toTransform);
-void transform_tohost_VkExternalMemoryProperties(
- ResourceTracker* resourceTracker,
- VkExternalMemoryProperties* toTransform);
+void transform_tohost_VkExternalMemoryProperties(ResourceTracker* resourceTracker,
+ VkExternalMemoryProperties* toTransform);
-void transform_fromhost_VkExternalMemoryProperties(
- ResourceTracker* resourceTracker,
- VkExternalMemoryProperties* toTransform);
+void transform_fromhost_VkExternalMemoryProperties(ResourceTracker* resourceTracker,
+ VkExternalMemoryProperties* toTransform);
void transform_tohost_VkPhysicalDeviceExternalImageFormatInfo(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalImageFormatInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalImageFormatInfo* toTransform);
void transform_fromhost_VkPhysicalDeviceExternalImageFormatInfo(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalImageFormatInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalImageFormatInfo* toTransform);
-void transform_tohost_VkExternalImageFormatProperties(
- ResourceTracker* resourceTracker,
- VkExternalImageFormatProperties* toTransform);
+void transform_tohost_VkExternalImageFormatProperties(ResourceTracker* resourceTracker,
+ VkExternalImageFormatProperties* toTransform);
void transform_fromhost_VkExternalImageFormatProperties(
- ResourceTracker* resourceTracker,
- VkExternalImageFormatProperties* toTransform);
+ ResourceTracker* resourceTracker, VkExternalImageFormatProperties* toTransform);
void transform_tohost_VkPhysicalDeviceExternalBufferInfo(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalBufferInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalBufferInfo* toTransform);
void transform_fromhost_VkPhysicalDeviceExternalBufferInfo(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalBufferInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalBufferInfo* toTransform);
-void transform_tohost_VkExternalBufferProperties(
- ResourceTracker* resourceTracker,
- VkExternalBufferProperties* toTransform);
+void transform_tohost_VkExternalBufferProperties(ResourceTracker* resourceTracker,
+ VkExternalBufferProperties* toTransform);
-void transform_fromhost_VkExternalBufferProperties(
- ResourceTracker* resourceTracker,
- VkExternalBufferProperties* toTransform);
+void transform_fromhost_VkExternalBufferProperties(ResourceTracker* resourceTracker,
+ VkExternalBufferProperties* toTransform);
-void transform_tohost_VkPhysicalDeviceIDProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceIDProperties* toTransform);
+void transform_tohost_VkPhysicalDeviceIDProperties(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceIDProperties* toTransform);
-void transform_fromhost_VkPhysicalDeviceIDProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceIDProperties* toTransform);
+void transform_fromhost_VkPhysicalDeviceIDProperties(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceIDProperties* toTransform);
-void transform_tohost_VkExternalMemoryImageCreateInfo(
- ResourceTracker* resourceTracker,
- VkExternalMemoryImageCreateInfo* toTransform);
+void transform_tohost_VkExternalMemoryImageCreateInfo(ResourceTracker* resourceTracker,
+ VkExternalMemoryImageCreateInfo* toTransform);
void transform_fromhost_VkExternalMemoryImageCreateInfo(
- ResourceTracker* resourceTracker,
- VkExternalMemoryImageCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkExternalMemoryImageCreateInfo* toTransform);
void transform_tohost_VkExternalMemoryBufferCreateInfo(
- ResourceTracker* resourceTracker,
- VkExternalMemoryBufferCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkExternalMemoryBufferCreateInfo* toTransform);
void transform_fromhost_VkExternalMemoryBufferCreateInfo(
- ResourceTracker* resourceTracker,
- VkExternalMemoryBufferCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkExternalMemoryBufferCreateInfo* toTransform);
-void transform_tohost_VkExportMemoryAllocateInfo(
- ResourceTracker* resourceTracker,
- VkExportMemoryAllocateInfo* toTransform);
+void transform_tohost_VkExportMemoryAllocateInfo(ResourceTracker* resourceTracker,
+ VkExportMemoryAllocateInfo* toTransform);
-void transform_fromhost_VkExportMemoryAllocateInfo(
- ResourceTracker* resourceTracker,
- VkExportMemoryAllocateInfo* toTransform);
+void transform_fromhost_VkExportMemoryAllocateInfo(ResourceTracker* resourceTracker,
+ VkExportMemoryAllocateInfo* toTransform);
void transform_tohost_VkPhysicalDeviceExternalFenceInfo(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalFenceInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalFenceInfo* toTransform);
void transform_fromhost_VkPhysicalDeviceExternalFenceInfo(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalFenceInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalFenceInfo* toTransform);
-void transform_tohost_VkExternalFenceProperties(
- ResourceTracker* resourceTracker,
- VkExternalFenceProperties* toTransform);
+void transform_tohost_VkExternalFenceProperties(ResourceTracker* resourceTracker,
+ VkExternalFenceProperties* toTransform);
-void transform_fromhost_VkExternalFenceProperties(
- ResourceTracker* resourceTracker,
- VkExternalFenceProperties* toTransform);
+void transform_fromhost_VkExternalFenceProperties(ResourceTracker* resourceTracker,
+ VkExternalFenceProperties* toTransform);
-void transform_tohost_VkExportFenceCreateInfo(
- ResourceTracker* resourceTracker,
- VkExportFenceCreateInfo* toTransform);
+void transform_tohost_VkExportFenceCreateInfo(ResourceTracker* resourceTracker,
+ VkExportFenceCreateInfo* toTransform);
-void transform_fromhost_VkExportFenceCreateInfo(
- ResourceTracker* resourceTracker,
- VkExportFenceCreateInfo* toTransform);
+void transform_fromhost_VkExportFenceCreateInfo(ResourceTracker* resourceTracker,
+ VkExportFenceCreateInfo* toTransform);
-void transform_tohost_VkExportSemaphoreCreateInfo(
- ResourceTracker* resourceTracker,
- VkExportSemaphoreCreateInfo* toTransform);
+void transform_tohost_VkExportSemaphoreCreateInfo(ResourceTracker* resourceTracker,
+ VkExportSemaphoreCreateInfo* toTransform);
-void transform_fromhost_VkExportSemaphoreCreateInfo(
- ResourceTracker* resourceTracker,
- VkExportSemaphoreCreateInfo* toTransform);
+void transform_fromhost_VkExportSemaphoreCreateInfo(ResourceTracker* resourceTracker,
+ VkExportSemaphoreCreateInfo* toTransform);
void transform_tohost_VkPhysicalDeviceExternalSemaphoreInfo(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalSemaphoreInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalSemaphoreInfo* toTransform);
void transform_fromhost_VkPhysicalDeviceExternalSemaphoreInfo(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalSemaphoreInfo* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalSemaphoreInfo* toTransform);
-void transform_tohost_VkExternalSemaphoreProperties(
- ResourceTracker* resourceTracker,
- VkExternalSemaphoreProperties* toTransform);
+void transform_tohost_VkExternalSemaphoreProperties(ResourceTracker* resourceTracker,
+ VkExternalSemaphoreProperties* toTransform);
-void transform_fromhost_VkExternalSemaphoreProperties(
- ResourceTracker* resourceTracker,
- VkExternalSemaphoreProperties* toTransform);
+void transform_fromhost_VkExternalSemaphoreProperties(ResourceTracker* resourceTracker,
+ VkExternalSemaphoreProperties* toTransform);
void transform_tohost_VkPhysicalDeviceMaintenance3Properties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMaintenance3Properties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance3Properties* toTransform);
void transform_fromhost_VkPhysicalDeviceMaintenance3Properties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMaintenance3Properties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance3Properties* toTransform);
-void transform_tohost_VkDescriptorSetLayoutSupport(
- ResourceTracker* resourceTracker,
- VkDescriptorSetLayoutSupport* toTransform);
+void transform_tohost_VkDescriptorSetLayoutSupport(ResourceTracker* resourceTracker,
+ VkDescriptorSetLayoutSupport* toTransform);
-void transform_fromhost_VkDescriptorSetLayoutSupport(
- ResourceTracker* resourceTracker,
- VkDescriptorSetLayoutSupport* toTransform);
+void transform_fromhost_VkDescriptorSetLayoutSupport(ResourceTracker* resourceTracker,
+ VkDescriptorSetLayoutSupport* toTransform);
void transform_tohost_VkPhysicalDeviceShaderDrawParametersFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderDrawParametersFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderDrawParametersFeatures* toTransform);
void transform_fromhost_VkPhysicalDeviceShaderDrawParametersFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderDrawParametersFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderDrawParametersFeatures* toTransform);
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceShaderDrawParametersFeatures, transform_tohost_VkPhysicalDeviceShaderDrawParameterFeatures)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceShaderDrawParametersFeatures,
+ transform_tohost_VkPhysicalDeviceShaderDrawParameterFeatures)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceShaderDrawParametersFeatures, transform_fromhost_VkPhysicalDeviceShaderDrawParameterFeatures)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceShaderDrawParametersFeatures,
+ transform_fromhost_VkPhysicalDeviceShaderDrawParameterFeatures)
#endif
#ifdef VK_VERSION_1_2
void transform_tohost_VkPhysicalDeviceVulkan11Features(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVulkan11Features* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan11Features* toTransform);
void transform_fromhost_VkPhysicalDeviceVulkan11Features(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVulkan11Features* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan11Features* toTransform);
void transform_tohost_VkPhysicalDeviceVulkan11Properties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVulkan11Properties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan11Properties* toTransform);
void transform_fromhost_VkPhysicalDeviceVulkan11Properties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVulkan11Properties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan11Properties* toTransform);
void transform_tohost_VkPhysicalDeviceVulkan12Features(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVulkan12Features* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan12Features* toTransform);
void transform_fromhost_VkPhysicalDeviceVulkan12Features(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVulkan12Features* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan12Features* toTransform);
-void transform_tohost_VkConformanceVersion(
- ResourceTracker* resourceTracker,
- VkConformanceVersion* toTransform);
+void transform_tohost_VkConformanceVersion(ResourceTracker* resourceTracker,
+ VkConformanceVersion* toTransform);
-void transform_fromhost_VkConformanceVersion(
- ResourceTracker* resourceTracker,
- VkConformanceVersion* toTransform);
+void transform_fromhost_VkConformanceVersion(ResourceTracker* resourceTracker,
+ VkConformanceVersion* toTransform);
void transform_tohost_VkPhysicalDeviceVulkan12Properties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVulkan12Properties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan12Properties* toTransform);
void transform_fromhost_VkPhysicalDeviceVulkan12Properties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVulkan12Properties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkan12Properties* toTransform);
-void transform_tohost_VkImageFormatListCreateInfo(
- ResourceTracker* resourceTracker,
- VkImageFormatListCreateInfo* toTransform);
+void transform_tohost_VkImageFormatListCreateInfo(ResourceTracker* resourceTracker,
+ VkImageFormatListCreateInfo* toTransform);
-void transform_fromhost_VkImageFormatListCreateInfo(
- ResourceTracker* resourceTracker,
- VkImageFormatListCreateInfo* toTransform);
+void transform_fromhost_VkImageFormatListCreateInfo(ResourceTracker* resourceTracker,
+ VkImageFormatListCreateInfo* toTransform);
-void transform_tohost_VkAttachmentDescription2(
- ResourceTracker* resourceTracker,
- VkAttachmentDescription2* toTransform);
+void transform_tohost_VkAttachmentDescription2(ResourceTracker* resourceTracker,
+ VkAttachmentDescription2* toTransform);
-void transform_fromhost_VkAttachmentDescription2(
- ResourceTracker* resourceTracker,
- VkAttachmentDescription2* toTransform);
+void transform_fromhost_VkAttachmentDescription2(ResourceTracker* resourceTracker,
+ VkAttachmentDescription2* toTransform);
-void transform_tohost_VkAttachmentReference2(
- ResourceTracker* resourceTracker,
- VkAttachmentReference2* toTransform);
+void transform_tohost_VkAttachmentReference2(ResourceTracker* resourceTracker,
+ VkAttachmentReference2* toTransform);
-void transform_fromhost_VkAttachmentReference2(
- ResourceTracker* resourceTracker,
- VkAttachmentReference2* toTransform);
+void transform_fromhost_VkAttachmentReference2(ResourceTracker* resourceTracker,
+ VkAttachmentReference2* toTransform);
-void transform_tohost_VkSubpassDescription2(
- ResourceTracker* resourceTracker,
- VkSubpassDescription2* toTransform);
+void transform_tohost_VkSubpassDescription2(ResourceTracker* resourceTracker,
+ VkSubpassDescription2* toTransform);
-void transform_fromhost_VkSubpassDescription2(
- ResourceTracker* resourceTracker,
- VkSubpassDescription2* toTransform);
+void transform_fromhost_VkSubpassDescription2(ResourceTracker* resourceTracker,
+ VkSubpassDescription2* toTransform);
-void transform_tohost_VkSubpassDependency2(
- ResourceTracker* resourceTracker,
- VkSubpassDependency2* toTransform);
+void transform_tohost_VkSubpassDependency2(ResourceTracker* resourceTracker,
+ VkSubpassDependency2* toTransform);
-void transform_fromhost_VkSubpassDependency2(
- ResourceTracker* resourceTracker,
- VkSubpassDependency2* toTransform);
+void transform_fromhost_VkSubpassDependency2(ResourceTracker* resourceTracker,
+ VkSubpassDependency2* toTransform);
-void transform_tohost_VkRenderPassCreateInfo2(
- ResourceTracker* resourceTracker,
- VkRenderPassCreateInfo2* toTransform);
+void transform_tohost_VkRenderPassCreateInfo2(ResourceTracker* resourceTracker,
+ VkRenderPassCreateInfo2* toTransform);
-void transform_fromhost_VkRenderPassCreateInfo2(
- ResourceTracker* resourceTracker,
- VkRenderPassCreateInfo2* toTransform);
+void transform_fromhost_VkRenderPassCreateInfo2(ResourceTracker* resourceTracker,
+ VkRenderPassCreateInfo2* toTransform);
-void transform_tohost_VkSubpassBeginInfo(
- ResourceTracker* resourceTracker,
- VkSubpassBeginInfo* toTransform);
+void transform_tohost_VkSubpassBeginInfo(ResourceTracker* resourceTracker,
+ VkSubpassBeginInfo* toTransform);
-void transform_fromhost_VkSubpassBeginInfo(
- ResourceTracker* resourceTracker,
- VkSubpassBeginInfo* toTransform);
+void transform_fromhost_VkSubpassBeginInfo(ResourceTracker* resourceTracker,
+ VkSubpassBeginInfo* toTransform);
-void transform_tohost_VkSubpassEndInfo(
- ResourceTracker* resourceTracker,
- VkSubpassEndInfo* toTransform);
+void transform_tohost_VkSubpassEndInfo(ResourceTracker* resourceTracker,
+ VkSubpassEndInfo* toTransform);
-void transform_fromhost_VkSubpassEndInfo(
- ResourceTracker* resourceTracker,
- VkSubpassEndInfo* toTransform);
+void transform_fromhost_VkSubpassEndInfo(ResourceTracker* resourceTracker,
+ VkSubpassEndInfo* toTransform);
void transform_tohost_VkPhysicalDevice8BitStorageFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDevice8BitStorageFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevice8BitStorageFeatures* toTransform);
void transform_fromhost_VkPhysicalDevice8BitStorageFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDevice8BitStorageFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevice8BitStorageFeatures* toTransform);
void transform_tohost_VkPhysicalDeviceDriverProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDriverProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDriverProperties* toTransform);
void transform_fromhost_VkPhysicalDeviceDriverProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDriverProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDriverProperties* toTransform);
void transform_tohost_VkPhysicalDeviceShaderAtomicInt64Features(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderAtomicInt64Features* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderAtomicInt64Features* toTransform);
void transform_fromhost_VkPhysicalDeviceShaderAtomicInt64Features(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderAtomicInt64Features* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderAtomicInt64Features* toTransform);
void transform_tohost_VkPhysicalDeviceShaderFloat16Int8Features(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderFloat16Int8Features* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderFloat16Int8Features* toTransform);
void transform_fromhost_VkPhysicalDeviceShaderFloat16Int8Features(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderFloat16Int8Features* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderFloat16Int8Features* toTransform);
void transform_tohost_VkPhysicalDeviceFloatControlsProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFloatControlsProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFloatControlsProperties* toTransform);
void transform_fromhost_VkPhysicalDeviceFloatControlsProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFloatControlsProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFloatControlsProperties* toTransform);
void transform_tohost_VkDescriptorSetLayoutBindingFlagsCreateInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorSetLayoutBindingFlagsCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkDescriptorSetLayoutBindingFlagsCreateInfo* toTransform);
void transform_fromhost_VkDescriptorSetLayoutBindingFlagsCreateInfo(
- ResourceTracker* resourceTracker,
- VkDescriptorSetLayoutBindingFlagsCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkDescriptorSetLayoutBindingFlagsCreateInfo* toTransform);
void transform_tohost_VkPhysicalDeviceDescriptorIndexingFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDescriptorIndexingFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDescriptorIndexingFeatures* toTransform);
void transform_fromhost_VkPhysicalDeviceDescriptorIndexingFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDescriptorIndexingFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDescriptorIndexingFeatures* toTransform);
void transform_tohost_VkPhysicalDeviceDescriptorIndexingProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDescriptorIndexingProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDescriptorIndexingProperties* toTransform);
void transform_fromhost_VkPhysicalDeviceDescriptorIndexingProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDescriptorIndexingProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDescriptorIndexingProperties* toTransform);
void transform_tohost_VkDescriptorSetVariableDescriptorCountAllocateInfo(
ResourceTracker* resourceTracker,
@@ -1674,92 +1255,70 @@
VkDescriptorSetVariableDescriptorCountLayoutSupport* toTransform);
void transform_tohost_VkSubpassDescriptionDepthStencilResolve(
- ResourceTracker* resourceTracker,
- VkSubpassDescriptionDepthStencilResolve* toTransform);
+ ResourceTracker* resourceTracker, VkSubpassDescriptionDepthStencilResolve* toTransform);
void transform_fromhost_VkSubpassDescriptionDepthStencilResolve(
- ResourceTracker* resourceTracker,
- VkSubpassDescriptionDepthStencilResolve* toTransform);
+ ResourceTracker* resourceTracker, VkSubpassDescriptionDepthStencilResolve* toTransform);
void transform_tohost_VkPhysicalDeviceDepthStencilResolveProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDepthStencilResolveProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDepthStencilResolveProperties* toTransform);
void transform_fromhost_VkPhysicalDeviceDepthStencilResolveProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDepthStencilResolveProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDepthStencilResolveProperties* toTransform);
void transform_tohost_VkPhysicalDeviceScalarBlockLayoutFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceScalarBlockLayoutFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceScalarBlockLayoutFeatures* toTransform);
void transform_fromhost_VkPhysicalDeviceScalarBlockLayoutFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceScalarBlockLayoutFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceScalarBlockLayoutFeatures* toTransform);
-void transform_tohost_VkImageStencilUsageCreateInfo(
- ResourceTracker* resourceTracker,
- VkImageStencilUsageCreateInfo* toTransform);
+void transform_tohost_VkImageStencilUsageCreateInfo(ResourceTracker* resourceTracker,
+ VkImageStencilUsageCreateInfo* toTransform);
-void transform_fromhost_VkImageStencilUsageCreateInfo(
- ResourceTracker* resourceTracker,
- VkImageStencilUsageCreateInfo* toTransform);
+void transform_fromhost_VkImageStencilUsageCreateInfo(ResourceTracker* resourceTracker,
+ VkImageStencilUsageCreateInfo* toTransform);
void transform_tohost_VkSamplerReductionModeCreateInfo(
- ResourceTracker* resourceTracker,
- VkSamplerReductionModeCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkSamplerReductionModeCreateInfo* toTransform);
void transform_fromhost_VkSamplerReductionModeCreateInfo(
- ResourceTracker* resourceTracker,
- VkSamplerReductionModeCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkSamplerReductionModeCreateInfo* toTransform);
void transform_tohost_VkPhysicalDeviceSamplerFilterMinmaxProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSamplerFilterMinmaxProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSamplerFilterMinmaxProperties* toTransform);
void transform_fromhost_VkPhysicalDeviceSamplerFilterMinmaxProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSamplerFilterMinmaxProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSamplerFilterMinmaxProperties* toTransform);
void transform_tohost_VkPhysicalDeviceVulkanMemoryModelFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVulkanMemoryModelFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkanMemoryModelFeatures* toTransform);
void transform_fromhost_VkPhysicalDeviceVulkanMemoryModelFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVulkanMemoryModelFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVulkanMemoryModelFeatures* toTransform);
void transform_tohost_VkPhysicalDeviceImagelessFramebufferFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceImagelessFramebufferFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceImagelessFramebufferFeatures* toTransform);
void transform_fromhost_VkPhysicalDeviceImagelessFramebufferFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceImagelessFramebufferFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceImagelessFramebufferFeatures* toTransform);
void transform_tohost_VkFramebufferAttachmentImageInfo(
- ResourceTracker* resourceTracker,
- VkFramebufferAttachmentImageInfo* toTransform);
+ ResourceTracker* resourceTracker, VkFramebufferAttachmentImageInfo* toTransform);
void transform_fromhost_VkFramebufferAttachmentImageInfo(
- ResourceTracker* resourceTracker,
- VkFramebufferAttachmentImageInfo* toTransform);
+ ResourceTracker* resourceTracker, VkFramebufferAttachmentImageInfo* toTransform);
void transform_tohost_VkFramebufferAttachmentsCreateInfo(
- ResourceTracker* resourceTracker,
- VkFramebufferAttachmentsCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkFramebufferAttachmentsCreateInfo* toTransform);
void transform_fromhost_VkFramebufferAttachmentsCreateInfo(
- ResourceTracker* resourceTracker,
- VkFramebufferAttachmentsCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkFramebufferAttachmentsCreateInfo* toTransform);
-void transform_tohost_VkRenderPassAttachmentBeginInfo(
- ResourceTracker* resourceTracker,
- VkRenderPassAttachmentBeginInfo* toTransform);
+void transform_tohost_VkRenderPassAttachmentBeginInfo(ResourceTracker* resourceTracker,
+ VkRenderPassAttachmentBeginInfo* toTransform);
void transform_fromhost_VkRenderPassAttachmentBeginInfo(
- ResourceTracker* resourceTracker,
- VkRenderPassAttachmentBeginInfo* toTransform);
+ ResourceTracker* resourceTracker, VkRenderPassAttachmentBeginInfo* toTransform);
void transform_tohost_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
ResourceTracker* resourceTracker,
@@ -1786,620 +1345,533 @@
VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* toTransform);
void transform_tohost_VkAttachmentReferenceStencilLayout(
- ResourceTracker* resourceTracker,
- VkAttachmentReferenceStencilLayout* toTransform);
+ ResourceTracker* resourceTracker, VkAttachmentReferenceStencilLayout* toTransform);
void transform_fromhost_VkAttachmentReferenceStencilLayout(
- ResourceTracker* resourceTracker,
- VkAttachmentReferenceStencilLayout* toTransform);
+ ResourceTracker* resourceTracker, VkAttachmentReferenceStencilLayout* toTransform);
void transform_tohost_VkAttachmentDescriptionStencilLayout(
- ResourceTracker* resourceTracker,
- VkAttachmentDescriptionStencilLayout* toTransform);
+ ResourceTracker* resourceTracker, VkAttachmentDescriptionStencilLayout* toTransform);
void transform_fromhost_VkAttachmentDescriptionStencilLayout(
- ResourceTracker* resourceTracker,
- VkAttachmentDescriptionStencilLayout* toTransform);
+ ResourceTracker* resourceTracker, VkAttachmentDescriptionStencilLayout* toTransform);
void transform_tohost_VkPhysicalDeviceHostQueryResetFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceHostQueryResetFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceHostQueryResetFeatures* toTransform);
void transform_fromhost_VkPhysicalDeviceHostQueryResetFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceHostQueryResetFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceHostQueryResetFeatures* toTransform);
void transform_tohost_VkPhysicalDeviceTimelineSemaphoreFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceTimelineSemaphoreFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceTimelineSemaphoreFeatures* toTransform);
void transform_fromhost_VkPhysicalDeviceTimelineSemaphoreFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceTimelineSemaphoreFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceTimelineSemaphoreFeatures* toTransform);
void transform_tohost_VkPhysicalDeviceTimelineSemaphoreProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceTimelineSemaphoreProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceTimelineSemaphoreProperties* toTransform);
void transform_fromhost_VkPhysicalDeviceTimelineSemaphoreProperties(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceTimelineSemaphoreProperties* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceTimelineSemaphoreProperties* toTransform);
-void transform_tohost_VkSemaphoreTypeCreateInfo(
- ResourceTracker* resourceTracker,
- VkSemaphoreTypeCreateInfo* toTransform);
+void transform_tohost_VkSemaphoreTypeCreateInfo(ResourceTracker* resourceTracker,
+ VkSemaphoreTypeCreateInfo* toTransform);
-void transform_fromhost_VkSemaphoreTypeCreateInfo(
- ResourceTracker* resourceTracker,
- VkSemaphoreTypeCreateInfo* toTransform);
+void transform_fromhost_VkSemaphoreTypeCreateInfo(ResourceTracker* resourceTracker,
+ VkSemaphoreTypeCreateInfo* toTransform);
-void transform_tohost_VkTimelineSemaphoreSubmitInfo(
- ResourceTracker* resourceTracker,
- VkTimelineSemaphoreSubmitInfo* toTransform);
+void transform_tohost_VkTimelineSemaphoreSubmitInfo(ResourceTracker* resourceTracker,
+ VkTimelineSemaphoreSubmitInfo* toTransform);
-void transform_fromhost_VkTimelineSemaphoreSubmitInfo(
- ResourceTracker* resourceTracker,
- VkTimelineSemaphoreSubmitInfo* toTransform);
+void transform_fromhost_VkTimelineSemaphoreSubmitInfo(ResourceTracker* resourceTracker,
+ VkTimelineSemaphoreSubmitInfo* toTransform);
-void transform_tohost_VkSemaphoreWaitInfo(
- ResourceTracker* resourceTracker,
- VkSemaphoreWaitInfo* toTransform);
+void transform_tohost_VkSemaphoreWaitInfo(ResourceTracker* resourceTracker,
+ VkSemaphoreWaitInfo* toTransform);
-void transform_fromhost_VkSemaphoreWaitInfo(
- ResourceTracker* resourceTracker,
- VkSemaphoreWaitInfo* toTransform);
+void transform_fromhost_VkSemaphoreWaitInfo(ResourceTracker* resourceTracker,
+ VkSemaphoreWaitInfo* toTransform);
-void transform_tohost_VkSemaphoreSignalInfo(
- ResourceTracker* resourceTracker,
- VkSemaphoreSignalInfo* toTransform);
+void transform_tohost_VkSemaphoreSignalInfo(ResourceTracker* resourceTracker,
+ VkSemaphoreSignalInfo* toTransform);
-void transform_fromhost_VkSemaphoreSignalInfo(
- ResourceTracker* resourceTracker,
- VkSemaphoreSignalInfo* toTransform);
+void transform_fromhost_VkSemaphoreSignalInfo(ResourceTracker* resourceTracker,
+ VkSemaphoreSignalInfo* toTransform);
void transform_tohost_VkPhysicalDeviceBufferDeviceAddressFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceBufferDeviceAddressFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceBufferDeviceAddressFeatures* toTransform);
void transform_fromhost_VkPhysicalDeviceBufferDeviceAddressFeatures(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceBufferDeviceAddressFeatures* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceBufferDeviceAddressFeatures* toTransform);
-void transform_tohost_VkBufferDeviceAddressInfo(
- ResourceTracker* resourceTracker,
- VkBufferDeviceAddressInfo* toTransform);
+void transform_tohost_VkBufferDeviceAddressInfo(ResourceTracker* resourceTracker,
+ VkBufferDeviceAddressInfo* toTransform);
-void transform_fromhost_VkBufferDeviceAddressInfo(
- ResourceTracker* resourceTracker,
- VkBufferDeviceAddressInfo* toTransform);
+void transform_fromhost_VkBufferDeviceAddressInfo(ResourceTracker* resourceTracker,
+ VkBufferDeviceAddressInfo* toTransform);
void transform_tohost_VkBufferOpaqueCaptureAddressCreateInfo(
- ResourceTracker* resourceTracker,
- VkBufferOpaqueCaptureAddressCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkBufferOpaqueCaptureAddressCreateInfo* toTransform);
void transform_fromhost_VkBufferOpaqueCaptureAddressCreateInfo(
- ResourceTracker* resourceTracker,
- VkBufferOpaqueCaptureAddressCreateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkBufferOpaqueCaptureAddressCreateInfo* toTransform);
void transform_tohost_VkMemoryOpaqueCaptureAddressAllocateInfo(
- ResourceTracker* resourceTracker,
- VkMemoryOpaqueCaptureAddressAllocateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkMemoryOpaqueCaptureAddressAllocateInfo* toTransform);
void transform_fromhost_VkMemoryOpaqueCaptureAddressAllocateInfo(
- ResourceTracker* resourceTracker,
- VkMemoryOpaqueCaptureAddressAllocateInfo* toTransform);
+ ResourceTracker* resourceTracker, VkMemoryOpaqueCaptureAddressAllocateInfo* toTransform);
void transform_tohost_VkDeviceMemoryOpaqueCaptureAddressInfo(
- ResourceTracker* resourceTracker,
- VkDeviceMemoryOpaqueCaptureAddressInfo* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceMemoryOpaqueCaptureAddressInfo* toTransform);
void transform_fromhost_VkDeviceMemoryOpaqueCaptureAddressInfo(
- ResourceTracker* resourceTracker,
- VkDeviceMemoryOpaqueCaptureAddressInfo* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceMemoryOpaqueCaptureAddressInfo* toTransform);
#endif
#ifdef VK_KHR_surface
-void transform_tohost_VkSurfaceCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkSurfaceCapabilitiesKHR* toTransform);
+void transform_tohost_VkSurfaceCapabilitiesKHR(ResourceTracker* resourceTracker,
+ VkSurfaceCapabilitiesKHR* toTransform);
-void transform_fromhost_VkSurfaceCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkSurfaceCapabilitiesKHR* toTransform);
+void transform_fromhost_VkSurfaceCapabilitiesKHR(ResourceTracker* resourceTracker,
+ VkSurfaceCapabilitiesKHR* toTransform);
-void transform_tohost_VkSurfaceFormatKHR(
- ResourceTracker* resourceTracker,
- VkSurfaceFormatKHR* toTransform);
+void transform_tohost_VkSurfaceFormatKHR(ResourceTracker* resourceTracker,
+ VkSurfaceFormatKHR* toTransform);
-void transform_fromhost_VkSurfaceFormatKHR(
- ResourceTracker* resourceTracker,
- VkSurfaceFormatKHR* toTransform);
+void transform_fromhost_VkSurfaceFormatKHR(ResourceTracker* resourceTracker,
+ VkSurfaceFormatKHR* toTransform);
#endif
#ifdef VK_KHR_swapchain
-void transform_tohost_VkSwapchainCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkSwapchainCreateInfoKHR* toTransform);
+void transform_tohost_VkSwapchainCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkSwapchainCreateInfoKHR* toTransform);
-void transform_fromhost_VkSwapchainCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkSwapchainCreateInfoKHR* toTransform);
+void transform_fromhost_VkSwapchainCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkSwapchainCreateInfoKHR* toTransform);
-void transform_tohost_VkPresentInfoKHR(
- ResourceTracker* resourceTracker,
- VkPresentInfoKHR* toTransform);
+void transform_tohost_VkPresentInfoKHR(ResourceTracker* resourceTracker,
+ VkPresentInfoKHR* toTransform);
-void transform_fromhost_VkPresentInfoKHR(
- ResourceTracker* resourceTracker,
- VkPresentInfoKHR* toTransform);
+void transform_fromhost_VkPresentInfoKHR(ResourceTracker* resourceTracker,
+ VkPresentInfoKHR* toTransform);
-void transform_tohost_VkImageSwapchainCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkImageSwapchainCreateInfoKHR* toTransform);
+void transform_tohost_VkImageSwapchainCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkImageSwapchainCreateInfoKHR* toTransform);
-void transform_fromhost_VkImageSwapchainCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkImageSwapchainCreateInfoKHR* toTransform);
+void transform_fromhost_VkImageSwapchainCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkImageSwapchainCreateInfoKHR* toTransform);
void transform_tohost_VkBindImageMemorySwapchainInfoKHR(
- ResourceTracker* resourceTracker,
- VkBindImageMemorySwapchainInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkBindImageMemorySwapchainInfoKHR* toTransform);
void transform_fromhost_VkBindImageMemorySwapchainInfoKHR(
- ResourceTracker* resourceTracker,
- VkBindImageMemorySwapchainInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkBindImageMemorySwapchainInfoKHR* toTransform);
-void transform_tohost_VkAcquireNextImageInfoKHR(
- ResourceTracker* resourceTracker,
- VkAcquireNextImageInfoKHR* toTransform);
+void transform_tohost_VkAcquireNextImageInfoKHR(ResourceTracker* resourceTracker,
+ VkAcquireNextImageInfoKHR* toTransform);
-void transform_fromhost_VkAcquireNextImageInfoKHR(
- ResourceTracker* resourceTracker,
- VkAcquireNextImageInfoKHR* toTransform);
+void transform_fromhost_VkAcquireNextImageInfoKHR(ResourceTracker* resourceTracker,
+ VkAcquireNextImageInfoKHR* toTransform);
void transform_tohost_VkDeviceGroupPresentCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkDeviceGroupPresentCapabilitiesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceGroupPresentCapabilitiesKHR* toTransform);
void transform_fromhost_VkDeviceGroupPresentCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkDeviceGroupPresentCapabilitiesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceGroupPresentCapabilitiesKHR* toTransform);
-void transform_tohost_VkDeviceGroupPresentInfoKHR(
- ResourceTracker* resourceTracker,
- VkDeviceGroupPresentInfoKHR* toTransform);
+void transform_tohost_VkDeviceGroupPresentInfoKHR(ResourceTracker* resourceTracker,
+ VkDeviceGroupPresentInfoKHR* toTransform);
-void transform_fromhost_VkDeviceGroupPresentInfoKHR(
- ResourceTracker* resourceTracker,
- VkDeviceGroupPresentInfoKHR* toTransform);
+void transform_fromhost_VkDeviceGroupPresentInfoKHR(ResourceTracker* resourceTracker,
+ VkDeviceGroupPresentInfoKHR* toTransform);
void transform_tohost_VkDeviceGroupSwapchainCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkDeviceGroupSwapchainCreateInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceGroupSwapchainCreateInfoKHR* toTransform);
void transform_fromhost_VkDeviceGroupSwapchainCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkDeviceGroupSwapchainCreateInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceGroupSwapchainCreateInfoKHR* toTransform);
#endif
#ifdef VK_KHR_display
-void transform_tohost_VkDisplayModeParametersKHR(
- ResourceTracker* resourceTracker,
- VkDisplayModeParametersKHR* toTransform);
+void transform_tohost_VkDisplayModeParametersKHR(ResourceTracker* resourceTracker,
+ VkDisplayModeParametersKHR* toTransform);
-void transform_fromhost_VkDisplayModeParametersKHR(
- ResourceTracker* resourceTracker,
- VkDisplayModeParametersKHR* toTransform);
+void transform_fromhost_VkDisplayModeParametersKHR(ResourceTracker* resourceTracker,
+ VkDisplayModeParametersKHR* toTransform);
-void transform_tohost_VkDisplayModeCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkDisplayModeCreateInfoKHR* toTransform);
+void transform_tohost_VkDisplayModeCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkDisplayModeCreateInfoKHR* toTransform);
-void transform_fromhost_VkDisplayModeCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkDisplayModeCreateInfoKHR* toTransform);
+void transform_fromhost_VkDisplayModeCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkDisplayModeCreateInfoKHR* toTransform);
-void transform_tohost_VkDisplayModePropertiesKHR(
- ResourceTracker* resourceTracker,
- VkDisplayModePropertiesKHR* toTransform);
+void transform_tohost_VkDisplayModePropertiesKHR(ResourceTracker* resourceTracker,
+ VkDisplayModePropertiesKHR* toTransform);
-void transform_fromhost_VkDisplayModePropertiesKHR(
- ResourceTracker* resourceTracker,
- VkDisplayModePropertiesKHR* toTransform);
+void transform_fromhost_VkDisplayModePropertiesKHR(ResourceTracker* resourceTracker,
+ VkDisplayModePropertiesKHR* toTransform);
-void transform_tohost_VkDisplayPlaneCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkDisplayPlaneCapabilitiesKHR* toTransform);
+void transform_tohost_VkDisplayPlaneCapabilitiesKHR(ResourceTracker* resourceTracker,
+ VkDisplayPlaneCapabilitiesKHR* toTransform);
-void transform_fromhost_VkDisplayPlaneCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkDisplayPlaneCapabilitiesKHR* toTransform);
+void transform_fromhost_VkDisplayPlaneCapabilitiesKHR(ResourceTracker* resourceTracker,
+ VkDisplayPlaneCapabilitiesKHR* toTransform);
-void transform_tohost_VkDisplayPlanePropertiesKHR(
- ResourceTracker* resourceTracker,
- VkDisplayPlanePropertiesKHR* toTransform);
+void transform_tohost_VkDisplayPlanePropertiesKHR(ResourceTracker* resourceTracker,
+ VkDisplayPlanePropertiesKHR* toTransform);
-void transform_fromhost_VkDisplayPlanePropertiesKHR(
- ResourceTracker* resourceTracker,
- VkDisplayPlanePropertiesKHR* toTransform);
+void transform_fromhost_VkDisplayPlanePropertiesKHR(ResourceTracker* resourceTracker,
+ VkDisplayPlanePropertiesKHR* toTransform);
-void transform_tohost_VkDisplayPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkDisplayPropertiesKHR* toTransform);
+void transform_tohost_VkDisplayPropertiesKHR(ResourceTracker* resourceTracker,
+ VkDisplayPropertiesKHR* toTransform);
-void transform_fromhost_VkDisplayPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkDisplayPropertiesKHR* toTransform);
+void transform_fromhost_VkDisplayPropertiesKHR(ResourceTracker* resourceTracker,
+ VkDisplayPropertiesKHR* toTransform);
-void transform_tohost_VkDisplaySurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkDisplaySurfaceCreateInfoKHR* toTransform);
+void transform_tohost_VkDisplaySurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkDisplaySurfaceCreateInfoKHR* toTransform);
-void transform_fromhost_VkDisplaySurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkDisplaySurfaceCreateInfoKHR* toTransform);
+void transform_fromhost_VkDisplaySurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkDisplaySurfaceCreateInfoKHR* toTransform);
#endif
#ifdef VK_KHR_display_swapchain
-void transform_tohost_VkDisplayPresentInfoKHR(
- ResourceTracker* resourceTracker,
- VkDisplayPresentInfoKHR* toTransform);
+void transform_tohost_VkDisplayPresentInfoKHR(ResourceTracker* resourceTracker,
+ VkDisplayPresentInfoKHR* toTransform);
-void transform_fromhost_VkDisplayPresentInfoKHR(
- ResourceTracker* resourceTracker,
- VkDisplayPresentInfoKHR* toTransform);
+void transform_fromhost_VkDisplayPresentInfoKHR(ResourceTracker* resourceTracker,
+ VkDisplayPresentInfoKHR* toTransform);
#endif
#ifdef VK_KHR_xlib_surface
-void transform_tohost_VkXlibSurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkXlibSurfaceCreateInfoKHR* toTransform);
+void transform_tohost_VkXlibSurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkXlibSurfaceCreateInfoKHR* toTransform);
-void transform_fromhost_VkXlibSurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkXlibSurfaceCreateInfoKHR* toTransform);
+void transform_fromhost_VkXlibSurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkXlibSurfaceCreateInfoKHR* toTransform);
#endif
#ifdef VK_KHR_xcb_surface
-void transform_tohost_VkXcbSurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkXcbSurfaceCreateInfoKHR* toTransform);
+void transform_tohost_VkXcbSurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkXcbSurfaceCreateInfoKHR* toTransform);
-void transform_fromhost_VkXcbSurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkXcbSurfaceCreateInfoKHR* toTransform);
+void transform_fromhost_VkXcbSurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkXcbSurfaceCreateInfoKHR* toTransform);
#endif
#ifdef VK_KHR_wayland_surface
-void transform_tohost_VkWaylandSurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkWaylandSurfaceCreateInfoKHR* toTransform);
+void transform_tohost_VkWaylandSurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkWaylandSurfaceCreateInfoKHR* toTransform);
-void transform_fromhost_VkWaylandSurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkWaylandSurfaceCreateInfoKHR* toTransform);
+void transform_fromhost_VkWaylandSurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkWaylandSurfaceCreateInfoKHR* toTransform);
#endif
#ifdef VK_KHR_android_surface
-void transform_tohost_VkAndroidSurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkAndroidSurfaceCreateInfoKHR* toTransform);
+void transform_tohost_VkAndroidSurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkAndroidSurfaceCreateInfoKHR* toTransform);
-void transform_fromhost_VkAndroidSurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkAndroidSurfaceCreateInfoKHR* toTransform);
+void transform_fromhost_VkAndroidSurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkAndroidSurfaceCreateInfoKHR* toTransform);
#endif
#ifdef VK_KHR_win32_surface
-void transform_tohost_VkWin32SurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkWin32SurfaceCreateInfoKHR* toTransform);
+void transform_tohost_VkWin32SurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkWin32SurfaceCreateInfoKHR* toTransform);
-void transform_fromhost_VkWin32SurfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkWin32SurfaceCreateInfoKHR* toTransform);
+void transform_fromhost_VkWin32SurfaceCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkWin32SurfaceCreateInfoKHR* toTransform);
#endif
#ifdef VK_KHR_sampler_mirror_clamp_to_edge
#endif
#ifdef VK_KHR_video_queue
void transform_tohost_VkVideoQueueFamilyProperties2KHR(
- ResourceTracker* resourceTracker,
- VkVideoQueueFamilyProperties2KHR* toTransform);
+ ResourceTracker* resourceTracker, VkVideoQueueFamilyProperties2KHR* toTransform);
void transform_fromhost_VkVideoQueueFamilyProperties2KHR(
- ResourceTracker* resourceTracker,
- VkVideoQueueFamilyProperties2KHR* toTransform);
+ ResourceTracker* resourceTracker, VkVideoQueueFamilyProperties2KHR* toTransform);
-void transform_tohost_VkVideoProfileKHR(
- ResourceTracker* resourceTracker,
- VkVideoProfileKHR* toTransform);
+void transform_tohost_VkVideoProfileKHR(ResourceTracker* resourceTracker,
+ VkVideoProfileKHR* toTransform);
-void transform_fromhost_VkVideoProfileKHR(
- ResourceTracker* resourceTracker,
- VkVideoProfileKHR* toTransform);
+void transform_fromhost_VkVideoProfileKHR(ResourceTracker* resourceTracker,
+ VkVideoProfileKHR* toTransform);
-void transform_tohost_VkVideoProfilesKHR(
- ResourceTracker* resourceTracker,
- VkVideoProfilesKHR* toTransform);
+void transform_tohost_VkVideoProfilesKHR(ResourceTracker* resourceTracker,
+ VkVideoProfilesKHR* toTransform);
-void transform_fromhost_VkVideoProfilesKHR(
- ResourceTracker* resourceTracker,
- VkVideoProfilesKHR* toTransform);
+void transform_fromhost_VkVideoProfilesKHR(ResourceTracker* resourceTracker,
+ VkVideoProfilesKHR* toTransform);
-void transform_tohost_VkVideoCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkVideoCapabilitiesKHR* toTransform);
+void transform_tohost_VkVideoCapabilitiesKHR(ResourceTracker* resourceTracker,
+ VkVideoCapabilitiesKHR* toTransform);
-void transform_fromhost_VkVideoCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkVideoCapabilitiesKHR* toTransform);
+void transform_fromhost_VkVideoCapabilitiesKHR(ResourceTracker* resourceTracker,
+ VkVideoCapabilitiesKHR* toTransform);
void transform_tohost_VkPhysicalDeviceVideoFormatInfoKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVideoFormatInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVideoFormatInfoKHR* toTransform);
void transform_fromhost_VkPhysicalDeviceVideoFormatInfoKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceVideoFormatInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceVideoFormatInfoKHR* toTransform);
-void transform_tohost_VkVideoFormatPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkVideoFormatPropertiesKHR* toTransform);
+void transform_tohost_VkVideoFormatPropertiesKHR(ResourceTracker* resourceTracker,
+ VkVideoFormatPropertiesKHR* toTransform);
-void transform_fromhost_VkVideoFormatPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkVideoFormatPropertiesKHR* toTransform);
+void transform_fromhost_VkVideoFormatPropertiesKHR(ResourceTracker* resourceTracker,
+ VkVideoFormatPropertiesKHR* toTransform);
-void transform_tohost_VkVideoPictureResourceKHR(
- ResourceTracker* resourceTracker,
- VkVideoPictureResourceKHR* toTransform);
+void transform_tohost_VkVideoPictureResourceKHR(ResourceTracker* resourceTracker,
+ VkVideoPictureResourceKHR* toTransform);
-void transform_fromhost_VkVideoPictureResourceKHR(
- ResourceTracker* resourceTracker,
- VkVideoPictureResourceKHR* toTransform);
+void transform_fromhost_VkVideoPictureResourceKHR(ResourceTracker* resourceTracker,
+ VkVideoPictureResourceKHR* toTransform);
-void transform_tohost_VkVideoReferenceSlotKHR(
- ResourceTracker* resourceTracker,
- VkVideoReferenceSlotKHR* toTransform);
+void transform_tohost_VkVideoReferenceSlotKHR(ResourceTracker* resourceTracker,
+ VkVideoReferenceSlotKHR* toTransform);
-void transform_fromhost_VkVideoReferenceSlotKHR(
- ResourceTracker* resourceTracker,
- VkVideoReferenceSlotKHR* toTransform);
+void transform_fromhost_VkVideoReferenceSlotKHR(ResourceTracker* resourceTracker,
+ VkVideoReferenceSlotKHR* toTransform);
-void transform_tohost_VkVideoGetMemoryPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkVideoGetMemoryPropertiesKHR* toTransform);
+void transform_tohost_VkVideoGetMemoryPropertiesKHR(ResourceTracker* resourceTracker,
+ VkVideoGetMemoryPropertiesKHR* toTransform);
-void transform_fromhost_VkVideoGetMemoryPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkVideoGetMemoryPropertiesKHR* toTransform);
+void transform_fromhost_VkVideoGetMemoryPropertiesKHR(ResourceTracker* resourceTracker,
+ VkVideoGetMemoryPropertiesKHR* toTransform);
-void transform_tohost_VkVideoBindMemoryKHR(
- ResourceTracker* resourceTracker,
- VkVideoBindMemoryKHR* toTransform);
+void transform_tohost_VkVideoBindMemoryKHR(ResourceTracker* resourceTracker,
+ VkVideoBindMemoryKHR* toTransform);
-void transform_fromhost_VkVideoBindMemoryKHR(
- ResourceTracker* resourceTracker,
- VkVideoBindMemoryKHR* toTransform);
+void transform_fromhost_VkVideoBindMemoryKHR(ResourceTracker* resourceTracker,
+ VkVideoBindMemoryKHR* toTransform);
-void transform_tohost_VkVideoSessionCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoSessionCreateInfoKHR* toTransform);
+void transform_tohost_VkVideoSessionCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoSessionCreateInfoKHR* toTransform);
-void transform_fromhost_VkVideoSessionCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoSessionCreateInfoKHR* toTransform);
+void transform_fromhost_VkVideoSessionCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoSessionCreateInfoKHR* toTransform);
void transform_tohost_VkVideoSessionParametersCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoSessionParametersCreateInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkVideoSessionParametersCreateInfoKHR* toTransform);
void transform_fromhost_VkVideoSessionParametersCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoSessionParametersCreateInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkVideoSessionParametersCreateInfoKHR* toTransform);
void transform_tohost_VkVideoSessionParametersUpdateInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoSessionParametersUpdateInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkVideoSessionParametersUpdateInfoKHR* toTransform);
void transform_fromhost_VkVideoSessionParametersUpdateInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoSessionParametersUpdateInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkVideoSessionParametersUpdateInfoKHR* toTransform);
-void transform_tohost_VkVideoBeginCodingInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoBeginCodingInfoKHR* toTransform);
+void transform_tohost_VkVideoBeginCodingInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoBeginCodingInfoKHR* toTransform);
-void transform_fromhost_VkVideoBeginCodingInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoBeginCodingInfoKHR* toTransform);
+void transform_fromhost_VkVideoBeginCodingInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoBeginCodingInfoKHR* toTransform);
-void transform_tohost_VkVideoEndCodingInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoEndCodingInfoKHR* toTransform);
+void transform_tohost_VkVideoEndCodingInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoEndCodingInfoKHR* toTransform);
-void transform_fromhost_VkVideoEndCodingInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoEndCodingInfoKHR* toTransform);
+void transform_fromhost_VkVideoEndCodingInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoEndCodingInfoKHR* toTransform);
-void transform_tohost_VkVideoCodingControlInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoCodingControlInfoKHR* toTransform);
+void transform_tohost_VkVideoCodingControlInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoCodingControlInfoKHR* toTransform);
-void transform_fromhost_VkVideoCodingControlInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoCodingControlInfoKHR* toTransform);
+void transform_fromhost_VkVideoCodingControlInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoCodingControlInfoKHR* toTransform);
#endif
#ifdef VK_KHR_video_decode_queue
-void transform_tohost_VkVideoDecodeInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoDecodeInfoKHR* toTransform);
+void transform_tohost_VkVideoDecodeInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoDecodeInfoKHR* toTransform);
-void transform_fromhost_VkVideoDecodeInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoDecodeInfoKHR* toTransform);
+void transform_fromhost_VkVideoDecodeInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoDecodeInfoKHR* toTransform);
#endif
#ifdef VK_KHR_dynamic_rendering
-void transform_tohost_VkRenderingAttachmentInfoKHR(
- ResourceTracker* resourceTracker,
- VkRenderingAttachmentInfoKHR* toTransform);
+void transform_tohost_VkRenderingAttachmentInfoKHR(ResourceTracker* resourceTracker,
+ VkRenderingAttachmentInfoKHR* toTransform);
-void transform_fromhost_VkRenderingAttachmentInfoKHR(
- ResourceTracker* resourceTracker,
- VkRenderingAttachmentInfoKHR* toTransform);
+void transform_fromhost_VkRenderingAttachmentInfoKHR(ResourceTracker* resourceTracker,
+ VkRenderingAttachmentInfoKHR* toTransform);
-void transform_tohost_VkRenderingInfoKHR(
- ResourceTracker* resourceTracker,
- VkRenderingInfoKHR* toTransform);
+void transform_tohost_VkRenderingInfoKHR(ResourceTracker* resourceTracker,
+ VkRenderingInfoKHR* toTransform);
-void transform_fromhost_VkRenderingInfoKHR(
- ResourceTracker* resourceTracker,
- VkRenderingInfoKHR* toTransform);
+void transform_fromhost_VkRenderingInfoKHR(ResourceTracker* resourceTracker,
+ VkRenderingInfoKHR* toTransform);
void transform_tohost_VkPipelineRenderingCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkPipelineRenderingCreateInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineRenderingCreateInfoKHR* toTransform);
void transform_fromhost_VkPipelineRenderingCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkPipelineRenderingCreateInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineRenderingCreateInfoKHR* toTransform);
void transform_tohost_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDynamicRenderingFeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDynamicRenderingFeaturesKHR* toTransform);
void transform_fromhost_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDynamicRenderingFeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDynamicRenderingFeaturesKHR* toTransform);
void transform_tohost_VkCommandBufferInheritanceRenderingInfoKHR(
- ResourceTracker* resourceTracker,
- VkCommandBufferInheritanceRenderingInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkCommandBufferInheritanceRenderingInfoKHR* toTransform);
void transform_fromhost_VkCommandBufferInheritanceRenderingInfoKHR(
- ResourceTracker* resourceTracker,
- VkCommandBufferInheritanceRenderingInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkCommandBufferInheritanceRenderingInfoKHR* toTransform);
void transform_tohost_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- ResourceTracker* resourceTracker,
- VkRenderingFragmentShadingRateAttachmentInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkRenderingFragmentShadingRateAttachmentInfoKHR* toTransform);
void transform_fromhost_VkRenderingFragmentShadingRateAttachmentInfoKHR(
- ResourceTracker* resourceTracker,
- VkRenderingFragmentShadingRateAttachmentInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkRenderingFragmentShadingRateAttachmentInfoKHR* toTransform);
void transform_tohost_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- ResourceTracker* resourceTracker,
- VkRenderingFragmentDensityMapAttachmentInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkRenderingFragmentDensityMapAttachmentInfoEXT* toTransform);
void transform_fromhost_VkRenderingFragmentDensityMapAttachmentInfoEXT(
- ResourceTracker* resourceTracker,
- VkRenderingFragmentDensityMapAttachmentInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkRenderingFragmentDensityMapAttachmentInfoEXT* toTransform);
-void transform_tohost_VkAttachmentSampleCountInfoAMD(
- ResourceTracker* resourceTracker,
- VkAttachmentSampleCountInfoAMD* toTransform);
+void transform_tohost_VkAttachmentSampleCountInfoAMD(ResourceTracker* resourceTracker,
+ VkAttachmentSampleCountInfoAMD* toTransform);
-void transform_fromhost_VkAttachmentSampleCountInfoAMD(
- ResourceTracker* resourceTracker,
- VkAttachmentSampleCountInfoAMD* toTransform);
+void transform_fromhost_VkAttachmentSampleCountInfoAMD(ResourceTracker* resourceTracker,
+ VkAttachmentSampleCountInfoAMD* toTransform);
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkAttachmentSampleCountInfoAMD, transform_tohost_VkAttachmentSampleCountInfoNV)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkAttachmentSampleCountInfoAMD,
+ transform_tohost_VkAttachmentSampleCountInfoNV)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkAttachmentSampleCountInfoAMD, transform_fromhost_VkAttachmentSampleCountInfoNV)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkAttachmentSampleCountInfoAMD,
+ transform_fromhost_VkAttachmentSampleCountInfoNV)
void transform_tohost_VkMultiviewPerViewAttributesInfoNVX(
- ResourceTracker* resourceTracker,
- VkMultiviewPerViewAttributesInfoNVX* toTransform);
+ ResourceTracker* resourceTracker, VkMultiviewPerViewAttributesInfoNVX* toTransform);
void transform_fromhost_VkMultiviewPerViewAttributesInfoNVX(
- ResourceTracker* resourceTracker,
- VkMultiviewPerViewAttributesInfoNVX* toTransform);
+ ResourceTracker* resourceTracker, VkMultiviewPerViewAttributesInfoNVX* toTransform);
#endif
#ifdef VK_KHR_multiview
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkRenderPassMultiviewCreateInfo, transform_tohost_VkRenderPassMultiviewCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkRenderPassMultiviewCreateInfo,
+ transform_tohost_VkRenderPassMultiviewCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkRenderPassMultiviewCreateInfo, transform_fromhost_VkRenderPassMultiviewCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkRenderPassMultiviewCreateInfo,
+ transform_fromhost_VkRenderPassMultiviewCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceMultiviewFeatures, transform_tohost_VkPhysicalDeviceMultiviewFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceMultiviewFeatures,
+ transform_tohost_VkPhysicalDeviceMultiviewFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceMultiviewFeatures, transform_fromhost_VkPhysicalDeviceMultiviewFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceMultiviewFeatures,
+ transform_fromhost_VkPhysicalDeviceMultiviewFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceMultiviewProperties, transform_tohost_VkPhysicalDeviceMultiviewPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceMultiviewProperties,
+ transform_tohost_VkPhysicalDeviceMultiviewPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceMultiviewProperties, transform_fromhost_VkPhysicalDeviceMultiviewPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceMultiviewProperties,
+ transform_fromhost_VkPhysicalDeviceMultiviewPropertiesKHR)
#endif
#ifdef VK_KHR_get_physical_device_properties2
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceFeatures2, transform_tohost_VkPhysicalDeviceFeatures2KHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceFeatures2,
+ transform_tohost_VkPhysicalDeviceFeatures2KHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceFeatures2, transform_fromhost_VkPhysicalDeviceFeatures2KHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceFeatures2,
+ transform_fromhost_VkPhysicalDeviceFeatures2KHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceProperties2, transform_tohost_VkPhysicalDeviceProperties2KHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceProperties2,
+ transform_tohost_VkPhysicalDeviceProperties2KHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceProperties2, transform_fromhost_VkPhysicalDeviceProperties2KHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceProperties2,
+ transform_fromhost_VkPhysicalDeviceProperties2KHR)
DEFINE_ALIAS_FUNCTION(transform_tohost_VkFormatProperties2, transform_tohost_VkFormatProperties2KHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkFormatProperties2, transform_fromhost_VkFormatProperties2KHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkFormatProperties2,
+ transform_fromhost_VkFormatProperties2KHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageFormatProperties2, transform_tohost_VkImageFormatProperties2KHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageFormatProperties2,
+ transform_tohost_VkImageFormatProperties2KHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageFormatProperties2, transform_fromhost_VkImageFormatProperties2KHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageFormatProperties2,
+ transform_fromhost_VkImageFormatProperties2KHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceImageFormatInfo2, transform_tohost_VkPhysicalDeviceImageFormatInfo2KHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceImageFormatInfo2,
+ transform_tohost_VkPhysicalDeviceImageFormatInfo2KHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceImageFormatInfo2, transform_fromhost_VkPhysicalDeviceImageFormatInfo2KHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceImageFormatInfo2,
+ transform_fromhost_VkPhysicalDeviceImageFormatInfo2KHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkQueueFamilyProperties2, transform_tohost_VkQueueFamilyProperties2KHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkQueueFamilyProperties2,
+ transform_tohost_VkQueueFamilyProperties2KHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkQueueFamilyProperties2, transform_fromhost_VkQueueFamilyProperties2KHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkQueueFamilyProperties2,
+ transform_fromhost_VkQueueFamilyProperties2KHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceMemoryProperties2, transform_tohost_VkPhysicalDeviceMemoryProperties2KHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceMemoryProperties2,
+ transform_tohost_VkPhysicalDeviceMemoryProperties2KHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceMemoryProperties2, transform_fromhost_VkPhysicalDeviceMemoryProperties2KHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceMemoryProperties2,
+ transform_fromhost_VkPhysicalDeviceMemoryProperties2KHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkSparseImageFormatProperties2, transform_tohost_VkSparseImageFormatProperties2KHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkSparseImageFormatProperties2,
+ transform_tohost_VkSparseImageFormatProperties2KHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSparseImageFormatProperties2, transform_fromhost_VkSparseImageFormatProperties2KHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSparseImageFormatProperties2,
+ transform_fromhost_VkSparseImageFormatProperties2KHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceSparseImageFormatInfo2, transform_tohost_VkPhysicalDeviceSparseImageFormatInfo2KHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceSparseImageFormatInfo2,
+ transform_tohost_VkPhysicalDeviceSparseImageFormatInfo2KHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceSparseImageFormatInfo2, transform_fromhost_VkPhysicalDeviceSparseImageFormatInfo2KHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceSparseImageFormatInfo2,
+ transform_fromhost_VkPhysicalDeviceSparseImageFormatInfo2KHR)
#endif
#ifdef VK_KHR_device_group
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkMemoryAllocateFlagsInfo, transform_tohost_VkMemoryAllocateFlagsInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkMemoryAllocateFlagsInfo,
+ transform_tohost_VkMemoryAllocateFlagsInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkMemoryAllocateFlagsInfo, transform_fromhost_VkMemoryAllocateFlagsInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkMemoryAllocateFlagsInfo,
+ transform_fromhost_VkMemoryAllocateFlagsInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkDeviceGroupRenderPassBeginInfo, transform_tohost_VkDeviceGroupRenderPassBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkDeviceGroupRenderPassBeginInfo,
+ transform_tohost_VkDeviceGroupRenderPassBeginInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDeviceGroupRenderPassBeginInfo, transform_fromhost_VkDeviceGroupRenderPassBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDeviceGroupRenderPassBeginInfo,
+ transform_fromhost_VkDeviceGroupRenderPassBeginInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkDeviceGroupCommandBufferBeginInfo, transform_tohost_VkDeviceGroupCommandBufferBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkDeviceGroupCommandBufferBeginInfo,
+ transform_tohost_VkDeviceGroupCommandBufferBeginInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDeviceGroupCommandBufferBeginInfo, transform_fromhost_VkDeviceGroupCommandBufferBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDeviceGroupCommandBufferBeginInfo,
+ transform_fromhost_VkDeviceGroupCommandBufferBeginInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkDeviceGroupSubmitInfo, transform_tohost_VkDeviceGroupSubmitInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkDeviceGroupSubmitInfo,
+ transform_tohost_VkDeviceGroupSubmitInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDeviceGroupSubmitInfo, transform_fromhost_VkDeviceGroupSubmitInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDeviceGroupSubmitInfo,
+ transform_fromhost_VkDeviceGroupSubmitInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkDeviceGroupBindSparseInfo, transform_tohost_VkDeviceGroupBindSparseInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkDeviceGroupBindSparseInfo,
+ transform_tohost_VkDeviceGroupBindSparseInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDeviceGroupBindSparseInfo, transform_fromhost_VkDeviceGroupBindSparseInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDeviceGroupBindSparseInfo,
+ transform_fromhost_VkDeviceGroupBindSparseInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkBindBufferMemoryDeviceGroupInfo, transform_tohost_VkBindBufferMemoryDeviceGroupInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkBindBufferMemoryDeviceGroupInfo,
+ transform_tohost_VkBindBufferMemoryDeviceGroupInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBindBufferMemoryDeviceGroupInfo, transform_fromhost_VkBindBufferMemoryDeviceGroupInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBindBufferMemoryDeviceGroupInfo,
+ transform_fromhost_VkBindBufferMemoryDeviceGroupInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkBindImageMemoryDeviceGroupInfo, transform_tohost_VkBindImageMemoryDeviceGroupInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkBindImageMemoryDeviceGroupInfo,
+ transform_tohost_VkBindImageMemoryDeviceGroupInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBindImageMemoryDeviceGroupInfo, transform_fromhost_VkBindImageMemoryDeviceGroupInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBindImageMemoryDeviceGroupInfo,
+ transform_fromhost_VkBindImageMemoryDeviceGroupInfoKHR)
#endif
#ifdef VK_KHR_shader_draw_parameters
@@ -2407,297 +1879,317 @@
#ifdef VK_KHR_maintenance1
#endif
#ifdef VK_KHR_device_group_creation
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceGroupProperties, transform_tohost_VkPhysicalDeviceGroupPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceGroupProperties,
+ transform_tohost_VkPhysicalDeviceGroupPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceGroupProperties, transform_fromhost_VkPhysicalDeviceGroupPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceGroupProperties,
+ transform_fromhost_VkPhysicalDeviceGroupPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkDeviceGroupDeviceCreateInfo, transform_tohost_VkDeviceGroupDeviceCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkDeviceGroupDeviceCreateInfo,
+ transform_tohost_VkDeviceGroupDeviceCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDeviceGroupDeviceCreateInfo, transform_fromhost_VkDeviceGroupDeviceCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDeviceGroupDeviceCreateInfo,
+ transform_fromhost_VkDeviceGroupDeviceCreateInfoKHR)
#endif
#ifdef VK_KHR_external_memory_capabilities
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkExternalMemoryProperties, transform_tohost_VkExternalMemoryPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkExternalMemoryProperties,
+ transform_tohost_VkExternalMemoryPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkExternalMemoryProperties, transform_fromhost_VkExternalMemoryPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkExternalMemoryProperties,
+ transform_fromhost_VkExternalMemoryPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceExternalImageFormatInfo, transform_tohost_VkPhysicalDeviceExternalImageFormatInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceExternalImageFormatInfo,
+ transform_tohost_VkPhysicalDeviceExternalImageFormatInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceExternalImageFormatInfo, transform_fromhost_VkPhysicalDeviceExternalImageFormatInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceExternalImageFormatInfo,
+ transform_fromhost_VkPhysicalDeviceExternalImageFormatInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkExternalImageFormatProperties, transform_tohost_VkExternalImageFormatPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkExternalImageFormatProperties,
+ transform_tohost_VkExternalImageFormatPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkExternalImageFormatProperties, transform_fromhost_VkExternalImageFormatPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkExternalImageFormatProperties,
+ transform_fromhost_VkExternalImageFormatPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceExternalBufferInfo, transform_tohost_VkPhysicalDeviceExternalBufferInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceExternalBufferInfo,
+ transform_tohost_VkPhysicalDeviceExternalBufferInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceExternalBufferInfo, transform_fromhost_VkPhysicalDeviceExternalBufferInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceExternalBufferInfo,
+ transform_fromhost_VkPhysicalDeviceExternalBufferInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkExternalBufferProperties, transform_tohost_VkExternalBufferPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkExternalBufferProperties,
+ transform_tohost_VkExternalBufferPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkExternalBufferProperties, transform_fromhost_VkExternalBufferPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkExternalBufferProperties,
+ transform_fromhost_VkExternalBufferPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceIDProperties, transform_tohost_VkPhysicalDeviceIDPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceIDProperties,
+ transform_tohost_VkPhysicalDeviceIDPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceIDProperties, transform_fromhost_VkPhysicalDeviceIDPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceIDProperties,
+ transform_fromhost_VkPhysicalDeviceIDPropertiesKHR)
#endif
#ifdef VK_KHR_external_memory
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkExternalMemoryImageCreateInfo, transform_tohost_VkExternalMemoryImageCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkExternalMemoryImageCreateInfo,
+ transform_tohost_VkExternalMemoryImageCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkExternalMemoryImageCreateInfo, transform_fromhost_VkExternalMemoryImageCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkExternalMemoryImageCreateInfo,
+ transform_fromhost_VkExternalMemoryImageCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkExternalMemoryBufferCreateInfo, transform_tohost_VkExternalMemoryBufferCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkExternalMemoryBufferCreateInfo,
+ transform_tohost_VkExternalMemoryBufferCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkExternalMemoryBufferCreateInfo, transform_fromhost_VkExternalMemoryBufferCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkExternalMemoryBufferCreateInfo,
+ transform_fromhost_VkExternalMemoryBufferCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkExportMemoryAllocateInfo, transform_tohost_VkExportMemoryAllocateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkExportMemoryAllocateInfo,
+ transform_tohost_VkExportMemoryAllocateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkExportMemoryAllocateInfo, transform_fromhost_VkExportMemoryAllocateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkExportMemoryAllocateInfo,
+ transform_fromhost_VkExportMemoryAllocateInfoKHR)
#endif
#ifdef VK_KHR_external_memory_win32
void transform_tohost_VkImportMemoryWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportMemoryWin32HandleInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkImportMemoryWin32HandleInfoKHR* toTransform);
void transform_fromhost_VkImportMemoryWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportMemoryWin32HandleInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkImportMemoryWin32HandleInfoKHR* toTransform);
void transform_tohost_VkExportMemoryWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkExportMemoryWin32HandleInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkExportMemoryWin32HandleInfoKHR* toTransform);
void transform_fromhost_VkExportMemoryWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkExportMemoryWin32HandleInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkExportMemoryWin32HandleInfoKHR* toTransform);
void transform_tohost_VkMemoryWin32HandlePropertiesKHR(
- ResourceTracker* resourceTracker,
- VkMemoryWin32HandlePropertiesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkMemoryWin32HandlePropertiesKHR* toTransform);
void transform_fromhost_VkMemoryWin32HandlePropertiesKHR(
- ResourceTracker* resourceTracker,
- VkMemoryWin32HandlePropertiesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkMemoryWin32HandlePropertiesKHR* toTransform);
-void transform_tohost_VkMemoryGetWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkMemoryGetWin32HandleInfoKHR* toTransform);
+void transform_tohost_VkMemoryGetWin32HandleInfoKHR(ResourceTracker* resourceTracker,
+ VkMemoryGetWin32HandleInfoKHR* toTransform);
-void transform_fromhost_VkMemoryGetWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkMemoryGetWin32HandleInfoKHR* toTransform);
+void transform_fromhost_VkMemoryGetWin32HandleInfoKHR(ResourceTracker* resourceTracker,
+ VkMemoryGetWin32HandleInfoKHR* toTransform);
#endif
#ifdef VK_KHR_external_memory_fd
-void transform_tohost_VkImportMemoryFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportMemoryFdInfoKHR* toTransform);
+void transform_tohost_VkImportMemoryFdInfoKHR(ResourceTracker* resourceTracker,
+ VkImportMemoryFdInfoKHR* toTransform);
-void transform_fromhost_VkImportMemoryFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportMemoryFdInfoKHR* toTransform);
+void transform_fromhost_VkImportMemoryFdInfoKHR(ResourceTracker* resourceTracker,
+ VkImportMemoryFdInfoKHR* toTransform);
-void transform_tohost_VkMemoryFdPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkMemoryFdPropertiesKHR* toTransform);
+void transform_tohost_VkMemoryFdPropertiesKHR(ResourceTracker* resourceTracker,
+ VkMemoryFdPropertiesKHR* toTransform);
-void transform_fromhost_VkMemoryFdPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkMemoryFdPropertiesKHR* toTransform);
+void transform_fromhost_VkMemoryFdPropertiesKHR(ResourceTracker* resourceTracker,
+ VkMemoryFdPropertiesKHR* toTransform);
-void transform_tohost_VkMemoryGetFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkMemoryGetFdInfoKHR* toTransform);
+void transform_tohost_VkMemoryGetFdInfoKHR(ResourceTracker* resourceTracker,
+ VkMemoryGetFdInfoKHR* toTransform);
-void transform_fromhost_VkMemoryGetFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkMemoryGetFdInfoKHR* toTransform);
+void transform_fromhost_VkMemoryGetFdInfoKHR(ResourceTracker* resourceTracker,
+ VkMemoryGetFdInfoKHR* toTransform);
#endif
#ifdef VK_KHR_win32_keyed_mutex
void transform_tohost_VkWin32KeyedMutexAcquireReleaseInfoKHR(
- ResourceTracker* resourceTracker,
- VkWin32KeyedMutexAcquireReleaseInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkWin32KeyedMutexAcquireReleaseInfoKHR* toTransform);
void transform_fromhost_VkWin32KeyedMutexAcquireReleaseInfoKHR(
- ResourceTracker* resourceTracker,
- VkWin32KeyedMutexAcquireReleaseInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkWin32KeyedMutexAcquireReleaseInfoKHR* toTransform);
#endif
#ifdef VK_KHR_external_semaphore_capabilities
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceExternalSemaphoreInfo, transform_tohost_VkPhysicalDeviceExternalSemaphoreInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceExternalSemaphoreInfo,
+ transform_tohost_VkPhysicalDeviceExternalSemaphoreInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceExternalSemaphoreInfo, transform_fromhost_VkPhysicalDeviceExternalSemaphoreInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceExternalSemaphoreInfo,
+ transform_fromhost_VkPhysicalDeviceExternalSemaphoreInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkExternalSemaphoreProperties, transform_tohost_VkExternalSemaphorePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkExternalSemaphoreProperties,
+ transform_tohost_VkExternalSemaphorePropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkExternalSemaphoreProperties, transform_fromhost_VkExternalSemaphorePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkExternalSemaphoreProperties,
+ transform_fromhost_VkExternalSemaphorePropertiesKHR)
#endif
#ifdef VK_KHR_external_semaphore
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkExportSemaphoreCreateInfo, transform_tohost_VkExportSemaphoreCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkExportSemaphoreCreateInfo,
+ transform_tohost_VkExportSemaphoreCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkExportSemaphoreCreateInfo, transform_fromhost_VkExportSemaphoreCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkExportSemaphoreCreateInfo,
+ transform_fromhost_VkExportSemaphoreCreateInfoKHR)
#endif
#ifdef VK_KHR_external_semaphore_win32
void transform_tohost_VkImportSemaphoreWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportSemaphoreWin32HandleInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkImportSemaphoreWin32HandleInfoKHR* toTransform);
void transform_fromhost_VkImportSemaphoreWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportSemaphoreWin32HandleInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkImportSemaphoreWin32HandleInfoKHR* toTransform);
void transform_tohost_VkExportSemaphoreWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkExportSemaphoreWin32HandleInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkExportSemaphoreWin32HandleInfoKHR* toTransform);
void transform_fromhost_VkExportSemaphoreWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkExportSemaphoreWin32HandleInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkExportSemaphoreWin32HandleInfoKHR* toTransform);
-void transform_tohost_VkD3D12FenceSubmitInfoKHR(
- ResourceTracker* resourceTracker,
- VkD3D12FenceSubmitInfoKHR* toTransform);
+void transform_tohost_VkD3D12FenceSubmitInfoKHR(ResourceTracker* resourceTracker,
+ VkD3D12FenceSubmitInfoKHR* toTransform);
-void transform_fromhost_VkD3D12FenceSubmitInfoKHR(
- ResourceTracker* resourceTracker,
- VkD3D12FenceSubmitInfoKHR* toTransform);
+void transform_fromhost_VkD3D12FenceSubmitInfoKHR(ResourceTracker* resourceTracker,
+ VkD3D12FenceSubmitInfoKHR* toTransform);
void transform_tohost_VkSemaphoreGetWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkSemaphoreGetWin32HandleInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkSemaphoreGetWin32HandleInfoKHR* toTransform);
void transform_fromhost_VkSemaphoreGetWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkSemaphoreGetWin32HandleInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkSemaphoreGetWin32HandleInfoKHR* toTransform);
#endif
#ifdef VK_KHR_external_semaphore_fd
-void transform_tohost_VkImportSemaphoreFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportSemaphoreFdInfoKHR* toTransform);
+void transform_tohost_VkImportSemaphoreFdInfoKHR(ResourceTracker* resourceTracker,
+ VkImportSemaphoreFdInfoKHR* toTransform);
-void transform_fromhost_VkImportSemaphoreFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportSemaphoreFdInfoKHR* toTransform);
+void transform_fromhost_VkImportSemaphoreFdInfoKHR(ResourceTracker* resourceTracker,
+ VkImportSemaphoreFdInfoKHR* toTransform);
-void transform_tohost_VkSemaphoreGetFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkSemaphoreGetFdInfoKHR* toTransform);
+void transform_tohost_VkSemaphoreGetFdInfoKHR(ResourceTracker* resourceTracker,
+ VkSemaphoreGetFdInfoKHR* toTransform);
-void transform_fromhost_VkSemaphoreGetFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkSemaphoreGetFdInfoKHR* toTransform);
+void transform_fromhost_VkSemaphoreGetFdInfoKHR(ResourceTracker* resourceTracker,
+ VkSemaphoreGetFdInfoKHR* toTransform);
#endif
#ifdef VK_KHR_push_descriptor
void transform_tohost_VkPhysicalDevicePushDescriptorPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePushDescriptorPropertiesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevicePushDescriptorPropertiesKHR* toTransform);
void transform_fromhost_VkPhysicalDevicePushDescriptorPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePushDescriptorPropertiesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevicePushDescriptorPropertiesKHR* toTransform);
#endif
#ifdef VK_KHR_shader_float16_int8
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceShaderFloat16Int8Features, transform_tohost_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceShaderFloat16Int8Features,
+ transform_tohost_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceShaderFloat16Int8Features, transform_fromhost_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceShaderFloat16Int8Features,
+ transform_fromhost_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceShaderFloat16Int8Features, transform_tohost_VkPhysicalDeviceFloat16Int8FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceShaderFloat16Int8Features,
+ transform_tohost_VkPhysicalDeviceFloat16Int8FeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceShaderFloat16Int8Features, transform_fromhost_VkPhysicalDeviceFloat16Int8FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceShaderFloat16Int8Features,
+ transform_fromhost_VkPhysicalDeviceFloat16Int8FeaturesKHR)
#endif
#ifdef VK_KHR_16bit_storage
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDevice16BitStorageFeatures, transform_tohost_VkPhysicalDevice16BitStorageFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDevice16BitStorageFeatures,
+ transform_tohost_VkPhysicalDevice16BitStorageFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDevice16BitStorageFeatures, transform_fromhost_VkPhysicalDevice16BitStorageFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDevice16BitStorageFeatures,
+ transform_fromhost_VkPhysicalDevice16BitStorageFeaturesKHR)
#endif
#ifdef VK_KHR_incremental_present
-void transform_tohost_VkRectLayerKHR(
- ResourceTracker* resourceTracker,
- VkRectLayerKHR* toTransform);
+void transform_tohost_VkRectLayerKHR(ResourceTracker* resourceTracker, VkRectLayerKHR* toTransform);
-void transform_fromhost_VkRectLayerKHR(
- ResourceTracker* resourceTracker,
- VkRectLayerKHR* toTransform);
+void transform_fromhost_VkRectLayerKHR(ResourceTracker* resourceTracker,
+ VkRectLayerKHR* toTransform);
-void transform_tohost_VkPresentRegionKHR(
- ResourceTracker* resourceTracker,
- VkPresentRegionKHR* toTransform);
+void transform_tohost_VkPresentRegionKHR(ResourceTracker* resourceTracker,
+ VkPresentRegionKHR* toTransform);
-void transform_fromhost_VkPresentRegionKHR(
- ResourceTracker* resourceTracker,
- VkPresentRegionKHR* toTransform);
+void transform_fromhost_VkPresentRegionKHR(ResourceTracker* resourceTracker,
+ VkPresentRegionKHR* toTransform);
-void transform_tohost_VkPresentRegionsKHR(
- ResourceTracker* resourceTracker,
- VkPresentRegionsKHR* toTransform);
+void transform_tohost_VkPresentRegionsKHR(ResourceTracker* resourceTracker,
+ VkPresentRegionsKHR* toTransform);
-void transform_fromhost_VkPresentRegionsKHR(
- ResourceTracker* resourceTracker,
- VkPresentRegionsKHR* toTransform);
+void transform_fromhost_VkPresentRegionsKHR(ResourceTracker* resourceTracker,
+ VkPresentRegionsKHR* toTransform);
#endif
#ifdef VK_KHR_descriptor_update_template
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkDescriptorUpdateTemplateEntry, transform_tohost_VkDescriptorUpdateTemplateEntryKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkDescriptorUpdateTemplateEntry,
+ transform_tohost_VkDescriptorUpdateTemplateEntryKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDescriptorUpdateTemplateEntry, transform_fromhost_VkDescriptorUpdateTemplateEntryKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDescriptorUpdateTemplateEntry,
+ transform_fromhost_VkDescriptorUpdateTemplateEntryKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkDescriptorUpdateTemplateCreateInfo, transform_tohost_VkDescriptorUpdateTemplateCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkDescriptorUpdateTemplateCreateInfo,
+ transform_tohost_VkDescriptorUpdateTemplateCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDescriptorUpdateTemplateCreateInfo, transform_fromhost_VkDescriptorUpdateTemplateCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDescriptorUpdateTemplateCreateInfo,
+ transform_fromhost_VkDescriptorUpdateTemplateCreateInfoKHR)
#endif
#ifdef VK_KHR_imageless_framebuffer
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceImagelessFramebufferFeatures, transform_tohost_VkPhysicalDeviceImagelessFramebufferFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceImagelessFramebufferFeatures,
+ transform_tohost_VkPhysicalDeviceImagelessFramebufferFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceImagelessFramebufferFeatures, transform_fromhost_VkPhysicalDeviceImagelessFramebufferFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceImagelessFramebufferFeatures,
+ transform_fromhost_VkPhysicalDeviceImagelessFramebufferFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkFramebufferAttachmentsCreateInfo, transform_tohost_VkFramebufferAttachmentsCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkFramebufferAttachmentsCreateInfo,
+ transform_tohost_VkFramebufferAttachmentsCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkFramebufferAttachmentsCreateInfo, transform_fromhost_VkFramebufferAttachmentsCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkFramebufferAttachmentsCreateInfo,
+ transform_fromhost_VkFramebufferAttachmentsCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkFramebufferAttachmentImageInfo, transform_tohost_VkFramebufferAttachmentImageInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkFramebufferAttachmentImageInfo,
+ transform_tohost_VkFramebufferAttachmentImageInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkFramebufferAttachmentImageInfo, transform_fromhost_VkFramebufferAttachmentImageInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkFramebufferAttachmentImageInfo,
+ transform_fromhost_VkFramebufferAttachmentImageInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkRenderPassAttachmentBeginInfo, transform_tohost_VkRenderPassAttachmentBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkRenderPassAttachmentBeginInfo,
+ transform_tohost_VkRenderPassAttachmentBeginInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkRenderPassAttachmentBeginInfo, transform_fromhost_VkRenderPassAttachmentBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkRenderPassAttachmentBeginInfo,
+ transform_fromhost_VkRenderPassAttachmentBeginInfoKHR)
#endif
#ifdef VK_KHR_create_renderpass2
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkRenderPassCreateInfo2, transform_tohost_VkRenderPassCreateInfo2KHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkRenderPassCreateInfo2,
+ transform_tohost_VkRenderPassCreateInfo2KHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkRenderPassCreateInfo2, transform_fromhost_VkRenderPassCreateInfo2KHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkRenderPassCreateInfo2,
+ transform_fromhost_VkRenderPassCreateInfo2KHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkAttachmentDescription2, transform_tohost_VkAttachmentDescription2KHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkAttachmentDescription2,
+ transform_tohost_VkAttachmentDescription2KHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkAttachmentDescription2, transform_fromhost_VkAttachmentDescription2KHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkAttachmentDescription2,
+ transform_fromhost_VkAttachmentDescription2KHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkAttachmentReference2, transform_tohost_VkAttachmentReference2KHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkAttachmentReference2,
+ transform_tohost_VkAttachmentReference2KHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkAttachmentReference2, transform_fromhost_VkAttachmentReference2KHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkAttachmentReference2,
+ transform_fromhost_VkAttachmentReference2KHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkSubpassDescription2, transform_tohost_VkSubpassDescription2KHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkSubpassDescription2,
+ transform_tohost_VkSubpassDescription2KHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSubpassDescription2, transform_fromhost_VkSubpassDescription2KHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSubpassDescription2,
+ transform_fromhost_VkSubpassDescription2KHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkSubpassDependency2, transform_tohost_VkSubpassDependency2KHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkSubpassDependency2,
+ transform_tohost_VkSubpassDependency2KHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSubpassDependency2, transform_fromhost_VkSubpassDependency2KHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSubpassDependency2,
+ transform_fromhost_VkSubpassDependency2KHR)
DEFINE_ALIAS_FUNCTION(transform_tohost_VkSubpassBeginInfo, transform_tohost_VkSubpassBeginInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSubpassBeginInfo, transform_fromhost_VkSubpassBeginInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSubpassBeginInfo,
+ transform_fromhost_VkSubpassBeginInfoKHR)
DEFINE_ALIAS_FUNCTION(transform_tohost_VkSubpassEndInfo, transform_tohost_VkSubpassEndInfoKHR)
@@ -2706,248 +2198,228 @@
#endif
#ifdef VK_KHR_shared_presentable_image
void transform_tohost_VkSharedPresentSurfaceCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkSharedPresentSurfaceCapabilitiesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkSharedPresentSurfaceCapabilitiesKHR* toTransform);
void transform_fromhost_VkSharedPresentSurfaceCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkSharedPresentSurfaceCapabilitiesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkSharedPresentSurfaceCapabilitiesKHR* toTransform);
#endif
#ifdef VK_KHR_external_fence_capabilities
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceExternalFenceInfo, transform_tohost_VkPhysicalDeviceExternalFenceInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceExternalFenceInfo,
+ transform_tohost_VkPhysicalDeviceExternalFenceInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceExternalFenceInfo, transform_fromhost_VkPhysicalDeviceExternalFenceInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceExternalFenceInfo,
+ transform_fromhost_VkPhysicalDeviceExternalFenceInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkExternalFenceProperties, transform_tohost_VkExternalFencePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkExternalFenceProperties,
+ transform_tohost_VkExternalFencePropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkExternalFenceProperties, transform_fromhost_VkExternalFencePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkExternalFenceProperties,
+ transform_fromhost_VkExternalFencePropertiesKHR)
#endif
#ifdef VK_KHR_external_fence
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkExportFenceCreateInfo, transform_tohost_VkExportFenceCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkExportFenceCreateInfo,
+ transform_tohost_VkExportFenceCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkExportFenceCreateInfo, transform_fromhost_VkExportFenceCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkExportFenceCreateInfo,
+ transform_fromhost_VkExportFenceCreateInfoKHR)
#endif
#ifdef VK_KHR_external_fence_win32
-void transform_tohost_VkImportFenceWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportFenceWin32HandleInfoKHR* toTransform);
+void transform_tohost_VkImportFenceWin32HandleInfoKHR(ResourceTracker* resourceTracker,
+ VkImportFenceWin32HandleInfoKHR* toTransform);
void transform_fromhost_VkImportFenceWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportFenceWin32HandleInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkImportFenceWin32HandleInfoKHR* toTransform);
-void transform_tohost_VkExportFenceWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkExportFenceWin32HandleInfoKHR* toTransform);
+void transform_tohost_VkExportFenceWin32HandleInfoKHR(ResourceTracker* resourceTracker,
+ VkExportFenceWin32HandleInfoKHR* toTransform);
void transform_fromhost_VkExportFenceWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkExportFenceWin32HandleInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkExportFenceWin32HandleInfoKHR* toTransform);
-void transform_tohost_VkFenceGetWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkFenceGetWin32HandleInfoKHR* toTransform);
+void transform_tohost_VkFenceGetWin32HandleInfoKHR(ResourceTracker* resourceTracker,
+ VkFenceGetWin32HandleInfoKHR* toTransform);
-void transform_fromhost_VkFenceGetWin32HandleInfoKHR(
- ResourceTracker* resourceTracker,
- VkFenceGetWin32HandleInfoKHR* toTransform);
+void transform_fromhost_VkFenceGetWin32HandleInfoKHR(ResourceTracker* resourceTracker,
+ VkFenceGetWin32HandleInfoKHR* toTransform);
#endif
#ifdef VK_KHR_external_fence_fd
-void transform_tohost_VkImportFenceFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportFenceFdInfoKHR* toTransform);
+void transform_tohost_VkImportFenceFdInfoKHR(ResourceTracker* resourceTracker,
+ VkImportFenceFdInfoKHR* toTransform);
-void transform_fromhost_VkImportFenceFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkImportFenceFdInfoKHR* toTransform);
+void transform_fromhost_VkImportFenceFdInfoKHR(ResourceTracker* resourceTracker,
+ VkImportFenceFdInfoKHR* toTransform);
-void transform_tohost_VkFenceGetFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkFenceGetFdInfoKHR* toTransform);
+void transform_tohost_VkFenceGetFdInfoKHR(ResourceTracker* resourceTracker,
+ VkFenceGetFdInfoKHR* toTransform);
-void transform_fromhost_VkFenceGetFdInfoKHR(
- ResourceTracker* resourceTracker,
- VkFenceGetFdInfoKHR* toTransform);
+void transform_fromhost_VkFenceGetFdInfoKHR(ResourceTracker* resourceTracker,
+ VkFenceGetFdInfoKHR* toTransform);
#endif
#ifdef VK_KHR_performance_query
void transform_tohost_VkPhysicalDevicePerformanceQueryFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePerformanceQueryFeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevicePerformanceQueryFeaturesKHR* toTransform);
void transform_fromhost_VkPhysicalDevicePerformanceQueryFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePerformanceQueryFeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevicePerformanceQueryFeaturesKHR* toTransform);
void transform_tohost_VkPhysicalDevicePerformanceQueryPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePerformanceQueryPropertiesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevicePerformanceQueryPropertiesKHR* toTransform);
void transform_fromhost_VkPhysicalDevicePerformanceQueryPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePerformanceQueryPropertiesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevicePerformanceQueryPropertiesKHR* toTransform);
-void transform_tohost_VkPerformanceCounterKHR(
- ResourceTracker* resourceTracker,
- VkPerformanceCounterKHR* toTransform);
+void transform_tohost_VkPerformanceCounterKHR(ResourceTracker* resourceTracker,
+ VkPerformanceCounterKHR* toTransform);
-void transform_fromhost_VkPerformanceCounterKHR(
- ResourceTracker* resourceTracker,
- VkPerformanceCounterKHR* toTransform);
+void transform_fromhost_VkPerformanceCounterKHR(ResourceTracker* resourceTracker,
+ VkPerformanceCounterKHR* toTransform);
void transform_tohost_VkPerformanceCounterDescriptionKHR(
- ResourceTracker* resourceTracker,
- VkPerformanceCounterDescriptionKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPerformanceCounterDescriptionKHR* toTransform);
void transform_fromhost_VkPerformanceCounterDescriptionKHR(
- ResourceTracker* resourceTracker,
- VkPerformanceCounterDescriptionKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPerformanceCounterDescriptionKHR* toTransform);
void transform_tohost_VkQueryPoolPerformanceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkQueryPoolPerformanceCreateInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkQueryPoolPerformanceCreateInfoKHR* toTransform);
void transform_fromhost_VkQueryPoolPerformanceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkQueryPoolPerformanceCreateInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkQueryPoolPerformanceCreateInfoKHR* toTransform);
-void transform_tohost_VkPerformanceCounterResultKHR(
- ResourceTracker* resourceTracker,
- VkPerformanceCounterResultKHR* toTransform);
+void transform_tohost_VkPerformanceCounterResultKHR(ResourceTracker* resourceTracker,
+ VkPerformanceCounterResultKHR* toTransform);
-void transform_fromhost_VkPerformanceCounterResultKHR(
- ResourceTracker* resourceTracker,
- VkPerformanceCounterResultKHR* toTransform);
+void transform_fromhost_VkPerformanceCounterResultKHR(ResourceTracker* resourceTracker,
+ VkPerformanceCounterResultKHR* toTransform);
-void transform_tohost_VkAcquireProfilingLockInfoKHR(
- ResourceTracker* resourceTracker,
- VkAcquireProfilingLockInfoKHR* toTransform);
+void transform_tohost_VkAcquireProfilingLockInfoKHR(ResourceTracker* resourceTracker,
+ VkAcquireProfilingLockInfoKHR* toTransform);
-void transform_fromhost_VkAcquireProfilingLockInfoKHR(
- ResourceTracker* resourceTracker,
- VkAcquireProfilingLockInfoKHR* toTransform);
+void transform_fromhost_VkAcquireProfilingLockInfoKHR(ResourceTracker* resourceTracker,
+ VkAcquireProfilingLockInfoKHR* toTransform);
-void transform_tohost_VkPerformanceQuerySubmitInfoKHR(
- ResourceTracker* resourceTracker,
- VkPerformanceQuerySubmitInfoKHR* toTransform);
+void transform_tohost_VkPerformanceQuerySubmitInfoKHR(ResourceTracker* resourceTracker,
+ VkPerformanceQuerySubmitInfoKHR* toTransform);
void transform_fromhost_VkPerformanceQuerySubmitInfoKHR(
- ResourceTracker* resourceTracker,
- VkPerformanceQuerySubmitInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPerformanceQuerySubmitInfoKHR* toTransform);
#endif
#ifdef VK_KHR_maintenance2
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDevicePointClippingProperties, transform_tohost_VkPhysicalDevicePointClippingPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDevicePointClippingProperties,
+ transform_tohost_VkPhysicalDevicePointClippingPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDevicePointClippingProperties, transform_fromhost_VkPhysicalDevicePointClippingPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDevicePointClippingProperties,
+ transform_fromhost_VkPhysicalDevicePointClippingPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkRenderPassInputAttachmentAspectCreateInfo, transform_tohost_VkRenderPassInputAttachmentAspectCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkRenderPassInputAttachmentAspectCreateInfo,
+ transform_tohost_VkRenderPassInputAttachmentAspectCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkRenderPassInputAttachmentAspectCreateInfo, transform_fromhost_VkRenderPassInputAttachmentAspectCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkRenderPassInputAttachmentAspectCreateInfo,
+ transform_fromhost_VkRenderPassInputAttachmentAspectCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkInputAttachmentAspectReference, transform_tohost_VkInputAttachmentAspectReferenceKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkInputAttachmentAspectReference,
+ transform_tohost_VkInputAttachmentAspectReferenceKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkInputAttachmentAspectReference, transform_fromhost_VkInputAttachmentAspectReferenceKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkInputAttachmentAspectReference,
+ transform_fromhost_VkInputAttachmentAspectReferenceKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageViewUsageCreateInfo, transform_tohost_VkImageViewUsageCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageViewUsageCreateInfo,
+ transform_tohost_VkImageViewUsageCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageViewUsageCreateInfo, transform_fromhost_VkImageViewUsageCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageViewUsageCreateInfo,
+ transform_fromhost_VkImageViewUsageCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPipelineTessellationDomainOriginStateCreateInfo, transform_tohost_VkPipelineTessellationDomainOriginStateCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPipelineTessellationDomainOriginStateCreateInfo,
+ transform_tohost_VkPipelineTessellationDomainOriginStateCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPipelineTessellationDomainOriginStateCreateInfo, transform_fromhost_VkPipelineTessellationDomainOriginStateCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPipelineTessellationDomainOriginStateCreateInfo,
+ transform_fromhost_VkPipelineTessellationDomainOriginStateCreateInfoKHR)
#endif
#ifdef VK_KHR_get_surface_capabilities2
-void transform_tohost_VkPhysicalDeviceSurfaceInfo2KHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSurfaceInfo2KHR* toTransform);
+void transform_tohost_VkPhysicalDeviceSurfaceInfo2KHR(ResourceTracker* resourceTracker,
+ VkPhysicalDeviceSurfaceInfo2KHR* toTransform);
void transform_fromhost_VkPhysicalDeviceSurfaceInfo2KHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSurfaceInfo2KHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSurfaceInfo2KHR* toTransform);
-void transform_tohost_VkSurfaceCapabilities2KHR(
- ResourceTracker* resourceTracker,
- VkSurfaceCapabilities2KHR* toTransform);
+void transform_tohost_VkSurfaceCapabilities2KHR(ResourceTracker* resourceTracker,
+ VkSurfaceCapabilities2KHR* toTransform);
-void transform_fromhost_VkSurfaceCapabilities2KHR(
- ResourceTracker* resourceTracker,
- VkSurfaceCapabilities2KHR* toTransform);
+void transform_fromhost_VkSurfaceCapabilities2KHR(ResourceTracker* resourceTracker,
+ VkSurfaceCapabilities2KHR* toTransform);
-void transform_tohost_VkSurfaceFormat2KHR(
- ResourceTracker* resourceTracker,
- VkSurfaceFormat2KHR* toTransform);
+void transform_tohost_VkSurfaceFormat2KHR(ResourceTracker* resourceTracker,
+ VkSurfaceFormat2KHR* toTransform);
-void transform_fromhost_VkSurfaceFormat2KHR(
- ResourceTracker* resourceTracker,
- VkSurfaceFormat2KHR* toTransform);
+void transform_fromhost_VkSurfaceFormat2KHR(ResourceTracker* resourceTracker,
+ VkSurfaceFormat2KHR* toTransform);
#endif
#ifdef VK_KHR_variable_pointers
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceVariablePointersFeatures, transform_tohost_VkPhysicalDeviceVariablePointerFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceVariablePointersFeatures,
+ transform_tohost_VkPhysicalDeviceVariablePointerFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceVariablePointersFeatures, transform_fromhost_VkPhysicalDeviceVariablePointerFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceVariablePointersFeatures,
+ transform_fromhost_VkPhysicalDeviceVariablePointerFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceVariablePointersFeatures, transform_tohost_VkPhysicalDeviceVariablePointersFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceVariablePointersFeatures,
+ transform_tohost_VkPhysicalDeviceVariablePointersFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceVariablePointersFeatures, transform_fromhost_VkPhysicalDeviceVariablePointersFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceVariablePointersFeatures,
+ transform_fromhost_VkPhysicalDeviceVariablePointersFeaturesKHR)
#endif
#ifdef VK_KHR_get_display_properties2
-void transform_tohost_VkDisplayProperties2KHR(
- ResourceTracker* resourceTracker,
- VkDisplayProperties2KHR* toTransform);
+void transform_tohost_VkDisplayProperties2KHR(ResourceTracker* resourceTracker,
+ VkDisplayProperties2KHR* toTransform);
-void transform_fromhost_VkDisplayProperties2KHR(
- ResourceTracker* resourceTracker,
- VkDisplayProperties2KHR* toTransform);
+void transform_fromhost_VkDisplayProperties2KHR(ResourceTracker* resourceTracker,
+ VkDisplayProperties2KHR* toTransform);
-void transform_tohost_VkDisplayPlaneProperties2KHR(
- ResourceTracker* resourceTracker,
- VkDisplayPlaneProperties2KHR* toTransform);
+void transform_tohost_VkDisplayPlaneProperties2KHR(ResourceTracker* resourceTracker,
+ VkDisplayPlaneProperties2KHR* toTransform);
-void transform_fromhost_VkDisplayPlaneProperties2KHR(
- ResourceTracker* resourceTracker,
- VkDisplayPlaneProperties2KHR* toTransform);
+void transform_fromhost_VkDisplayPlaneProperties2KHR(ResourceTracker* resourceTracker,
+ VkDisplayPlaneProperties2KHR* toTransform);
-void transform_tohost_VkDisplayModeProperties2KHR(
- ResourceTracker* resourceTracker,
- VkDisplayModeProperties2KHR* toTransform);
+void transform_tohost_VkDisplayModeProperties2KHR(ResourceTracker* resourceTracker,
+ VkDisplayModeProperties2KHR* toTransform);
-void transform_fromhost_VkDisplayModeProperties2KHR(
- ResourceTracker* resourceTracker,
- VkDisplayModeProperties2KHR* toTransform);
+void transform_fromhost_VkDisplayModeProperties2KHR(ResourceTracker* resourceTracker,
+ VkDisplayModeProperties2KHR* toTransform);
-void transform_tohost_VkDisplayPlaneInfo2KHR(
- ResourceTracker* resourceTracker,
- VkDisplayPlaneInfo2KHR* toTransform);
+void transform_tohost_VkDisplayPlaneInfo2KHR(ResourceTracker* resourceTracker,
+ VkDisplayPlaneInfo2KHR* toTransform);
-void transform_fromhost_VkDisplayPlaneInfo2KHR(
- ResourceTracker* resourceTracker,
- VkDisplayPlaneInfo2KHR* toTransform);
+void transform_fromhost_VkDisplayPlaneInfo2KHR(ResourceTracker* resourceTracker,
+ VkDisplayPlaneInfo2KHR* toTransform);
-void transform_tohost_VkDisplayPlaneCapabilities2KHR(
- ResourceTracker* resourceTracker,
- VkDisplayPlaneCapabilities2KHR* toTransform);
+void transform_tohost_VkDisplayPlaneCapabilities2KHR(ResourceTracker* resourceTracker,
+ VkDisplayPlaneCapabilities2KHR* toTransform);
-void transform_fromhost_VkDisplayPlaneCapabilities2KHR(
- ResourceTracker* resourceTracker,
- VkDisplayPlaneCapabilities2KHR* toTransform);
+void transform_fromhost_VkDisplayPlaneCapabilities2KHR(ResourceTracker* resourceTracker,
+ VkDisplayPlaneCapabilities2KHR* toTransform);
#endif
#ifdef VK_KHR_dedicated_allocation
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkMemoryDedicatedRequirements, transform_tohost_VkMemoryDedicatedRequirementsKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkMemoryDedicatedRequirements,
+ transform_tohost_VkMemoryDedicatedRequirementsKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkMemoryDedicatedRequirements, transform_fromhost_VkMemoryDedicatedRequirementsKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkMemoryDedicatedRequirements,
+ transform_fromhost_VkMemoryDedicatedRequirementsKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkMemoryDedicatedAllocateInfo, transform_tohost_VkMemoryDedicatedAllocateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkMemoryDedicatedAllocateInfo,
+ transform_tohost_VkMemoryDedicatedAllocateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkMemoryDedicatedAllocateInfo, transform_fromhost_VkMemoryDedicatedAllocateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkMemoryDedicatedAllocateInfo,
+ transform_fromhost_VkMemoryDedicatedAllocateInfoKHR)
#endif
#ifdef VK_KHR_storage_buffer_storage_class
@@ -2955,185 +2427,240 @@
#ifdef VK_KHR_relaxed_block_layout
#endif
#ifdef VK_KHR_get_memory_requirements2
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkBufferMemoryRequirementsInfo2, transform_tohost_VkBufferMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkBufferMemoryRequirementsInfo2,
+ transform_tohost_VkBufferMemoryRequirementsInfo2KHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBufferMemoryRequirementsInfo2, transform_fromhost_VkBufferMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBufferMemoryRequirementsInfo2,
+ transform_fromhost_VkBufferMemoryRequirementsInfo2KHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageMemoryRequirementsInfo2, transform_tohost_VkImageMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageMemoryRequirementsInfo2,
+ transform_tohost_VkImageMemoryRequirementsInfo2KHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageMemoryRequirementsInfo2, transform_fromhost_VkImageMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageMemoryRequirementsInfo2,
+ transform_fromhost_VkImageMemoryRequirementsInfo2KHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageSparseMemoryRequirementsInfo2, transform_tohost_VkImageSparseMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageSparseMemoryRequirementsInfo2,
+ transform_tohost_VkImageSparseMemoryRequirementsInfo2KHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageSparseMemoryRequirementsInfo2, transform_fromhost_VkImageSparseMemoryRequirementsInfo2KHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageSparseMemoryRequirementsInfo2,
+ transform_fromhost_VkImageSparseMemoryRequirementsInfo2KHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkMemoryRequirements2, transform_tohost_VkMemoryRequirements2KHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkMemoryRequirements2,
+ transform_tohost_VkMemoryRequirements2KHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkMemoryRequirements2, transform_fromhost_VkMemoryRequirements2KHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkMemoryRequirements2,
+ transform_fromhost_VkMemoryRequirements2KHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkSparseImageMemoryRequirements2, transform_tohost_VkSparseImageMemoryRequirements2KHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkSparseImageMemoryRequirements2,
+ transform_tohost_VkSparseImageMemoryRequirements2KHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSparseImageMemoryRequirements2, transform_fromhost_VkSparseImageMemoryRequirements2KHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSparseImageMemoryRequirements2,
+ transform_fromhost_VkSparseImageMemoryRequirements2KHR)
#endif
#ifdef VK_KHR_image_format_list
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageFormatListCreateInfo, transform_tohost_VkImageFormatListCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageFormatListCreateInfo,
+ transform_tohost_VkImageFormatListCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageFormatListCreateInfo, transform_fromhost_VkImageFormatListCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageFormatListCreateInfo,
+ transform_fromhost_VkImageFormatListCreateInfoKHR)
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkSamplerYcbcrConversionCreateInfo, transform_tohost_VkSamplerYcbcrConversionCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkSamplerYcbcrConversionCreateInfo,
+ transform_tohost_VkSamplerYcbcrConversionCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSamplerYcbcrConversionCreateInfo, transform_fromhost_VkSamplerYcbcrConversionCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSamplerYcbcrConversionCreateInfo,
+ transform_fromhost_VkSamplerYcbcrConversionCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkSamplerYcbcrConversionInfo, transform_tohost_VkSamplerYcbcrConversionInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkSamplerYcbcrConversionInfo,
+ transform_tohost_VkSamplerYcbcrConversionInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSamplerYcbcrConversionInfo, transform_fromhost_VkSamplerYcbcrConversionInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSamplerYcbcrConversionInfo,
+ transform_fromhost_VkSamplerYcbcrConversionInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkBindImagePlaneMemoryInfo, transform_tohost_VkBindImagePlaneMemoryInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkBindImagePlaneMemoryInfo,
+ transform_tohost_VkBindImagePlaneMemoryInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBindImagePlaneMemoryInfo, transform_fromhost_VkBindImagePlaneMemoryInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBindImagePlaneMemoryInfo,
+ transform_fromhost_VkBindImagePlaneMemoryInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkImagePlaneMemoryRequirementsInfo, transform_tohost_VkImagePlaneMemoryRequirementsInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkImagePlaneMemoryRequirementsInfo,
+ transform_tohost_VkImagePlaneMemoryRequirementsInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImagePlaneMemoryRequirementsInfo, transform_fromhost_VkImagePlaneMemoryRequirementsInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImagePlaneMemoryRequirementsInfo,
+ transform_fromhost_VkImagePlaneMemoryRequirementsInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceSamplerYcbcrConversionFeatures, transform_tohost_VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceSamplerYcbcrConversionFeatures,
+ transform_tohost_VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceSamplerYcbcrConversionFeatures, transform_fromhost_VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceSamplerYcbcrConversionFeatures,
+ transform_fromhost_VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkSamplerYcbcrConversionImageFormatProperties, transform_tohost_VkSamplerYcbcrConversionImageFormatPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkSamplerYcbcrConversionImageFormatProperties,
+ transform_tohost_VkSamplerYcbcrConversionImageFormatPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSamplerYcbcrConversionImageFormatProperties, transform_fromhost_VkSamplerYcbcrConversionImageFormatPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSamplerYcbcrConversionImageFormatProperties,
+ transform_fromhost_VkSamplerYcbcrConversionImageFormatPropertiesKHR)
#endif
#ifdef VK_KHR_bind_memory2
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkBindBufferMemoryInfo, transform_tohost_VkBindBufferMemoryInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkBindBufferMemoryInfo,
+ transform_tohost_VkBindBufferMemoryInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBindBufferMemoryInfo, transform_fromhost_VkBindBufferMemoryInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBindBufferMemoryInfo,
+ transform_fromhost_VkBindBufferMemoryInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkBindImageMemoryInfo, transform_tohost_VkBindImageMemoryInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkBindImageMemoryInfo,
+ transform_tohost_VkBindImageMemoryInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBindImageMemoryInfo, transform_fromhost_VkBindImageMemoryInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBindImageMemoryInfo,
+ transform_fromhost_VkBindImageMemoryInfoKHR)
#endif
#ifdef VK_KHR_portability_subset
void transform_tohost_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePortabilitySubsetFeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevicePortabilitySubsetFeaturesKHR* toTransform);
void transform_fromhost_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePortabilitySubsetFeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevicePortabilitySubsetFeaturesKHR* toTransform);
void transform_tohost_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePortabilitySubsetPropertiesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevicePortabilitySubsetPropertiesKHR* toTransform);
void transform_fromhost_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePortabilitySubsetPropertiesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevicePortabilitySubsetPropertiesKHR* toTransform);
#endif
#ifdef VK_KHR_maintenance3
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceMaintenance3Properties, transform_tohost_VkPhysicalDeviceMaintenance3PropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceMaintenance3Properties,
+ transform_tohost_VkPhysicalDeviceMaintenance3PropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceMaintenance3Properties, transform_fromhost_VkPhysicalDeviceMaintenance3PropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceMaintenance3Properties,
+ transform_fromhost_VkPhysicalDeviceMaintenance3PropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkDescriptorSetLayoutSupport, transform_tohost_VkDescriptorSetLayoutSupportKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkDescriptorSetLayoutSupport,
+ transform_tohost_VkDescriptorSetLayoutSupportKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDescriptorSetLayoutSupport, transform_fromhost_VkDescriptorSetLayoutSupportKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDescriptorSetLayoutSupport,
+ transform_fromhost_VkDescriptorSetLayoutSupportKHR)
#endif
#ifdef VK_KHR_draw_indirect_count
#endif
#ifdef VK_KHR_shader_subgroup_extended_types
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, transform_tohost_VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures,
+ transform_tohost_VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, transform_fromhost_VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures,
+ transform_fromhost_VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)
#endif
#ifdef VK_KHR_8bit_storage
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDevice8BitStorageFeatures, transform_tohost_VkPhysicalDevice8BitStorageFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDevice8BitStorageFeatures,
+ transform_tohost_VkPhysicalDevice8BitStorageFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDevice8BitStorageFeatures, transform_fromhost_VkPhysicalDevice8BitStorageFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDevice8BitStorageFeatures,
+ transform_fromhost_VkPhysicalDevice8BitStorageFeaturesKHR)
#endif
#ifdef VK_KHR_shader_atomic_int64
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceShaderAtomicInt64Features, transform_tohost_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceShaderAtomicInt64Features,
+ transform_tohost_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceShaderAtomicInt64Features, transform_fromhost_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceShaderAtomicInt64Features,
+ transform_fromhost_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR)
#endif
#ifdef VK_KHR_shader_clock
void transform_tohost_VkPhysicalDeviceShaderClockFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderClockFeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderClockFeaturesKHR* toTransform);
void transform_fromhost_VkPhysicalDeviceShaderClockFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderClockFeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderClockFeaturesKHR* toTransform);
#endif
#ifdef VK_KHR_driver_properties
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkConformanceVersion, transform_tohost_VkConformanceVersionKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkConformanceVersion,
+ transform_tohost_VkConformanceVersionKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkConformanceVersion, transform_fromhost_VkConformanceVersionKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkConformanceVersion,
+ transform_fromhost_VkConformanceVersionKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceDriverProperties, transform_tohost_VkPhysicalDeviceDriverPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceDriverProperties,
+ transform_tohost_VkPhysicalDeviceDriverPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceDriverProperties, transform_fromhost_VkPhysicalDeviceDriverPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceDriverProperties,
+ transform_fromhost_VkPhysicalDeviceDriverPropertiesKHR)
#endif
#ifdef VK_KHR_shader_float_controls
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceFloatControlsProperties, transform_tohost_VkPhysicalDeviceFloatControlsPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceFloatControlsProperties,
+ transform_tohost_VkPhysicalDeviceFloatControlsPropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceFloatControlsProperties, transform_fromhost_VkPhysicalDeviceFloatControlsPropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceFloatControlsProperties,
+ transform_fromhost_VkPhysicalDeviceFloatControlsPropertiesKHR)
#endif
#ifdef VK_KHR_depth_stencil_resolve
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkSubpassDescriptionDepthStencilResolve, transform_tohost_VkSubpassDescriptionDepthStencilResolveKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkSubpassDescriptionDepthStencilResolve,
+ transform_tohost_VkSubpassDescriptionDepthStencilResolveKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSubpassDescriptionDepthStencilResolve, transform_fromhost_VkSubpassDescriptionDepthStencilResolveKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSubpassDescriptionDepthStencilResolve,
+ transform_fromhost_VkSubpassDescriptionDepthStencilResolveKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceDepthStencilResolveProperties, transform_tohost_VkPhysicalDeviceDepthStencilResolvePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceDepthStencilResolveProperties,
+ transform_tohost_VkPhysicalDeviceDepthStencilResolvePropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceDepthStencilResolveProperties, transform_fromhost_VkPhysicalDeviceDepthStencilResolvePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceDepthStencilResolveProperties,
+ transform_fromhost_VkPhysicalDeviceDepthStencilResolvePropertiesKHR)
#endif
#ifdef VK_KHR_swapchain_mutable_format
#endif
#ifdef VK_KHR_timeline_semaphore
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceTimelineSemaphoreFeatures, transform_tohost_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceTimelineSemaphoreFeatures,
+ transform_tohost_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceTimelineSemaphoreFeatures, transform_fromhost_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceTimelineSemaphoreFeatures,
+ transform_fromhost_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceTimelineSemaphoreProperties, transform_tohost_VkPhysicalDeviceTimelineSemaphorePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceTimelineSemaphoreProperties,
+ transform_tohost_VkPhysicalDeviceTimelineSemaphorePropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceTimelineSemaphoreProperties, transform_fromhost_VkPhysicalDeviceTimelineSemaphorePropertiesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceTimelineSemaphoreProperties,
+ transform_fromhost_VkPhysicalDeviceTimelineSemaphorePropertiesKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkSemaphoreTypeCreateInfo, transform_tohost_VkSemaphoreTypeCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkSemaphoreTypeCreateInfo,
+ transform_tohost_VkSemaphoreTypeCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSemaphoreTypeCreateInfo, transform_fromhost_VkSemaphoreTypeCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSemaphoreTypeCreateInfo,
+ transform_fromhost_VkSemaphoreTypeCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkTimelineSemaphoreSubmitInfo, transform_tohost_VkTimelineSemaphoreSubmitInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkTimelineSemaphoreSubmitInfo,
+ transform_tohost_VkTimelineSemaphoreSubmitInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkTimelineSemaphoreSubmitInfo, transform_fromhost_VkTimelineSemaphoreSubmitInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkTimelineSemaphoreSubmitInfo,
+ transform_fromhost_VkTimelineSemaphoreSubmitInfoKHR)
DEFINE_ALIAS_FUNCTION(transform_tohost_VkSemaphoreWaitInfo, transform_tohost_VkSemaphoreWaitInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSemaphoreWaitInfo, transform_fromhost_VkSemaphoreWaitInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSemaphoreWaitInfo,
+ transform_fromhost_VkSemaphoreWaitInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkSemaphoreSignalInfo, transform_tohost_VkSemaphoreSignalInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkSemaphoreSignalInfo,
+ transform_tohost_VkSemaphoreSignalInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSemaphoreSignalInfo, transform_fromhost_VkSemaphoreSignalInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSemaphoreSignalInfo,
+ transform_fromhost_VkSemaphoreSignalInfoKHR)
#endif
#ifdef VK_KHR_vulkan_memory_model
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceVulkanMemoryModelFeatures, transform_tohost_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceVulkanMemoryModelFeatures,
+ transform_tohost_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceVulkanMemoryModelFeatures, transform_fromhost_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceVulkanMemoryModelFeatures,
+ transform_fromhost_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR)
#endif
#ifdef VK_KHR_shader_terminate_invocation
@@ -3148,28 +2675,22 @@
#endif
#ifdef VK_KHR_fragment_shading_rate
void transform_tohost_VkFragmentShadingRateAttachmentInfoKHR(
- ResourceTracker* resourceTracker,
- VkFragmentShadingRateAttachmentInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkFragmentShadingRateAttachmentInfoKHR* toTransform);
void transform_fromhost_VkFragmentShadingRateAttachmentInfoKHR(
- ResourceTracker* resourceTracker,
- VkFragmentShadingRateAttachmentInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkFragmentShadingRateAttachmentInfoKHR* toTransform);
void transform_tohost_VkPipelineFragmentShadingRateStateCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkPipelineFragmentShadingRateStateCreateInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineFragmentShadingRateStateCreateInfoKHR* toTransform);
void transform_fromhost_VkPipelineFragmentShadingRateStateCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkPipelineFragmentShadingRateStateCreateInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineFragmentShadingRateStateCreateInfoKHR* toTransform);
void transform_tohost_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentShadingRateFeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFragmentShadingRateFeaturesKHR* toTransform);
void transform_fromhost_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentShadingRateFeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFragmentShadingRateFeaturesKHR* toTransform);
void transform_tohost_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
ResourceTracker* resourceTracker,
@@ -3180,76 +2701,88 @@
VkPhysicalDeviceFragmentShadingRatePropertiesKHR* toTransform);
void transform_tohost_VkPhysicalDeviceFragmentShadingRateKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentShadingRateKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFragmentShadingRateKHR* toTransform);
void transform_fromhost_VkPhysicalDeviceFragmentShadingRateKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentShadingRateKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFragmentShadingRateKHR* toTransform);
#endif
#ifdef VK_KHR_spirv_1_4
#endif
#ifdef VK_KHR_surface_protected_capabilities
void transform_tohost_VkSurfaceProtectedCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkSurfaceProtectedCapabilitiesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkSurfaceProtectedCapabilitiesKHR* toTransform);
void transform_fromhost_VkSurfaceProtectedCapabilitiesKHR(
- ResourceTracker* resourceTracker,
- VkSurfaceProtectedCapabilitiesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkSurfaceProtectedCapabilitiesKHR* toTransform);
#endif
#ifdef VK_KHR_separate_depth_stencil_layouts
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, transform_tohost_VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures,
+ transform_tohost_VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, transform_fromhost_VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures,
+ transform_fromhost_VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkAttachmentReferenceStencilLayout, transform_tohost_VkAttachmentReferenceStencilLayoutKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkAttachmentReferenceStencilLayout,
+ transform_tohost_VkAttachmentReferenceStencilLayoutKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkAttachmentReferenceStencilLayout, transform_fromhost_VkAttachmentReferenceStencilLayoutKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkAttachmentReferenceStencilLayout,
+ transform_fromhost_VkAttachmentReferenceStencilLayoutKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkAttachmentDescriptionStencilLayout, transform_tohost_VkAttachmentDescriptionStencilLayoutKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkAttachmentDescriptionStencilLayout,
+ transform_tohost_VkAttachmentDescriptionStencilLayoutKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkAttachmentDescriptionStencilLayout, transform_fromhost_VkAttachmentDescriptionStencilLayoutKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkAttachmentDescriptionStencilLayout,
+ transform_fromhost_VkAttachmentDescriptionStencilLayoutKHR)
#endif
#ifdef VK_KHR_present_wait
void transform_tohost_VkPhysicalDevicePresentWaitFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePresentWaitFeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevicePresentWaitFeaturesKHR* toTransform);
void transform_fromhost_VkPhysicalDevicePresentWaitFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePresentWaitFeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevicePresentWaitFeaturesKHR* toTransform);
#endif
#ifdef VK_KHR_uniform_buffer_standard_layout
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceUniformBufferStandardLayoutFeatures, transform_tohost_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceUniformBufferStandardLayoutFeatures,
+ transform_tohost_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceUniformBufferStandardLayoutFeatures, transform_fromhost_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceUniformBufferStandardLayoutFeatures,
+ transform_fromhost_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)
#endif
#ifdef VK_KHR_buffer_device_address
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceBufferDeviceAddressFeatures, transform_tohost_VkPhysicalDeviceBufferDeviceAddressFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceBufferDeviceAddressFeatures,
+ transform_tohost_VkPhysicalDeviceBufferDeviceAddressFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceBufferDeviceAddressFeatures, transform_fromhost_VkPhysicalDeviceBufferDeviceAddressFeaturesKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceBufferDeviceAddressFeatures,
+ transform_fromhost_VkPhysicalDeviceBufferDeviceAddressFeaturesKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkBufferDeviceAddressInfo, transform_tohost_VkBufferDeviceAddressInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkBufferDeviceAddressInfo,
+ transform_tohost_VkBufferDeviceAddressInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBufferDeviceAddressInfo, transform_fromhost_VkBufferDeviceAddressInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBufferDeviceAddressInfo,
+ transform_fromhost_VkBufferDeviceAddressInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkBufferOpaqueCaptureAddressCreateInfo, transform_tohost_VkBufferOpaqueCaptureAddressCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkBufferOpaqueCaptureAddressCreateInfo,
+ transform_tohost_VkBufferOpaqueCaptureAddressCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBufferOpaqueCaptureAddressCreateInfo, transform_fromhost_VkBufferOpaqueCaptureAddressCreateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBufferOpaqueCaptureAddressCreateInfo,
+ transform_fromhost_VkBufferOpaqueCaptureAddressCreateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkMemoryOpaqueCaptureAddressAllocateInfo, transform_tohost_VkMemoryOpaqueCaptureAddressAllocateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkMemoryOpaqueCaptureAddressAllocateInfo,
+ transform_tohost_VkMemoryOpaqueCaptureAddressAllocateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkMemoryOpaqueCaptureAddressAllocateInfo, transform_fromhost_VkMemoryOpaqueCaptureAddressAllocateInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkMemoryOpaqueCaptureAddressAllocateInfo,
+ transform_fromhost_VkMemoryOpaqueCaptureAddressAllocateInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkDeviceMemoryOpaqueCaptureAddressInfo, transform_tohost_VkDeviceMemoryOpaqueCaptureAddressInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkDeviceMemoryOpaqueCaptureAddressInfo,
+ transform_tohost_VkDeviceMemoryOpaqueCaptureAddressInfoKHR)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDeviceMemoryOpaqueCaptureAddressInfo, transform_fromhost_VkDeviceMemoryOpaqueCaptureAddressInfoKHR)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDeviceMemoryOpaqueCaptureAddressInfo,
+ transform_fromhost_VkDeviceMemoryOpaqueCaptureAddressInfoKHR)
#endif
#ifdef VK_KHR_deferred_host_operations
@@ -3263,53 +2796,41 @@
ResourceTracker* resourceTracker,
VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* toTransform);
-void transform_tohost_VkPipelineInfoKHR(
- ResourceTracker* resourceTracker,
- VkPipelineInfoKHR* toTransform);
+void transform_tohost_VkPipelineInfoKHR(ResourceTracker* resourceTracker,
+ VkPipelineInfoKHR* toTransform);
-void transform_fromhost_VkPipelineInfoKHR(
- ResourceTracker* resourceTracker,
- VkPipelineInfoKHR* toTransform);
+void transform_fromhost_VkPipelineInfoKHR(ResourceTracker* resourceTracker,
+ VkPipelineInfoKHR* toTransform);
void transform_tohost_VkPipelineExecutablePropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPipelineExecutablePropertiesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineExecutablePropertiesKHR* toTransform);
void transform_fromhost_VkPipelineExecutablePropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPipelineExecutablePropertiesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineExecutablePropertiesKHR* toTransform);
-void transform_tohost_VkPipelineExecutableInfoKHR(
- ResourceTracker* resourceTracker,
- VkPipelineExecutableInfoKHR* toTransform);
+void transform_tohost_VkPipelineExecutableInfoKHR(ResourceTracker* resourceTracker,
+ VkPipelineExecutableInfoKHR* toTransform);
-void transform_fromhost_VkPipelineExecutableInfoKHR(
- ResourceTracker* resourceTracker,
- VkPipelineExecutableInfoKHR* toTransform);
+void transform_fromhost_VkPipelineExecutableInfoKHR(ResourceTracker* resourceTracker,
+ VkPipelineExecutableInfoKHR* toTransform);
void transform_tohost_VkPipelineExecutableStatisticValueKHR(
- ResourceTracker* resourceTracker,
- VkPipelineExecutableStatisticValueKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineExecutableStatisticValueKHR* toTransform);
void transform_fromhost_VkPipelineExecutableStatisticValueKHR(
- ResourceTracker* resourceTracker,
- VkPipelineExecutableStatisticValueKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineExecutableStatisticValueKHR* toTransform);
void transform_tohost_VkPipelineExecutableStatisticKHR(
- ResourceTracker* resourceTracker,
- VkPipelineExecutableStatisticKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineExecutableStatisticKHR* toTransform);
void transform_fromhost_VkPipelineExecutableStatisticKHR(
- ResourceTracker* resourceTracker,
- VkPipelineExecutableStatisticKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineExecutableStatisticKHR* toTransform);
void transform_tohost_VkPipelineExecutableInternalRepresentationKHR(
- ResourceTracker* resourceTracker,
- VkPipelineExecutableInternalRepresentationKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineExecutableInternalRepresentationKHR* toTransform);
void transform_fromhost_VkPipelineExecutableInternalRepresentationKHR(
- ResourceTracker* resourceTracker,
- VkPipelineExecutableInternalRepresentationKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineExecutableInternalRepresentationKHR* toTransform);
#endif
#ifdef VK_KHR_shader_integer_dot_product
@@ -3331,133 +2852,102 @@
#endif
#ifdef VK_KHR_pipeline_library
-void transform_tohost_VkPipelineLibraryCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkPipelineLibraryCreateInfoKHR* toTransform);
+void transform_tohost_VkPipelineLibraryCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkPipelineLibraryCreateInfoKHR* toTransform);
-void transform_fromhost_VkPipelineLibraryCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkPipelineLibraryCreateInfoKHR* toTransform);
+void transform_fromhost_VkPipelineLibraryCreateInfoKHR(ResourceTracker* resourceTracker,
+ VkPipelineLibraryCreateInfoKHR* toTransform);
#endif
#ifdef VK_KHR_shader_non_semantic_info
#endif
#ifdef VK_KHR_present_id
-void transform_tohost_VkPresentIdKHR(
- ResourceTracker* resourceTracker,
- VkPresentIdKHR* toTransform);
+void transform_tohost_VkPresentIdKHR(ResourceTracker* resourceTracker, VkPresentIdKHR* toTransform);
-void transform_fromhost_VkPresentIdKHR(
- ResourceTracker* resourceTracker,
- VkPresentIdKHR* toTransform);
+void transform_fromhost_VkPresentIdKHR(ResourceTracker* resourceTracker,
+ VkPresentIdKHR* toTransform);
void transform_tohost_VkPhysicalDevicePresentIdFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePresentIdFeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevicePresentIdFeaturesKHR* toTransform);
void transform_fromhost_VkPhysicalDevicePresentIdFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePresentIdFeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevicePresentIdFeaturesKHR* toTransform);
#endif
#ifdef VK_KHR_video_encode_queue
-void transform_tohost_VkVideoEncodeInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoEncodeInfoKHR* toTransform);
+void transform_tohost_VkVideoEncodeInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoEncodeInfoKHR* toTransform);
-void transform_fromhost_VkVideoEncodeInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoEncodeInfoKHR* toTransform);
+void transform_fromhost_VkVideoEncodeInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoEncodeInfoKHR* toTransform);
-void transform_tohost_VkVideoEncodeRateControlInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoEncodeRateControlInfoKHR* toTransform);
+void transform_tohost_VkVideoEncodeRateControlInfoKHR(ResourceTracker* resourceTracker,
+ VkVideoEncodeRateControlInfoKHR* toTransform);
void transform_fromhost_VkVideoEncodeRateControlInfoKHR(
- ResourceTracker* resourceTracker,
- VkVideoEncodeRateControlInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeRateControlInfoKHR* toTransform);
#endif
#ifdef VK_KHR_synchronization2
-void transform_tohost_VkMemoryBarrier2KHR(
- ResourceTracker* resourceTracker,
- VkMemoryBarrier2KHR* toTransform);
+void transform_tohost_VkMemoryBarrier2KHR(ResourceTracker* resourceTracker,
+ VkMemoryBarrier2KHR* toTransform);
-void transform_fromhost_VkMemoryBarrier2KHR(
- ResourceTracker* resourceTracker,
- VkMemoryBarrier2KHR* toTransform);
+void transform_fromhost_VkMemoryBarrier2KHR(ResourceTracker* resourceTracker,
+ VkMemoryBarrier2KHR* toTransform);
-void transform_tohost_VkBufferMemoryBarrier2KHR(
- ResourceTracker* resourceTracker,
- VkBufferMemoryBarrier2KHR* toTransform);
+void transform_tohost_VkBufferMemoryBarrier2KHR(ResourceTracker* resourceTracker,
+ VkBufferMemoryBarrier2KHR* toTransform);
-void transform_fromhost_VkBufferMemoryBarrier2KHR(
- ResourceTracker* resourceTracker,
- VkBufferMemoryBarrier2KHR* toTransform);
+void transform_fromhost_VkBufferMemoryBarrier2KHR(ResourceTracker* resourceTracker,
+ VkBufferMemoryBarrier2KHR* toTransform);
-void transform_tohost_VkImageMemoryBarrier2KHR(
- ResourceTracker* resourceTracker,
- VkImageMemoryBarrier2KHR* toTransform);
+void transform_tohost_VkImageMemoryBarrier2KHR(ResourceTracker* resourceTracker,
+ VkImageMemoryBarrier2KHR* toTransform);
-void transform_fromhost_VkImageMemoryBarrier2KHR(
- ResourceTracker* resourceTracker,
- VkImageMemoryBarrier2KHR* toTransform);
+void transform_fromhost_VkImageMemoryBarrier2KHR(ResourceTracker* resourceTracker,
+ VkImageMemoryBarrier2KHR* toTransform);
-void transform_tohost_VkDependencyInfoKHR(
- ResourceTracker* resourceTracker,
- VkDependencyInfoKHR* toTransform);
+void transform_tohost_VkDependencyInfoKHR(ResourceTracker* resourceTracker,
+ VkDependencyInfoKHR* toTransform);
-void transform_fromhost_VkDependencyInfoKHR(
- ResourceTracker* resourceTracker,
- VkDependencyInfoKHR* toTransform);
+void transform_fromhost_VkDependencyInfoKHR(ResourceTracker* resourceTracker,
+ VkDependencyInfoKHR* toTransform);
-void transform_tohost_VkSemaphoreSubmitInfoKHR(
- ResourceTracker* resourceTracker,
- VkSemaphoreSubmitInfoKHR* toTransform);
+void transform_tohost_VkSemaphoreSubmitInfoKHR(ResourceTracker* resourceTracker,
+ VkSemaphoreSubmitInfoKHR* toTransform);
-void transform_fromhost_VkSemaphoreSubmitInfoKHR(
- ResourceTracker* resourceTracker,
- VkSemaphoreSubmitInfoKHR* toTransform);
+void transform_fromhost_VkSemaphoreSubmitInfoKHR(ResourceTracker* resourceTracker,
+ VkSemaphoreSubmitInfoKHR* toTransform);
-void transform_tohost_VkCommandBufferSubmitInfoKHR(
- ResourceTracker* resourceTracker,
- VkCommandBufferSubmitInfoKHR* toTransform);
+void transform_tohost_VkCommandBufferSubmitInfoKHR(ResourceTracker* resourceTracker,
+ VkCommandBufferSubmitInfoKHR* toTransform);
-void transform_fromhost_VkCommandBufferSubmitInfoKHR(
- ResourceTracker* resourceTracker,
- VkCommandBufferSubmitInfoKHR* toTransform);
+void transform_fromhost_VkCommandBufferSubmitInfoKHR(ResourceTracker* resourceTracker,
+ VkCommandBufferSubmitInfoKHR* toTransform);
-void transform_tohost_VkSubmitInfo2KHR(
- ResourceTracker* resourceTracker,
- VkSubmitInfo2KHR* toTransform);
+void transform_tohost_VkSubmitInfo2KHR(ResourceTracker* resourceTracker,
+ VkSubmitInfo2KHR* toTransform);
-void transform_fromhost_VkSubmitInfo2KHR(
- ResourceTracker* resourceTracker,
- VkSubmitInfo2KHR* toTransform);
+void transform_fromhost_VkSubmitInfo2KHR(ResourceTracker* resourceTracker,
+ VkSubmitInfo2KHR* toTransform);
void transform_tohost_VkPhysicalDeviceSynchronization2FeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSynchronization2FeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSynchronization2FeaturesKHR* toTransform);
void transform_fromhost_VkPhysicalDeviceSynchronization2FeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSynchronization2FeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSynchronization2FeaturesKHR* toTransform);
void transform_tohost_VkQueueFamilyCheckpointProperties2NV(
- ResourceTracker* resourceTracker,
- VkQueueFamilyCheckpointProperties2NV* toTransform);
+ ResourceTracker* resourceTracker, VkQueueFamilyCheckpointProperties2NV* toTransform);
void transform_fromhost_VkQueueFamilyCheckpointProperties2NV(
- ResourceTracker* resourceTracker,
- VkQueueFamilyCheckpointProperties2NV* toTransform);
+ ResourceTracker* resourceTracker, VkQueueFamilyCheckpointProperties2NV* toTransform);
-void transform_tohost_VkCheckpointData2NV(
- ResourceTracker* resourceTracker,
- VkCheckpointData2NV* toTransform);
+void transform_tohost_VkCheckpointData2NV(ResourceTracker* resourceTracker,
+ VkCheckpointData2NV* toTransform);
-void transform_fromhost_VkCheckpointData2NV(
- ResourceTracker* resourceTracker,
- VkCheckpointData2NV* toTransform);
+void transform_fromhost_VkCheckpointData2NV(ResourceTracker* resourceTracker,
+ VkCheckpointData2NV* toTransform);
#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
@@ -3491,157 +2981,121 @@
#endif
#ifdef VK_KHR_copy_commands2
-void transform_tohost_VkBufferCopy2KHR(
- ResourceTracker* resourceTracker,
- VkBufferCopy2KHR* toTransform);
+void transform_tohost_VkBufferCopy2KHR(ResourceTracker* resourceTracker,
+ VkBufferCopy2KHR* toTransform);
-void transform_fromhost_VkBufferCopy2KHR(
- ResourceTracker* resourceTracker,
- VkBufferCopy2KHR* toTransform);
+void transform_fromhost_VkBufferCopy2KHR(ResourceTracker* resourceTracker,
+ VkBufferCopy2KHR* toTransform);
-void transform_tohost_VkCopyBufferInfo2KHR(
- ResourceTracker* resourceTracker,
- VkCopyBufferInfo2KHR* toTransform);
+void transform_tohost_VkCopyBufferInfo2KHR(ResourceTracker* resourceTracker,
+ VkCopyBufferInfo2KHR* toTransform);
-void transform_fromhost_VkCopyBufferInfo2KHR(
- ResourceTracker* resourceTracker,
- VkCopyBufferInfo2KHR* toTransform);
+void transform_fromhost_VkCopyBufferInfo2KHR(ResourceTracker* resourceTracker,
+ VkCopyBufferInfo2KHR* toTransform);
-void transform_tohost_VkImageCopy2KHR(
- ResourceTracker* resourceTracker,
- VkImageCopy2KHR* toTransform);
+void transform_tohost_VkImageCopy2KHR(ResourceTracker* resourceTracker,
+ VkImageCopy2KHR* toTransform);
-void transform_fromhost_VkImageCopy2KHR(
- ResourceTracker* resourceTracker,
- VkImageCopy2KHR* toTransform);
+void transform_fromhost_VkImageCopy2KHR(ResourceTracker* resourceTracker,
+ VkImageCopy2KHR* toTransform);
-void transform_tohost_VkCopyImageInfo2KHR(
- ResourceTracker* resourceTracker,
- VkCopyImageInfo2KHR* toTransform);
+void transform_tohost_VkCopyImageInfo2KHR(ResourceTracker* resourceTracker,
+ VkCopyImageInfo2KHR* toTransform);
-void transform_fromhost_VkCopyImageInfo2KHR(
- ResourceTracker* resourceTracker,
- VkCopyImageInfo2KHR* toTransform);
+void transform_fromhost_VkCopyImageInfo2KHR(ResourceTracker* resourceTracker,
+ VkCopyImageInfo2KHR* toTransform);
-void transform_tohost_VkBufferImageCopy2KHR(
- ResourceTracker* resourceTracker,
- VkBufferImageCopy2KHR* toTransform);
+void transform_tohost_VkBufferImageCopy2KHR(ResourceTracker* resourceTracker,
+ VkBufferImageCopy2KHR* toTransform);
-void transform_fromhost_VkBufferImageCopy2KHR(
- ResourceTracker* resourceTracker,
- VkBufferImageCopy2KHR* toTransform);
+void transform_fromhost_VkBufferImageCopy2KHR(ResourceTracker* resourceTracker,
+ VkBufferImageCopy2KHR* toTransform);
-void transform_tohost_VkCopyBufferToImageInfo2KHR(
- ResourceTracker* resourceTracker,
- VkCopyBufferToImageInfo2KHR* toTransform);
+void transform_tohost_VkCopyBufferToImageInfo2KHR(ResourceTracker* resourceTracker,
+ VkCopyBufferToImageInfo2KHR* toTransform);
-void transform_fromhost_VkCopyBufferToImageInfo2KHR(
- ResourceTracker* resourceTracker,
- VkCopyBufferToImageInfo2KHR* toTransform);
+void transform_fromhost_VkCopyBufferToImageInfo2KHR(ResourceTracker* resourceTracker,
+ VkCopyBufferToImageInfo2KHR* toTransform);
-void transform_tohost_VkCopyImageToBufferInfo2KHR(
- ResourceTracker* resourceTracker,
- VkCopyImageToBufferInfo2KHR* toTransform);
+void transform_tohost_VkCopyImageToBufferInfo2KHR(ResourceTracker* resourceTracker,
+ VkCopyImageToBufferInfo2KHR* toTransform);
-void transform_fromhost_VkCopyImageToBufferInfo2KHR(
- ResourceTracker* resourceTracker,
- VkCopyImageToBufferInfo2KHR* toTransform);
+void transform_fromhost_VkCopyImageToBufferInfo2KHR(ResourceTracker* resourceTracker,
+ VkCopyImageToBufferInfo2KHR* toTransform);
-void transform_tohost_VkImageBlit2KHR(
- ResourceTracker* resourceTracker,
- VkImageBlit2KHR* toTransform);
+void transform_tohost_VkImageBlit2KHR(ResourceTracker* resourceTracker,
+ VkImageBlit2KHR* toTransform);
-void transform_fromhost_VkImageBlit2KHR(
- ResourceTracker* resourceTracker,
- VkImageBlit2KHR* toTransform);
+void transform_fromhost_VkImageBlit2KHR(ResourceTracker* resourceTracker,
+ VkImageBlit2KHR* toTransform);
-void transform_tohost_VkBlitImageInfo2KHR(
- ResourceTracker* resourceTracker,
- VkBlitImageInfo2KHR* toTransform);
+void transform_tohost_VkBlitImageInfo2KHR(ResourceTracker* resourceTracker,
+ VkBlitImageInfo2KHR* toTransform);
-void transform_fromhost_VkBlitImageInfo2KHR(
- ResourceTracker* resourceTracker,
- VkBlitImageInfo2KHR* toTransform);
+void transform_fromhost_VkBlitImageInfo2KHR(ResourceTracker* resourceTracker,
+ VkBlitImageInfo2KHR* toTransform);
-void transform_tohost_VkImageResolve2KHR(
- ResourceTracker* resourceTracker,
- VkImageResolve2KHR* toTransform);
+void transform_tohost_VkImageResolve2KHR(ResourceTracker* resourceTracker,
+ VkImageResolve2KHR* toTransform);
-void transform_fromhost_VkImageResolve2KHR(
- ResourceTracker* resourceTracker,
- VkImageResolve2KHR* toTransform);
+void transform_fromhost_VkImageResolve2KHR(ResourceTracker* resourceTracker,
+ VkImageResolve2KHR* toTransform);
-void transform_tohost_VkResolveImageInfo2KHR(
- ResourceTracker* resourceTracker,
- VkResolveImageInfo2KHR* toTransform);
+void transform_tohost_VkResolveImageInfo2KHR(ResourceTracker* resourceTracker,
+ VkResolveImageInfo2KHR* toTransform);
-void transform_fromhost_VkResolveImageInfo2KHR(
- ResourceTracker* resourceTracker,
- VkResolveImageInfo2KHR* toTransform);
+void transform_fromhost_VkResolveImageInfo2KHR(ResourceTracker* resourceTracker,
+ VkResolveImageInfo2KHR* toTransform);
#endif
#ifdef VK_KHR_format_feature_flags2
-void transform_tohost_VkFormatProperties3KHR(
- ResourceTracker* resourceTracker,
- VkFormatProperties3KHR* toTransform);
+void transform_tohost_VkFormatProperties3KHR(ResourceTracker* resourceTracker,
+ VkFormatProperties3KHR* toTransform);
-void transform_fromhost_VkFormatProperties3KHR(
- ResourceTracker* resourceTracker,
- VkFormatProperties3KHR* toTransform);
+void transform_fromhost_VkFormatProperties3KHR(ResourceTracker* resourceTracker,
+ VkFormatProperties3KHR* toTransform);
#endif
#ifdef VK_KHR_maintenance4
void transform_tohost_VkPhysicalDeviceMaintenance4FeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMaintenance4FeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance4FeaturesKHR* toTransform);
void transform_fromhost_VkPhysicalDeviceMaintenance4FeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMaintenance4FeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance4FeaturesKHR* toTransform);
void transform_tohost_VkPhysicalDeviceMaintenance4PropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMaintenance4PropertiesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance4PropertiesKHR* toTransform);
void transform_fromhost_VkPhysicalDeviceMaintenance4PropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMaintenance4PropertiesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMaintenance4PropertiesKHR* toTransform);
void transform_tohost_VkDeviceBufferMemoryRequirementsKHR(
- ResourceTracker* resourceTracker,
- VkDeviceBufferMemoryRequirementsKHR* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceBufferMemoryRequirementsKHR* toTransform);
void transform_fromhost_VkDeviceBufferMemoryRequirementsKHR(
- ResourceTracker* resourceTracker,
- VkDeviceBufferMemoryRequirementsKHR* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceBufferMemoryRequirementsKHR* toTransform);
void transform_tohost_VkDeviceImageMemoryRequirementsKHR(
- ResourceTracker* resourceTracker,
- VkDeviceImageMemoryRequirementsKHR* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceImageMemoryRequirementsKHR* toTransform);
void transform_fromhost_VkDeviceImageMemoryRequirementsKHR(
- ResourceTracker* resourceTracker,
- VkDeviceImageMemoryRequirementsKHR* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceImageMemoryRequirementsKHR* toTransform);
#endif
#ifdef VK_ANDROID_native_buffer
-void transform_tohost_VkNativeBufferANDROID(
- ResourceTracker* resourceTracker,
- VkNativeBufferANDROID* toTransform);
+void transform_tohost_VkNativeBufferANDROID(ResourceTracker* resourceTracker,
+ VkNativeBufferANDROID* toTransform);
-void transform_fromhost_VkNativeBufferANDROID(
- ResourceTracker* resourceTracker,
- VkNativeBufferANDROID* toTransform);
+void transform_fromhost_VkNativeBufferANDROID(ResourceTracker* resourceTracker,
+ VkNativeBufferANDROID* toTransform);
#endif
#ifdef VK_EXT_debug_report
void transform_tohost_VkDebugReportCallbackCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugReportCallbackCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkDebugReportCallbackCreateInfoEXT* toTransform);
void transform_fromhost_VkDebugReportCallbackCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugReportCallbackCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkDebugReportCallbackCreateInfoEXT* toTransform);
#endif
#ifdef VK_NV_glsl_shader
@@ -3665,127 +3119,99 @@
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
-void transform_tohost_VkDebugMarkerObjectNameInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugMarkerObjectNameInfoEXT* toTransform);
+void transform_tohost_VkDebugMarkerObjectNameInfoEXT(ResourceTracker* resourceTracker,
+ VkDebugMarkerObjectNameInfoEXT* toTransform);
-void transform_fromhost_VkDebugMarkerObjectNameInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugMarkerObjectNameInfoEXT* toTransform);
+void transform_fromhost_VkDebugMarkerObjectNameInfoEXT(ResourceTracker* resourceTracker,
+ VkDebugMarkerObjectNameInfoEXT* toTransform);
-void transform_tohost_VkDebugMarkerObjectTagInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugMarkerObjectTagInfoEXT* toTransform);
+void transform_tohost_VkDebugMarkerObjectTagInfoEXT(ResourceTracker* resourceTracker,
+ VkDebugMarkerObjectTagInfoEXT* toTransform);
-void transform_fromhost_VkDebugMarkerObjectTagInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugMarkerObjectTagInfoEXT* toTransform);
+void transform_fromhost_VkDebugMarkerObjectTagInfoEXT(ResourceTracker* resourceTracker,
+ VkDebugMarkerObjectTagInfoEXT* toTransform);
-void transform_tohost_VkDebugMarkerMarkerInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugMarkerMarkerInfoEXT* toTransform);
+void transform_tohost_VkDebugMarkerMarkerInfoEXT(ResourceTracker* resourceTracker,
+ VkDebugMarkerMarkerInfoEXT* toTransform);
-void transform_fromhost_VkDebugMarkerMarkerInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugMarkerMarkerInfoEXT* toTransform);
+void transform_fromhost_VkDebugMarkerMarkerInfoEXT(ResourceTracker* resourceTracker,
+ VkDebugMarkerMarkerInfoEXT* toTransform);
#endif
#ifdef VK_AMD_gcn_shader
#endif
#ifdef VK_NV_dedicated_allocation
void transform_tohost_VkDedicatedAllocationImageCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkDedicatedAllocationImageCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkDedicatedAllocationImageCreateInfoNV* toTransform);
void transform_fromhost_VkDedicatedAllocationImageCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkDedicatedAllocationImageCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkDedicatedAllocationImageCreateInfoNV* toTransform);
void transform_tohost_VkDedicatedAllocationBufferCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkDedicatedAllocationBufferCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkDedicatedAllocationBufferCreateInfoNV* toTransform);
void transform_fromhost_VkDedicatedAllocationBufferCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkDedicatedAllocationBufferCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkDedicatedAllocationBufferCreateInfoNV* toTransform);
void transform_tohost_VkDedicatedAllocationMemoryAllocateInfoNV(
- ResourceTracker* resourceTracker,
- VkDedicatedAllocationMemoryAllocateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkDedicatedAllocationMemoryAllocateInfoNV* toTransform);
void transform_fromhost_VkDedicatedAllocationMemoryAllocateInfoNV(
- ResourceTracker* resourceTracker,
- VkDedicatedAllocationMemoryAllocateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkDedicatedAllocationMemoryAllocateInfoNV* toTransform);
#endif
#ifdef VK_EXT_transform_feedback
void transform_tohost_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceTransformFeedbackFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceTransformFeedbackFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceTransformFeedbackFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceTransformFeedbackFeaturesEXT* toTransform);
void transform_tohost_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceTransformFeedbackPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceTransformFeedbackPropertiesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceTransformFeedbackPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceTransformFeedbackPropertiesEXT* toTransform);
void transform_tohost_VkPipelineRasterizationStateStreamCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineRasterizationStateStreamCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineRasterizationStateStreamCreateInfoEXT* toTransform);
void transform_fromhost_VkPipelineRasterizationStateStreamCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineRasterizationStateStreamCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineRasterizationStateStreamCreateInfoEXT* toTransform);
#endif
#ifdef VK_NVX_binary_import
-void transform_tohost_VkCuModuleCreateInfoNVX(
- ResourceTracker* resourceTracker,
- VkCuModuleCreateInfoNVX* toTransform);
+void transform_tohost_VkCuModuleCreateInfoNVX(ResourceTracker* resourceTracker,
+ VkCuModuleCreateInfoNVX* toTransform);
-void transform_fromhost_VkCuModuleCreateInfoNVX(
- ResourceTracker* resourceTracker,
- VkCuModuleCreateInfoNVX* toTransform);
+void transform_fromhost_VkCuModuleCreateInfoNVX(ResourceTracker* resourceTracker,
+ VkCuModuleCreateInfoNVX* toTransform);
-void transform_tohost_VkCuFunctionCreateInfoNVX(
- ResourceTracker* resourceTracker,
- VkCuFunctionCreateInfoNVX* toTransform);
+void transform_tohost_VkCuFunctionCreateInfoNVX(ResourceTracker* resourceTracker,
+ VkCuFunctionCreateInfoNVX* toTransform);
-void transform_fromhost_VkCuFunctionCreateInfoNVX(
- ResourceTracker* resourceTracker,
- VkCuFunctionCreateInfoNVX* toTransform);
+void transform_fromhost_VkCuFunctionCreateInfoNVX(ResourceTracker* resourceTracker,
+ VkCuFunctionCreateInfoNVX* toTransform);
-void transform_tohost_VkCuLaunchInfoNVX(
- ResourceTracker* resourceTracker,
- VkCuLaunchInfoNVX* toTransform);
+void transform_tohost_VkCuLaunchInfoNVX(ResourceTracker* resourceTracker,
+ VkCuLaunchInfoNVX* toTransform);
-void transform_fromhost_VkCuLaunchInfoNVX(
- ResourceTracker* resourceTracker,
- VkCuLaunchInfoNVX* toTransform);
+void transform_fromhost_VkCuLaunchInfoNVX(ResourceTracker* resourceTracker,
+ VkCuLaunchInfoNVX* toTransform);
#endif
#ifdef VK_NVX_image_view_handle
-void transform_tohost_VkImageViewHandleInfoNVX(
- ResourceTracker* resourceTracker,
- VkImageViewHandleInfoNVX* toTransform);
+void transform_tohost_VkImageViewHandleInfoNVX(ResourceTracker* resourceTracker,
+ VkImageViewHandleInfoNVX* toTransform);
-void transform_fromhost_VkImageViewHandleInfoNVX(
- ResourceTracker* resourceTracker,
- VkImageViewHandleInfoNVX* toTransform);
+void transform_fromhost_VkImageViewHandleInfoNVX(ResourceTracker* resourceTracker,
+ VkImageViewHandleInfoNVX* toTransform);
-void transform_tohost_VkImageViewAddressPropertiesNVX(
- ResourceTracker* resourceTracker,
- VkImageViewAddressPropertiesNVX* toTransform);
+void transform_tohost_VkImageViewAddressPropertiesNVX(ResourceTracker* resourceTracker,
+ VkImageViewAddressPropertiesNVX* toTransform);
void transform_fromhost_VkImageViewAddressPropertiesNVX(
- ResourceTracker* resourceTracker,
- VkImageViewAddressPropertiesNVX* toTransform);
+ ResourceTracker* resourceTracker, VkImageViewAddressPropertiesNVX* toTransform);
#endif
#ifdef VK_AMD_draw_indirect_count
@@ -3798,352 +3224,272 @@
#endif
#ifdef VK_EXT_video_encode_h264
void transform_tohost_VkVideoEncodeH264CapabilitiesEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264CapabilitiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH264CapabilitiesEXT* toTransform);
void transform_fromhost_VkVideoEncodeH264CapabilitiesEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264CapabilitiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH264CapabilitiesEXT* toTransform);
void transform_tohost_VkVideoEncodeH264SessionCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264SessionCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH264SessionCreateInfoEXT* toTransform);
void transform_fromhost_VkVideoEncodeH264SessionCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264SessionCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH264SessionCreateInfoEXT* toTransform);
void transform_tohost_VkVideoEncodeH264SessionParametersAddInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264SessionParametersAddInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH264SessionParametersAddInfoEXT* toTransform);
void transform_fromhost_VkVideoEncodeH264SessionParametersAddInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264SessionParametersAddInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH264SessionParametersAddInfoEXT* toTransform);
void transform_tohost_VkVideoEncodeH264SessionParametersCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264SessionParametersCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH264SessionParametersCreateInfoEXT* toTransform);
void transform_fromhost_VkVideoEncodeH264SessionParametersCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264SessionParametersCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH264SessionParametersCreateInfoEXT* toTransform);
-void transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264DpbSlotInfoEXT* toTransform);
+void transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(ResourceTracker* resourceTracker,
+ VkVideoEncodeH264DpbSlotInfoEXT* toTransform);
void transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264DpbSlotInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH264DpbSlotInfoEXT* toTransform);
-void transform_tohost_VkVideoEncodeH264NaluSliceEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264NaluSliceEXT* toTransform);
+void transform_tohost_VkVideoEncodeH264NaluSliceEXT(ResourceTracker* resourceTracker,
+ VkVideoEncodeH264NaluSliceEXT* toTransform);
-void transform_fromhost_VkVideoEncodeH264NaluSliceEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264NaluSliceEXT* toTransform);
+void transform_fromhost_VkVideoEncodeH264NaluSliceEXT(ResourceTracker* resourceTracker,
+ VkVideoEncodeH264NaluSliceEXT* toTransform);
void transform_tohost_VkVideoEncodeH264VclFrameInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264VclFrameInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH264VclFrameInfoEXT* toTransform);
void transform_fromhost_VkVideoEncodeH264VclFrameInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264VclFrameInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH264VclFrameInfoEXT* toTransform);
void transform_tohost_VkVideoEncodeH264EmitPictureParametersEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264EmitPictureParametersEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH264EmitPictureParametersEXT* toTransform);
void transform_fromhost_VkVideoEncodeH264EmitPictureParametersEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264EmitPictureParametersEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH264EmitPictureParametersEXT* toTransform);
-void transform_tohost_VkVideoEncodeH264ProfileEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264ProfileEXT* toTransform);
+void transform_tohost_VkVideoEncodeH264ProfileEXT(ResourceTracker* resourceTracker,
+ VkVideoEncodeH264ProfileEXT* toTransform);
-void transform_fromhost_VkVideoEncodeH264ProfileEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH264ProfileEXT* toTransform);
+void transform_fromhost_VkVideoEncodeH264ProfileEXT(ResourceTracker* resourceTracker,
+ VkVideoEncodeH264ProfileEXT* toTransform);
#endif
#ifdef VK_EXT_video_encode_h265
void transform_tohost_VkVideoEncodeH265CapabilitiesEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265CapabilitiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH265CapabilitiesEXT* toTransform);
void transform_fromhost_VkVideoEncodeH265CapabilitiesEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265CapabilitiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH265CapabilitiesEXT* toTransform);
void transform_tohost_VkVideoEncodeH265SessionCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265SessionCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH265SessionCreateInfoEXT* toTransform);
void transform_fromhost_VkVideoEncodeH265SessionCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265SessionCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH265SessionCreateInfoEXT* toTransform);
void transform_tohost_VkVideoEncodeH265SessionParametersAddInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265SessionParametersAddInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH265SessionParametersAddInfoEXT* toTransform);
void transform_fromhost_VkVideoEncodeH265SessionParametersAddInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265SessionParametersAddInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH265SessionParametersAddInfoEXT* toTransform);
void transform_tohost_VkVideoEncodeH265SessionParametersCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265SessionParametersCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH265SessionParametersCreateInfoEXT* toTransform);
void transform_fromhost_VkVideoEncodeH265SessionParametersCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265SessionParametersCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH265SessionParametersCreateInfoEXT* toTransform);
-void transform_tohost_VkVideoEncodeH265DpbSlotInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265DpbSlotInfoEXT* toTransform);
+void transform_tohost_VkVideoEncodeH265DpbSlotInfoEXT(ResourceTracker* resourceTracker,
+ VkVideoEncodeH265DpbSlotInfoEXT* toTransform);
void transform_fromhost_VkVideoEncodeH265DpbSlotInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265DpbSlotInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH265DpbSlotInfoEXT* toTransform);
void transform_tohost_VkVideoEncodeH265ReferenceListsEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265ReferenceListsEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH265ReferenceListsEXT* toTransform);
void transform_fromhost_VkVideoEncodeH265ReferenceListsEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265ReferenceListsEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH265ReferenceListsEXT* toTransform);
-void transform_tohost_VkVideoEncodeH265NaluSliceEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265NaluSliceEXT* toTransform);
+void transform_tohost_VkVideoEncodeH265NaluSliceEXT(ResourceTracker* resourceTracker,
+ VkVideoEncodeH265NaluSliceEXT* toTransform);
-void transform_fromhost_VkVideoEncodeH265NaluSliceEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265NaluSliceEXT* toTransform);
+void transform_fromhost_VkVideoEncodeH265NaluSliceEXT(ResourceTracker* resourceTracker,
+ VkVideoEncodeH265NaluSliceEXT* toTransform);
void transform_tohost_VkVideoEncodeH265VclFrameInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265VclFrameInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH265VclFrameInfoEXT* toTransform);
void transform_fromhost_VkVideoEncodeH265VclFrameInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265VclFrameInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH265VclFrameInfoEXT* toTransform);
void transform_tohost_VkVideoEncodeH265EmitPictureParametersEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265EmitPictureParametersEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH265EmitPictureParametersEXT* toTransform);
void transform_fromhost_VkVideoEncodeH265EmitPictureParametersEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265EmitPictureParametersEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoEncodeH265EmitPictureParametersEXT* toTransform);
-void transform_tohost_VkVideoEncodeH265ProfileEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265ProfileEXT* toTransform);
+void transform_tohost_VkVideoEncodeH265ProfileEXT(ResourceTracker* resourceTracker,
+ VkVideoEncodeH265ProfileEXT* toTransform);
-void transform_fromhost_VkVideoEncodeH265ProfileEXT(
- ResourceTracker* resourceTracker,
- VkVideoEncodeH265ProfileEXT* toTransform);
+void transform_fromhost_VkVideoEncodeH265ProfileEXT(ResourceTracker* resourceTracker,
+ VkVideoEncodeH265ProfileEXT* toTransform);
#endif
#ifdef VK_EXT_video_decode_h264
-void transform_tohost_VkVideoDecodeH264ProfileEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264ProfileEXT* toTransform);
+void transform_tohost_VkVideoDecodeH264ProfileEXT(ResourceTracker* resourceTracker,
+ VkVideoDecodeH264ProfileEXT* toTransform);
-void transform_fromhost_VkVideoDecodeH264ProfileEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264ProfileEXT* toTransform);
+void transform_fromhost_VkVideoDecodeH264ProfileEXT(ResourceTracker* resourceTracker,
+ VkVideoDecodeH264ProfileEXT* toTransform);
void transform_tohost_VkVideoDecodeH264CapabilitiesEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264CapabilitiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoDecodeH264CapabilitiesEXT* toTransform);
void transform_fromhost_VkVideoDecodeH264CapabilitiesEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264CapabilitiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoDecodeH264CapabilitiesEXT* toTransform);
void transform_tohost_VkVideoDecodeH264SessionCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264SessionCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoDecodeH264SessionCreateInfoEXT* toTransform);
void transform_fromhost_VkVideoDecodeH264SessionCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264SessionCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoDecodeH264SessionCreateInfoEXT* toTransform);
void transform_tohost_VkVideoDecodeH264SessionParametersAddInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264SessionParametersAddInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoDecodeH264SessionParametersAddInfoEXT* toTransform);
void transform_fromhost_VkVideoDecodeH264SessionParametersAddInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264SessionParametersAddInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoDecodeH264SessionParametersAddInfoEXT* toTransform);
void transform_tohost_VkVideoDecodeH264SessionParametersCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264SessionParametersCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoDecodeH264SessionParametersCreateInfoEXT* toTransform);
void transform_fromhost_VkVideoDecodeH264SessionParametersCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264SessionParametersCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoDecodeH264SessionParametersCreateInfoEXT* toTransform);
-void transform_tohost_VkVideoDecodeH264PictureInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264PictureInfoEXT* toTransform);
+void transform_tohost_VkVideoDecodeH264PictureInfoEXT(ResourceTracker* resourceTracker,
+ VkVideoDecodeH264PictureInfoEXT* toTransform);
void transform_fromhost_VkVideoDecodeH264PictureInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264PictureInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoDecodeH264PictureInfoEXT* toTransform);
-void transform_tohost_VkVideoDecodeH264MvcEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264MvcEXT* toTransform);
+void transform_tohost_VkVideoDecodeH264MvcEXT(ResourceTracker* resourceTracker,
+ VkVideoDecodeH264MvcEXT* toTransform);
-void transform_fromhost_VkVideoDecodeH264MvcEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264MvcEXT* toTransform);
+void transform_fromhost_VkVideoDecodeH264MvcEXT(ResourceTracker* resourceTracker,
+ VkVideoDecodeH264MvcEXT* toTransform);
-void transform_tohost_VkVideoDecodeH264DpbSlotInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264DpbSlotInfoEXT* toTransform);
+void transform_tohost_VkVideoDecodeH264DpbSlotInfoEXT(ResourceTracker* resourceTracker,
+ VkVideoDecodeH264DpbSlotInfoEXT* toTransform);
void transform_fromhost_VkVideoDecodeH264DpbSlotInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH264DpbSlotInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoDecodeH264DpbSlotInfoEXT* toTransform);
#endif
#ifdef VK_AMD_texture_gather_bias_lod
void transform_tohost_VkTextureLODGatherFormatPropertiesAMD(
- ResourceTracker* resourceTracker,
- VkTextureLODGatherFormatPropertiesAMD* toTransform);
+ ResourceTracker* resourceTracker, VkTextureLODGatherFormatPropertiesAMD* toTransform);
void transform_fromhost_VkTextureLODGatherFormatPropertiesAMD(
- ResourceTracker* resourceTracker,
- VkTextureLODGatherFormatPropertiesAMD* toTransform);
+ ResourceTracker* resourceTracker, VkTextureLODGatherFormatPropertiesAMD* toTransform);
#endif
#ifdef VK_AMD_shader_info
-void transform_tohost_VkShaderResourceUsageAMD(
- ResourceTracker* resourceTracker,
- VkShaderResourceUsageAMD* toTransform);
+void transform_tohost_VkShaderResourceUsageAMD(ResourceTracker* resourceTracker,
+ VkShaderResourceUsageAMD* toTransform);
-void transform_fromhost_VkShaderResourceUsageAMD(
- ResourceTracker* resourceTracker,
- VkShaderResourceUsageAMD* toTransform);
+void transform_fromhost_VkShaderResourceUsageAMD(ResourceTracker* resourceTracker,
+ VkShaderResourceUsageAMD* toTransform);
-void transform_tohost_VkShaderStatisticsInfoAMD(
- ResourceTracker* resourceTracker,
- VkShaderStatisticsInfoAMD* toTransform);
+void transform_tohost_VkShaderStatisticsInfoAMD(ResourceTracker* resourceTracker,
+ VkShaderStatisticsInfoAMD* toTransform);
-void transform_fromhost_VkShaderStatisticsInfoAMD(
- ResourceTracker* resourceTracker,
- VkShaderStatisticsInfoAMD* toTransform);
+void transform_fromhost_VkShaderStatisticsInfoAMD(ResourceTracker* resourceTracker,
+ VkShaderStatisticsInfoAMD* toTransform);
#endif
#ifdef VK_AMD_shader_image_load_store_lod
#endif
#ifdef VK_GGP_stream_descriptor_surface
void transform_tohost_VkStreamDescriptorSurfaceCreateInfoGGP(
- ResourceTracker* resourceTracker,
- VkStreamDescriptorSurfaceCreateInfoGGP* toTransform);
+ ResourceTracker* resourceTracker, VkStreamDescriptorSurfaceCreateInfoGGP* toTransform);
void transform_fromhost_VkStreamDescriptorSurfaceCreateInfoGGP(
- ResourceTracker* resourceTracker,
- VkStreamDescriptorSurfaceCreateInfoGGP* toTransform);
+ ResourceTracker* resourceTracker, VkStreamDescriptorSurfaceCreateInfoGGP* toTransform);
#endif
#ifdef VK_NV_corner_sampled_image
void transform_tohost_VkPhysicalDeviceCornerSampledImageFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCornerSampledImageFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCornerSampledImageFeaturesNV* toTransform);
void transform_fromhost_VkPhysicalDeviceCornerSampledImageFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCornerSampledImageFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCornerSampledImageFeaturesNV* toTransform);
#endif
#ifdef VK_IMG_format_pvrtc
#endif
#ifdef VK_NV_external_memory_capabilities
void transform_tohost_VkExternalImageFormatPropertiesNV(
- ResourceTracker* resourceTracker,
- VkExternalImageFormatPropertiesNV* toTransform);
+ ResourceTracker* resourceTracker, VkExternalImageFormatPropertiesNV* toTransform);
void transform_fromhost_VkExternalImageFormatPropertiesNV(
- ResourceTracker* resourceTracker,
- VkExternalImageFormatPropertiesNV* toTransform);
+ ResourceTracker* resourceTracker, VkExternalImageFormatPropertiesNV* toTransform);
#endif
#ifdef VK_NV_external_memory
void transform_tohost_VkExternalMemoryImageCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkExternalMemoryImageCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkExternalMemoryImageCreateInfoNV* toTransform);
void transform_fromhost_VkExternalMemoryImageCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkExternalMemoryImageCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkExternalMemoryImageCreateInfoNV* toTransform);
-void transform_tohost_VkExportMemoryAllocateInfoNV(
- ResourceTracker* resourceTracker,
- VkExportMemoryAllocateInfoNV* toTransform);
+void transform_tohost_VkExportMemoryAllocateInfoNV(ResourceTracker* resourceTracker,
+ VkExportMemoryAllocateInfoNV* toTransform);
-void transform_fromhost_VkExportMemoryAllocateInfoNV(
- ResourceTracker* resourceTracker,
- VkExportMemoryAllocateInfoNV* toTransform);
+void transform_fromhost_VkExportMemoryAllocateInfoNV(ResourceTracker* resourceTracker,
+ VkExportMemoryAllocateInfoNV* toTransform);
#endif
#ifdef VK_NV_external_memory_win32
-void transform_tohost_VkImportMemoryWin32HandleInfoNV(
- ResourceTracker* resourceTracker,
- VkImportMemoryWin32HandleInfoNV* toTransform);
+void transform_tohost_VkImportMemoryWin32HandleInfoNV(ResourceTracker* resourceTracker,
+ VkImportMemoryWin32HandleInfoNV* toTransform);
void transform_fromhost_VkImportMemoryWin32HandleInfoNV(
- ResourceTracker* resourceTracker,
- VkImportMemoryWin32HandleInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkImportMemoryWin32HandleInfoNV* toTransform);
-void transform_tohost_VkExportMemoryWin32HandleInfoNV(
- ResourceTracker* resourceTracker,
- VkExportMemoryWin32HandleInfoNV* toTransform);
+void transform_tohost_VkExportMemoryWin32HandleInfoNV(ResourceTracker* resourceTracker,
+ VkExportMemoryWin32HandleInfoNV* toTransform);
void transform_fromhost_VkExportMemoryWin32HandleInfoNV(
- ResourceTracker* resourceTracker,
- VkExportMemoryWin32HandleInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkExportMemoryWin32HandleInfoNV* toTransform);
#endif
#ifdef VK_NV_win32_keyed_mutex
void transform_tohost_VkWin32KeyedMutexAcquireReleaseInfoNV(
- ResourceTracker* resourceTracker,
- VkWin32KeyedMutexAcquireReleaseInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkWin32KeyedMutexAcquireReleaseInfoNV* toTransform);
void transform_fromhost_VkWin32KeyedMutexAcquireReleaseInfoNV(
- ResourceTracker* resourceTracker,
- VkWin32KeyedMutexAcquireReleaseInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkWin32KeyedMutexAcquireReleaseInfoNV* toTransform);
#endif
#ifdef VK_EXT_validation_flags
-void transform_tohost_VkValidationFlagsEXT(
- ResourceTracker* resourceTracker,
- VkValidationFlagsEXT* toTransform);
+void transform_tohost_VkValidationFlagsEXT(ResourceTracker* resourceTracker,
+ VkValidationFlagsEXT* toTransform);
-void transform_fromhost_VkValidationFlagsEXT(
- ResourceTracker* resourceTracker,
- VkValidationFlagsEXT* toTransform);
+void transform_fromhost_VkValidationFlagsEXT(ResourceTracker* resourceTracker,
+ VkValidationFlagsEXT* toTransform);
#endif
#ifdef VK_NN_vi_surface
-void transform_tohost_VkViSurfaceCreateInfoNN(
- ResourceTracker* resourceTracker,
- VkViSurfaceCreateInfoNN* toTransform);
+void transform_tohost_VkViSurfaceCreateInfoNN(ResourceTracker* resourceTracker,
+ VkViSurfaceCreateInfoNN* toTransform);
-void transform_fromhost_VkViSurfaceCreateInfoNN(
- ResourceTracker* resourceTracker,
- VkViSurfaceCreateInfoNN* toTransform);
+void transform_fromhost_VkViSurfaceCreateInfoNN(ResourceTracker* resourceTracker,
+ VkViSurfaceCreateInfoNN* toTransform);
#endif
#ifdef VK_EXT_shader_subgroup_ballot
@@ -4161,39 +3507,31 @@
#endif
#ifdef VK_EXT_astc_decode_mode
-void transform_tohost_VkImageViewASTCDecodeModeEXT(
- ResourceTracker* resourceTracker,
- VkImageViewASTCDecodeModeEXT* toTransform);
+void transform_tohost_VkImageViewASTCDecodeModeEXT(ResourceTracker* resourceTracker,
+ VkImageViewASTCDecodeModeEXT* toTransform);
-void transform_fromhost_VkImageViewASTCDecodeModeEXT(
- ResourceTracker* resourceTracker,
- VkImageViewASTCDecodeModeEXT* toTransform);
+void transform_fromhost_VkImageViewASTCDecodeModeEXT(ResourceTracker* resourceTracker,
+ VkImageViewASTCDecodeModeEXT* toTransform);
void transform_tohost_VkPhysicalDeviceASTCDecodeFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceASTCDecodeFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceASTCDecodeFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceASTCDecodeFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceASTCDecodeFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceASTCDecodeFeaturesEXT* toTransform);
#endif
#ifdef VK_EXT_conditional_rendering
void transform_tohost_VkConditionalRenderingBeginInfoEXT(
- ResourceTracker* resourceTracker,
- VkConditionalRenderingBeginInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkConditionalRenderingBeginInfoEXT* toTransform);
void transform_fromhost_VkConditionalRenderingBeginInfoEXT(
- ResourceTracker* resourceTracker,
- VkConditionalRenderingBeginInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkConditionalRenderingBeginInfoEXT* toTransform);
void transform_tohost_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceConditionalRenderingFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceConditionalRenderingFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceConditionalRenderingFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceConditionalRenderingFeaturesEXT* toTransform);
void transform_tohost_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
ResourceTracker* resourceTracker,
@@ -4205,21 +3543,17 @@
#endif
#ifdef VK_NV_clip_space_w_scaling
-void transform_tohost_VkViewportWScalingNV(
- ResourceTracker* resourceTracker,
- VkViewportWScalingNV* toTransform);
+void transform_tohost_VkViewportWScalingNV(ResourceTracker* resourceTracker,
+ VkViewportWScalingNV* toTransform);
-void transform_fromhost_VkViewportWScalingNV(
- ResourceTracker* resourceTracker,
- VkViewportWScalingNV* toTransform);
+void transform_fromhost_VkViewportWScalingNV(ResourceTracker* resourceTracker,
+ VkViewportWScalingNV* toTransform);
void transform_tohost_VkPipelineViewportWScalingStateCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkPipelineViewportWScalingStateCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineViewportWScalingStateCreateInfoNV* toTransform);
void transform_fromhost_VkPipelineViewportWScalingStateCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkPipelineViewportWScalingStateCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineViewportWScalingStateCreateInfoNV* toTransform);
#endif
#ifdef VK_EXT_direct_mode_display
@@ -4227,81 +3561,63 @@
#ifdef VK_EXT_acquire_xlib_display
#endif
#ifdef VK_EXT_display_surface_counter
-void transform_tohost_VkSurfaceCapabilities2EXT(
- ResourceTracker* resourceTracker,
- VkSurfaceCapabilities2EXT* toTransform);
+void transform_tohost_VkSurfaceCapabilities2EXT(ResourceTracker* resourceTracker,
+ VkSurfaceCapabilities2EXT* toTransform);
-void transform_fromhost_VkSurfaceCapabilities2EXT(
- ResourceTracker* resourceTracker,
- VkSurfaceCapabilities2EXT* toTransform);
+void transform_fromhost_VkSurfaceCapabilities2EXT(ResourceTracker* resourceTracker,
+ VkSurfaceCapabilities2EXT* toTransform);
#endif
#ifdef VK_EXT_display_control
-void transform_tohost_VkDisplayPowerInfoEXT(
- ResourceTracker* resourceTracker,
- VkDisplayPowerInfoEXT* toTransform);
+void transform_tohost_VkDisplayPowerInfoEXT(ResourceTracker* resourceTracker,
+ VkDisplayPowerInfoEXT* toTransform);
-void transform_fromhost_VkDisplayPowerInfoEXT(
- ResourceTracker* resourceTracker,
- VkDisplayPowerInfoEXT* toTransform);
+void transform_fromhost_VkDisplayPowerInfoEXT(ResourceTracker* resourceTracker,
+ VkDisplayPowerInfoEXT* toTransform);
-void transform_tohost_VkDeviceEventInfoEXT(
- ResourceTracker* resourceTracker,
- VkDeviceEventInfoEXT* toTransform);
+void transform_tohost_VkDeviceEventInfoEXT(ResourceTracker* resourceTracker,
+ VkDeviceEventInfoEXT* toTransform);
-void transform_fromhost_VkDeviceEventInfoEXT(
- ResourceTracker* resourceTracker,
- VkDeviceEventInfoEXT* toTransform);
+void transform_fromhost_VkDeviceEventInfoEXT(ResourceTracker* resourceTracker,
+ VkDeviceEventInfoEXT* toTransform);
-void transform_tohost_VkDisplayEventInfoEXT(
- ResourceTracker* resourceTracker,
- VkDisplayEventInfoEXT* toTransform);
+void transform_tohost_VkDisplayEventInfoEXT(ResourceTracker* resourceTracker,
+ VkDisplayEventInfoEXT* toTransform);
-void transform_fromhost_VkDisplayEventInfoEXT(
- ResourceTracker* resourceTracker,
- VkDisplayEventInfoEXT* toTransform);
+void transform_fromhost_VkDisplayEventInfoEXT(ResourceTracker* resourceTracker,
+ VkDisplayEventInfoEXT* toTransform);
-void transform_tohost_VkSwapchainCounterCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkSwapchainCounterCreateInfoEXT* toTransform);
+void transform_tohost_VkSwapchainCounterCreateInfoEXT(ResourceTracker* resourceTracker,
+ VkSwapchainCounterCreateInfoEXT* toTransform);
void transform_fromhost_VkSwapchainCounterCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkSwapchainCounterCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkSwapchainCounterCreateInfoEXT* toTransform);
#endif
#ifdef VK_GOOGLE_display_timing
-void transform_tohost_VkRefreshCycleDurationGOOGLE(
- ResourceTracker* resourceTracker,
- VkRefreshCycleDurationGOOGLE* toTransform);
+void transform_tohost_VkRefreshCycleDurationGOOGLE(ResourceTracker* resourceTracker,
+ VkRefreshCycleDurationGOOGLE* toTransform);
-void transform_fromhost_VkRefreshCycleDurationGOOGLE(
- ResourceTracker* resourceTracker,
- VkRefreshCycleDurationGOOGLE* toTransform);
+void transform_fromhost_VkRefreshCycleDurationGOOGLE(ResourceTracker* resourceTracker,
+ VkRefreshCycleDurationGOOGLE* toTransform);
-void transform_tohost_VkPastPresentationTimingGOOGLE(
- ResourceTracker* resourceTracker,
- VkPastPresentationTimingGOOGLE* toTransform);
+void transform_tohost_VkPastPresentationTimingGOOGLE(ResourceTracker* resourceTracker,
+ VkPastPresentationTimingGOOGLE* toTransform);
-void transform_fromhost_VkPastPresentationTimingGOOGLE(
- ResourceTracker* resourceTracker,
- VkPastPresentationTimingGOOGLE* toTransform);
+void transform_fromhost_VkPastPresentationTimingGOOGLE(ResourceTracker* resourceTracker,
+ VkPastPresentationTimingGOOGLE* toTransform);
-void transform_tohost_VkPresentTimeGOOGLE(
- ResourceTracker* resourceTracker,
- VkPresentTimeGOOGLE* toTransform);
+void transform_tohost_VkPresentTimeGOOGLE(ResourceTracker* resourceTracker,
+ VkPresentTimeGOOGLE* toTransform);
-void transform_fromhost_VkPresentTimeGOOGLE(
- ResourceTracker* resourceTracker,
- VkPresentTimeGOOGLE* toTransform);
+void transform_fromhost_VkPresentTimeGOOGLE(ResourceTracker* resourceTracker,
+ VkPresentTimeGOOGLE* toTransform);
-void transform_tohost_VkPresentTimesInfoGOOGLE(
- ResourceTracker* resourceTracker,
- VkPresentTimesInfoGOOGLE* toTransform);
+void transform_tohost_VkPresentTimesInfoGOOGLE(ResourceTracker* resourceTracker,
+ VkPresentTimesInfoGOOGLE* toTransform);
-void transform_fromhost_VkPresentTimesInfoGOOGLE(
- ResourceTracker* resourceTracker,
- VkPresentTimesInfoGOOGLE* toTransform);
+void transform_fromhost_VkPresentTimesInfoGOOGLE(ResourceTracker* resourceTracker,
+ VkPresentTimesInfoGOOGLE* toTransform);
#endif
#ifdef VK_NV_sample_mask_override_coverage
@@ -4321,39 +3637,31 @@
#endif
#ifdef VK_NV_viewport_swizzle
-void transform_tohost_VkViewportSwizzleNV(
- ResourceTracker* resourceTracker,
- VkViewportSwizzleNV* toTransform);
+void transform_tohost_VkViewportSwizzleNV(ResourceTracker* resourceTracker,
+ VkViewportSwizzleNV* toTransform);
-void transform_fromhost_VkViewportSwizzleNV(
- ResourceTracker* resourceTracker,
- VkViewportSwizzleNV* toTransform);
+void transform_fromhost_VkViewportSwizzleNV(ResourceTracker* resourceTracker,
+ VkViewportSwizzleNV* toTransform);
void transform_tohost_VkPipelineViewportSwizzleStateCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkPipelineViewportSwizzleStateCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineViewportSwizzleStateCreateInfoNV* toTransform);
void transform_fromhost_VkPipelineViewportSwizzleStateCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkPipelineViewportSwizzleStateCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineViewportSwizzleStateCreateInfoNV* toTransform);
#endif
#ifdef VK_EXT_discard_rectangles
void transform_tohost_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDiscardRectanglePropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDiscardRectanglePropertiesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDiscardRectanglePropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDiscardRectanglePropertiesEXT* toTransform);
void transform_tohost_VkPipelineDiscardRectangleStateCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineDiscardRectangleStateCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineDiscardRectangleStateCreateInfoEXT* toTransform);
void transform_fromhost_VkPipelineDiscardRectangleStateCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineDiscardRectangleStateCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineDiscardRectangleStateCreateInfoEXT* toTransform);
#endif
#ifdef VK_EXT_conservative_rasterization
@@ -4376,12 +3684,10 @@
#endif
#ifdef VK_EXT_depth_clip_enable
void transform_tohost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDepthClipEnableFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDepthClipEnableFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDepthClipEnableFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDepthClipEnableFeaturesEXT* toTransform);
void transform_tohost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
ResourceTracker* resourceTracker,
@@ -4395,41 +3701,31 @@
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
-void transform_tohost_VkXYColorEXT(
- ResourceTracker* resourceTracker,
- VkXYColorEXT* toTransform);
+void transform_tohost_VkXYColorEXT(ResourceTracker* resourceTracker, VkXYColorEXT* toTransform);
-void transform_fromhost_VkXYColorEXT(
- ResourceTracker* resourceTracker,
- VkXYColorEXT* toTransform);
+void transform_fromhost_VkXYColorEXT(ResourceTracker* resourceTracker, VkXYColorEXT* toTransform);
-void transform_tohost_VkHdrMetadataEXT(
- ResourceTracker* resourceTracker,
- VkHdrMetadataEXT* toTransform);
+void transform_tohost_VkHdrMetadataEXT(ResourceTracker* resourceTracker,
+ VkHdrMetadataEXT* toTransform);
-void transform_fromhost_VkHdrMetadataEXT(
- ResourceTracker* resourceTracker,
- VkHdrMetadataEXT* toTransform);
+void transform_fromhost_VkHdrMetadataEXT(ResourceTracker* resourceTracker,
+ VkHdrMetadataEXT* toTransform);
#endif
#ifdef VK_MVK_ios_surface
-void transform_tohost_VkIOSSurfaceCreateInfoMVK(
- ResourceTracker* resourceTracker,
- VkIOSSurfaceCreateInfoMVK* toTransform);
+void transform_tohost_VkIOSSurfaceCreateInfoMVK(ResourceTracker* resourceTracker,
+ VkIOSSurfaceCreateInfoMVK* toTransform);
-void transform_fromhost_VkIOSSurfaceCreateInfoMVK(
- ResourceTracker* resourceTracker,
- VkIOSSurfaceCreateInfoMVK* toTransform);
+void transform_fromhost_VkIOSSurfaceCreateInfoMVK(ResourceTracker* resourceTracker,
+ VkIOSSurfaceCreateInfoMVK* toTransform);
#endif
#ifdef VK_MVK_macos_surface
-void transform_tohost_VkMacOSSurfaceCreateInfoMVK(
- ResourceTracker* resourceTracker,
- VkMacOSSurfaceCreateInfoMVK* toTransform);
+void transform_tohost_VkMacOSSurfaceCreateInfoMVK(ResourceTracker* resourceTracker,
+ VkMacOSSurfaceCreateInfoMVK* toTransform);
-void transform_fromhost_VkMacOSSurfaceCreateInfoMVK(
- ResourceTracker* resourceTracker,
- VkMacOSSurfaceCreateInfoMVK* toTransform);
+void transform_fromhost_VkMacOSSurfaceCreateInfoMVK(ResourceTracker* resourceTracker,
+ VkMacOSSurfaceCreateInfoMVK* toTransform);
#endif
#ifdef VK_MVK_moltenvk
@@ -4439,113 +3735,93 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
-void transform_tohost_VkDebugUtilsLabelEXT(
- ResourceTracker* resourceTracker,
- VkDebugUtilsLabelEXT* toTransform);
+void transform_tohost_VkDebugUtilsLabelEXT(ResourceTracker* resourceTracker,
+ VkDebugUtilsLabelEXT* toTransform);
-void transform_fromhost_VkDebugUtilsLabelEXT(
- ResourceTracker* resourceTracker,
- VkDebugUtilsLabelEXT* toTransform);
+void transform_fromhost_VkDebugUtilsLabelEXT(ResourceTracker* resourceTracker,
+ VkDebugUtilsLabelEXT* toTransform);
-void transform_tohost_VkDebugUtilsObjectNameInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugUtilsObjectNameInfoEXT* toTransform);
+void transform_tohost_VkDebugUtilsObjectNameInfoEXT(ResourceTracker* resourceTracker,
+ VkDebugUtilsObjectNameInfoEXT* toTransform);
-void transform_fromhost_VkDebugUtilsObjectNameInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugUtilsObjectNameInfoEXT* toTransform);
+void transform_fromhost_VkDebugUtilsObjectNameInfoEXT(ResourceTracker* resourceTracker,
+ VkDebugUtilsObjectNameInfoEXT* toTransform);
void transform_tohost_VkDebugUtilsMessengerCallbackDataEXT(
- ResourceTracker* resourceTracker,
- VkDebugUtilsMessengerCallbackDataEXT* toTransform);
+ ResourceTracker* resourceTracker, VkDebugUtilsMessengerCallbackDataEXT* toTransform);
void transform_fromhost_VkDebugUtilsMessengerCallbackDataEXT(
- ResourceTracker* resourceTracker,
- VkDebugUtilsMessengerCallbackDataEXT* toTransform);
+ ResourceTracker* resourceTracker, VkDebugUtilsMessengerCallbackDataEXT* toTransform);
void transform_tohost_VkDebugUtilsMessengerCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugUtilsMessengerCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkDebugUtilsMessengerCreateInfoEXT* toTransform);
void transform_fromhost_VkDebugUtilsMessengerCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugUtilsMessengerCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkDebugUtilsMessengerCreateInfoEXT* toTransform);
-void transform_tohost_VkDebugUtilsObjectTagInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugUtilsObjectTagInfoEXT* toTransform);
+void transform_tohost_VkDebugUtilsObjectTagInfoEXT(ResourceTracker* resourceTracker,
+ VkDebugUtilsObjectTagInfoEXT* toTransform);
-void transform_fromhost_VkDebugUtilsObjectTagInfoEXT(
- ResourceTracker* resourceTracker,
- VkDebugUtilsObjectTagInfoEXT* toTransform);
+void transform_fromhost_VkDebugUtilsObjectTagInfoEXT(ResourceTracker* resourceTracker,
+ VkDebugUtilsObjectTagInfoEXT* toTransform);
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
void transform_tohost_VkAndroidHardwareBufferUsageANDROID(
- ResourceTracker* resourceTracker,
- VkAndroidHardwareBufferUsageANDROID* toTransform);
+ ResourceTracker* resourceTracker, VkAndroidHardwareBufferUsageANDROID* toTransform);
void transform_fromhost_VkAndroidHardwareBufferUsageANDROID(
- ResourceTracker* resourceTracker,
- VkAndroidHardwareBufferUsageANDROID* toTransform);
+ ResourceTracker* resourceTracker, VkAndroidHardwareBufferUsageANDROID* toTransform);
void transform_tohost_VkAndroidHardwareBufferPropertiesANDROID(
- ResourceTracker* resourceTracker,
- VkAndroidHardwareBufferPropertiesANDROID* toTransform);
+ ResourceTracker* resourceTracker, VkAndroidHardwareBufferPropertiesANDROID* toTransform);
void transform_fromhost_VkAndroidHardwareBufferPropertiesANDROID(
- ResourceTracker* resourceTracker,
- VkAndroidHardwareBufferPropertiesANDROID* toTransform);
+ ResourceTracker* resourceTracker, VkAndroidHardwareBufferPropertiesANDROID* toTransform);
void transform_tohost_VkAndroidHardwareBufferFormatPropertiesANDROID(
- ResourceTracker* resourceTracker,
- VkAndroidHardwareBufferFormatPropertiesANDROID* toTransform);
+ ResourceTracker* resourceTracker, VkAndroidHardwareBufferFormatPropertiesANDROID* toTransform);
void transform_fromhost_VkAndroidHardwareBufferFormatPropertiesANDROID(
- ResourceTracker* resourceTracker,
- VkAndroidHardwareBufferFormatPropertiesANDROID* toTransform);
+ ResourceTracker* resourceTracker, VkAndroidHardwareBufferFormatPropertiesANDROID* toTransform);
void transform_tohost_VkImportAndroidHardwareBufferInfoANDROID(
- ResourceTracker* resourceTracker,
- VkImportAndroidHardwareBufferInfoANDROID* toTransform);
+ ResourceTracker* resourceTracker, VkImportAndroidHardwareBufferInfoANDROID* toTransform);
void transform_fromhost_VkImportAndroidHardwareBufferInfoANDROID(
- ResourceTracker* resourceTracker,
- VkImportAndroidHardwareBufferInfoANDROID* toTransform);
+ ResourceTracker* resourceTracker, VkImportAndroidHardwareBufferInfoANDROID* toTransform);
void transform_tohost_VkMemoryGetAndroidHardwareBufferInfoANDROID(
- ResourceTracker* resourceTracker,
- VkMemoryGetAndroidHardwareBufferInfoANDROID* toTransform);
+ ResourceTracker* resourceTracker, VkMemoryGetAndroidHardwareBufferInfoANDROID* toTransform);
void transform_fromhost_VkMemoryGetAndroidHardwareBufferInfoANDROID(
- ResourceTracker* resourceTracker,
- VkMemoryGetAndroidHardwareBufferInfoANDROID* toTransform);
+ ResourceTracker* resourceTracker, VkMemoryGetAndroidHardwareBufferInfoANDROID* toTransform);
-void transform_tohost_VkExternalFormatANDROID(
- ResourceTracker* resourceTracker,
- VkExternalFormatANDROID* toTransform);
+void transform_tohost_VkExternalFormatANDROID(ResourceTracker* resourceTracker,
+ VkExternalFormatANDROID* toTransform);
-void transform_fromhost_VkExternalFormatANDROID(
- ResourceTracker* resourceTracker,
- VkExternalFormatANDROID* toTransform);
+void transform_fromhost_VkExternalFormatANDROID(ResourceTracker* resourceTracker,
+ VkExternalFormatANDROID* toTransform);
void transform_tohost_VkAndroidHardwareBufferFormatProperties2ANDROID(
- ResourceTracker* resourceTracker,
- VkAndroidHardwareBufferFormatProperties2ANDROID* toTransform);
+ ResourceTracker* resourceTracker, VkAndroidHardwareBufferFormatProperties2ANDROID* toTransform);
void transform_fromhost_VkAndroidHardwareBufferFormatProperties2ANDROID(
- ResourceTracker* resourceTracker,
- VkAndroidHardwareBufferFormatProperties2ANDROID* toTransform);
+ ResourceTracker* resourceTracker, VkAndroidHardwareBufferFormatProperties2ANDROID* toTransform);
#endif
#ifdef VK_EXT_sampler_filter_minmax
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkSamplerReductionModeCreateInfo, transform_tohost_VkSamplerReductionModeCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkSamplerReductionModeCreateInfo,
+ transform_tohost_VkSamplerReductionModeCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSamplerReductionModeCreateInfo, transform_fromhost_VkSamplerReductionModeCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSamplerReductionModeCreateInfo,
+ transform_fromhost_VkSamplerReductionModeCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceSamplerFilterMinmaxProperties, transform_tohost_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceSamplerFilterMinmaxProperties,
+ transform_tohost_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceSamplerFilterMinmaxProperties, transform_fromhost_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceSamplerFilterMinmaxProperties,
+ transform_fromhost_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT)
#endif
#ifdef VK_AMD_gpu_shader_int16
@@ -4556,104 +3832,80 @@
#endif
#ifdef VK_EXT_inline_uniform_block
void transform_tohost_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toTransform);
void transform_tohost_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toTransform);
void transform_tohost_VkWriteDescriptorSetInlineUniformBlockEXT(
- ResourceTracker* resourceTracker,
- VkWriteDescriptorSetInlineUniformBlockEXT* toTransform);
+ ResourceTracker* resourceTracker, VkWriteDescriptorSetInlineUniformBlockEXT* toTransform);
void transform_fromhost_VkWriteDescriptorSetInlineUniformBlockEXT(
- ResourceTracker* resourceTracker,
- VkWriteDescriptorSetInlineUniformBlockEXT* toTransform);
+ ResourceTracker* resourceTracker, VkWriteDescriptorSetInlineUniformBlockEXT* toTransform);
void transform_tohost_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toTransform);
void transform_fromhost_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toTransform);
#endif
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
-void transform_tohost_VkSampleLocationEXT(
- ResourceTracker* resourceTracker,
- VkSampleLocationEXT* toTransform);
+void transform_tohost_VkSampleLocationEXT(ResourceTracker* resourceTracker,
+ VkSampleLocationEXT* toTransform);
-void transform_fromhost_VkSampleLocationEXT(
- ResourceTracker* resourceTracker,
- VkSampleLocationEXT* toTransform);
+void transform_fromhost_VkSampleLocationEXT(ResourceTracker* resourceTracker,
+ VkSampleLocationEXT* toTransform);
-void transform_tohost_VkSampleLocationsInfoEXT(
- ResourceTracker* resourceTracker,
- VkSampleLocationsInfoEXT* toTransform);
+void transform_tohost_VkSampleLocationsInfoEXT(ResourceTracker* resourceTracker,
+ VkSampleLocationsInfoEXT* toTransform);
-void transform_fromhost_VkSampleLocationsInfoEXT(
- ResourceTracker* resourceTracker,
- VkSampleLocationsInfoEXT* toTransform);
+void transform_fromhost_VkSampleLocationsInfoEXT(ResourceTracker* resourceTracker,
+ VkSampleLocationsInfoEXT* toTransform);
-void transform_tohost_VkAttachmentSampleLocationsEXT(
- ResourceTracker* resourceTracker,
- VkAttachmentSampleLocationsEXT* toTransform);
+void transform_tohost_VkAttachmentSampleLocationsEXT(ResourceTracker* resourceTracker,
+ VkAttachmentSampleLocationsEXT* toTransform);
-void transform_fromhost_VkAttachmentSampleLocationsEXT(
- ResourceTracker* resourceTracker,
- VkAttachmentSampleLocationsEXT* toTransform);
+void transform_fromhost_VkAttachmentSampleLocationsEXT(ResourceTracker* resourceTracker,
+ VkAttachmentSampleLocationsEXT* toTransform);
-void transform_tohost_VkSubpassSampleLocationsEXT(
- ResourceTracker* resourceTracker,
- VkSubpassSampleLocationsEXT* toTransform);
+void transform_tohost_VkSubpassSampleLocationsEXT(ResourceTracker* resourceTracker,
+ VkSubpassSampleLocationsEXT* toTransform);
-void transform_fromhost_VkSubpassSampleLocationsEXT(
- ResourceTracker* resourceTracker,
- VkSubpassSampleLocationsEXT* toTransform);
+void transform_fromhost_VkSubpassSampleLocationsEXT(ResourceTracker* resourceTracker,
+ VkSubpassSampleLocationsEXT* toTransform);
void transform_tohost_VkRenderPassSampleLocationsBeginInfoEXT(
- ResourceTracker* resourceTracker,
- VkRenderPassSampleLocationsBeginInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkRenderPassSampleLocationsBeginInfoEXT* toTransform);
void transform_fromhost_VkRenderPassSampleLocationsBeginInfoEXT(
- ResourceTracker* resourceTracker,
- VkRenderPassSampleLocationsBeginInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkRenderPassSampleLocationsBeginInfoEXT* toTransform);
void transform_tohost_VkPipelineSampleLocationsStateCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineSampleLocationsStateCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineSampleLocationsStateCreateInfoEXT* toTransform);
void transform_fromhost_VkPipelineSampleLocationsStateCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineSampleLocationsStateCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineSampleLocationsStateCreateInfoEXT* toTransform);
void transform_tohost_VkPhysicalDeviceSampleLocationsPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSampleLocationsPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSampleLocationsPropertiesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceSampleLocationsPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSampleLocationsPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSampleLocationsPropertiesEXT* toTransform);
-void transform_tohost_VkMultisamplePropertiesEXT(
- ResourceTracker* resourceTracker,
- VkMultisamplePropertiesEXT* toTransform);
+void transform_tohost_VkMultisamplePropertiesEXT(ResourceTracker* resourceTracker,
+ VkMultisamplePropertiesEXT* toTransform);
-void transform_fromhost_VkMultisamplePropertiesEXT(
- ResourceTracker* resourceTracker,
- VkMultisamplePropertiesEXT* toTransform);
+void transform_fromhost_VkMultisamplePropertiesEXT(ResourceTracker* resourceTracker,
+ VkMultisamplePropertiesEXT* toTransform);
#endif
#ifdef VK_EXT_blend_operation_advanced
@@ -4674,172 +3926,150 @@
VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* toTransform);
void transform_tohost_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineColorBlendAdvancedStateCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineColorBlendAdvancedStateCreateInfoEXT* toTransform);
void transform_fromhost_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineColorBlendAdvancedStateCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineColorBlendAdvancedStateCreateInfoEXT* toTransform);
#endif
#ifdef VK_NV_fragment_coverage_to_color
void transform_tohost_VkPipelineCoverageToColorStateCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkPipelineCoverageToColorStateCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineCoverageToColorStateCreateInfoNV* toTransform);
void transform_fromhost_VkPipelineCoverageToColorStateCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkPipelineCoverageToColorStateCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineCoverageToColorStateCreateInfoNV* toTransform);
#endif
#ifdef VK_NV_framebuffer_mixed_samples
void transform_tohost_VkPipelineCoverageModulationStateCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkPipelineCoverageModulationStateCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineCoverageModulationStateCreateInfoNV* toTransform);
void transform_fromhost_VkPipelineCoverageModulationStateCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkPipelineCoverageModulationStateCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineCoverageModulationStateCreateInfoNV* toTransform);
#endif
#ifdef VK_NV_fill_rectangle
#endif
#ifdef VK_NV_shader_sm_builtins
void transform_tohost_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* toTransform);
void transform_fromhost_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* toTransform);
void transform_tohost_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* toTransform);
void transform_fromhost_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* toTransform);
#endif
#ifdef VK_EXT_post_depth_coverage
#endif
#ifdef VK_EXT_image_drm_format_modifier
void transform_tohost_VkDrmFormatModifierPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkDrmFormatModifierPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkDrmFormatModifierPropertiesEXT* toTransform);
void transform_fromhost_VkDrmFormatModifierPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkDrmFormatModifierPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkDrmFormatModifierPropertiesEXT* toTransform);
void transform_tohost_VkDrmFormatModifierPropertiesListEXT(
- ResourceTracker* resourceTracker,
- VkDrmFormatModifierPropertiesListEXT* toTransform);
+ ResourceTracker* resourceTracker, VkDrmFormatModifierPropertiesListEXT* toTransform);
void transform_fromhost_VkDrmFormatModifierPropertiesListEXT(
- ResourceTracker* resourceTracker,
- VkDrmFormatModifierPropertiesListEXT* toTransform);
+ ResourceTracker* resourceTracker, VkDrmFormatModifierPropertiesListEXT* toTransform);
void transform_tohost_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceImageDrmFormatModifierInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceImageDrmFormatModifierInfoEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceImageDrmFormatModifierInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceImageDrmFormatModifierInfoEXT* toTransform);
void transform_tohost_VkImageDrmFormatModifierListCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkImageDrmFormatModifierListCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkImageDrmFormatModifierListCreateInfoEXT* toTransform);
void transform_fromhost_VkImageDrmFormatModifierListCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkImageDrmFormatModifierListCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkImageDrmFormatModifierListCreateInfoEXT* toTransform);
void transform_tohost_VkImageDrmFormatModifierExplicitCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkImageDrmFormatModifierExplicitCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkImageDrmFormatModifierExplicitCreateInfoEXT* toTransform);
void transform_fromhost_VkImageDrmFormatModifierExplicitCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkImageDrmFormatModifierExplicitCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkImageDrmFormatModifierExplicitCreateInfoEXT* toTransform);
void transform_tohost_VkImageDrmFormatModifierPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkImageDrmFormatModifierPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkImageDrmFormatModifierPropertiesEXT* toTransform);
void transform_fromhost_VkImageDrmFormatModifierPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkImageDrmFormatModifierPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkImageDrmFormatModifierPropertiesEXT* toTransform);
void transform_tohost_VkDrmFormatModifierProperties2EXT(
- ResourceTracker* resourceTracker,
- VkDrmFormatModifierProperties2EXT* toTransform);
+ ResourceTracker* resourceTracker, VkDrmFormatModifierProperties2EXT* toTransform);
void transform_fromhost_VkDrmFormatModifierProperties2EXT(
- ResourceTracker* resourceTracker,
- VkDrmFormatModifierProperties2EXT* toTransform);
+ ResourceTracker* resourceTracker, VkDrmFormatModifierProperties2EXT* toTransform);
void transform_tohost_VkDrmFormatModifierPropertiesList2EXT(
- ResourceTracker* resourceTracker,
- VkDrmFormatModifierPropertiesList2EXT* toTransform);
+ ResourceTracker* resourceTracker, VkDrmFormatModifierPropertiesList2EXT* toTransform);
void transform_fromhost_VkDrmFormatModifierPropertiesList2EXT(
- ResourceTracker* resourceTracker,
- VkDrmFormatModifierPropertiesList2EXT* toTransform);
+ ResourceTracker* resourceTracker, VkDrmFormatModifierPropertiesList2EXT* toTransform);
#endif
#ifdef VK_EXT_validation_cache
-void transform_tohost_VkValidationCacheCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkValidationCacheCreateInfoEXT* toTransform);
+void transform_tohost_VkValidationCacheCreateInfoEXT(ResourceTracker* resourceTracker,
+ VkValidationCacheCreateInfoEXT* toTransform);
-void transform_fromhost_VkValidationCacheCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkValidationCacheCreateInfoEXT* toTransform);
+void transform_fromhost_VkValidationCacheCreateInfoEXT(ResourceTracker* resourceTracker,
+ VkValidationCacheCreateInfoEXT* toTransform);
void transform_tohost_VkShaderModuleValidationCacheCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkShaderModuleValidationCacheCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkShaderModuleValidationCacheCreateInfoEXT* toTransform);
void transform_fromhost_VkShaderModuleValidationCacheCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkShaderModuleValidationCacheCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkShaderModuleValidationCacheCreateInfoEXT* toTransform);
#endif
#ifdef VK_EXT_descriptor_indexing
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkDescriptorSetLayoutBindingFlagsCreateInfo, transform_tohost_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkDescriptorSetLayoutBindingFlagsCreateInfo,
+ transform_tohost_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDescriptorSetLayoutBindingFlagsCreateInfo, transform_fromhost_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDescriptorSetLayoutBindingFlagsCreateInfo,
+ transform_fromhost_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceDescriptorIndexingFeatures, transform_tohost_VkPhysicalDeviceDescriptorIndexingFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceDescriptorIndexingFeatures,
+ transform_tohost_VkPhysicalDeviceDescriptorIndexingFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceDescriptorIndexingFeatures, transform_fromhost_VkPhysicalDeviceDescriptorIndexingFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceDescriptorIndexingFeatures,
+ transform_fromhost_VkPhysicalDeviceDescriptorIndexingFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceDescriptorIndexingProperties, transform_tohost_VkPhysicalDeviceDescriptorIndexingPropertiesEXT)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceDescriptorIndexingProperties,
+ transform_tohost_VkPhysicalDeviceDescriptorIndexingPropertiesEXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceDescriptorIndexingProperties, transform_fromhost_VkPhysicalDeviceDescriptorIndexingPropertiesEXT)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceDescriptorIndexingProperties,
+ transform_fromhost_VkPhysicalDeviceDescriptorIndexingPropertiesEXT)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkDescriptorSetVariableDescriptorCountAllocateInfo, transform_tohost_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkDescriptorSetVariableDescriptorCountAllocateInfo,
+ transform_tohost_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDescriptorSetVariableDescriptorCountAllocateInfo, transform_fromhost_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDescriptorSetVariableDescriptorCountAllocateInfo,
+ transform_fromhost_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkDescriptorSetVariableDescriptorCountLayoutSupport, transform_tohost_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkDescriptorSetVariableDescriptorCountLayoutSupport,
+ transform_tohost_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDescriptorSetVariableDescriptorCountLayoutSupport, transform_fromhost_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDescriptorSetVariableDescriptorCountLayoutSupport,
+ transform_fromhost_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT)
#endif
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_NV_shading_rate_image
-void transform_tohost_VkShadingRatePaletteNV(
- ResourceTracker* resourceTracker,
- VkShadingRatePaletteNV* toTransform);
+void transform_tohost_VkShadingRatePaletteNV(ResourceTracker* resourceTracker,
+ VkShadingRatePaletteNV* toTransform);
-void transform_fromhost_VkShadingRatePaletteNV(
- ResourceTracker* resourceTracker,
- VkShadingRatePaletteNV* toTransform);
+void transform_fromhost_VkShadingRatePaletteNV(ResourceTracker* resourceTracker,
+ VkShadingRatePaletteNV* toTransform);
void transform_tohost_VkPipelineViewportShadingRateImageStateCreateInfoNV(
ResourceTracker* resourceTracker,
@@ -4850,36 +4080,28 @@
VkPipelineViewportShadingRateImageStateCreateInfoNV* toTransform);
void transform_tohost_VkPhysicalDeviceShadingRateImageFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShadingRateImageFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShadingRateImageFeaturesNV* toTransform);
void transform_fromhost_VkPhysicalDeviceShadingRateImageFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShadingRateImageFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShadingRateImageFeaturesNV* toTransform);
void transform_tohost_VkPhysicalDeviceShadingRateImagePropertiesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShadingRateImagePropertiesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShadingRateImagePropertiesNV* toTransform);
void transform_fromhost_VkPhysicalDeviceShadingRateImagePropertiesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShadingRateImagePropertiesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShadingRateImagePropertiesNV* toTransform);
-void transform_tohost_VkCoarseSampleLocationNV(
- ResourceTracker* resourceTracker,
- VkCoarseSampleLocationNV* toTransform);
+void transform_tohost_VkCoarseSampleLocationNV(ResourceTracker* resourceTracker,
+ VkCoarseSampleLocationNV* toTransform);
-void transform_fromhost_VkCoarseSampleLocationNV(
- ResourceTracker* resourceTracker,
- VkCoarseSampleLocationNV* toTransform);
+void transform_fromhost_VkCoarseSampleLocationNV(ResourceTracker* resourceTracker,
+ VkCoarseSampleLocationNV* toTransform);
-void transform_tohost_VkCoarseSampleOrderCustomNV(
- ResourceTracker* resourceTracker,
- VkCoarseSampleOrderCustomNV* toTransform);
+void transform_tohost_VkCoarseSampleOrderCustomNV(ResourceTracker* resourceTracker,
+ VkCoarseSampleOrderCustomNV* toTransform);
-void transform_fromhost_VkCoarseSampleOrderCustomNV(
- ResourceTracker* resourceTracker,
- VkCoarseSampleOrderCustomNV* toTransform);
+void transform_fromhost_VkCoarseSampleOrderCustomNV(ResourceTracker* resourceTracker,
+ VkCoarseSampleOrderCustomNV* toTransform);
void transform_tohost_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
ResourceTracker* resourceTracker,
@@ -4892,136 +4114,107 @@
#endif
#ifdef VK_NV_ray_tracing
void transform_tohost_VkRayTracingShaderGroupCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkRayTracingShaderGroupCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkRayTracingShaderGroupCreateInfoNV* toTransform);
void transform_fromhost_VkRayTracingShaderGroupCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkRayTracingShaderGroupCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkRayTracingShaderGroupCreateInfoNV* toTransform);
void transform_tohost_VkRayTracingPipelineCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkRayTracingPipelineCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkRayTracingPipelineCreateInfoNV* toTransform);
void transform_fromhost_VkRayTracingPipelineCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkRayTracingPipelineCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkRayTracingPipelineCreateInfoNV* toTransform);
-void transform_tohost_VkGeometryTrianglesNV(
- ResourceTracker* resourceTracker,
- VkGeometryTrianglesNV* toTransform);
+void transform_tohost_VkGeometryTrianglesNV(ResourceTracker* resourceTracker,
+ VkGeometryTrianglesNV* toTransform);
-void transform_fromhost_VkGeometryTrianglesNV(
- ResourceTracker* resourceTracker,
- VkGeometryTrianglesNV* toTransform);
+void transform_fromhost_VkGeometryTrianglesNV(ResourceTracker* resourceTracker,
+ VkGeometryTrianglesNV* toTransform);
-void transform_tohost_VkGeometryAABBNV(
- ResourceTracker* resourceTracker,
- VkGeometryAABBNV* toTransform);
+void transform_tohost_VkGeometryAABBNV(ResourceTracker* resourceTracker,
+ VkGeometryAABBNV* toTransform);
-void transform_fromhost_VkGeometryAABBNV(
- ResourceTracker* resourceTracker,
- VkGeometryAABBNV* toTransform);
+void transform_fromhost_VkGeometryAABBNV(ResourceTracker* resourceTracker,
+ VkGeometryAABBNV* toTransform);
-void transform_tohost_VkGeometryDataNV(
- ResourceTracker* resourceTracker,
- VkGeometryDataNV* toTransform);
+void transform_tohost_VkGeometryDataNV(ResourceTracker* resourceTracker,
+ VkGeometryDataNV* toTransform);
-void transform_fromhost_VkGeometryDataNV(
- ResourceTracker* resourceTracker,
- VkGeometryDataNV* toTransform);
+void transform_fromhost_VkGeometryDataNV(ResourceTracker* resourceTracker,
+ VkGeometryDataNV* toTransform);
-void transform_tohost_VkGeometryNV(
- ResourceTracker* resourceTracker,
- VkGeometryNV* toTransform);
+void transform_tohost_VkGeometryNV(ResourceTracker* resourceTracker, VkGeometryNV* toTransform);
-void transform_fromhost_VkGeometryNV(
- ResourceTracker* resourceTracker,
- VkGeometryNV* toTransform);
+void transform_fromhost_VkGeometryNV(ResourceTracker* resourceTracker, VkGeometryNV* toTransform);
-void transform_tohost_VkAccelerationStructureInfoNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureInfoNV* toTransform);
+void transform_tohost_VkAccelerationStructureInfoNV(ResourceTracker* resourceTracker,
+ VkAccelerationStructureInfoNV* toTransform);
-void transform_fromhost_VkAccelerationStructureInfoNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureInfoNV* toTransform);
+void transform_fromhost_VkAccelerationStructureInfoNV(ResourceTracker* resourceTracker,
+ VkAccelerationStructureInfoNV* toTransform);
void transform_tohost_VkAccelerationStructureCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureCreateInfoNV* toTransform);
void transform_fromhost_VkAccelerationStructureCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureCreateInfoNV* toTransform);
void transform_tohost_VkBindAccelerationStructureMemoryInfoNV(
- ResourceTracker* resourceTracker,
- VkBindAccelerationStructureMemoryInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkBindAccelerationStructureMemoryInfoNV* toTransform);
void transform_fromhost_VkBindAccelerationStructureMemoryInfoNV(
- ResourceTracker* resourceTracker,
- VkBindAccelerationStructureMemoryInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkBindAccelerationStructureMemoryInfoNV* toTransform);
void transform_tohost_VkWriteDescriptorSetAccelerationStructureNV(
- ResourceTracker* resourceTracker,
- VkWriteDescriptorSetAccelerationStructureNV* toTransform);
+ ResourceTracker* resourceTracker, VkWriteDescriptorSetAccelerationStructureNV* toTransform);
void transform_fromhost_VkWriteDescriptorSetAccelerationStructureNV(
- ResourceTracker* resourceTracker,
- VkWriteDescriptorSetAccelerationStructureNV* toTransform);
+ ResourceTracker* resourceTracker, VkWriteDescriptorSetAccelerationStructureNV* toTransform);
void transform_tohost_VkAccelerationStructureMemoryRequirementsInfoNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureMemoryRequirementsInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureMemoryRequirementsInfoNV* toTransform);
void transform_fromhost_VkAccelerationStructureMemoryRequirementsInfoNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureMemoryRequirementsInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureMemoryRequirementsInfoNV* toTransform);
void transform_tohost_VkPhysicalDeviceRayTracingPropertiesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRayTracingPropertiesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRayTracingPropertiesNV* toTransform);
void transform_fromhost_VkPhysicalDeviceRayTracingPropertiesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRayTracingPropertiesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRayTracingPropertiesNV* toTransform);
-void transform_tohost_VkTransformMatrixKHR(
- ResourceTracker* resourceTracker,
- VkTransformMatrixKHR* toTransform);
+void transform_tohost_VkTransformMatrixKHR(ResourceTracker* resourceTracker,
+ VkTransformMatrixKHR* toTransform);
-void transform_fromhost_VkTransformMatrixKHR(
- ResourceTracker* resourceTracker,
- VkTransformMatrixKHR* toTransform);
+void transform_fromhost_VkTransformMatrixKHR(ResourceTracker* resourceTracker,
+ VkTransformMatrixKHR* toTransform);
DEFINE_ALIAS_FUNCTION(transform_tohost_VkTransformMatrixKHR, transform_tohost_VkTransformMatrixNV)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkTransformMatrixKHR, transform_fromhost_VkTransformMatrixNV)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkTransformMatrixKHR,
+ transform_fromhost_VkTransformMatrixNV)
-void transform_tohost_VkAabbPositionsKHR(
- ResourceTracker* resourceTracker,
- VkAabbPositionsKHR* toTransform);
+void transform_tohost_VkAabbPositionsKHR(ResourceTracker* resourceTracker,
+ VkAabbPositionsKHR* toTransform);
-void transform_fromhost_VkAabbPositionsKHR(
- ResourceTracker* resourceTracker,
- VkAabbPositionsKHR* toTransform);
+void transform_fromhost_VkAabbPositionsKHR(ResourceTracker* resourceTracker,
+ VkAabbPositionsKHR* toTransform);
DEFINE_ALIAS_FUNCTION(transform_tohost_VkAabbPositionsKHR, transform_tohost_VkAabbPositionsNV)
DEFINE_ALIAS_FUNCTION(transform_fromhost_VkAabbPositionsKHR, transform_fromhost_VkAabbPositionsNV)
void transform_tohost_VkAccelerationStructureInstanceKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureInstanceKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureInstanceKHR* toTransform);
void transform_fromhost_VkAccelerationStructureInstanceKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureInstanceKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureInstanceKHR* toTransform);
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkAccelerationStructureInstanceKHR, transform_tohost_VkAccelerationStructureInstanceNV)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkAccelerationStructureInstanceKHR,
+ transform_tohost_VkAccelerationStructureInstanceNV)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkAccelerationStructureInstanceKHR, transform_fromhost_VkAccelerationStructureInstanceNV)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkAccelerationStructureInstanceKHR,
+ transform_fromhost_VkAccelerationStructureInstanceNV)
#endif
#ifdef VK_NV_representative_fragment_test
@@ -5044,158 +4237,124 @@
#endif
#ifdef VK_EXT_filter_cubic
void transform_tohost_VkPhysicalDeviceImageViewImageFormatInfoEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceImageViewImageFormatInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceImageViewImageFormatInfoEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceImageViewImageFormatInfoEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceImageViewImageFormatInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceImageViewImageFormatInfoEXT* toTransform);
void transform_tohost_VkFilterCubicImageViewImageFormatPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkFilterCubicImageViewImageFormatPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkFilterCubicImageViewImageFormatPropertiesEXT* toTransform);
void transform_fromhost_VkFilterCubicImageViewImageFormatPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkFilterCubicImageViewImageFormatPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkFilterCubicImageViewImageFormatPropertiesEXT* toTransform);
#endif
#ifdef VK_QCOM_render_pass_shader_resolve
#endif
#ifdef VK_EXT_global_priority
void transform_tohost_VkDeviceQueueGlobalPriorityCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDeviceQueueGlobalPriorityCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceQueueGlobalPriorityCreateInfoEXT* toTransform);
void transform_fromhost_VkDeviceQueueGlobalPriorityCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDeviceQueueGlobalPriorityCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceQueueGlobalPriorityCreateInfoEXT* toTransform);
#endif
#ifdef VK_EXT_external_memory_host
void transform_tohost_VkImportMemoryHostPointerInfoEXT(
- ResourceTracker* resourceTracker,
- VkImportMemoryHostPointerInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkImportMemoryHostPointerInfoEXT* toTransform);
void transform_fromhost_VkImportMemoryHostPointerInfoEXT(
- ResourceTracker* resourceTracker,
- VkImportMemoryHostPointerInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkImportMemoryHostPointerInfoEXT* toTransform);
void transform_tohost_VkMemoryHostPointerPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkMemoryHostPointerPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkMemoryHostPointerPropertiesEXT* toTransform);
void transform_fromhost_VkMemoryHostPointerPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkMemoryHostPointerPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkMemoryHostPointerPropertiesEXT* toTransform);
void transform_tohost_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toTransform);
#endif
#ifdef VK_AMD_buffer_marker
#endif
#ifdef VK_AMD_pipeline_compiler_control
void transform_tohost_VkPipelineCompilerControlCreateInfoAMD(
- ResourceTracker* resourceTracker,
- VkPipelineCompilerControlCreateInfoAMD* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineCompilerControlCreateInfoAMD* toTransform);
void transform_fromhost_VkPipelineCompilerControlCreateInfoAMD(
- ResourceTracker* resourceTracker,
- VkPipelineCompilerControlCreateInfoAMD* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineCompilerControlCreateInfoAMD* toTransform);
#endif
#ifdef VK_EXT_calibrated_timestamps
-void transform_tohost_VkCalibratedTimestampInfoEXT(
- ResourceTracker* resourceTracker,
- VkCalibratedTimestampInfoEXT* toTransform);
+void transform_tohost_VkCalibratedTimestampInfoEXT(ResourceTracker* resourceTracker,
+ VkCalibratedTimestampInfoEXT* toTransform);
-void transform_fromhost_VkCalibratedTimestampInfoEXT(
- ResourceTracker* resourceTracker,
- VkCalibratedTimestampInfoEXT* toTransform);
+void transform_fromhost_VkCalibratedTimestampInfoEXT(ResourceTracker* resourceTracker,
+ VkCalibratedTimestampInfoEXT* toTransform);
#endif
#ifdef VK_AMD_shader_core_properties
void transform_tohost_VkPhysicalDeviceShaderCorePropertiesAMD(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderCorePropertiesAMD* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderCorePropertiesAMD* toTransform);
void transform_fromhost_VkPhysicalDeviceShaderCorePropertiesAMD(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderCorePropertiesAMD* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderCorePropertiesAMD* toTransform);
#endif
#ifdef VK_EXT_video_decode_h265
-void transform_tohost_VkVideoDecodeH265ProfileEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265ProfileEXT* toTransform);
+void transform_tohost_VkVideoDecodeH265ProfileEXT(ResourceTracker* resourceTracker,
+ VkVideoDecodeH265ProfileEXT* toTransform);
-void transform_fromhost_VkVideoDecodeH265ProfileEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265ProfileEXT* toTransform);
+void transform_fromhost_VkVideoDecodeH265ProfileEXT(ResourceTracker* resourceTracker,
+ VkVideoDecodeH265ProfileEXT* toTransform);
void transform_tohost_VkVideoDecodeH265CapabilitiesEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265CapabilitiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoDecodeH265CapabilitiesEXT* toTransform);
void transform_fromhost_VkVideoDecodeH265CapabilitiesEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265CapabilitiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoDecodeH265CapabilitiesEXT* toTransform);
void transform_tohost_VkVideoDecodeH265SessionCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265SessionCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoDecodeH265SessionCreateInfoEXT* toTransform);
void transform_fromhost_VkVideoDecodeH265SessionCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265SessionCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoDecodeH265SessionCreateInfoEXT* toTransform);
void transform_tohost_VkVideoDecodeH265SessionParametersAddInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265SessionParametersAddInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoDecodeH265SessionParametersAddInfoEXT* toTransform);
void transform_fromhost_VkVideoDecodeH265SessionParametersAddInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265SessionParametersAddInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoDecodeH265SessionParametersAddInfoEXT* toTransform);
void transform_tohost_VkVideoDecodeH265SessionParametersCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265SessionParametersCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoDecodeH265SessionParametersCreateInfoEXT* toTransform);
void transform_fromhost_VkVideoDecodeH265SessionParametersCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265SessionParametersCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoDecodeH265SessionParametersCreateInfoEXT* toTransform);
-void transform_tohost_VkVideoDecodeH265PictureInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265PictureInfoEXT* toTransform);
+void transform_tohost_VkVideoDecodeH265PictureInfoEXT(ResourceTracker* resourceTracker,
+ VkVideoDecodeH265PictureInfoEXT* toTransform);
void transform_fromhost_VkVideoDecodeH265PictureInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265PictureInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoDecodeH265PictureInfoEXT* toTransform);
-void transform_tohost_VkVideoDecodeH265DpbSlotInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265DpbSlotInfoEXT* toTransform);
+void transform_tohost_VkVideoDecodeH265DpbSlotInfoEXT(ResourceTracker* resourceTracker,
+ VkVideoDecodeH265DpbSlotInfoEXT* toTransform);
void transform_fromhost_VkVideoDecodeH265DpbSlotInfoEXT(
- ResourceTracker* resourceTracker,
- VkVideoDecodeH265DpbSlotInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVideoDecodeH265DpbSlotInfoEXT* toTransform);
#endif
#ifdef VK_AMD_memory_overallocation_behavior
void transform_tohost_VkDeviceMemoryOverallocationCreateInfoAMD(
- ResourceTracker* resourceTracker,
- VkDeviceMemoryOverallocationCreateInfoAMD* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceMemoryOverallocationCreateInfoAMD* toTransform);
void transform_fromhost_VkDeviceMemoryOverallocationCreateInfoAMD(
- ResourceTracker* resourceTracker,
- VkDeviceMemoryOverallocationCreateInfoAMD* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceMemoryOverallocationCreateInfoAMD* toTransform);
#endif
#ifdef VK_EXT_vertex_attribute_divisor
@@ -5208,20 +4367,16 @@
VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* toTransform);
void transform_tohost_VkVertexInputBindingDivisorDescriptionEXT(
- ResourceTracker* resourceTracker,
- VkVertexInputBindingDivisorDescriptionEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVertexInputBindingDivisorDescriptionEXT* toTransform);
void transform_fromhost_VkVertexInputBindingDivisorDescriptionEXT(
- ResourceTracker* resourceTracker,
- VkVertexInputBindingDivisorDescriptionEXT* toTransform);
+ ResourceTracker* resourceTracker, VkVertexInputBindingDivisorDescriptionEXT* toTransform);
void transform_tohost_VkPipelineVertexInputDivisorStateCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineVertexInputDivisorStateCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineVertexInputDivisorStateCreateInfoEXT* toTransform);
void transform_fromhost_VkPipelineVertexInputDivisorStateCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineVertexInputDivisorStateCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineVertexInputDivisorStateCreateInfoEXT* toTransform);
void transform_tohost_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
ResourceTracker* resourceTracker,
@@ -5233,31 +4388,25 @@
#endif
#ifdef VK_GGP_frame_token
-void transform_tohost_VkPresentFrameTokenGGP(
- ResourceTracker* resourceTracker,
- VkPresentFrameTokenGGP* toTransform);
+void transform_tohost_VkPresentFrameTokenGGP(ResourceTracker* resourceTracker,
+ VkPresentFrameTokenGGP* toTransform);
-void transform_fromhost_VkPresentFrameTokenGGP(
- ResourceTracker* resourceTracker,
- VkPresentFrameTokenGGP* toTransform);
+void transform_fromhost_VkPresentFrameTokenGGP(ResourceTracker* resourceTracker,
+ VkPresentFrameTokenGGP* toTransform);
#endif
#ifdef VK_EXT_pipeline_creation_feedback
-void transform_tohost_VkPipelineCreationFeedbackEXT(
- ResourceTracker* resourceTracker,
- VkPipelineCreationFeedbackEXT* toTransform);
+void transform_tohost_VkPipelineCreationFeedbackEXT(ResourceTracker* resourceTracker,
+ VkPipelineCreationFeedbackEXT* toTransform);
-void transform_fromhost_VkPipelineCreationFeedbackEXT(
- ResourceTracker* resourceTracker,
- VkPipelineCreationFeedbackEXT* toTransform);
+void transform_fromhost_VkPipelineCreationFeedbackEXT(ResourceTracker* resourceTracker,
+ VkPipelineCreationFeedbackEXT* toTransform);
void transform_tohost_VkPipelineCreationFeedbackCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineCreationFeedbackCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineCreationFeedbackCreateInfoEXT* toTransform);
void transform_fromhost_VkPipelineCreationFeedbackCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineCreationFeedbackCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineCreationFeedbackCreateInfoEXT* toTransform);
#endif
#ifdef VK_NV_shader_subgroup_partitioned
@@ -5274,28 +4423,22 @@
#endif
#ifdef VK_NV_mesh_shader
void transform_tohost_VkPhysicalDeviceMeshShaderFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMeshShaderFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMeshShaderFeaturesNV* toTransform);
void transform_fromhost_VkPhysicalDeviceMeshShaderFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMeshShaderFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMeshShaderFeaturesNV* toTransform);
void transform_tohost_VkPhysicalDeviceMeshShaderPropertiesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMeshShaderPropertiesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMeshShaderPropertiesNV* toTransform);
void transform_fromhost_VkPhysicalDeviceMeshShaderPropertiesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMeshShaderPropertiesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMeshShaderPropertiesNV* toTransform);
void transform_tohost_VkDrawMeshTasksIndirectCommandNV(
- ResourceTracker* resourceTracker,
- VkDrawMeshTasksIndirectCommandNV* toTransform);
+ ResourceTracker* resourceTracker, VkDrawMeshTasksIndirectCommandNV* toTransform);
void transform_fromhost_VkDrawMeshTasksIndirectCommandNV(
- ResourceTracker* resourceTracker,
- VkDrawMeshTasksIndirectCommandNV* toTransform);
+ ResourceTracker* resourceTracker, VkDrawMeshTasksIndirectCommandNV* toTransform);
#endif
#ifdef VK_NV_fragment_shader_barycentric
@@ -5310,12 +4453,10 @@
#endif
#ifdef VK_NV_shader_image_footprint
void transform_tohost_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderImageFootprintFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderImageFootprintFeaturesNV* toTransform);
void transform_fromhost_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderImageFootprintFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderImageFootprintFeaturesNV* toTransform);
#endif
#ifdef VK_NV_scissor_exclusive
@@ -5328,30 +4469,24 @@
VkPipelineViewportExclusiveScissorStateCreateInfoNV* toTransform);
void transform_tohost_VkPhysicalDeviceExclusiveScissorFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExclusiveScissorFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExclusiveScissorFeaturesNV* toTransform);
void transform_fromhost_VkPhysicalDeviceExclusiveScissorFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExclusiveScissorFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExclusiveScissorFeaturesNV* toTransform);
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
void transform_tohost_VkQueueFamilyCheckpointPropertiesNV(
- ResourceTracker* resourceTracker,
- VkQueueFamilyCheckpointPropertiesNV* toTransform);
+ ResourceTracker* resourceTracker, VkQueueFamilyCheckpointPropertiesNV* toTransform);
void transform_fromhost_VkQueueFamilyCheckpointPropertiesNV(
- ResourceTracker* resourceTracker,
- VkQueueFamilyCheckpointPropertiesNV* toTransform);
+ ResourceTracker* resourceTracker, VkQueueFamilyCheckpointPropertiesNV* toTransform);
-void transform_tohost_VkCheckpointDataNV(
- ResourceTracker* resourceTracker,
- VkCheckpointDataNV* toTransform);
+void transform_tohost_VkCheckpointDataNV(ResourceTracker* resourceTracker,
+ VkCheckpointDataNV* toTransform);
-void transform_fromhost_VkCheckpointDataNV(
- ResourceTracker* resourceTracker,
- VkCheckpointDataNV* toTransform);
+void transform_fromhost_VkCheckpointDataNV(ResourceTracker* resourceTracker,
+ VkCheckpointDataNV* toTransform);
#endif
#ifdef VK_INTEL_shader_integer_functions2
@@ -5365,153 +4500,125 @@
#endif
#ifdef VK_INTEL_performance_query
-void transform_tohost_VkPerformanceValueDataINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceValueDataINTEL* toTransform);
+void transform_tohost_VkPerformanceValueDataINTEL(ResourceTracker* resourceTracker,
+ VkPerformanceValueDataINTEL* toTransform);
-void transform_fromhost_VkPerformanceValueDataINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceValueDataINTEL* toTransform);
+void transform_fromhost_VkPerformanceValueDataINTEL(ResourceTracker* resourceTracker,
+ VkPerformanceValueDataINTEL* toTransform);
-void transform_tohost_VkPerformanceValueINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceValueINTEL* toTransform);
+void transform_tohost_VkPerformanceValueINTEL(ResourceTracker* resourceTracker,
+ VkPerformanceValueINTEL* toTransform);
-void transform_fromhost_VkPerformanceValueINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceValueINTEL* toTransform);
+void transform_fromhost_VkPerformanceValueINTEL(ResourceTracker* resourceTracker,
+ VkPerformanceValueINTEL* toTransform);
void transform_tohost_VkInitializePerformanceApiInfoINTEL(
- ResourceTracker* resourceTracker,
- VkInitializePerformanceApiInfoINTEL* toTransform);
+ ResourceTracker* resourceTracker, VkInitializePerformanceApiInfoINTEL* toTransform);
void transform_fromhost_VkInitializePerformanceApiInfoINTEL(
- ResourceTracker* resourceTracker,
- VkInitializePerformanceApiInfoINTEL* toTransform);
+ ResourceTracker* resourceTracker, VkInitializePerformanceApiInfoINTEL* toTransform);
void transform_tohost_VkQueryPoolPerformanceQueryCreateInfoINTEL(
- ResourceTracker* resourceTracker,
- VkQueryPoolPerformanceQueryCreateInfoINTEL* toTransform);
+ ResourceTracker* resourceTracker, VkQueryPoolPerformanceQueryCreateInfoINTEL* toTransform);
void transform_fromhost_VkQueryPoolPerformanceQueryCreateInfoINTEL(
- ResourceTracker* resourceTracker,
- VkQueryPoolPerformanceQueryCreateInfoINTEL* toTransform);
+ ResourceTracker* resourceTracker, VkQueryPoolPerformanceQueryCreateInfoINTEL* toTransform);
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkQueryPoolPerformanceQueryCreateInfoINTEL, transform_tohost_VkQueryPoolCreateInfoINTEL)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkQueryPoolPerformanceQueryCreateInfoINTEL,
+ transform_tohost_VkQueryPoolCreateInfoINTEL)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkQueryPoolPerformanceQueryCreateInfoINTEL, transform_fromhost_VkQueryPoolCreateInfoINTEL)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkQueryPoolPerformanceQueryCreateInfoINTEL,
+ transform_fromhost_VkQueryPoolCreateInfoINTEL)
-void transform_tohost_VkPerformanceMarkerInfoINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceMarkerInfoINTEL* toTransform);
+void transform_tohost_VkPerformanceMarkerInfoINTEL(ResourceTracker* resourceTracker,
+ VkPerformanceMarkerInfoINTEL* toTransform);
-void transform_fromhost_VkPerformanceMarkerInfoINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceMarkerInfoINTEL* toTransform);
+void transform_fromhost_VkPerformanceMarkerInfoINTEL(ResourceTracker* resourceTracker,
+ VkPerformanceMarkerInfoINTEL* toTransform);
void transform_tohost_VkPerformanceStreamMarkerInfoINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceStreamMarkerInfoINTEL* toTransform);
+ ResourceTracker* resourceTracker, VkPerformanceStreamMarkerInfoINTEL* toTransform);
void transform_fromhost_VkPerformanceStreamMarkerInfoINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceStreamMarkerInfoINTEL* toTransform);
+ ResourceTracker* resourceTracker, VkPerformanceStreamMarkerInfoINTEL* toTransform);
-void transform_tohost_VkPerformanceOverrideInfoINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceOverrideInfoINTEL* toTransform);
+void transform_tohost_VkPerformanceOverrideInfoINTEL(ResourceTracker* resourceTracker,
+ VkPerformanceOverrideInfoINTEL* toTransform);
-void transform_fromhost_VkPerformanceOverrideInfoINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceOverrideInfoINTEL* toTransform);
+void transform_fromhost_VkPerformanceOverrideInfoINTEL(ResourceTracker* resourceTracker,
+ VkPerformanceOverrideInfoINTEL* toTransform);
void transform_tohost_VkPerformanceConfigurationAcquireInfoINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceConfigurationAcquireInfoINTEL* toTransform);
+ ResourceTracker* resourceTracker, VkPerformanceConfigurationAcquireInfoINTEL* toTransform);
void transform_fromhost_VkPerformanceConfigurationAcquireInfoINTEL(
- ResourceTracker* resourceTracker,
- VkPerformanceConfigurationAcquireInfoINTEL* toTransform);
+ ResourceTracker* resourceTracker, VkPerformanceConfigurationAcquireInfoINTEL* toTransform);
#endif
#ifdef VK_EXT_pci_bus_info
void transform_tohost_VkPhysicalDevicePCIBusInfoPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePCIBusInfoPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevicePCIBusInfoPropertiesEXT* toTransform);
void transform_fromhost_VkPhysicalDevicePCIBusInfoPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePCIBusInfoPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevicePCIBusInfoPropertiesEXT* toTransform);
#endif
#ifdef VK_AMD_display_native_hdr
void transform_tohost_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
- ResourceTracker* resourceTracker,
- VkDisplayNativeHdrSurfaceCapabilitiesAMD* toTransform);
+ ResourceTracker* resourceTracker, VkDisplayNativeHdrSurfaceCapabilitiesAMD* toTransform);
void transform_fromhost_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
- ResourceTracker* resourceTracker,
- VkDisplayNativeHdrSurfaceCapabilitiesAMD* toTransform);
+ ResourceTracker* resourceTracker, VkDisplayNativeHdrSurfaceCapabilitiesAMD* toTransform);
void transform_tohost_VkSwapchainDisplayNativeHdrCreateInfoAMD(
- ResourceTracker* resourceTracker,
- VkSwapchainDisplayNativeHdrCreateInfoAMD* toTransform);
+ ResourceTracker* resourceTracker, VkSwapchainDisplayNativeHdrCreateInfoAMD* toTransform);
void transform_fromhost_VkSwapchainDisplayNativeHdrCreateInfoAMD(
- ResourceTracker* resourceTracker,
- VkSwapchainDisplayNativeHdrCreateInfoAMD* toTransform);
+ ResourceTracker* resourceTracker, VkSwapchainDisplayNativeHdrCreateInfoAMD* toTransform);
#endif
#ifdef VK_FUCHSIA_imagepipe_surface
void transform_tohost_VkImagePipeSurfaceCreateInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImagePipeSurfaceCreateInfoFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkImagePipeSurfaceCreateInfoFUCHSIA* toTransform);
void transform_fromhost_VkImagePipeSurfaceCreateInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImagePipeSurfaceCreateInfoFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkImagePipeSurfaceCreateInfoFUCHSIA* toTransform);
#endif
#ifdef VK_EXT_metal_surface
-void transform_tohost_VkMetalSurfaceCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkMetalSurfaceCreateInfoEXT* toTransform);
+void transform_tohost_VkMetalSurfaceCreateInfoEXT(ResourceTracker* resourceTracker,
+ VkMetalSurfaceCreateInfoEXT* toTransform);
-void transform_fromhost_VkMetalSurfaceCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkMetalSurfaceCreateInfoEXT* toTransform);
+void transform_fromhost_VkMetalSurfaceCreateInfoEXT(ResourceTracker* resourceTracker,
+ VkMetalSurfaceCreateInfoEXT* toTransform);
#endif
#ifdef VK_EXT_fragment_density_map
void transform_tohost_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFragmentDensityMapFeaturesEXT* toTransform);
void transform_tohost_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFragmentDensityMapPropertiesEXT* toTransform);
void transform_tohost_VkRenderPassFragmentDensityMapCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkRenderPassFragmentDensityMapCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkRenderPassFragmentDensityMapCreateInfoEXT* toTransform);
void transform_fromhost_VkRenderPassFragmentDensityMapCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkRenderPassFragmentDensityMapCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkRenderPassFragmentDensityMapCreateInfoEXT* toTransform);
#endif
#ifdef VK_EXT_scalar_block_layout
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceScalarBlockLayoutFeatures, transform_tohost_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceScalarBlockLayoutFeatures,
+ transform_tohost_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceScalarBlockLayoutFeatures, transform_fromhost_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceScalarBlockLayoutFeatures,
+ transform_fromhost_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT)
#endif
#ifdef VK_GOOGLE_hlsl_functionality1
@@ -5520,12 +4627,10 @@
#endif
#ifdef VK_EXT_subgroup_size_control
void transform_tohost_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toTransform);
void transform_tohost_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
ResourceTracker* resourceTracker,
@@ -5546,22 +4651,18 @@
#endif
#ifdef VK_AMD_shader_core_properties2
void transform_tohost_VkPhysicalDeviceShaderCoreProperties2AMD(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderCoreProperties2AMD* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderCoreProperties2AMD* toTransform);
void transform_fromhost_VkPhysicalDeviceShaderCoreProperties2AMD(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderCoreProperties2AMD* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderCoreProperties2AMD* toTransform);
#endif
#ifdef VK_AMD_device_coherent_memory
void transform_tohost_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCoherentMemoryFeaturesAMD* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCoherentMemoryFeaturesAMD* toTransform);
void transform_fromhost_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCoherentMemoryFeaturesAMD* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCoherentMemoryFeaturesAMD* toTransform);
#endif
#ifdef VK_EXT_shader_image_atomic_int64
@@ -5576,30 +4677,24 @@
#endif
#ifdef VK_EXT_memory_budget
void transform_tohost_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMemoryBudgetPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMemoryBudgetPropertiesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMemoryBudgetPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMemoryBudgetPropertiesEXT* toTransform);
#endif
#ifdef VK_EXT_memory_priority
void transform_tohost_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMemoryPriorityFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMemoryPriorityFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMemoryPriorityFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMemoryPriorityFeaturesEXT* toTransform);
-void transform_tohost_VkMemoryPriorityAllocateInfoEXT(
- ResourceTracker* resourceTracker,
- VkMemoryPriorityAllocateInfoEXT* toTransform);
+void transform_tohost_VkMemoryPriorityAllocateInfoEXT(ResourceTracker* resourceTracker,
+ VkMemoryPriorityAllocateInfoEXT* toTransform);
void transform_fromhost_VkMemoryPriorityAllocateInfoEXT(
- ResourceTracker* resourceTracker,
- VkMemoryPriorityAllocateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkMemoryPriorityAllocateInfoEXT* toTransform);
#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
@@ -5614,106 +4709,92 @@
#endif
#ifdef VK_EXT_buffer_device_address
void transform_tohost_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* toTransform);
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, transform_tohost_VkPhysicalDeviceBufferAddressFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT,
+ transform_tohost_VkPhysicalDeviceBufferAddressFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, transform_fromhost_VkPhysicalDeviceBufferAddressFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT,
+ transform_fromhost_VkPhysicalDeviceBufferAddressFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkBufferDeviceAddressInfo, transform_tohost_VkBufferDeviceAddressInfoEXT)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkBufferDeviceAddressInfo,
+ transform_tohost_VkBufferDeviceAddressInfoEXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBufferDeviceAddressInfo, transform_fromhost_VkBufferDeviceAddressInfoEXT)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBufferDeviceAddressInfo,
+ transform_fromhost_VkBufferDeviceAddressInfoEXT)
void transform_tohost_VkBufferDeviceAddressCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkBufferDeviceAddressCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkBufferDeviceAddressCreateInfoEXT* toTransform);
void transform_fromhost_VkBufferDeviceAddressCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkBufferDeviceAddressCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkBufferDeviceAddressCreateInfoEXT* toTransform);
#endif
#ifdef VK_EXT_tooling_info
void transform_tohost_VkPhysicalDeviceToolPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceToolPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceToolPropertiesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceToolPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceToolPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceToolPropertiesEXT* toTransform);
#endif
#ifdef VK_EXT_separate_stencil_usage
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageStencilUsageCreateInfo, transform_tohost_VkImageStencilUsageCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageStencilUsageCreateInfo,
+ transform_tohost_VkImageStencilUsageCreateInfoEXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageStencilUsageCreateInfo, transform_fromhost_VkImageStencilUsageCreateInfoEXT)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageStencilUsageCreateInfo,
+ transform_fromhost_VkImageStencilUsageCreateInfoEXT)
#endif
#ifdef VK_EXT_validation_features
-void transform_tohost_VkValidationFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkValidationFeaturesEXT* toTransform);
+void transform_tohost_VkValidationFeaturesEXT(ResourceTracker* resourceTracker,
+ VkValidationFeaturesEXT* toTransform);
-void transform_fromhost_VkValidationFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkValidationFeaturesEXT* toTransform);
+void transform_fromhost_VkValidationFeaturesEXT(ResourceTracker* resourceTracker,
+ VkValidationFeaturesEXT* toTransform);
#endif
#ifdef VK_NV_cooperative_matrix
-void transform_tohost_VkCooperativeMatrixPropertiesNV(
- ResourceTracker* resourceTracker,
- VkCooperativeMatrixPropertiesNV* toTransform);
+void transform_tohost_VkCooperativeMatrixPropertiesNV(ResourceTracker* resourceTracker,
+ VkCooperativeMatrixPropertiesNV* toTransform);
void transform_fromhost_VkCooperativeMatrixPropertiesNV(
- ResourceTracker* resourceTracker,
- VkCooperativeMatrixPropertiesNV* toTransform);
+ ResourceTracker* resourceTracker, VkCooperativeMatrixPropertiesNV* toTransform);
void transform_tohost_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCooperativeMatrixFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCooperativeMatrixFeaturesNV* toTransform);
void transform_fromhost_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCooperativeMatrixFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCooperativeMatrixFeaturesNV* toTransform);
void transform_tohost_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCooperativeMatrixPropertiesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCooperativeMatrixPropertiesNV* toTransform);
void transform_fromhost_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCooperativeMatrixPropertiesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCooperativeMatrixPropertiesNV* toTransform);
#endif
#ifdef VK_NV_coverage_reduction_mode
void transform_tohost_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCoverageReductionModeFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCoverageReductionModeFeaturesNV* toTransform);
void transform_fromhost_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCoverageReductionModeFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCoverageReductionModeFeaturesNV* toTransform);
void transform_tohost_VkPipelineCoverageReductionStateCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkPipelineCoverageReductionStateCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineCoverageReductionStateCreateInfoNV* toTransform);
void transform_fromhost_VkPipelineCoverageReductionStateCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkPipelineCoverageReductionStateCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineCoverageReductionStateCreateInfoNV* toTransform);
void transform_tohost_VkFramebufferMixedSamplesCombinationNV(
- ResourceTracker* resourceTracker,
- VkFramebufferMixedSamplesCombinationNV* toTransform);
+ ResourceTracker* resourceTracker, VkFramebufferMixedSamplesCombinationNV* toTransform);
void transform_fromhost_VkFramebufferMixedSamplesCombinationNV(
- ResourceTracker* resourceTracker,
- VkFramebufferMixedSamplesCombinationNV* toTransform);
+ ResourceTracker* resourceTracker, VkFramebufferMixedSamplesCombinationNV* toTransform);
#endif
#ifdef VK_EXT_fragment_shader_interlock
@@ -5728,30 +4809,24 @@
#endif
#ifdef VK_EXT_ycbcr_image_arrays
void transform_tohost_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* toTransform);
#endif
#ifdef VK_EXT_provoking_vertex
void transform_tohost_VkPhysicalDeviceProvokingVertexFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProvokingVertexFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceProvokingVertexFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceProvokingVertexFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProvokingVertexFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceProvokingVertexFeaturesEXT* toTransform);
void transform_tohost_VkPhysicalDeviceProvokingVertexPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProvokingVertexPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceProvokingVertexPropertiesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceProvokingVertexPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceProvokingVertexPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceProvokingVertexPropertiesEXT* toTransform);
void transform_tohost_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
ResourceTracker* resourceTracker,
@@ -5764,110 +4839,90 @@
#endif
#ifdef VK_EXT_full_screen_exclusive
void transform_tohost_VkSurfaceFullScreenExclusiveInfoEXT(
- ResourceTracker* resourceTracker,
- VkSurfaceFullScreenExclusiveInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkSurfaceFullScreenExclusiveInfoEXT* toTransform);
void transform_fromhost_VkSurfaceFullScreenExclusiveInfoEXT(
- ResourceTracker* resourceTracker,
- VkSurfaceFullScreenExclusiveInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkSurfaceFullScreenExclusiveInfoEXT* toTransform);
void transform_tohost_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
- ResourceTracker* resourceTracker,
- VkSurfaceCapabilitiesFullScreenExclusiveEXT* toTransform);
+ ResourceTracker* resourceTracker, VkSurfaceCapabilitiesFullScreenExclusiveEXT* toTransform);
void transform_fromhost_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
- ResourceTracker* resourceTracker,
- VkSurfaceCapabilitiesFullScreenExclusiveEXT* toTransform);
+ ResourceTracker* resourceTracker, VkSurfaceCapabilitiesFullScreenExclusiveEXT* toTransform);
void transform_tohost_VkSurfaceFullScreenExclusiveWin32InfoEXT(
- ResourceTracker* resourceTracker,
- VkSurfaceFullScreenExclusiveWin32InfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkSurfaceFullScreenExclusiveWin32InfoEXT* toTransform);
void transform_fromhost_VkSurfaceFullScreenExclusiveWin32InfoEXT(
- ResourceTracker* resourceTracker,
- VkSurfaceFullScreenExclusiveWin32InfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkSurfaceFullScreenExclusiveWin32InfoEXT* toTransform);
#endif
#ifdef VK_EXT_headless_surface
-void transform_tohost_VkHeadlessSurfaceCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkHeadlessSurfaceCreateInfoEXT* toTransform);
+void transform_tohost_VkHeadlessSurfaceCreateInfoEXT(ResourceTracker* resourceTracker,
+ VkHeadlessSurfaceCreateInfoEXT* toTransform);
-void transform_fromhost_VkHeadlessSurfaceCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkHeadlessSurfaceCreateInfoEXT* toTransform);
+void transform_fromhost_VkHeadlessSurfaceCreateInfoEXT(ResourceTracker* resourceTracker,
+ VkHeadlessSurfaceCreateInfoEXT* toTransform);
#endif
#ifdef VK_EXT_line_rasterization
void transform_tohost_VkPhysicalDeviceLineRasterizationFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceLineRasterizationFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceLineRasterizationFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceLineRasterizationFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationFeaturesEXT* toTransform);
void transform_tohost_VkPhysicalDeviceLineRasterizationPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceLineRasterizationPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationPropertiesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceLineRasterizationPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceLineRasterizationPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceLineRasterizationPropertiesEXT* toTransform);
void transform_tohost_VkPipelineRasterizationLineStateCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineRasterizationLineStateCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineRasterizationLineStateCreateInfoEXT* toTransform);
void transform_fromhost_VkPipelineRasterizationLineStateCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineRasterizationLineStateCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineRasterizationLineStateCreateInfoEXT* toTransform);
#endif
#ifdef VK_EXT_shader_atomic_float
void transform_tohost_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* toTransform);
#endif
#ifdef VK_EXT_host_query_reset
-DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceHostQueryResetFeatures, transform_tohost_VkPhysicalDeviceHostQueryResetFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceHostQueryResetFeatures,
+ transform_tohost_VkPhysicalDeviceHostQueryResetFeaturesEXT)
-DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceHostQueryResetFeatures, transform_fromhost_VkPhysicalDeviceHostQueryResetFeaturesEXT)
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceHostQueryResetFeatures,
+ transform_fromhost_VkPhysicalDeviceHostQueryResetFeaturesEXT)
#endif
#ifdef VK_EXT_index_type_uint8
void transform_tohost_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceIndexTypeUint8FeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceIndexTypeUint8FeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceIndexTypeUint8FeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceIndexTypeUint8FeaturesEXT* toTransform);
#endif
#ifdef VK_EXT_extended_dynamic_state
void transform_tohost_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toTransform);
#endif
#ifdef VK_EXT_shader_atomic_float2
void transform_tohost_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* toTransform);
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
@@ -5898,92 +4953,70 @@
VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* toTransform);
void transform_tohost_VkGraphicsShaderGroupCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkGraphicsShaderGroupCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkGraphicsShaderGroupCreateInfoNV* toTransform);
void transform_fromhost_VkGraphicsShaderGroupCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkGraphicsShaderGroupCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkGraphicsShaderGroupCreateInfoNV* toTransform);
void transform_tohost_VkGraphicsPipelineShaderGroupsCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkGraphicsPipelineShaderGroupsCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkGraphicsPipelineShaderGroupsCreateInfoNV* toTransform);
void transform_fromhost_VkGraphicsPipelineShaderGroupsCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkGraphicsPipelineShaderGroupsCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkGraphicsPipelineShaderGroupsCreateInfoNV* toTransform);
void transform_tohost_VkBindShaderGroupIndirectCommandNV(
- ResourceTracker* resourceTracker,
- VkBindShaderGroupIndirectCommandNV* toTransform);
+ ResourceTracker* resourceTracker, VkBindShaderGroupIndirectCommandNV* toTransform);
void transform_fromhost_VkBindShaderGroupIndirectCommandNV(
- ResourceTracker* resourceTracker,
- VkBindShaderGroupIndirectCommandNV* toTransform);
+ ResourceTracker* resourceTracker, VkBindShaderGroupIndirectCommandNV* toTransform);
void transform_tohost_VkBindIndexBufferIndirectCommandNV(
- ResourceTracker* resourceTracker,
- VkBindIndexBufferIndirectCommandNV* toTransform);
+ ResourceTracker* resourceTracker, VkBindIndexBufferIndirectCommandNV* toTransform);
void transform_fromhost_VkBindIndexBufferIndirectCommandNV(
- ResourceTracker* resourceTracker,
- VkBindIndexBufferIndirectCommandNV* toTransform);
+ ResourceTracker* resourceTracker, VkBindIndexBufferIndirectCommandNV* toTransform);
void transform_tohost_VkBindVertexBufferIndirectCommandNV(
- ResourceTracker* resourceTracker,
- VkBindVertexBufferIndirectCommandNV* toTransform);
+ ResourceTracker* resourceTracker, VkBindVertexBufferIndirectCommandNV* toTransform);
void transform_fromhost_VkBindVertexBufferIndirectCommandNV(
- ResourceTracker* resourceTracker,
- VkBindVertexBufferIndirectCommandNV* toTransform);
+ ResourceTracker* resourceTracker, VkBindVertexBufferIndirectCommandNV* toTransform);
void transform_tohost_VkSetStateFlagsIndirectCommandNV(
- ResourceTracker* resourceTracker,
- VkSetStateFlagsIndirectCommandNV* toTransform);
+ ResourceTracker* resourceTracker, VkSetStateFlagsIndirectCommandNV* toTransform);
void transform_fromhost_VkSetStateFlagsIndirectCommandNV(
- ResourceTracker* resourceTracker,
- VkSetStateFlagsIndirectCommandNV* toTransform);
+ ResourceTracker* resourceTracker, VkSetStateFlagsIndirectCommandNV* toTransform);
-void transform_tohost_VkIndirectCommandsStreamNV(
- ResourceTracker* resourceTracker,
- VkIndirectCommandsStreamNV* toTransform);
+void transform_tohost_VkIndirectCommandsStreamNV(ResourceTracker* resourceTracker,
+ VkIndirectCommandsStreamNV* toTransform);
-void transform_fromhost_VkIndirectCommandsStreamNV(
- ResourceTracker* resourceTracker,
- VkIndirectCommandsStreamNV* toTransform);
+void transform_fromhost_VkIndirectCommandsStreamNV(ResourceTracker* resourceTracker,
+ VkIndirectCommandsStreamNV* toTransform);
-void transform_tohost_VkIndirectCommandsLayoutTokenNV(
- ResourceTracker* resourceTracker,
- VkIndirectCommandsLayoutTokenNV* toTransform);
+void transform_tohost_VkIndirectCommandsLayoutTokenNV(ResourceTracker* resourceTracker,
+ VkIndirectCommandsLayoutTokenNV* toTransform);
void transform_fromhost_VkIndirectCommandsLayoutTokenNV(
- ResourceTracker* resourceTracker,
- VkIndirectCommandsLayoutTokenNV* toTransform);
+ ResourceTracker* resourceTracker, VkIndirectCommandsLayoutTokenNV* toTransform);
void transform_tohost_VkIndirectCommandsLayoutCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkIndirectCommandsLayoutCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkIndirectCommandsLayoutCreateInfoNV* toTransform);
void transform_fromhost_VkIndirectCommandsLayoutCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkIndirectCommandsLayoutCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkIndirectCommandsLayoutCreateInfoNV* toTransform);
-void transform_tohost_VkGeneratedCommandsInfoNV(
- ResourceTracker* resourceTracker,
- VkGeneratedCommandsInfoNV* toTransform);
+void transform_tohost_VkGeneratedCommandsInfoNV(ResourceTracker* resourceTracker,
+ VkGeneratedCommandsInfoNV* toTransform);
-void transform_fromhost_VkGeneratedCommandsInfoNV(
- ResourceTracker* resourceTracker,
- VkGeneratedCommandsInfoNV* toTransform);
+void transform_fromhost_VkGeneratedCommandsInfoNV(ResourceTracker* resourceTracker,
+ VkGeneratedCommandsInfoNV* toTransform);
void transform_tohost_VkGeneratedCommandsMemoryRequirementsInfoNV(
- ResourceTracker* resourceTracker,
- VkGeneratedCommandsMemoryRequirementsInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkGeneratedCommandsMemoryRequirementsInfoNV* toTransform);
void transform_fromhost_VkGeneratedCommandsMemoryRequirementsInfoNV(
- ResourceTracker* resourceTracker,
- VkGeneratedCommandsMemoryRequirementsInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkGeneratedCommandsMemoryRequirementsInfoNV* toTransform);
#endif
#ifdef VK_NV_inherited_viewport_scissor
@@ -5996,22 +5029,18 @@
VkPhysicalDeviceInheritedViewportScissorFeaturesNV* toTransform);
void transform_tohost_VkCommandBufferInheritanceViewportScissorInfoNV(
- ResourceTracker* resourceTracker,
- VkCommandBufferInheritanceViewportScissorInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkCommandBufferInheritanceViewportScissorInfoNV* toTransform);
void transform_fromhost_VkCommandBufferInheritanceViewportScissorInfoNV(
- ResourceTracker* resourceTracker,
- VkCommandBufferInheritanceViewportScissorInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkCommandBufferInheritanceViewportScissorInfoNV* toTransform);
#endif
#ifdef VK_EXT_texel_buffer_alignment
void transform_tohost_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toTransform);
void transform_tohost_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
ResourceTracker* resourceTracker,
@@ -6024,12 +5053,10 @@
#endif
#ifdef VK_QCOM_render_pass_transform
void transform_tohost_VkRenderPassTransformBeginInfoQCOM(
- ResourceTracker* resourceTracker,
- VkRenderPassTransformBeginInfoQCOM* toTransform);
+ ResourceTracker* resourceTracker, VkRenderPassTransformBeginInfoQCOM* toTransform);
void transform_fromhost_VkRenderPassTransformBeginInfoQCOM(
- ResourceTracker* resourceTracker,
- VkRenderPassTransformBeginInfoQCOM* toTransform);
+ ResourceTracker* resourceTracker, VkRenderPassTransformBeginInfoQCOM* toTransform);
void transform_tohost_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
ResourceTracker* resourceTracker,
@@ -6042,102 +5069,80 @@
#endif
#ifdef VK_EXT_device_memory_report
void transform_tohost_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* toTransform);
void transform_tohost_VkDeviceMemoryReportCallbackDataEXT(
- ResourceTracker* resourceTracker,
- VkDeviceMemoryReportCallbackDataEXT* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceMemoryReportCallbackDataEXT* toTransform);
void transform_fromhost_VkDeviceMemoryReportCallbackDataEXT(
- ResourceTracker* resourceTracker,
- VkDeviceMemoryReportCallbackDataEXT* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceMemoryReportCallbackDataEXT* toTransform);
void transform_tohost_VkDeviceDeviceMemoryReportCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDeviceDeviceMemoryReportCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceDeviceMemoryReportCreateInfoEXT* toTransform);
void transform_fromhost_VkDeviceDeviceMemoryReportCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDeviceDeviceMemoryReportCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceDeviceMemoryReportCreateInfoEXT* toTransform);
#endif
#ifdef VK_EXT_acquire_drm_display
#endif
#ifdef VK_EXT_robustness2
void transform_tohost_VkPhysicalDeviceRobustness2FeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRobustness2FeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRobustness2FeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceRobustness2FeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRobustness2FeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRobustness2FeaturesEXT* toTransform);
void transform_tohost_VkPhysicalDeviceRobustness2PropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRobustness2PropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRobustness2PropertiesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceRobustness2PropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRobustness2PropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRobustness2PropertiesEXT* toTransform);
#endif
#ifdef VK_EXT_custom_border_color
void transform_tohost_VkSamplerCustomBorderColorCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkSamplerCustomBorderColorCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkSamplerCustomBorderColorCreateInfoEXT* toTransform);
void transform_fromhost_VkSamplerCustomBorderColorCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkSamplerCustomBorderColorCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkSamplerCustomBorderColorCreateInfoEXT* toTransform);
void transform_tohost_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCustomBorderColorPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCustomBorderColorPropertiesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCustomBorderColorPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCustomBorderColorPropertiesEXT* toTransform);
void transform_tohost_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCustomBorderColorFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCustomBorderColorFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceCustomBorderColorFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceCustomBorderColorFeaturesEXT* toTransform);
#endif
#ifdef VK_GOOGLE_user_type
#endif
#ifdef VK_EXT_private_data
void transform_tohost_VkPhysicalDevicePrivateDataFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePrivateDataFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevicePrivateDataFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDevicePrivateDataFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDevicePrivateDataFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevicePrivateDataFeaturesEXT* toTransform);
void transform_tohost_VkDevicePrivateDataCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDevicePrivateDataCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkDevicePrivateDataCreateInfoEXT* toTransform);
void transform_fromhost_VkDevicePrivateDataCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDevicePrivateDataCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkDevicePrivateDataCreateInfoEXT* toTransform);
-void transform_tohost_VkPrivateDataSlotCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPrivateDataSlotCreateInfoEXT* toTransform);
+void transform_tohost_VkPrivateDataSlotCreateInfoEXT(ResourceTracker* resourceTracker,
+ VkPrivateDataSlotCreateInfoEXT* toTransform);
-void transform_fromhost_VkPrivateDataSlotCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPrivateDataSlotCreateInfoEXT* toTransform);
+void transform_fromhost_VkPrivateDataSlotCreateInfoEXT(ResourceTracker* resourceTracker,
+ VkPrivateDataSlotCreateInfoEXT* toTransform);
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
@@ -6152,20 +5157,16 @@
#endif
#ifdef VK_NV_device_diagnostics_config
void transform_tohost_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toTransform);
void transform_fromhost_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toTransform);
void transform_tohost_VkDeviceDiagnosticsConfigCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkDeviceDiagnosticsConfigCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceDiagnosticsConfigCreateInfoNV* toTransform);
void transform_fromhost_VkDeviceDiagnosticsConfigCreateInfoNV(
- ResourceTracker* resourceTracker,
- VkDeviceDiagnosticsConfigCreateInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkDeviceDiagnosticsConfigCreateInfoNV* toTransform);
#endif
#ifdef VK_QCOM_render_pass_store_ops
@@ -6197,13 +5198,11 @@
#endif
#ifdef VK_NV_ray_tracing_motion_blur
-void transform_tohost_VkDeviceOrHostAddressConstKHR(
- ResourceTracker* resourceTracker,
- VkDeviceOrHostAddressConstKHR* toTransform);
+void transform_tohost_VkDeviceOrHostAddressConstKHR(ResourceTracker* resourceTracker,
+ VkDeviceOrHostAddressConstKHR* toTransform);
-void transform_fromhost_VkDeviceOrHostAddressConstKHR(
- ResourceTracker* resourceTracker,
- VkDeviceOrHostAddressConstKHR* toTransform);
+void transform_fromhost_VkDeviceOrHostAddressConstKHR(ResourceTracker* resourceTracker,
+ VkDeviceOrHostAddressConstKHR* toTransform);
void transform_tohost_VkAccelerationStructureGeometryMotionTrianglesDataNV(
ResourceTracker* resourceTracker,
@@ -6214,60 +5213,44 @@
VkAccelerationStructureGeometryMotionTrianglesDataNV* toTransform);
void transform_tohost_VkAccelerationStructureMotionInfoNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureMotionInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureMotionInfoNV* toTransform);
void transform_fromhost_VkAccelerationStructureMotionInfoNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureMotionInfoNV* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureMotionInfoNV* toTransform);
void transform_tohost_VkAccelerationStructureMatrixMotionInstanceNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureMatrixMotionInstanceNV* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureMatrixMotionInstanceNV* toTransform);
void transform_fromhost_VkAccelerationStructureMatrixMotionInstanceNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureMatrixMotionInstanceNV* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureMatrixMotionInstanceNV* toTransform);
-void transform_tohost_VkSRTDataNV(
- ResourceTracker* resourceTracker,
- VkSRTDataNV* toTransform);
+void transform_tohost_VkSRTDataNV(ResourceTracker* resourceTracker, VkSRTDataNV* toTransform);
-void transform_fromhost_VkSRTDataNV(
- ResourceTracker* resourceTracker,
- VkSRTDataNV* toTransform);
+void transform_fromhost_VkSRTDataNV(ResourceTracker* resourceTracker, VkSRTDataNV* toTransform);
void transform_tohost_VkAccelerationStructureSRTMotionInstanceNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureSRTMotionInstanceNV* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureSRTMotionInstanceNV* toTransform);
void transform_fromhost_VkAccelerationStructureSRTMotionInstanceNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureSRTMotionInstanceNV* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureSRTMotionInstanceNV* toTransform);
void transform_tohost_VkAccelerationStructureMotionInstanceDataNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureMotionInstanceDataNV* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureMotionInstanceDataNV* toTransform);
void transform_fromhost_VkAccelerationStructureMotionInstanceDataNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureMotionInstanceDataNV* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureMotionInstanceDataNV* toTransform);
void transform_tohost_VkAccelerationStructureMotionInstanceNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureMotionInstanceNV* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureMotionInstanceNV* toTransform);
void transform_fromhost_VkAccelerationStructureMotionInstanceNV(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureMotionInstanceNV* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureMotionInstanceNV* toTransform);
void transform_tohost_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* toTransform);
void transform_fromhost_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* toTransform);
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
@@ -6282,12 +5265,10 @@
#endif
#ifdef VK_EXT_fragment_density_map2
void transform_tohost_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* toTransform);
void transform_tohost_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
ResourceTracker* resourceTracker,
@@ -6299,55 +5280,45 @@
#endif
#ifdef VK_QCOM_rotated_copy_commands
-void transform_tohost_VkCopyCommandTransformInfoQCOM(
- ResourceTracker* resourceTracker,
- VkCopyCommandTransformInfoQCOM* toTransform);
+void transform_tohost_VkCopyCommandTransformInfoQCOM(ResourceTracker* resourceTracker,
+ VkCopyCommandTransformInfoQCOM* toTransform);
-void transform_fromhost_VkCopyCommandTransformInfoQCOM(
- ResourceTracker* resourceTracker,
- VkCopyCommandTransformInfoQCOM* toTransform);
+void transform_fromhost_VkCopyCommandTransformInfoQCOM(ResourceTracker* resourceTracker,
+ VkCopyCommandTransformInfoQCOM* toTransform);
#endif
#ifdef VK_EXT_image_robustness
void transform_tohost_VkPhysicalDeviceImageRobustnessFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceImageRobustnessFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceImageRobustnessFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceImageRobustnessFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceImageRobustnessFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceImageRobustnessFeaturesEXT* toTransform);
#endif
#ifdef VK_EXT_4444_formats
void transform_tohost_VkPhysicalDevice4444FormatsFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDevice4444FormatsFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevice4444FormatsFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDevice4444FormatsFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDevice4444FormatsFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDevice4444FormatsFeaturesEXT* toTransform);
#endif
#ifdef VK_EXT_rgba10x6_formats
void transform_tohost_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* toTransform);
#endif
#ifdef VK_NV_acquire_winrt_display
#endif
#ifdef VK_EXT_directfb_surface
-void transform_tohost_VkDirectFBSurfaceCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDirectFBSurfaceCreateInfoEXT* toTransform);
+void transform_tohost_VkDirectFBSurfaceCreateInfoEXT(ResourceTracker* resourceTracker,
+ VkDirectFBSurfaceCreateInfoEXT* toTransform);
-void transform_fromhost_VkDirectFBSurfaceCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkDirectFBSurfaceCreateInfoEXT* toTransform);
+void transform_fromhost_VkDirectFBSurfaceCreateInfoEXT(ResourceTracker* resourceTracker,
+ VkDirectFBSurfaceCreateInfoEXT* toTransform);
#endif
#ifdef VK_VALVE_mutable_descriptor_type
@@ -6360,20 +5331,16 @@
VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* toTransform);
void transform_tohost_VkMutableDescriptorTypeListVALVE(
- ResourceTracker* resourceTracker,
- VkMutableDescriptorTypeListVALVE* toTransform);
+ ResourceTracker* resourceTracker, VkMutableDescriptorTypeListVALVE* toTransform);
void transform_fromhost_VkMutableDescriptorTypeListVALVE(
- ResourceTracker* resourceTracker,
- VkMutableDescriptorTypeListVALVE* toTransform);
+ ResourceTracker* resourceTracker, VkMutableDescriptorTypeListVALVE* toTransform);
void transform_tohost_VkMutableDescriptorTypeCreateInfoVALVE(
- ResourceTracker* resourceTracker,
- VkMutableDescriptorTypeCreateInfoVALVE* toTransform);
+ ResourceTracker* resourceTracker, VkMutableDescriptorTypeCreateInfoVALVE* toTransform);
void transform_fromhost_VkMutableDescriptorTypeCreateInfoVALVE(
- ResourceTracker* resourceTracker,
- VkMutableDescriptorTypeCreateInfoVALVE* toTransform);
+ ResourceTracker* resourceTracker, VkMutableDescriptorTypeCreateInfoVALVE* toTransform);
#endif
#ifdef VK_EXT_vertex_input_dynamic_state
@@ -6386,30 +5353,24 @@
VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* toTransform);
void transform_tohost_VkVertexInputBindingDescription2EXT(
- ResourceTracker* resourceTracker,
- VkVertexInputBindingDescription2EXT* toTransform);
+ ResourceTracker* resourceTracker, VkVertexInputBindingDescription2EXT* toTransform);
void transform_fromhost_VkVertexInputBindingDescription2EXT(
- ResourceTracker* resourceTracker,
- VkVertexInputBindingDescription2EXT* toTransform);
+ ResourceTracker* resourceTracker, VkVertexInputBindingDescription2EXT* toTransform);
void transform_tohost_VkVertexInputAttributeDescription2EXT(
- ResourceTracker* resourceTracker,
- VkVertexInputAttributeDescription2EXT* toTransform);
+ ResourceTracker* resourceTracker, VkVertexInputAttributeDescription2EXT* toTransform);
void transform_fromhost_VkVertexInputAttributeDescription2EXT(
- ResourceTracker* resourceTracker,
- VkVertexInputAttributeDescription2EXT* toTransform);
+ ResourceTracker* resourceTracker, VkVertexInputAttributeDescription2EXT* toTransform);
#endif
#ifdef VK_EXT_physical_device_drm
void transform_tohost_VkPhysicalDeviceDrmPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDrmPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDrmPropertiesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceDrmPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceDrmPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceDrmPropertiesEXT* toTransform);
#endif
#ifdef VK_EXT_primitive_topology_list_restart
@@ -6424,182 +5385,140 @@
#endif
#ifdef VK_FUCHSIA_external_memory
void transform_tohost_VkImportMemoryZirconHandleInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImportMemoryZirconHandleInfoFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkImportMemoryZirconHandleInfoFUCHSIA* toTransform);
void transform_fromhost_VkImportMemoryZirconHandleInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImportMemoryZirconHandleInfoFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkImportMemoryZirconHandleInfoFUCHSIA* toTransform);
void transform_tohost_VkMemoryZirconHandlePropertiesFUCHSIA(
- ResourceTracker* resourceTracker,
- VkMemoryZirconHandlePropertiesFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkMemoryZirconHandlePropertiesFUCHSIA* toTransform);
void transform_fromhost_VkMemoryZirconHandlePropertiesFUCHSIA(
- ResourceTracker* resourceTracker,
- VkMemoryZirconHandlePropertiesFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkMemoryZirconHandlePropertiesFUCHSIA* toTransform);
void transform_tohost_VkMemoryGetZirconHandleInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkMemoryGetZirconHandleInfoFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkMemoryGetZirconHandleInfoFUCHSIA* toTransform);
void transform_fromhost_VkMemoryGetZirconHandleInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkMemoryGetZirconHandleInfoFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkMemoryGetZirconHandleInfoFUCHSIA* toTransform);
#endif
#ifdef VK_FUCHSIA_external_semaphore
void transform_tohost_VkImportSemaphoreZirconHandleInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImportSemaphoreZirconHandleInfoFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkImportSemaphoreZirconHandleInfoFUCHSIA* toTransform);
void transform_fromhost_VkImportSemaphoreZirconHandleInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImportSemaphoreZirconHandleInfoFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkImportSemaphoreZirconHandleInfoFUCHSIA* toTransform);
void transform_tohost_VkSemaphoreGetZirconHandleInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkSemaphoreGetZirconHandleInfoFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkSemaphoreGetZirconHandleInfoFUCHSIA* toTransform);
void transform_fromhost_VkSemaphoreGetZirconHandleInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkSemaphoreGetZirconHandleInfoFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkSemaphoreGetZirconHandleInfoFUCHSIA* toTransform);
#endif
#ifdef VK_FUCHSIA_buffer_collection
void transform_tohost_VkBufferCollectionCreateInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferCollectionCreateInfoFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkBufferCollectionCreateInfoFUCHSIA* toTransform);
void transform_fromhost_VkBufferCollectionCreateInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferCollectionCreateInfoFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkBufferCollectionCreateInfoFUCHSIA* toTransform);
void transform_tohost_VkImportMemoryBufferCollectionFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImportMemoryBufferCollectionFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkImportMemoryBufferCollectionFUCHSIA* toTransform);
void transform_fromhost_VkImportMemoryBufferCollectionFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImportMemoryBufferCollectionFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkImportMemoryBufferCollectionFUCHSIA* toTransform);
void transform_tohost_VkBufferCollectionImageCreateInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferCollectionImageCreateInfoFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkBufferCollectionImageCreateInfoFUCHSIA* toTransform);
void transform_fromhost_VkBufferCollectionImageCreateInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferCollectionImageCreateInfoFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkBufferCollectionImageCreateInfoFUCHSIA* toTransform);
void transform_tohost_VkBufferCollectionConstraintsInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferCollectionConstraintsInfoFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkBufferCollectionConstraintsInfoFUCHSIA* toTransform);
void transform_fromhost_VkBufferCollectionConstraintsInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferCollectionConstraintsInfoFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkBufferCollectionConstraintsInfoFUCHSIA* toTransform);
-void transform_tohost_VkBufferConstraintsInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferConstraintsInfoFUCHSIA* toTransform);
+void transform_tohost_VkBufferConstraintsInfoFUCHSIA(ResourceTracker* resourceTracker,
+ VkBufferConstraintsInfoFUCHSIA* toTransform);
-void transform_fromhost_VkBufferConstraintsInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferConstraintsInfoFUCHSIA* toTransform);
+void transform_fromhost_VkBufferConstraintsInfoFUCHSIA(ResourceTracker* resourceTracker,
+ VkBufferConstraintsInfoFUCHSIA* toTransform);
void transform_tohost_VkBufferCollectionBufferCreateInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferCollectionBufferCreateInfoFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkBufferCollectionBufferCreateInfoFUCHSIA* toTransform);
void transform_fromhost_VkBufferCollectionBufferCreateInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferCollectionBufferCreateInfoFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkBufferCollectionBufferCreateInfoFUCHSIA* toTransform);
-void transform_tohost_VkSysmemColorSpaceFUCHSIA(
- ResourceTracker* resourceTracker,
- VkSysmemColorSpaceFUCHSIA* toTransform);
+void transform_tohost_VkSysmemColorSpaceFUCHSIA(ResourceTracker* resourceTracker,
+ VkSysmemColorSpaceFUCHSIA* toTransform);
-void transform_fromhost_VkSysmemColorSpaceFUCHSIA(
- ResourceTracker* resourceTracker,
- VkSysmemColorSpaceFUCHSIA* toTransform);
+void transform_fromhost_VkSysmemColorSpaceFUCHSIA(ResourceTracker* resourceTracker,
+ VkSysmemColorSpaceFUCHSIA* toTransform);
void transform_tohost_VkBufferCollectionPropertiesFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferCollectionPropertiesFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkBufferCollectionPropertiesFUCHSIA* toTransform);
void transform_fromhost_VkBufferCollectionPropertiesFUCHSIA(
- ResourceTracker* resourceTracker,
- VkBufferCollectionPropertiesFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkBufferCollectionPropertiesFUCHSIA* toTransform);
void transform_tohost_VkImageFormatConstraintsInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImageFormatConstraintsInfoFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkImageFormatConstraintsInfoFUCHSIA* toTransform);
void transform_fromhost_VkImageFormatConstraintsInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImageFormatConstraintsInfoFUCHSIA* toTransform);
+ ResourceTracker* resourceTracker, VkImageFormatConstraintsInfoFUCHSIA* toTransform);
-void transform_tohost_VkImageConstraintsInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImageConstraintsInfoFUCHSIA* toTransform);
+void transform_tohost_VkImageConstraintsInfoFUCHSIA(ResourceTracker* resourceTracker,
+ VkImageConstraintsInfoFUCHSIA* toTransform);
-void transform_fromhost_VkImageConstraintsInfoFUCHSIA(
- ResourceTracker* resourceTracker,
- VkImageConstraintsInfoFUCHSIA* toTransform);
+void transform_fromhost_VkImageConstraintsInfoFUCHSIA(ResourceTracker* resourceTracker,
+ VkImageConstraintsInfoFUCHSIA* toTransform);
#endif
#ifdef VK_HUAWEI_subpass_shading
void transform_tohost_VkSubpassShadingPipelineCreateInfoHUAWEI(
- ResourceTracker* resourceTracker,
- VkSubpassShadingPipelineCreateInfoHUAWEI* toTransform);
+ ResourceTracker* resourceTracker, VkSubpassShadingPipelineCreateInfoHUAWEI* toTransform);
void transform_fromhost_VkSubpassShadingPipelineCreateInfoHUAWEI(
- ResourceTracker* resourceTracker,
- VkSubpassShadingPipelineCreateInfoHUAWEI* toTransform);
+ ResourceTracker* resourceTracker, VkSubpassShadingPipelineCreateInfoHUAWEI* toTransform);
void transform_tohost_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* toTransform);
void transform_fromhost_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* toTransform);
void transform_tohost_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* toTransform);
void transform_fromhost_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* toTransform);
#endif
#ifdef VK_HUAWEI_invocation_mask
void transform_tohost_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* toTransform);
void transform_fromhost_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* toTransform);
#endif
#ifdef VK_NV_external_memory_rdma
-void transform_tohost_VkMemoryGetRemoteAddressInfoNV(
- ResourceTracker* resourceTracker,
- VkMemoryGetRemoteAddressInfoNV* toTransform);
+void transform_tohost_VkMemoryGetRemoteAddressInfoNV(ResourceTracker* resourceTracker,
+ VkMemoryGetRemoteAddressInfoNV* toTransform);
-void transform_fromhost_VkMemoryGetRemoteAddressInfoNV(
- ResourceTracker* resourceTracker,
- VkMemoryGetRemoteAddressInfoNV* toTransform);
+void transform_fromhost_VkMemoryGetRemoteAddressInfoNV(ResourceTracker* resourceTracker,
+ VkMemoryGetRemoteAddressInfoNV* toTransform);
void transform_tohost_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* toTransform);
void transform_fromhost_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* toTransform);
#endif
#ifdef VK_EXT_extended_dynamic_state2
@@ -6613,121 +5532,95 @@
#endif
#ifdef VK_QNX_screen_surface
-void transform_tohost_VkScreenSurfaceCreateInfoQNX(
- ResourceTracker* resourceTracker,
- VkScreenSurfaceCreateInfoQNX* toTransform);
+void transform_tohost_VkScreenSurfaceCreateInfoQNX(ResourceTracker* resourceTracker,
+ VkScreenSurfaceCreateInfoQNX* toTransform);
-void transform_fromhost_VkScreenSurfaceCreateInfoQNX(
- ResourceTracker* resourceTracker,
- VkScreenSurfaceCreateInfoQNX* toTransform);
+void transform_fromhost_VkScreenSurfaceCreateInfoQNX(ResourceTracker* resourceTracker,
+ VkScreenSurfaceCreateInfoQNX* toTransform);
#endif
#ifdef VK_EXT_color_write_enable
void transform_tohost_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceColorWriteEnableFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceColorWriteEnableFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceColorWriteEnableFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceColorWriteEnableFeaturesEXT* toTransform);
void transform_tohost_VkPipelineColorWriteCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineColorWriteCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineColorWriteCreateInfoEXT* toTransform);
void transform_fromhost_VkPipelineColorWriteCreateInfoEXT(
- ResourceTracker* resourceTracker,
- VkPipelineColorWriteCreateInfoEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPipelineColorWriteCreateInfoEXT* toTransform);
#endif
#ifdef VK_GOOGLE_gfxstream
-void transform_tohost_VkImportColorBufferGOOGLE(
- ResourceTracker* resourceTracker,
- VkImportColorBufferGOOGLE* toTransform);
+void transform_tohost_VkImportColorBufferGOOGLE(ResourceTracker* resourceTracker,
+ VkImportColorBufferGOOGLE* toTransform);
-void transform_fromhost_VkImportColorBufferGOOGLE(
- ResourceTracker* resourceTracker,
- VkImportColorBufferGOOGLE* toTransform);
+void transform_fromhost_VkImportColorBufferGOOGLE(ResourceTracker* resourceTracker,
+ VkImportColorBufferGOOGLE* toTransform);
-void transform_tohost_VkImportBufferGOOGLE(
- ResourceTracker* resourceTracker,
- VkImportBufferGOOGLE* toTransform);
+void transform_tohost_VkImportBufferGOOGLE(ResourceTracker* resourceTracker,
+ VkImportBufferGOOGLE* toTransform);
-void transform_fromhost_VkImportBufferGOOGLE(
- ResourceTracker* resourceTracker,
- VkImportBufferGOOGLE* toTransform);
+void transform_fromhost_VkImportBufferGOOGLE(ResourceTracker* resourceTracker,
+ VkImportBufferGOOGLE* toTransform);
-void transform_tohost_VkImportPhysicalAddressGOOGLE(
- ResourceTracker* resourceTracker,
- VkImportPhysicalAddressGOOGLE* toTransform);
+void transform_tohost_VkImportPhysicalAddressGOOGLE(ResourceTracker* resourceTracker,
+ VkImportPhysicalAddressGOOGLE* toTransform);
-void transform_fromhost_VkImportPhysicalAddressGOOGLE(
- ResourceTracker* resourceTracker,
- VkImportPhysicalAddressGOOGLE* toTransform);
+void transform_fromhost_VkImportPhysicalAddressGOOGLE(ResourceTracker* resourceTracker,
+ VkImportPhysicalAddressGOOGLE* toTransform);
#endif
#ifdef VK_EXT_global_priority_query
void transform_tohost_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toTransform);
void transform_tohost_VkQueueFamilyGlobalPriorityPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkQueueFamilyGlobalPriorityPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkQueueFamilyGlobalPriorityPropertiesEXT* toTransform);
void transform_fromhost_VkQueueFamilyGlobalPriorityPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkQueueFamilyGlobalPriorityPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkQueueFamilyGlobalPriorityPropertiesEXT* toTransform);
#endif
#ifdef VK_EXT_multi_draw
void transform_tohost_VkPhysicalDeviceMultiDrawFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMultiDrawFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMultiDrawFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceMultiDrawFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMultiDrawFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMultiDrawFeaturesEXT* toTransform);
void transform_tohost_VkPhysicalDeviceMultiDrawPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMultiDrawPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMultiDrawPropertiesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceMultiDrawPropertiesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceMultiDrawPropertiesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceMultiDrawPropertiesEXT* toTransform);
-void transform_tohost_VkMultiDrawInfoEXT(
- ResourceTracker* resourceTracker,
- VkMultiDrawInfoEXT* toTransform);
+void transform_tohost_VkMultiDrawInfoEXT(ResourceTracker* resourceTracker,
+ VkMultiDrawInfoEXT* toTransform);
-void transform_fromhost_VkMultiDrawInfoEXT(
- ResourceTracker* resourceTracker,
- VkMultiDrawInfoEXT* toTransform);
+void transform_fromhost_VkMultiDrawInfoEXT(ResourceTracker* resourceTracker,
+ VkMultiDrawInfoEXT* toTransform);
-void transform_tohost_VkMultiDrawIndexedInfoEXT(
- ResourceTracker* resourceTracker,
- VkMultiDrawIndexedInfoEXT* toTransform);
+void transform_tohost_VkMultiDrawIndexedInfoEXT(ResourceTracker* resourceTracker,
+ VkMultiDrawIndexedInfoEXT* toTransform);
-void transform_fromhost_VkMultiDrawIndexedInfoEXT(
- ResourceTracker* resourceTracker,
- VkMultiDrawIndexedInfoEXT* toTransform);
+void transform_fromhost_VkMultiDrawIndexedInfoEXT(ResourceTracker* resourceTracker,
+ VkMultiDrawIndexedInfoEXT* toTransform);
#endif
#ifdef VK_EXT_load_store_op_none
#endif
#ifdef VK_EXT_border_color_swizzle
void transform_tohost_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* toTransform);
void transform_fromhost_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* toTransform);
void transform_tohost_VkSamplerBorderColorComponentMappingCreateInfoEXT(
ResourceTracker* resourceTracker,
@@ -6749,85 +5642,65 @@
#endif
#ifdef VK_KHR_acceleration_structure
-void transform_tohost_VkDeviceOrHostAddressKHR(
- ResourceTracker* resourceTracker,
- VkDeviceOrHostAddressKHR* toTransform);
+void transform_tohost_VkDeviceOrHostAddressKHR(ResourceTracker* resourceTracker,
+ VkDeviceOrHostAddressKHR* toTransform);
-void transform_fromhost_VkDeviceOrHostAddressKHR(
- ResourceTracker* resourceTracker,
- VkDeviceOrHostAddressKHR* toTransform);
+void transform_fromhost_VkDeviceOrHostAddressKHR(ResourceTracker* resourceTracker,
+ VkDeviceOrHostAddressKHR* toTransform);
void transform_tohost_VkAccelerationStructureBuildRangeInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureBuildRangeInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureBuildRangeInfoKHR* toTransform);
void transform_fromhost_VkAccelerationStructureBuildRangeInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureBuildRangeInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureBuildRangeInfoKHR* toTransform);
void transform_tohost_VkAccelerationStructureGeometryTrianglesDataKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryTrianglesDataKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureGeometryTrianglesDataKHR* toTransform);
void transform_fromhost_VkAccelerationStructureGeometryTrianglesDataKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryTrianglesDataKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureGeometryTrianglesDataKHR* toTransform);
void transform_tohost_VkAccelerationStructureGeometryAabbsDataKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryAabbsDataKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureGeometryAabbsDataKHR* toTransform);
void transform_fromhost_VkAccelerationStructureGeometryAabbsDataKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryAabbsDataKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureGeometryAabbsDataKHR* toTransform);
void transform_tohost_VkAccelerationStructureGeometryInstancesDataKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryInstancesDataKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureGeometryInstancesDataKHR* toTransform);
void transform_fromhost_VkAccelerationStructureGeometryInstancesDataKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryInstancesDataKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureGeometryInstancesDataKHR* toTransform);
void transform_tohost_VkAccelerationStructureGeometryDataKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryDataKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureGeometryDataKHR* toTransform);
void transform_fromhost_VkAccelerationStructureGeometryDataKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryDataKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureGeometryDataKHR* toTransform);
void transform_tohost_VkAccelerationStructureGeometryKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureGeometryKHR* toTransform);
void transform_fromhost_VkAccelerationStructureGeometryKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureGeometryKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureGeometryKHR* toTransform);
void transform_tohost_VkAccelerationStructureBuildGeometryInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureBuildGeometryInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureBuildGeometryInfoKHR* toTransform);
void transform_fromhost_VkAccelerationStructureBuildGeometryInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureBuildGeometryInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureBuildGeometryInfoKHR* toTransform);
void transform_tohost_VkAccelerationStructureCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureCreateInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureCreateInfoKHR* toTransform);
void transform_fromhost_VkAccelerationStructureCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureCreateInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureCreateInfoKHR* toTransform);
void transform_tohost_VkWriteDescriptorSetAccelerationStructureKHR(
- ResourceTracker* resourceTracker,
- VkWriteDescriptorSetAccelerationStructureKHR* toTransform);
+ ResourceTracker* resourceTracker, VkWriteDescriptorSetAccelerationStructureKHR* toTransform);
void transform_fromhost_VkWriteDescriptorSetAccelerationStructureKHR(
- ResourceTracker* resourceTracker,
- VkWriteDescriptorSetAccelerationStructureKHR* toTransform);
+ ResourceTracker* resourceTracker, VkWriteDescriptorSetAccelerationStructureKHR* toTransform);
void transform_tohost_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
ResourceTracker* resourceTracker,
@@ -6846,121 +5719,93 @@
VkPhysicalDeviceAccelerationStructurePropertiesKHR* toTransform);
void transform_tohost_VkAccelerationStructureDeviceAddressInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureDeviceAddressInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureDeviceAddressInfoKHR* toTransform);
void transform_fromhost_VkAccelerationStructureDeviceAddressInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureDeviceAddressInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureDeviceAddressInfoKHR* toTransform);
void transform_tohost_VkAccelerationStructureVersionInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureVersionInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureVersionInfoKHR* toTransform);
void transform_fromhost_VkAccelerationStructureVersionInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureVersionInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureVersionInfoKHR* toTransform);
void transform_tohost_VkCopyAccelerationStructureToMemoryInfoKHR(
- ResourceTracker* resourceTracker,
- VkCopyAccelerationStructureToMemoryInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkCopyAccelerationStructureToMemoryInfoKHR* toTransform);
void transform_fromhost_VkCopyAccelerationStructureToMemoryInfoKHR(
- ResourceTracker* resourceTracker,
- VkCopyAccelerationStructureToMemoryInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkCopyAccelerationStructureToMemoryInfoKHR* toTransform);
void transform_tohost_VkCopyMemoryToAccelerationStructureInfoKHR(
- ResourceTracker* resourceTracker,
- VkCopyMemoryToAccelerationStructureInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkCopyMemoryToAccelerationStructureInfoKHR* toTransform);
void transform_fromhost_VkCopyMemoryToAccelerationStructureInfoKHR(
- ResourceTracker* resourceTracker,
- VkCopyMemoryToAccelerationStructureInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkCopyMemoryToAccelerationStructureInfoKHR* toTransform);
void transform_tohost_VkCopyAccelerationStructureInfoKHR(
- ResourceTracker* resourceTracker,
- VkCopyAccelerationStructureInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkCopyAccelerationStructureInfoKHR* toTransform);
void transform_fromhost_VkCopyAccelerationStructureInfoKHR(
- ResourceTracker* resourceTracker,
- VkCopyAccelerationStructureInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkCopyAccelerationStructureInfoKHR* toTransform);
void transform_tohost_VkAccelerationStructureBuildSizesInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureBuildSizesInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureBuildSizesInfoKHR* toTransform);
void transform_fromhost_VkAccelerationStructureBuildSizesInfoKHR(
- ResourceTracker* resourceTracker,
- VkAccelerationStructureBuildSizesInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkAccelerationStructureBuildSizesInfoKHR* toTransform);
#endif
#ifdef VK_KHR_ray_tracing_pipeline
void transform_tohost_VkRayTracingShaderGroupCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkRayTracingShaderGroupCreateInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkRayTracingShaderGroupCreateInfoKHR* toTransform);
void transform_fromhost_VkRayTracingShaderGroupCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkRayTracingShaderGroupCreateInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkRayTracingShaderGroupCreateInfoKHR* toTransform);
void transform_tohost_VkRayTracingPipelineInterfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkRayTracingPipelineInterfaceCreateInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkRayTracingPipelineInterfaceCreateInfoKHR* toTransform);
void transform_fromhost_VkRayTracingPipelineInterfaceCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkRayTracingPipelineInterfaceCreateInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkRayTracingPipelineInterfaceCreateInfoKHR* toTransform);
void transform_tohost_VkRayTracingPipelineCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkRayTracingPipelineCreateInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkRayTracingPipelineCreateInfoKHR* toTransform);
void transform_fromhost_VkRayTracingPipelineCreateInfoKHR(
- ResourceTracker* resourceTracker,
- VkRayTracingPipelineCreateInfoKHR* toTransform);
+ ResourceTracker* resourceTracker, VkRayTracingPipelineCreateInfoKHR* toTransform);
void transform_tohost_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toTransform);
void transform_fromhost_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRayTracingPipelineFeaturesKHR* toTransform);
void transform_tohost_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toTransform);
void transform_fromhost_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRayTracingPipelinePropertiesKHR* toTransform);
-void transform_tohost_VkStridedDeviceAddressRegionKHR(
- ResourceTracker* resourceTracker,
- VkStridedDeviceAddressRegionKHR* toTransform);
+void transform_tohost_VkStridedDeviceAddressRegionKHR(ResourceTracker* resourceTracker,
+ VkStridedDeviceAddressRegionKHR* toTransform);
void transform_fromhost_VkStridedDeviceAddressRegionKHR(
- ResourceTracker* resourceTracker,
- VkStridedDeviceAddressRegionKHR* toTransform);
+ ResourceTracker* resourceTracker, VkStridedDeviceAddressRegionKHR* toTransform);
-void transform_tohost_VkTraceRaysIndirectCommandKHR(
- ResourceTracker* resourceTracker,
- VkTraceRaysIndirectCommandKHR* toTransform);
+void transform_tohost_VkTraceRaysIndirectCommandKHR(ResourceTracker* resourceTracker,
+ VkTraceRaysIndirectCommandKHR* toTransform);
-void transform_fromhost_VkTraceRaysIndirectCommandKHR(
- ResourceTracker* resourceTracker,
- VkTraceRaysIndirectCommandKHR* toTransform);
+void transform_fromhost_VkTraceRaysIndirectCommandKHR(ResourceTracker* resourceTracker,
+ VkTraceRaysIndirectCommandKHR* toTransform);
#endif
#ifdef VK_KHR_ray_query
void transform_tohost_VkPhysicalDeviceRayQueryFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRayQueryFeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRayQueryFeaturesKHR* toTransform);
void transform_fromhost_VkPhysicalDeviceRayQueryFeaturesKHR(
- ResourceTracker* resourceTracker,
- VkPhysicalDeviceRayQueryFeaturesKHR* toTransform);
+ ResourceTracker* resourceTracker, VkPhysicalDeviceRayQueryFeaturesKHR* toTransform);
#endif
-} // namespace goldfish_vk
+} // namespace goldfish_vk
diff --git a/system/vulkan_enc/meson.build b/system/vulkan_enc/meson.build
index be3eba9..716bac3 100644
--- a/system/vulkan_enc/meson.build
+++ b/system/vulkan_enc/meson.build
@@ -27,6 +27,7 @@
cpp_args: cpp_args,
include_directories: [inc_android_emu, inc_host, inc_android_compat,
inc_opengl_codec, inc_render_enc, inc_system,
- inc_goldfish_address_space],
+ inc_goldfish_address_space, inc_platform],
+ link_with: [lib_platform],
dependencies: dependency('libdrm'),
)
diff --git a/system/vulkan_enc/vk_format_info.h b/system/vulkan_enc/vk_format_info.h
index f96d59e..af19ec5 100644
--- a/system/vulkan_enc/vk_format_info.h
+++ b/system/vulkan_enc/vk_format_info.h
@@ -46,6 +46,12 @@
#define OMX_COLOR_FormatYUV420Planar 0x13
+// TODO: update users of this function to query the DRM fourcc
+// code using the standard Gralloc4 metadata type and instead
+// translate the DRM fourcc code to a Vulkan format as Android
+// formats such as AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420 could be
+// either VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM or
+// VK_FORMAT_G8_B8R8_2PLANE_420_UNORM.
static inline VkFormat
vk_format_from_android(unsigned android_format)
{
@@ -63,9 +69,12 @@
case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
case HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL:
- return VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
- return VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM;
+ return VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
+#if __ANDROID_API__ >= 30
+ case AHARDWAREBUFFER_FORMAT_YCbCr_P010:
+ return VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16;
+#endif
#ifdef VK_USE_PLATFORM_ANDROID_KHR
case HAL_PIXEL_FORMAT_YV12:
case OMX_COLOR_FormatYUV420Planar:
@@ -104,13 +113,29 @@
android_format_is_yuv(unsigned android_format)
{
switch (android_format) {
+ case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
+ case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
+ case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
+ case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
+ case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
+ case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
+ case AHARDWAREBUFFER_FORMAT_D16_UNORM:
+ case AHARDWAREBUFFER_FORMAT_D24_UNORM:
+ case AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT:
+ case AHARDWAREBUFFER_FORMAT_D32_FLOAT:
+ case AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT:
+ case AHARDWAREBUFFER_FORMAT_S8_UINT:
+ return false;
case HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL:
case OMX_COLOR_FormatYUV420Planar:
case HAL_PIXEL_FORMAT_YV12:
+#if __ANDROID_API__ >= 30
+ case AHARDWAREBUFFER_FORMAT_YCbCr_P010:
+#endif
case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
return true;
-
default:
+ ALOGE("%s: unhandled format: %d", __FUNCTION__, android_format);
return false;
}
}
diff --git a/system/vulkan_enc/vk_struct_id.h b/system/vulkan_enc/vk_struct_id.h
index 833ad6d..32d6b86 100644
--- a/system/vulkan_enc/vk_struct_id.h
+++ b/system/vulkan_enc/vk_struct_id.h
@@ -16,26 +16,33 @@
#include <vulkan/vulkan.h>
#include "goldfish_vk_private_defs.h"
+#include "vulkan_gfxstream.h"
template <class T> struct vk_get_vk_struct_id;
#define REGISTER_VK_STRUCT_ID(T, ID) \
template <> struct vk_get_vk_struct_id<T> { static constexpr VkStructureType id = ID; }
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
REGISTER_VK_STRUCT_ID(VkAndroidHardwareBufferPropertiesANDROID, VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID);
REGISTER_VK_STRUCT_ID(VkAndroidHardwareBufferFormatPropertiesANDROID, VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID);
REGISTER_VK_STRUCT_ID(VkAndroidHardwareBufferUsageANDROID, VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID);
+#endif
REGISTER_VK_STRUCT_ID(VkBufferCreateInfo, VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO);
REGISTER_VK_STRUCT_ID(VkImageCreateInfo, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO);
REGISTER_VK_STRUCT_ID(VkImageFormatProperties2, VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2);
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
REGISTER_VK_STRUCT_ID(VkNativeBufferANDROID, VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID);
REGISTER_VK_STRUCT_ID(VkExternalFormatANDROID, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID);
+#endif
REGISTER_VK_STRUCT_ID(VkExternalMemoryBufferCreateInfo, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO);
REGISTER_VK_STRUCT_ID(VkExternalMemoryImageCreateInfo, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO);
REGISTER_VK_STRUCT_ID(VkMemoryAllocateInfo, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO);
REGISTER_VK_STRUCT_ID(VkMemoryDedicatedAllocateInfo, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO);
REGISTER_VK_STRUCT_ID(VkMemoryDedicatedRequirements, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS);
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
REGISTER_VK_STRUCT_ID(VkImportAndroidHardwareBufferInfoANDROID, VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID);
+#endif
REGISTER_VK_STRUCT_ID(VkExportMemoryAllocateInfo, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO);
REGISTER_VK_STRUCT_ID(VkMemoryRequirements2, VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2);
REGISTER_VK_STRUCT_ID(VkSemaphoreCreateInfo, VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO);
@@ -48,9 +55,6 @@
REGISTER_VK_STRUCT_ID(VkImportMemoryZirconHandleInfoFUCHSIA, VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA);
REGISTER_VK_STRUCT_ID(VkBufferCollectionImageCreateInfoFUCHSIA, VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA);
REGISTER_VK_STRUCT_ID(VkBufferCollectionBufferCreateInfoFUCHSIA, VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA);
-REGISTER_VK_STRUCT_ID(VkImportMemoryBufferCollectionFUCHSIAX, VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIAX);
-REGISTER_VK_STRUCT_ID(VkBufferCollectionImageCreateInfoFUCHSIAX, VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIAX);
-REGISTER_VK_STRUCT_ID(VkBufferCollectionBufferCreateInfoFUCHSIAX, VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIAX);
#endif // VK_USE_PLATFORM_FUCHSIA
REGISTER_VK_STRUCT_ID(VkSamplerCreateInfo, VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);
REGISTER_VK_STRUCT_ID(VkSamplerCustomBorderColorCreateInfoEXT, VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT);
diff --git a/system/vulkan_enc/vk_util.h b/system/vulkan_enc/vk_util.h
index 39de991..160bf06 100644
--- a/system/vulkan_enc/vk_util.h
+++ b/system/vulkan_enc/vk_util.h
@@ -199,13 +199,13 @@
template <class T, class H> T* vk_find_struct(H* head)
{
- vk_get_vk_struct_id<H>::id;
+ (void)vk_get_vk_struct_id<H>::id;
return static_cast<T*>(__vk_find_struct(static_cast<void*>(head), vk_get_vk_struct_id<T>::id));
}
template <class T, class H> const T* vk_find_struct(const H* head)
{
- vk_get_vk_struct_id<H>::id;
+ (void)vk_get_vk_struct_id<H>::id;
return static_cast<const T*>(__vk_find_struct(const_cast<void*>(static_cast<const void*>(head)),
vk_get_vk_struct_id<T>::id));
}
@@ -228,14 +228,14 @@
template <class T> vk_struct_chain_iterator vk_make_chain_iterator(T* vk_struct)
{
- vk_get_vk_struct_id<T>::id;
+ (void)vk_get_vk_struct_id<T>::id;
vk_struct_chain_iterator result = { reinterpret_cast<vk_struct_common*>(vk_struct) };
return result;
}
template <class T> void vk_append_struct(vk_struct_chain_iterator* i, T* vk_struct)
{
- vk_get_vk_struct_id<T>::id;
+ (void)vk_get_vk_struct_id<T>::id;
vk_struct_common* p = i->value;
if (p->pNext) {
diff --git a/system/vulkan_enc/vulkan_gfxstream.h b/system/vulkan_enc/vulkan_gfxstream.h
new file mode 100644
index 0000000..b8c99a0
--- /dev/null
+++ b/system/vulkan_enc/vulkan_gfxstream.h
@@ -0,0 +1,213 @@
+// Copyright (C) 2022 The Android Open Source Project
+// Copyright (C) 2022 Google 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.
+//
+// Autogenerated header vulkan_gfxstream.h
+// Please do not modify directly;
+// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
+// or directly from Python by calling the genvk.py script with correct parameters.
+
+#pragma once
+#ifdef VK_GFXSTREAM_STRUCTURE_TYPE_EXT
+#include "vulkan_gfxstream_structure_type.h"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define VK_GOOGLE_gfxstream 1
+#define VK_GOOGLE_GFXSTREAM_SPEC_VERSION 0
+#define VK_GOOGLE_GFXSTREAM_NUMBER 386
+#define VK_GOOGLE_GFXSTREAM_EXTENSION_NAME "VK_GOOGLE_gfxstream"
+typedef struct VkImportColorBufferGOOGLE {
+ VkStructureType sType;
+ void* pNext;
+ uint32_t colorBuffer;
+} VkImportColorBufferGOOGLE;
+
+typedef struct VkImportBufferGOOGLE {
+ VkStructureType sType;
+ void* pNext;
+ uint32_t buffer;
+} VkImportBufferGOOGLE;
+
+typedef struct VkImportPhysicalAddressGOOGLE {
+ VkStructureType sType;
+ void* pNext;
+ uint64_t physicalAddress;
+ VkDeviceSize size;
+ VkFormat format;
+ VkImageTiling tiling;
+ uint32_t tilingParameter;
+} VkImportPhysicalAddressGOOGLE;
+
+typedef VkResult(VKAPI_PTR* PFN_vkRegisterImageColorBufferGOOGLE)(VkDevice device, VkImage image,
+ uint32_t colorBuffer);
+typedef VkResult(VKAPI_PTR* PFN_vkRegisterBufferColorBufferGOOGLE)(VkDevice device, VkBuffer buffer,
+ uint32_t colorBuffer);
+typedef VkResult(VKAPI_PTR* PFN_vkMapMemoryIntoAddressSpaceGOOGLE)(VkDevice device,
+ VkDeviceMemory memory,
+ uint64_t* pAddress);
+typedef void(VKAPI_PTR* PFN_vkUpdateDescriptorSetWithTemplateSizedGOOGLE)(
+ VkDevice device, VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
+ uint32_t bufferInfoCount, uint32_t bufferViewCount, const uint32_t* pImageInfoEntryIndices,
+ const uint32_t* pBufferInfoEntryIndices, const uint32_t* pBufferViewEntryIndices,
+ const VkDescriptorImageInfo* pImageInfos, const VkDescriptorBufferInfo* pBufferInfos,
+ const VkBufferView* pBufferViews);
+typedef void(VKAPI_PTR* PFN_vkBeginCommandBufferAsyncGOOGLE)(
+ VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
+typedef void(VKAPI_PTR* PFN_vkEndCommandBufferAsyncGOOGLE)(VkCommandBuffer commandBuffer);
+typedef void(VKAPI_PTR* PFN_vkResetCommandBufferAsyncGOOGLE)(VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags);
+typedef void(VKAPI_PTR* PFN_vkCommandBufferHostSyncGOOGLE)(VkCommandBuffer commandBuffer,
+ uint32_t needHostSync,
+ uint32_t sequenceNumber);
+typedef VkResult(VKAPI_PTR* PFN_vkCreateImageWithRequirementsGOOGLE)(
+ VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage, VkMemoryRequirements* pMemoryRequirements);
+typedef VkResult(VKAPI_PTR* PFN_vkCreateBufferWithRequirementsGOOGLE)(
+ VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer, VkMemoryRequirements* pMemoryRequirements);
+typedef VkResult(VKAPI_PTR* PFN_vkGetMemoryHostAddressInfoGOOGLE)(VkDevice device,
+ VkDeviceMemory memory,
+ uint64_t* pAddress,
+ uint64_t* pSize,
+ uint64_t* pHostmemId);
+typedef VkResult(VKAPI_PTR* PFN_vkFreeMemorySyncGOOGLE)(VkDevice device, VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator);
+typedef void(VKAPI_PTR* PFN_vkQueueHostSyncGOOGLE)(VkQueue queue, uint32_t needHostSync,
+ uint32_t sequenceNumber);
+typedef void(VKAPI_PTR* PFN_vkQueueSubmitAsyncGOOGLE)(VkQueue queue, uint32_t submitCount,
+ const VkSubmitInfo* pSubmits, VkFence fence);
+typedef void(VKAPI_PTR* PFN_vkQueueWaitIdleAsyncGOOGLE)(VkQueue queue);
+typedef void(VKAPI_PTR* PFN_vkQueueBindSparseAsyncGOOGLE)(VkQueue queue, uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo,
+ VkFence fence);
+typedef void(VKAPI_PTR* PFN_vkGetLinearImageLayoutGOOGLE)(VkDevice device, VkFormat format,
+ VkDeviceSize* pOffset,
+ VkDeviceSize* pRowPitchAlignment);
+typedef void(VKAPI_PTR* PFN_vkGetLinearImageLayout2GOOGLE)(VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+ VkDeviceSize* pOffset,
+ VkDeviceSize* pRowPitchAlignment);
+typedef void(VKAPI_PTR* PFN_vkQueueFlushCommandsGOOGLE)(VkQueue queue,
+ VkCommandBuffer commandBuffer,
+ VkDeviceSize dataSize, const void* pData);
+typedef void(VKAPI_PTR* PFN_vkQueueCommitDescriptorSetUpdatesGOOGLE)(
+ VkQueue queue, uint32_t descriptorPoolCount, const VkDescriptorPool* pDescriptorPools,
+ uint32_t descriptorSetCount, const VkDescriptorSetLayout* pSetLayouts,
+ const uint64_t* pDescriptorSetPoolIds, const uint32_t* pDescriptorSetWhichPool,
+ const uint32_t* pDescriptorSetPendingAllocation,
+ const uint32_t* pDescriptorWriteStartingIndices, uint32_t pendingDescriptorWriteCount,
+ const VkWriteDescriptorSet* pPendingDescriptorWrites);
+typedef void(VKAPI_PTR* PFN_vkCollectDescriptorPoolIdsGOOGLE)(VkDevice device,
+ VkDescriptorPool descriptorPool,
+ uint32_t* pPoolIdCount,
+ uint64_t* pPoolIds);
+typedef void(VKAPI_PTR* PFN_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE)(
+ VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkRegisterImageColorBufferGOOGLE(VkDevice device, VkImage image,
+ uint32_t colorBuffer);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkRegisterBufferColorBufferGOOGLE(VkDevice device, VkBuffer buffer,
+ uint32_t colorBuffer);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkMapMemoryIntoAddressSpaceGOOGLE(VkDevice device,
+ VkDeviceMemory memory,
+ uint64_t* pAddress);
+
+VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
+ VkDevice device, VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
+ uint32_t bufferInfoCount, uint32_t bufferViewCount, const uint32_t* pImageInfoEntryIndices,
+ const uint32_t* pBufferInfoEntryIndices, const uint32_t* pBufferViewEntryIndices,
+ const VkDescriptorImageInfo* pImageInfos, const VkDescriptorBufferInfo* pBufferInfos,
+ const VkBufferView* pBufferViews);
+
+VKAPI_ATTR void VKAPI_CALL vkBeginCommandBufferAsyncGOOGLE(
+ VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkEndCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer);
+
+VKAPI_ATTR void VKAPI_CALL vkResetCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags);
+
+VKAPI_ATTR void VKAPI_CALL vkCommandBufferHostSyncGOOGLE(VkCommandBuffer commandBuffer,
+ uint32_t needHostSync,
+ uint32_t sequenceNumber);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageWithRequirementsGOOGLE(
+ VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
+ VkImage* pImage, VkMemoryRequirements* pMemoryRequirements);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferWithRequirementsGOOGLE(
+ VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
+ VkBuffer* pBuffer, VkMemoryRequirements* pMemoryRequirements);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostAddressInfoGOOGLE(VkDevice device,
+ VkDeviceMemory memory,
+ uint64_t* pAddress, uint64_t* pSize,
+ uint64_t* pHostmemId);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkFreeMemorySyncGOOGLE(VkDevice device, VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL vkQueueHostSyncGOOGLE(VkQueue queue, uint32_t needHostSync,
+ uint32_t sequenceNumber);
+
+VKAPI_ATTR void VKAPI_CALL vkQueueSubmitAsyncGOOGLE(VkQueue queue, uint32_t submitCount,
+ const VkSubmitInfo* pSubmits, VkFence fence);
+
+VKAPI_ATTR void VKAPI_CALL vkQueueWaitIdleAsyncGOOGLE(VkQueue queue);
+
+VKAPI_ATTR void VKAPI_CALL vkQueueBindSparseAsyncGOOGLE(VkQueue queue, uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo,
+ VkFence fence);
+
+VKAPI_ATTR void VKAPI_CALL vkGetLinearImageLayoutGOOGLE(VkDevice device, VkFormat format,
+ VkDeviceSize* pOffset,
+ VkDeviceSize* pRowPitchAlignment);
+
+VKAPI_ATTR void VKAPI_CALL vkGetLinearImageLayout2GOOGLE(VkDevice device,
+ const VkImageCreateInfo* pCreateInfo,
+ VkDeviceSize* pOffset,
+ VkDeviceSize* pRowPitchAlignment);
+
+VKAPI_ATTR void VKAPI_CALL vkQueueFlushCommandsGOOGLE(VkQueue queue, VkCommandBuffer commandBuffer,
+ VkDeviceSize dataSize, const void* pData);
+
+VKAPI_ATTR void VKAPI_CALL vkQueueCommitDescriptorSetUpdatesGOOGLE(
+ VkQueue queue, uint32_t descriptorPoolCount, const VkDescriptorPool* pDescriptorPools,
+ uint32_t descriptorSetCount, const VkDescriptorSetLayout* pSetLayouts,
+ const uint64_t* pDescriptorSetPoolIds, const uint32_t* pDescriptorSetWhichPool,
+ const uint32_t* pDescriptorSetPendingAllocation,
+ const uint32_t* pDescriptorWriteStartingIndices, uint32_t pendingDescriptorWriteCount,
+ const VkWriteDescriptorSet* pPendingDescriptorWrites);
+
+VKAPI_ATTR void VKAPI_CALL vkCollectDescriptorPoolIdsGOOGLE(VkDevice device,
+ VkDescriptorPool descriptorPool,
+ uint32_t* pPoolIdCount,
+ uint64_t* pPoolIds);
+
+VKAPI_ATTR void VKAPI_CALL vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(
+ VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/system/vulkan_enc/vulkan_gfxstream_structure_type.h b/system/vulkan_enc/vulkan_gfxstream_structure_type.h
new file mode 100644
index 0000000..b66918b
--- /dev/null
+++ b/system/vulkan_enc/vulkan_gfxstream_structure_type.h
@@ -0,0 +1,40 @@
+// Copyright (C) 2018 The Android Open Source Project
+// Copyright (C) 2018 Google 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.
+
+// Autogenerated module vulkan_gfxstream_structure_type
+//
+// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
+// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+//
+// Please do not modify directly;
+// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
+// or directly from Python by defining:
+// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
+// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
+// CEREAL_OUTPUT_DIR: Where to put the generated sources.
+//
+// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
+// $CEREAL_OUTPUT_DIR
+//
+#pragma once
+
+#define VK_GOOGLE_GFXSTREAM_ENUM(type, id) \
+ ((type)(1000000000 + (1000 * (VK_GOOGLE_GFXSTREAM_NUMBER - 1)) + (id)))
+
+#define VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE VK_GOOGLE_GFXSTREAM_ENUM(VkStructureType, 0)
+#define VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE \
+ VK_GOOGLE_GFXSTREAM_ENUM(VkStructureType, 1)
+#define VK_STRUCTURE_TYPE_IMPORT_BUFFER_HANDLE_GOOGLE VK_GOOGLE_GFXSTREAM_ENUM(VkStructureType, 2)
+#define VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE VK_GOOGLE_GFXSTREAM_ENUM(VkStructureType, 3)
